AI/src/heuristics/points_heuristic.hpp

+#ifndef __POINTS_HEURISTIC_HPP__
+#define __POINTS_HEURISTIC_HPP__
+
+#include "penguin_heuristic.hpp"
+
+namespace mcts
+{
+
+  class points_heuristic : public penguin_heuristic
+  {
+  public:
+    float get_value(const game::penguin& game, uint8_t move) const;
+    int get_count(const game::penguin& game, uint8_t move) const;
+  };
+};
+
+#endif

AI/src/main/main.cpp

@@ -23,20 +23,22 @@
 #include "test_mcts_two_players.hpp"
 #include "test_bits.hpp"
 #include "learning.hpp"
-
+#include "penguin_heuristic.hpp"
+#include "config.hpp"
 #include <omp.h>
 
 using namespace std;
 
 int main(int argc, char *argv[])
 {
-	// util::test_fast_log(100000000);
 	// mcts::test_allocator(10, 2);
 	// omp_set_num_threads(8);
+	game::config& c = game::config::get_config();
 
-	//game::run_test_two_players_game(game::penguin());
-	mcts::run_test_mcts_two_players(game::penguin());
+    const mcts::penguin_heuristic& h1 = *(c.get_heuristic(1));
+    const mcts::penguin_heuristic& h2 = *(c.get_heuristic(2));
+    
+    mcts::run_test_mcts_two_players(game::penguin(),h1,h2);
 
-	//util::test_bits(200000000);
 	return 0;
 }

AI/src/mcts/MCTS_SETTINGS.hpp

 #ifndef __MCTS_SETTINGS_HPP__
 #define __MCTS_SETTINGS_HPP__
 // Allocated memory for the mcts. If not enough the program may crash
-#define MCTS_ALLOCATOR_SIZE 1000000U
+#define MCTS_ALLOCATOR_SIZE 100000000U
 // Reflection time for every turn of the mcts (in ms)
 #define MCTS_TURN_TIME 5000
 

AI/src/mcts/mcts_two_players.hpp

@@ -9,60 +9,68 @@
 #include <fstream>
 #include <vector>
 #include "openings.hpp"
+#include "heuristic.hpp"
 
 namespace mcts
 {
-  template <typename Game>
-  class mcts_two_players : public mcts<Game>
-  {
+template <typename Game>
+class mcts_two_players : public mcts<Game>
+{
     allocator alloc_;
     const util::fast_log fast_log_;
     const float C_;
     const unsigned int nb_visits_before_expansion_;
+    const heuristic<Game>& heuristic_;
     const bool new_version_;
 
     inline node* select(const std::shared_ptr<Game>& game, std::mt19937& generator, node* parent);
     inline void expand(const std::shared_ptr<Game>& game, node* n);
     void think(const std::shared_ptr<Game>& game);
-  public:
-    mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8, bool new_version = true);
+public:
+    mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8,
+                     const heuristic<Game>& heuristic = zero_knowledge<Game>(), bool new_version = true);
     void reset();
     void init_with_openings(const openings& o);
     inline uint16_t select_move();
     void last_move(uint16_t move);
     void last_moves(uint16_t computer, uint16_t other);
-  };
+};
 
-  template <typename Game>
-  mcts_two_players<Game> make_mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8, bool new_version = true)
-  {
-    return mcts_two_players<Game>(game, milliseconds, C, nb_visits_before_expansion, new_version);
-  }
+template <typename Game>
+mcts_two_players<Game> make_mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8,
+        const heuristic<Game>& heuristic = zero_knowledge<Game>(),
+        bool new_version = true)
+{
+    return mcts_two_players<Game>(game, milliseconds, C, nb_visits_before_expansion, heuristic, new_version);
+}
 
-  template <typename Game>
-  mcts_two_players<Game>::mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion, bool new_version)
-    : mcts<Game>(game, milliseconds), C_(C), nb_visits_before_expansion_(nb_visits_before_expansion), new_version_(new_version)
-  {
+template <typename Game>
+mcts_two_players<Game>::mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion,
+        const heuristic<Game>& heuristic,
+        bool new_version)
+    : mcts<Game>(game, milliseconds), C_(C), nb_visits_before_expansion_(nb_visits_before_expansion),
+      heuristic_(heuristic), new_version_(new_version)
+{
     this->generators.assign(util::omp_util::get_num_threads(), std::mt19937());
     this->root = alloc_.allocate(1);
-  }
+}
 
-  template <typename Game>
-  void mcts_two_players<Game>::reset()
-  {
+template <typename Game>
+void mcts_two_players<Game>::reset()
+{
     alloc_.clear();
     this->root = alloc_.allocate(1);
-  }
+}
 
-  template <typename Game>
-  void mcts_two_players<Game>::init_with_openings(const openings& o)
-  {
+template <typename Game>
+void mcts_two_players<Game>::init_with_openings(const openings& o)
+{
     o.copy_to(this->root, alloc_);
-  }
+}
 
-  template <typename Game>
-  node* mcts_two_players<Game>::select(const std::shared_ptr<Game>& game, std::mt19937& generator, node* parent)
-  {
+template <typename Game>
+node* mcts_two_players<Game>::select(const std::shared_ptr<Game>& game, std::mt19937& generator, node* parent)
+{
     using namespace std;
     const unsigned int N = parent->get_statistics().count;
     const float log_of_N = fast_log_.log(N);
@@ -76,63 +84,63 @@ namespace mcts
     unsigned int count;
     float v;
     for (uint16_t i = 0; i < nb_children; ++i)
-      {
+    {
         node* child = children + k;
         count = child->get_statistics().count;
         v = -child->get_statistics().value + C_ * sqrt(log_of_N / count);
         if (v > best_value_so_far)
-	  {
+        {
             best_value_so_far = v;
             best_child_so_far = child;
             best_move_so_far = k;
-	  }
+        }
         ++k;
         if (k == nb_children) k = 0;
-      }
+    }
     if (best_child_so_far->is_proven())
-      {
+    {
         if (best_child_so_far->is_lost()) parent->set_won();
         else
-	  {
+        {
             bool all_won = true;
             for (uint16_t i = 0; i < nb_children; ++i)
-	      {
+            {
                 node* child = children + i;
                 if (!child->is_won())
-		  {
+                {
                     all_won = false;
                     break;
-		  }
-	      }
+                }
+            }
             if (all_won) parent->set_lost();
-	  }
-      }
+        }
+    }
     game->play(best_move_so_far);
     return best_child_so_far;
-  }
+}
 
-  template <typename Game>
-  void mcts_two_players<Game>::expand(const std::shared_ptr<Game>& game, node* n)
-  {
+template <typename Game>
+void mcts_two_players<Game>::expand(const std::shared_ptr<Game>& game, node* n)
+{
     unsigned int count = n->get_statistics().count;
     if (count >= nb_visits_before_expansion_ && !n->test_and_set())
-      {
+    {
         unsigned int nb_children = game->number_of_moves();
         node* children = alloc_.allocate(nb_children);
         for (unsigned int i = 0; i < nb_children; ++i)
-	  {
+        {
             node* child = children + i;
-            child->get_statistics_ref().count = 1;
-            child->get_statistics_ref().value = 0;
-	  }
+            child->get_statistics_ref().count = heuristic_.get_count(*game, i);
+            child->get_statistics_ref().value = heuristic_.get_value(*game, i);
+        }
         n->set_children(children);
         n->set_number_of_children(nb_children);
-      }
-  }
+    }
+}
 
-  template <typename Game>
-  void mcts_two_players<Game>::think(const std::shared_ptr<Game>& game)
-  {
+template <typename Game>
+void mcts_two_players<Game>::think(const std::shared_ptr<Game>& game)
+{
     using namespace std;
     const chrono::steady_clock::time_point start = chrono::steady_clock::now();
     chrono::steady_clock::time_point now;
@@ -142,72 +150,72 @@ namespace mcts
     vector<uint16_t> moves(200);
     unsigned int nb_iter = 0;
     do
-      {
+    {
         int size = 1;
         node* current = this->root;
         visited[0] = current;
         while (!game->end_of_game() && !current->is_leaf() && !current->is_proven())
-	  {
+        {
             current = select(game, generator, current);
             visited[size++] = current;
-	  }
+        }
         int game_value = 0;
         if (current->is_proven())
-	  {
+        {
             if (current->is_won()) game_value = 1;
             else
-	      {
+            {
                 game_value = -1;
-	      }
-	  }
+            }
+        }
         else if (game->end_of_game())
-	  {
+        {
             int v = game->value_for_current_player();
             if (v > 0)
-	      {
+            {
                 game_value = 1;
                 if (new_version_) current->set_won();
-	      }
+            }
             else if (v < 0)
-	      {
+            {
                 game_value = -1;
                 if (new_version_)
-		  {
+                {
                     current->set_lost();
                     if (size > 1) visited[size - 2]->set_won();
-		  }
-	      }
-	  }
+                }
+            }
+        }
         else
-	  {
+        {
             uint8_t player = game->current_player();
             expand(game, current);
             game->playout(generator);
             int v = game->value(player);
             if (v > 0) game_value = 1;
             else if (v < 0) game_value = -1;
-	  }
+        }
         for (int i = size - 1; i >= 0; --i)
-	  {
+        {
             visited[i]->update(game_value);
             game_value = -game_value;
-	  }
+        }
         game->set_state(state);
         ++nb_iter;
         if ((nb_iter & 0x3F) == 0) now = chrono::steady_clock::now();
-      }
+    }
     while ((nb_iter & 0x3F) != 0 || now < start + this->milliseconds);
-  }
+}
 
-  template <typename Game>
-  uint16_t mcts_two_players<Game>::select_move()
-  {
+template <typename Game>
+uint16_t mcts_two_players<Game>::select_move()
+{
     using namespace std;
     if (!this->root->is_proven())
-      {
-#pragma omp parallel
+    {
+        #pragma omp parallel
         think(game::copy(this->game));
-      }
+    }
     // std::ofstream ofs ("graph.gv", ofstream::out);
     //    util::display_node::node_to_dot(ofs, this->root, 1000, 50);
     util::display_node::node_to_ascii(cout, this->root, 1);
@@ -222,52 +230,52 @@ namespace mcts
     node* children = this->root->get_children();
     unsigned int c;
     for (uint16_t i = 0; i < nb_children; ++i)
-      {
+    {
         node *child = children + k;
         if (child->is_lost())
-	  {
+        {
             best_move_so_far = k;
             break;
-	  }
+        }
         c = children[k].get_statistics().count;
         if (c > best_count_so_far)
-	  {
+        {
             best_count_so_far = c;
             best_move_so_far = k;
-	  }
+        }
         ++k;
         if (k == nb_children) k = 0;
-      }
+    }
     return best_move_so_far;
-  }
+}
 
-  template <typename Game>
-  void mcts_two_players<Game>::last_moves(uint16_t computer, uint16_t other)
-  {
+template <typename Game>
+void mcts_two_players<Game>::last_moves(uint16_t computer, uint16_t other)
+{
     if (this->root->is_leaf() || this->root->get_children()[computer].is_leaf())
-      {
+    {
         alloc_.clear();
         this->root = alloc_.allocate(1);
-      }
+    }
     else
-      {
+    {
         this->root = alloc_.move(&this->root->get_children()[computer].get_children()[other]);
-      }
-  }
+    }
+}
 
-  template <typename Game>
-  void mcts_two_players<Game>::last_move(uint16_t move)
-  {
+template <typename Game>
+void mcts_two_players<Game>::last_move(uint16_t move)
+{
     if (this->root->is_leaf())
-      {
+    {
         alloc_.clear();
         this->root = alloc_.allocate(1);
-      }
+    }
     else
-      {
+    {
         this->root = alloc_.move(&this->root->get_children()[move], 20);
-      }
-  }
+    }
+}
 
 }
 

AI/src/mcts/penguin_heuristic.cpp.orig

+#include "penguin_heuristic.hpp"
+#include "penguin.hpp"
+using namespace std;
+
+namespace mcts
+{
+  float penguin_heuristic::get_value(const game::penguin& game, uint8_t move) const
+  {
+	
+    return 0.f;
+  }
+
+  int penguin_heuristic::get_count(const game::penguin& game, uint8_t move) const
+  {
+    return 1;
+  }
+
+  float go_left_up_heuristic::get_value(const game::penguin& game, uint8_t move) const
+  {
+<<<<<<< HEAD
+		std::shared_ptr<game::penguin> played = game::copy(game);
+		played->play(move);
+		game::penguin_state state = played->get_state();
+		uint32_t* penguins = state.peng_blue;
+		if(!state.current_player_red) {
+			penguins = state.peng_red;
+		}
+		uint32_t sPos = 0;
+		for(int i=0; i< 4; i++) {
+			sPos+=PENGUIN_POS(penguins[i]);
+		}
+		double res = (double) (-(-118.0 + sPos) / 118.0);
+		return res;
+    
+=======
+	    
+	std::shared_ptr<game::penguin> played = game::copy(game);
+    	played->play(move);
+	game::penguin_state state = played->get_state();
+	uint32_t* penguins = state.peng_blue;
+	if(!state.current_player_red) {
+		penguins = state.peng_red;
+	}
+	uint32_t sPos = 0;
+	for(int i=0; i< 4; i++) {
+		sPos+=PENGUIN_POS(penguins[i]);
+	}
+	double res = (double) (-(-118.0 + sPos) / 118.0);
+    return res;
+>>>>>>> 34412ade6e5941a3c916b90b915655977cb2068c
+  }
+
+  int go_left_up_heuristic::get_count(const game::penguin& game, uint8_t move) const
+  {
+    return 100000000;
+  }
+}

AI/src/mcts/test_mcts_two_players.hpp

 #ifndef __TEST_MCTS_TWO_PLAYERS_HPP__
 #define __TEST_MCTS_TWO_PLAYERS_HPP__
-
 #include "openings.hpp"
 #include "mcts_two_players.hpp"
 #include "MCTS_SETTINGS.hpp"
@@ -10,67 +9,78 @@
 #include <iomanip>
 #include <set>
 #include <fstream>
+#include "heuristic.hpp"
+#include "config.hpp"
+#include "test_statistics.hpp"
+#include <unistd.h>
+#include "penguin.hpp"
 
 namespace mcts
 {
-  template <typename Game>
-  class test_mcts_two_players
-  {
+template <typename Game>
+class test_mcts_two_players
+{
     openings openings_;
 
-    void play(Game g);
+    void play(Game g, const heuristic<Game>& h);
     void self_play(Game g);
-    void self_play(Game g, int n, bool with_openings = false);
+    void self_play(Game g, const heuristic<Game>& h1 = zero_knowledge<Game>(), const heuristic<Game>& h2 = zero_knowledge<Game>());
     void self_play_learn_openings(Game g, int n);
     void test_openings(Game g, int nb_learning, int nb_testing);
     int select_move(Game& game);
-  public:
-    test_mcts_two_players(const Game& g);
-  };
+public:
+    test_mcts_two_players(const Game& g, const heuristic<Game>& h1 = zero_knowledge<Game>(), const heuristic<Game>& h2 = zero_knowledge<Game>());
+};
 
-  template <typename Game>
-  test_mcts_two_players<Game>::test_mcts_two_players(const Game& g) : openings_(g)
-  {
-    //self_play(g, 1000);
-    play(g);
-    //test_openings(g, 10000, 1000);
-  }
+template <typename Game>
+test_mcts_two_players<Game>::test_mcts_two_players(const Game& g, const heuristic<Game>& h, const heuristic<Game>& h2) : openings_(g)
+{
+    game::config& config = game::config::get_config();
+    if(config.is_ai_vs_ai())
+    {
+        self_play(g, h,h2);
+    }
+    else
+    {
+        play(g, h);
+    }
+}
 
-  template <typename Game>
-  void run_test_mcts_two_players(const Game& g)
-  {
-    test_mcts_two_players<Game>{g};
-  }
+template <typename Game>
+void run_test_mcts_two_players(const Game& g, const heuristic<Game>& h = zero_knowledge<Game>(),const heuristic<Game>& h2 = zero_knowledge<Game>())
+{
+    test_mcts_two_players<Game> {g, h, h2};
+}
 
 
-  template <typename Game>
-  void test_mcts_two_players<Game>::test_openings(Game g, int nb_learning, int nb_testing)
-  {
-    //    self_play(g, nb_testing);
+template <typename Game>
+void test_mcts_two_players<Game>::test_openings(Game g, int nb_learning, int nb_testing)
+{
+    //self_play(g, nb_testing);
     self_play_learn_openings(g, nb_learning);
     self_play(g, nb_testing, true);
-  }
+}
 
-  template <typename Game>
-  int test_mcts_two_players<Game>::select_move(Game& game)
-  {
+template <typename Game>
+int test_mcts_two_players<Game>::select_move(Game& game)
+{
     std::cout << game.player_to_string(game.current_player()) << " move: ";
     std::map<std::string, int> m;
     for (int i = 0; i < game.number_of_moves(); ++i)
-      {
+    {
         m[game.move_to_string(i)] = i;
-      }
+    }
     std::string move;
     getline(std::cin, move);
     game.play(m[move]);
     return m[move];
-  }
+}
 
-  template <typename Game>
-  void test_mcts_two_players<Game>::play(Game g)
-  {
+template <typename Game>
+void test_mcts_two_players<Game>::play(Game g, const heuristic<Game>& h)
+{
     //    ProfilerStart("theturk.prof");
-    auto the_turk = make_mcts_two_players(g, MCTS_TURN_TIME, 0.4, 8);
+    auto the_turk = make_mcts_two_players(g, MCTS_TURN_TIME, 0.4, 8, h);
     std::cout << "play one game" << std::endl;
     std::cout << "who's first? (h)uman/(c)omputer ";
     std::string ans;
@@ -78,41 +88,41 @@ namespace mcts
     std::cout << g.to_string() << std::endl;
     int human_last_move = -1, computer_last_move = -1;
     while (!g.end_of_game())
-      {
+    {
         if ((ans == "h" && g.current_player() == 0) || (ans == "c" && g.current_player() == 1))
-	  {
+        {
             human_last_move = select_move(g);
-	  }
+        }
         else
-	  {
+        {
             if (human_last_move != -1 && computer_last_move != -1)
-	      {
+            {
                 the_turk.last_moves(computer_last_move, human_last_move);
-	      }
+            }
             uint16_t move = the_turk.select_move();
             computer_last_move = move;
             std::cout << g.player_to_string(g.current_player()) << " move: " << g.move_to_string(move) << std::endl;
             g.play(move);
-	  }
+        }
         std::cout << g << std::endl;
-      }
+    }
     if (g.won(0)) std::cout << g.player_to_string(0) << " won";
     else if (g.won(1)) std::cout << g.player_to_string(1) << " won";
     else std::cout << "draw";
     std::cout << std::endl;
     //    ProfilerStop();
-  }
+}
 
-  template <typename Game>
-  void test_mcts_two_players<Game>::self_play_learn_openings(Game g, int n)
-  {
+template <typename Game>
+void test_mcts_two_players<Game>::self_play_learn_openings(Game g, int n)
+{
     std::vector<uint16_t> moves(200);
     auto state = g.get_state();
     auto the_turk_1 = make_mcts_two_players(g, 1000, 0.6, 2);
     auto the_turk_2 = make_mcts_two_players(g, 1000, 0.6, 2);
     std::map<std::set<int>, std::pair<std::uint32_t, double>> learning_examples;
     for (int i = 0; i < n; ++i)
-      {
+    {
         std::cout << i << std::endl;
         std::cout << openings_ << std::endl << std::endl;
         moves.clear();
@@ -124,144 +134,163 @@ namespace mcts
         int the_turk_1_last_move = -1, the_turk_2_last_move = -1;
         int k = 0;
         while (!g.end_of_game())
-	  {
+        {
             if (k == 1) the_turk_2.last_move(the_turk_1_last_move);
             if (k % 2 == 0)
-	      {
+            {
                 if (the_turk_2_last_move != -1)
-		  {
+                {
                     the_turk_1.last_moves(the_turk_1_last_move, the_turk_2_last_move);
-		  }
+                }
                 std::uint16_t move = the_turk_1.select_move();
                 moves.push_back(move);
                 the_turk_1_last_move = move;
                 g.play(move);
-	      }
+            }
             else
-	      {
+            {
                 if (the_turk_2_last_move != -1)
-		  {
+                {
                     the_turk_2.last_moves(the_turk_2_last_move, the_turk_1_last_move);
-		  }
+                }
                 std::uint16_t move = the_turk_2.select_move();
                 moves.push_back(move);
                 the_turk_2_last_move = move;
                 g.play(move);
-	      }
+            }
             ++k;
-	  }
-	std::cout << g.to_string() << std::endl;
+        }
+        std::cout << g.to_string() << std::endl;
         int v = g.value(0);
         std::cout << "value for first player " << v << std::endl;
         g.set_state(state);
         openings_.update(g, moves, v);
-	g.set_state(state);
-	for (std::uint16_t m : moves)
-	  {
-	    g.play(m);
-	    v = -v;
-	    std::set<int> input_vector = std::move(g.to_input_vector());
-	    auto it = learning_examples.find(input_vector);
-	    if (it == learning_examples.end())
-	      {
-		learning_examples[input_vector] = std::make_pair(1, v);
-	      }
-	    else
-	      {
-		it->second.second = (it->second.second * it->second.first + v) / (it->second.first + 1);
-		it->second.first += 1;
-	      }
-	  }
-      }
+        g.set_state(state);
+        for (std::uint16_t m : moves)
+        {
+            g.play(m);
+            v = -v;
+            std::set<int> input_vector = std::move(g.to_input_vector());
+            auto it = learning_examples.find(input_vector);
+            if (it == learning_examples.end())
+            {
+                learning_examples[input_vector] = std::make_pair(1, v);
+            }
+            else
+            {
+                it->second.second = (it->second.second * it->second.first + v) / (it->second.first + 1);
+                it->second.first += 1;
+            }
+        }
+    }
     std::cout << "number of learning examples: " << learning_examples.size() << std::endl;
     std::ofstream output("learning_examples.txt");
     for (const auto& example : learning_examples)
-      {
-	output << example.second.second;
-	for (int index : example.first)
-	  {
-	    output << " " << index << ":" << 1;
-	  }
-	output << std::endl;
-      }
+    {
+        output << example.second.second;
+        for (int index : example.first)
+        {
+            output << " " << index << ":" << 1;
+        }
+        output << std::endl;
+    }
     output.close();
-  }
+}
 
-  template <typename Game>
-  void test_mcts_two_players<Game>::self_play(Game g, int n, bool with_openings)
-  {
+template <typename Game>
+void test_mcts_two_players<Game>::self_play(Game g, const heuristic<Game>& h1, const heuristic<Game>& h2)
+{
+    //std::cout << getFilePath() << std::endl;
+    
+    game::config& c = game::config::get_config();
     auto state = g.get_state();
-    auto the_turk_v1 = make_mcts_two_players(g, 1000, 0.6, 2);
-    auto the_turk_v2 = make_mcts_two_players(g, 1000, 0.6, 2);
+   
+    auto the_turk_v1 = make_mcts_two_players(g, c.get_think_time(), 0.6, 2, h1);
+    auto the_turk_v2 = make_mcts_two_players(g, c.get_think_time(), 0.6, 2, h2);
+    std::string result_directory(get_test_results_directory());
     int nb_win_v1 = 0, nb_win_v2 = 0, nb_draw = 0;
-    for (int i = 0; i < n; ++i)
-      {
-	std::cout << i << std::endl;
+    for (unsigned int i = 0; i < c.get_game_count(); ++i)
+    {
+        //std::cout << i << std::endl;
+		if(i%2 == 1)
+		{
+            
+			state = game::penguin::random_start_state();
+            
+        }
         g.set_state(state);
         the_turk_v1.reset();
         the_turk_v2.reset();
-	if (with_openings) the_turk_v2.init_with_openings(openings_);
         int the_turk_v1_last_move = -1, the_turk_v2_last_move = -1;
-	int k = 0;
+        int k = 0;
         while (!g.end_of_game())
-	  {
-            if (with_openings && k == 1 && i % 2 == 0) the_turk_v2.last_move(the_turk_v1_last_move);
-	    ++k;
+        {
+
+
+            ++k;
             //	    cout << c4 << endl;
             if ((i % 2 == 0 && g.current_player() == 0) || (i % 2 == 1 && g.current_player() == 1))
-	      {
+            {
                 if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
-		  {
+                {
                     the_turk_v1.last_moves(the_turk_v1_last_move, the_turk_v2_last_move);
-		  }
+                }
                 std::uint16_t move = the_turk_v1.select_move();
                 the_turk_v1_last_move = move;
                 g.play(move);
-	      }
+            }
             else
-	      {
+            {
                 if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
-		  {
+                {
                     the_turk_v2.last_moves(the_turk_v2_last_move, the_turk_v1_last_move);
-		  }
+                }
                 std::uint16_t move = the_turk_v2.select_move();
                 the_turk_v2_last_move = move;
-                play(move);
-	      }
-	  }
+                g.play(move);
+            }
+            if(c.should_send_game_to_gui())
+                std::cout << g;
+        }
+        
+        
         if (g.won(0))
-	  {
+        {
             if (i % 2 == 0)
-	      {
-                /*cout << "v1 won" << endl;*/ ++nb_win_v1;
-	      }
+            {
+                std::cout << "v1 won" << std::endl;
+                ++nb_win_v1;
+            }
             else
-	      {
-                /*cout << "v2 won" << endl;*/ ++nb_win_v2;
-	      }
-	  }
+            {
+                std::cout << "v2 won" << std::endl;
+                ++nb_win_v2;
+            }
+        }
         else if (g.won(1))
-	  {
+        {
             if (i % 2 == 0)
-	      {
-                /*cout << "v2 won" << endl;*/ ++nb_win_v2;
-	      }
+            {
+                std::cout << "v2 won" <<std::endl; ++nb_win_v2;
+            }
             else
-	      {
-                /*cout << "v1 won" << endl;*/ ++nb_win_v1;
-	      }
-	  }
+            {
+                std::cout << "v1 won" << std::endl; ++nb_win_v1;
+            }
+        }
         else
-	  {
+        {
             /*cout << "draw" << endl;*/ ++nb_draw;
-	  }
+        }
+        save_stats(result_directory,nb_win_v1,nb_win_v2,nb_draw);
         std::cout << std::setw(10) << "v1 nb wins: " << nb_win_v1 << " v2 nb wins: " << nb_win_v2 << " nb draws: " << nb_draw << std::endl;
-      }
-  }
+    }
+}
+
+template <typename Game>
+void test_mcts_two_players<Game>::self_play(Game g)
+{
 
-  template <typename Game>
-  void test_mcts_two_players<Game>::self_play(Game g)
-  {
     auto the_turk_v1 = make_mcts_two_players(g, 1000, 1.2, 2);
     auto the_turk_v2 = make_mcts_two_players(g, 1000, 1.2, 2);
     std::cout << "play one game" << std::endl;
@@ -271,36 +300,36 @@ namespace mcts
     std::cout << g << std::endl;
     int the_turk_v1_last_move = -1, the_turk_v2_last_move = -1;
     while (!g.end_of_game())
-      {
+    {
         if ((ans == "v1" && g.current_player() == 0) || (ans == "v2" && g.current_player() == 1))
-	  {
+        {
             if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
-	      {
+            {
                 the_turk_v1.last_moves(the_turk_v1_last_move, the_turk_v2_last_move);
-	      }
+            }
             std::uint16_t move = the_turk_v1.select_move();
             the_turk_v1_last_move = move;
             std::cout << g.player_to_string(g.current_player()) << " move: " << g.move_to_string(move) << std::endl;
             g.play(move);
-	  }
+        }
         else
-	  {
+        {
             if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
-	      {
+            {
                 the_turk_v2.last_moves(the_turk_v2_last_move, the_turk_v1_last_move);
-	      }
+            }
             std::uint16_t move = the_turk_v2.select_move();
             the_turk_v2_last_move = move;
             std::cout << g.player_to_string(g.current_player()) << " move: " << g.move_to_string(move) << std::endl;
             g.play(move);
-	  }
-        std::cout << g << std::endl;
-      }
+        }
+            std::cout << g << std::endl;
+    }
     if (g.won(0)) std::cout << g.player_to_string(0) << " won";
     else if (g.won(1)) std::cout << g.player_to_string(1) << " won";
     else std::cout << "draw";
     std::cout << std::endl;
-  }
+}
 
 }
 

GUI/src/controller/Controller.java

@@ -147,6 +147,7 @@ public class Controller implements Initializable
 				t.getFishLabel().setOnMouseClicked(phandl);
 			}
 			statusLabel.setText("Click to place RED penguins");
+			
 		}
 	}
 
@@ -173,6 +174,57 @@ public class Controller implements Initializable
 
 		}
 	}
+	public void randomGame()
+	{
+		gameState.clearFish();
+		gameState.setScore(Player.Red, 0);
+		gameState.setScore(Player.Blue, 0);
+		//Generating random fish values
+		int[] fishCount = {0,0,0};
+		for (int i = 0; i < 60; i++)
+		{
+			List<Integer> possibleFish = new ArrayList<>();
+			if(fishCount[0] < max1Fish)
+				possibleFish.add(1);
+			if(fishCount[1] < max2Fish)
+				possibleFish.add(2);
+			if(fishCount[2] < max3Fish)
+				possibleFish.add(3);
+			int nbFish = possibleFish.get(new Random().nextInt(possibleFish.size()));
+			gameState.setFish(i, nbFish);
+			board[i].setNbFish(nbFish);
+			boardView[i].update();
+			fishCount[nbFish-1]++;
+		}
+		List<Integer> excludedPositions = new ArrayList<>();
+		Random r = new Random();
+		penguinGenCounter = 0;
+		for(int i = 0; i < 8;++i)
+		{
+			int rand = r.nextInt(60);
+			Player p = Player.Red;
+			Tile.PenguinPresence pres = Tile.PenguinPresence.RED_PENGUIN;
+			if(i >= 4)
+			{
+				p = Player.Blue;
+				pres = Tile.PenguinPresence.BLUE_PENGUIN;
+			}
+			while(excludedPositions.contains(rand))
+			{
+				rand = r.nextInt(60);
+				
+			}
+			gameState.setPenguin(p, penguinGenCounter % 4, rand);
+			board[rand].setPenguinPresence(pres);
+			boardView[rand].update();
+			penguinGenCounter++;
+			excludedPositions.add(rand);
+		}
+		gameInput.println(gameState.toGameInputJSON());
+		
+		//Platform.runLater(() -> startGame());
+
+	}
 
 	/**
 	 * Updates model and view from the state

GUI/src/controller/UpdateThread.java

@@ -44,8 +44,13 @@ public class UpdateThread extends Thread
 				{
 					gameRunning = false;
 					Platform.runLater(() -> controller.gameEnd());
-				} else if (line.contains("{")) //Line contains JSON
+				} /*else if (line.contains("New")){
+
+						Platform.runLater(() -> controller.randomGame());
+				} */else if (line.contains("{")) //Line contains JSON
 				{
+					
+					
 					//gameState Update
 					gameState.update(line.substring(line.indexOf("{"), line.lastIndexOf("}") + 1)); //Extract JSON string
 					Platform.runLater(() -> controller.updateModelAndView());
@@ -68,6 +73,7 @@ public class UpdateThread extends Thread
 							});
 						}
 					}
+				
 
 				}
 				else if (line.startsWith("(") && line.contains("value:")) //lines with values (estimation) of the computer winning chances

GUI/src/model/GameState.java

@@ -33,7 +33,7 @@ public class GameState
 
 	public void update(String jsonString)
 	{
-		//System.out.println(jsonString);
+
 		JSONObject json = new JSONObject(jsonString);
 		can_play.put(Player.Red, json.getJSONObject("can_play").getBoolean("red"));
 		can_play.put(Player.Blue, json.getJSONObject("can_play").getBoolean("blue"));
@@ -50,6 +50,7 @@ public class GameState
 		for (int i = 0; i < jsonPeng.length(); i++)
 			penguins.get(Player.Blue)[i] = jsonPeng.getInt(i);
 	}
+	
 
 
 	/**

Makefile

@@ -31,13 +31,13 @@ AIExecutable = $(AIOutputDir)/penguin
 # Source files directory
 AISRC = $(AIRoot)/src
 # Directories with .h files
-AIInclude=-I $(AISRC)/game -I $(AISRC)/util -I $(AISRC)/monte_carlo -I $(AISRC)/mcts -I $(AISRC)/json
+AIInclude=-I $(AISRC)/game -I $(AISRC)/util -I $(AISRC)/monte_carlo -I $(AISRC)/mcts -I $(AISRC)/json -I $(AISRC)/heuristics
 # Cpp source files
 AISourceFile = omp_util.cpp fast_log.cpp display_node.cpp penguin.cpp test_two_players_game.cpp monte_carlo.cpp \
 	test_fast_log.cpp statistics.cpp node.cpp allocator.cpp test_allocator.cpp openings.cpp mcts_two_players.cpp \
-	test_mcts_two_players.cpp bits.cpp test_bits.cpp main.cpp
+	test_mcts_two_players.cpp bits.cpp test_bits.cpp penguin_heuristic.cpp number_direction_freedom_heuristic.cpp main.cpp config.cpp movement_freedom_heuristic.cpp points_heuristic.cpp test_statistics.cpp go_left_up_heuristic.cpp
 # Directories in which make will search for files
-vpath %.cpp $(AISRC)/game $(AISRC)/main $(AISRC)/util $(AISRC)/monte_carlo $(AISRC)/mcts $(AISRC)/gdl
+vpath %.cpp $(AISRC)/game $(AISRC)/heuristics $(AISRC)/main $(AISRC)/util $(AISRC)/monte_carlo $(AISRC)/mcts $(AISRC)/gdl
 # Flags passed to the compiler
 CFLAGS=-g -O3 -ffast-math -fopenmp -Wall -std=c++11
 # Flags passed to the linker

Makefile.orig

+# Makefile for the Penguin game project.
+# This project is composed of two modules: AI(Artificial Intelligence), that manage the game, and GUI that allows you to play it
+# To compile the AI run 'make ai'; it is written in C++.
+# To compile the GUI run 'make gui'; it is written in java and javafx.
+# To compile everything run 'make all' or 'make'.
+# To run the GUI (that will launch the AI) run 'make run'.
+# Run 'make clean' to delete compiled files and programs. 'make cleanai' and 'make cleangui' also exist
+
+# COMPILERS AND PROGRAMS
+# Compiler for the AI: g++ >= 4.9
+CC = g++
+# JAVA ENVIRONMENT FOR THE GUI
+# Java compiler >= 1.8 (usually javac)
+JAVAC := javac
+# Java jar utility (usually jar)
+JAR := jar
+# Java application launcher >= 1.8 (usually java)
+JAVA := java
+
+all: ai gui
+
+clean: cleanai cleangui
+
+# ============================================ AI (C++) =============================================
+#Root directory for the AI module
+AIRoot = AI
+# Output directory
+AIOutputDir = $(AIRoot)/bin
+# Name of the executable
+AIExecutable = $(AIOutputDir)/penguin
+# Source files directory
+AISRC = $(AIRoot)/src
+# Directories with .h files
+AIInclude=-I $(AISRC)/game -I $(AISRC)/util -I $(AISRC)/monte_carlo -I $(AISRC)/mcts -I $(AISRC)/json
+# Cpp source files
+AISourceFile = omp_util.cpp fast_log.cpp display_node.cpp penguin.cpp test_two_players_game.cpp monte_carlo.cpp \
+	test_fast_log.cpp statistics.cpp node.cpp allocator.cpp test_allocator.cpp openings.cpp mcts_two_players.cpp \
+<<<<<<< HEAD
+	test_mcts_two_players.cpp bits.cpp test_bits.cpp penguin_heuristic.cpp points_heuristic.cpp main.cpp config.cpp
+=======
+	test_mcts_two_players.cpp bits.cpp test_bits.cpp penguin_heuristic.cpp movement_freedom_heuristic.cpp main.cpp config.cpp
+>>>>>>> 34412ade6e5941a3c916b90b915655977cb2068c
+# Directories in which make will search for files
+vpath %.cpp $(AISRC)/game $(AISRC)/main $(AISRC)/util $(AISRC)/monte_carlo $(AISRC)/mcts $(AISRC)/gdl
+# Flags passed to the compiler
+CFLAGS=-g -O3 -ffast-math -fopenmp -Wall -std=c++11
+# Flags passed to the linker
+LDFLAGS=-fopenmp -std=c++11 #-lprofiler -Wl,-no_pie
+# Generating .o files' names
+AIOobjects=$(addprefix $(AIOutputDir)/, $(AISourceFile:.cpp=.o))
+
+# ==== RULES ====
+# Main rule for creating the executable
+ai: $(AIOutputDir) $(AIExecutable)
+$(AIOutputDir):
+	mkdir -p $(AIOutputDir)
+
+$(AIExecutable): $(AIOobjects)
+	$(CC) $(LDFLAGS) $(AIOobjects) -o $@
+
+# Creates .o files with automatic generation of dependencies (.d) files
+$(AIOutputDir)/%.o: %.cpp
+	$(CC) -c $(CFLAGS) $(AIInclude) -MD -MP $< -o $@
+# Include the dependency files into the makefile
+-include $(AIOobjects:.o=.d)
+
+# Deletes .o, .d and the executable
+cleanai:
+	rm -f $(AIOutputDir)/*.o $(AIOutputDir)/*.d $(AIExecutable)
+
+# ============================================ GUI (Java) =============================================
+GUIRoot := GUI
+# Output root directory
+GUIOutDir := $(GUIRoot)/out
+# Jar output file name
+GUIJarFile := $(GUIOutDir)/penguin.jar
+# Compiled classes output directory
+GUIOutClassDir := $(GUIOutDir)/classes
+# Sources root directory: all your sources will be under this directory (packages and classes)
+GUISrcDir := $(GUIRoot)/src
+# Packages that will be compiled and included in the jar: every class in these packages will be compiled, if you have classes in a package and in a subpackage as well you must specify both. Example: main package package/subpackage
+GUIPackages := main model view controller
+# Additional classes tha will be compiled and included in the jar: useful for packages that contains classes that you don't want to include. Otherwise, just use the Packages variable. Specify the path inside the source root WITH EXTENSION. Example: main/Main.java package/subpackage/MyClass.java
+GUIAdditionalClasses :=
+# Entry point (main class) for jar file. In the form package/subpackage/Class
+GUIJAREntryPoint := main.Main
+# Additional resources that will be copied in jar file. In the form -C path/to/the/parent/folder resource/path (resource/path will also be the path of the resourc inside the jar)
+GUIJARResources := -C $(GUISrcDir) resource/ -C $(GUISrcDir) view/view.fxml
+# Classpath option for compilation or execution: colon (:) separated list, must prepend -classpath flag. Example: -classpath Library.jar:Library/Include
+GUIClassPath := -classpath $(GUIRoot)/json-20160212.jar
+# Compiler additional flags
+GUIJAVACFlags :=
+# JAR additional flags
+GUIJARFlags :=
+# Run arguments
+GUIRunArgs := $(AIExecutable)
+
+
+# ========== AUTOMATICALLY GENERATED VARIABLES ==========
+# Searching for java files inside the $(Packages): for every package we search for java files and later we strip the leading source folder that is not necessary
+GUIClassesSources := $(patsubst $(GUISrcDir)/%, %, $(foreach package, $(GUIPackages), $(wildcard $(GUISrcDir)/$(package)/*.java)))
+GUIClassesSources := $(GUIClassesSources) $(GUIAdditionalClasses)
+# We tell make to search for java sources inside the source directory
+vpath %.java $(GUISrcDir)
+
+# ========== RULES ==========
+gui: $(GUIJarFile)
+
+# You need all compiled version of classes to make jar file
+$(GUIJarFile): $(addprefix $(GUIOutClassDir)/, $(GUIClassesSources:.java=.class)) $(GUIOutDir)
+	$(JAR) cvfe $(GUIJarFile) $(GUIJAREntryPoint) -C $(GUIOutClassDir) ./ $(GUIJARResources) $(GUIJARFlags)
+
+$(GUIOutDir):
+	mkdir -p $(GUIOutDir)
+
+# To compile a class you need the source code and the output folder
+$(GUIOutClassDir)/%.class: $(GUISrcDir)/%.java $(GUIOutClassDir)
+	$(JAVAC) -sourcepath $(GUISrcDir) -d $(GUIOutClassDir) $(GUIClassPath) $(GUIJAVACFlags) $<
+
+$(GUIOutClassDir):
+	mkdir -p $(GUIOutClassDir)
+
+run:
+	@$(JAVA) $(GUIClassPath):$(GUIJarFile) main.Main $(GUIRunArgs)
+
+guicleanjar:
+	-rm -f $(GUIJarFile)
+
+guicleanclass:
+	-rm -f $(addprefix $(GUIOutClassDir)/, $(GUIClassesSources:.java=.class))
+
+cleangui: guicleanjar guicleanclass

sum_up_stats.sh

+#!/bin/bash
+
+for test_ver in `ls test` 
+do
+	win_v1=0
+	win_v2=0
+	draw=0
+	rm "test/$test_ver/res.stats"
+	for file in `ls test/$test_ver/*.stats`
+	do
+		read -r line < $file
+		IFS=' ' read -r -a wins <<< "$line"
+		win_v1=$((win_v1 + wins[0]))
+		win_v2=$((win_v2 + wins[1]))
+		draw=$((draw + wins[2]))
+	done
+	echo "$win_v1 $win_v2 $draw" > "test/$test_ver/res.stats"
+done