src/game/test_morpion.cpp

-#include "test_morpion.hpp"
-#include "mcts_two_players.hpp"
-#include "morpion.hpp"
-#include <iostream>
-#include <map>
-
-using namespace std;
-
-
-namespace game
-{
-	test_morpion::test_morpion()
-	{
-		cout << "=== Play tic tac toe ==="<<endl;
-		cout << "Do you want to play a Player vs (P)layer or a Player vs (C)omputer match? (enter P or C) "<<endl;
-		string choice;
-		cin >> choice;
-		if (choice == "P")
-			play();
-		else if (choice == "C")
-			playout();
-		else
-			cout << "Bad choice." << endl;
-	}
-	
-	/* Start a complete Player vs Player game */
-	void test_morpion::play()
-	{
-		morpion mor;
-		cout << "Player vs Player game!" << endl;
-		while(!mor.end_of_game())
-		{
-			cout << mor << endl;
-			cout << "It's " << mor.player_to_string(mor.current_player()) << " turn." << endl;
-			map<string, int> movesMap;
-			//cout << "Number of possible moves: " << mor.number_of_moves() << endl;
-			cout << "Possible moves:";
-			uint64_t possible_moves = mor.get_state().possible_moves;
-			for(int i = 0; i < mor.number_of_moves(); i++)
-			{
-				uint16_t move = possible_moves & ((uint64_t) 15); //15 = 1111 (a move is on 4 bits)
-				//cout << "Possible move: " << mor.move_to_string(move) << endl;
-				cout << " " << mor.move_to_string(move);
-				movesMap[mor.move_to_string(move)] = i; //In the map: the move as seen by the player and its representation for the computer
-				possible_moves = possible_moves >> 4;
-			}
-			cout << endl << "Choose your move: ";
-			string move;
-			cin >> move;
-			mor.play(movesMap[move]);
-		}
-		//Game ended: print the final state of the board
-		cout << mor << endl;
-		if (mor.won(0))
-			cout << mor.player_to_string(0) << " has won" << endl;
-		else if (mor.won(1))
-			cout << mor.player_to_string(1) << " has won" << endl;
-		else
-			cout << "Draw! too bad :(" << endl;
-		
-	}
-	
-	/* Start a complete Player vs Computer game */
-	void test_morpion::playout()
-	{
-		morpion mor;
-		auto mctsPlayer = mcts::make_mcts_two_players(mor, 1000, 0.3, 4); // creation du player a partir du morpion. 1000: ms de reflexion 0.3 fateur d'exploration 4: nb_visit_before_expansion on attend d'etre arrive 4 fois sur un noeud avant de le developper
-		cout << "Player vs Computer game!" << endl;
-		cout << "Who's first? (P)layer or (C)omputer?" << endl;
-		string choice;
-		cin >> choice;
-		int IAPlayer = 1; //Default: the computer will play second
-		if (choice == "C") //If however we choosed to let the computer play first
-			IAPlayer = 0;
-		while(!mor.end_of_game())
-		{
-			cout << mor << endl;
-			if(mor.current_player() == IAPlayer) //It's computer's turn
-			{
-				mctsPlayer.reset(); //Delete the entire tree: it will construct a new one starting from this state
-				uint16_t move = mctsPlayer.select_move();
-				//cout << "Computer played move number " << move << endl;
-				mor.play(move);
-			}
-			else //Human turn to play
-			{
-				cout << "It's your time to shine!" << endl;
-				map<string, int> movesMap;
-				//cout << "Number of possible moves: " << mor.number_of_moves() << endl;
-				cout << "Possible moves:";
-				uint64_t possible_moves = mor.get_state().possible_moves;
-				for(int i = 0; i < mor.number_of_moves(); i++)
-				{
-					uint16_t move = possible_moves & ((uint64_t) 15); //15 = 1111 (a move is on 4 bits)
-					//cout << "Possible move: " << mor.move_to_string(move) << endl;
-					cout << " " << mor.move_to_string(move);
-					movesMap[mor.move_to_string(move)] = i; //In the map: the move as seen by the player and 
-					possible_moves = possible_moves >> 4;
-				}
-				cout << endl << "Choose your move: ";
-				string move;
-				cin >> move;
-				mor.play(movesMap[move]);
-			}
-		}
-		//Game ended: print the final state of the board
-		cout << mor << endl;
-		if (mor.won(0))
-			cout << mor.player_to_string(0) << " has won" << endl;
-		else if (mor.won(1))
-			cout << mor.player_to_string(1) << " has won" << endl;
-		else
-			cout << "Draw! too bad :(" << endl;
-	}
-
-}

src/game/test_morpion.hpp

-#ifndef __TEST_MORPION_HPP__
-#define __TEST_MORPION_HPP__
-
-namespace game
-{
-	class test_morpion
-	{
-		void playout();
-		void play();
-		public:
-			test_morpion();
-	};
-}
-#endif

src/main/main.cpp

-//#include "test_connect4.hpp"
-#include "test_morpion.hpp"
-#include "test_monte_carlo.hpp"
-#include "test_fast_log.hpp"
-#include "test_allocator.hpp"
-#include "test_mcts_two_players.hpp"
-#include "test_minmax.hpp"
-#include "test_bits.hpp"
-#include "learning.hpp"
-
-#include <omp.h>
-
-using namespace std;
-
-int main(int argc, char *argv[])
-{
-	// game::test_connect4();
-	game::test_morpion();
-	// util::test_fast_log(100000000);
-	// mcts::test_allocator(10, 2);
-	// omp_set_num_threads(8);
-	//mcts::test_mcts_two_players();
-	// minmax::test_minmax();
-	//util::test_bits(200000000);
-	//game::connect4 c4;
-	//  util::learning::display_file(c4, "learning_examples.txt");
-	return 0;
-}

src/mcts/allocator.hpp~

-#ifndef __ALLOCATOR_HPP__
-#define __ALLOCATOR_HPP__
-
-#include "node.hpp"
-
-namespace mcts
-{
-  class allocator
-  {
-    node* node_arena;
-    node* limit;
-    node* free_pointer;
-
-    node* allocate_unsafe(unsigned int size);
-    void copy(node* n1, node* n2, unsigned int prunning = 0);
-
-  public:
-    allocator(unsigned int size = 1000000U);
-    ~allocator();
-    node* allocate(unsigned int size);
-    void clear();
-    node* move(node* root, unsigned int prunning = 0);
-    unsigned int size() const;
-    unsigned int free_space() const;
-  };
-}
-
-#endif

src/mcts/test_mcts_two_players.hpp

-#ifndef __TEST_MCTS_TWO_PLAYERS_HPP__
-#define __TEST_MCTS_TWO_PLAYERS_HPP__
-
-#include "openings.hpp"
-
-namespace mcts
-{
-  class test_mcts_two_players
-  {
-    openings openings_;
-
-    void play();
-    void self_play();
-    void self_play(int n, bool with_openings = false);
-    void self_play_learn_openings(int n);
-    void test_openings(int nb_learning, int nb_testing); 
-    
-    template <typename Game>
-    int select_move(Game& game);
-  public:
-    test_mcts_two_players();    
-  };
-}
-
-#endif

src/minmax/connect4_heuristic.cpp

-#include "connect4_heuristic.hpp"
-
-namespace minmax
-{
-  double connect4_heuristic::value(const connect4& c4) const
-  {
-    const connect4_state& state = c4.get_state();
-    return 0;
-  }
-
-}

src/minmax/connect4_heuristic.hpp

-#ifndef __CONNECT4_HEURISTIC_HPP__
-#define __CONNECT4_HEURISTIC_HPP__
-
-#include <connect4.hpp>
-
-namespace minmax
-{
-  class connect4_heuristic : public heuristic<connect4>
-  {
-    double value(const connect4& c4) const;
-  };
-}
-
-#endif

src/minmax/heuristic.hpp

-#ifndef __HEURISTIC_HPP__
-#define __HEURISTIC_HPP__
-
-namespace minmax
-{
-  template <typename Game>
-  class heuristic
-  {
-  public:
-    virtual double value(const Game& game) const = 0;
-  };
-
-  template <typename Game>
-  class null_heuristic : public heuristic<Game>
-  {
-    double value(const Game& game) const;
-  };
-
-  template <typename Game>
-  double null_heuristic<Game>::value(const Game& game) const
-  {
-    return 0;
-  }
-}
-
-#endif

src/minmax/minmax.hpp

-#ifndef __MINMAX_HPP__
-#define __MINMAX_HPP__
-
-#include <chrono>
-#include <vector>
-#include "game.hpp"
-#include "heuristic.hpp"
-#include <iostream>
-#include <limits>
-
-namespace minmax
-{
-  struct cannot_prove : std::exception
-  {
-    const char* what() const noexcept { return "cannot prove the game theoritical value"; }
-  };
-
-  template <typename Game>
-  class minmax
-  {
-  protected:
-    Game& game;
-    std::chrono::milliseconds milliseconds;
-    const heuristic<Game>& h;
-    std::vector<uint16_t> principal_variation;
-    std::chrono::steady_clock::time_point start;
-
-  public:
-    minmax(Game& game, uint32_t milliseconds, const heuristic<Game>& h = null_heuristic<Game>())
-      : game(game), milliseconds(milliseconds), h(h)
-    {
-    }
-
-    int prove();
-    double solve();
-    uint16_t select_move();
-
-  private:
-    long prove(int depth);
-    double solve(int depth);
-  };
-
-  template <typename Game>
-  minmax<Game> make_minmax(Game& game, uint32_t milliseconds, const heuristic<Game>& h = null_heuristic<Game>())
-  {
-    return minmax<Game>(game, milliseconds, h);
-  }
-    
-  template <typename Game>
-  double minmax<Game>::solve()
-  {
-    return 0;
-  }
-
-  template <typename Game>
-  double minmax<Game>::solve(int depth)
-  {
-    return 0;
-  }
-
-  template <typename Game>
-  uint16_t minmax<Game>::select_move()
-  {
-    return 0;
-  }
-
-  const long UNKNOWN = std::numeric_limits<long>::max();
-  
-  template <typename Game>
-  int minmax<Game>::prove()
-  {
-    start = std::chrono::steady_clock::now();
-    uint16_t nb_moves = game.number_of_moves();
-    long value[nb_moves];
-    std::fill_n(value, nb_moves, UNKNOWN);
-    int depth = 3;
-    auto state = game.get_state();
-    try
-      {
-	int nb_proved_moves = 0, nb_draws = 0;
-	while (true) 
-	  {
-	    for (uint16_t move = 0; move < nb_moves; ++move) 
-	      {
-		if (value[move] != UNKNOWN) continue;
-		game.play(move);
-		value[move] = prove(depth);
-		game.set_state(state);
-		if (value[move] == -1) return 1;
-		if (value[move] == 0) ++nb_draws;
-		if (value[move] != UNKNOWN) ++nb_proved_moves;
-	      }
-	    if (nb_proved_moves == nb_moves)
-	      {
-		if (nb_draws != 0) return 0;
-		return -1;
-	      }
-	    ++depth;
-	  }
-      }
-    catch (cannot_prove fail)
-      {
-	game.set_state(state);
-      }
-    throw cannot_prove();
-  }
-  
-  template <typename Game>
-  long minmax<Game>::prove(int depth)
-  {
-    if (game.end_of_game()) return game.value(game.current_player());
-    if (depth == 0) return UNKNOWN;
-    if ((depth & 3) && std::chrono::steady_clock::now() >= start + milliseconds) throw cannot_prove();
-    uint16_t nb_moves = game.number_of_moves();
-    auto state = game.get_state();
-    int nb_proved_moves = 0, nb_draws = 0;
-    for (uint16_t move = 0; move < nb_moves; ++move)
-      {
-	game.play(move);
-	long v = prove(depth - 1);
-	game.set_state(state);
-	if (v == -1) return 1;
-	if (v == 0) ++nb_draws;
-	if (v != UNKNOWN) ++nb_proved_moves;
-      }
-    if (nb_proved_moves == nb_moves)
-      {
-	if (nb_draws != 0) return 0;
-	return -1;
-      }
-    return UNKNOWN;
-  }
-}
-
-#endif

src/minmax/test_minmax.cpp

-#include "minmax.hpp"
-#include "test_minmax.hpp"
-#include "connect4.hpp"
-#include <iostream>
-#include <iomanip>
-#include <map>
-
-using namespace std;
-using namespace game;
-
-namespace minmax
-{
-  test_minmax::test_minmax()
-  {    
-    play();
-  }
-
-  template <typename Game>
-  int test_minmax::select_move(Game& game)
-  {
-    cout << game.player_to_string(game.current_player()) << " move: ";
-    map<string, int> m;
-    for (int i = 0; i < game.number_of_moves(); ++i) 
-      {
-	m[game.move_to_string(i)] = i;
-      }
-    string move;
-    getline(cin, move);
-    game.play(m[move]);
-    return m[move];
-  }
-
-  void test_minmax::play()
-  {
-    connect4 c4;
-    auto minimax = make_minmax(c4, 2000);
-    cout << "play one game" << endl;
-    cout << c4 << endl;
-    while (!c4.end_of_game())
-      {
-	cout << "try to prove? (y/n)" << endl;
-	string ans;
-	getline(cin, ans);
-	if (ans == "y")
-	  {
-	    try
-	      {
-		int v = minimax.prove();
-		if (v == 1) cout << "won position" << endl;
-		if (v == -1) cout << "lost position" << endl;
-		if (v == 0) cout << "drawn position" << endl;
-	      }
-	    catch (exception fail)
-	      {
-		cout << "unable to prove" << endl;
-	      }
-	  }
-	select_move(c4);
-	cout << c4 << endl;
-      }
-    if (c4.value(0) == 1) cout << c4.player_to_string(0) << " won";
-    else if (c4.value(1) == 1) cout << c4.player_to_string(1) << " won";
-    else cout << "draw";
-    cout << endl;
-  }
-
-}

src/minmax/test_minmax.hpp

-#ifndef __TEST_MINMAX_HPP__
-#define __TEST_MINMAX_HPP__
-
-namespace minmax
-{
-  class test_minmax
-  {
-    void play();
-    template <typename Game>
-    int select_move(Game& game);
-  public:
-    test_minmax();
-  };
-}
-
-#endif