Ajout de la doc sur les fonctions

doc/FonctionTest.markdown

+# Fonctions Test
+Fonctions qui servent pour tester le programme: ces fonctions sont appelées par le programme principal.
+
+## play()
+Jouer une partie joueur vs joueur, sert pour tester si les règles sont bien implementées dans le programme
+
+## playout()
+Jouer une partie joueur vs ordi: programme final. Comment ça marche ?
+
+- Créer une instance du jeu
+- Créer une instance du mcts pour ce jeu: `auto mctsPlayer = mcts::make_mcts_two_players(JEU, 5000, 0.3, 4); `
+  - 5000: temps de reflexion en ms pour chaque tour du jeu
+  - 0.3 Facteur d'exploration (?)
+  - 4 nombre de visites avant expansion: un noeud sera visité 4 fois avant que son expansion soit faite dans l'arbre
+- Tant que le jeu n'est pas fini, si c'est le tour de l'ordi
+  - Soit dire à l'ordi ce qu'on a choisi comme coup(?), soit lui faire un `mctsPlayer.reset()` qui efface tout l'arbre.
+  - Demander à l'ordi de choisir un coup `mctsPlayer.select_move();`
+  - Jouer ce coup
+- Quand le jeu est fini dire à l'humain qu'il a perdu (parce que le MCTS est trop fort)
\ No newline at end of file

doc/GameInterface.markdown

+# Game interface (game/game.hpp)
+Interface qui décrit un jeu, un jeu doit implémenter les fonctions décrites dans cette interface
+
+Comment implementer l'interface: squelette du fichier .h du jeu
+
+```C++
+namespace game
+{
+	struct JEU_state //structure qui décrit un état du jeu
+	{
+		[...]
+	}
+	
+	class JEU : public game<JEU_state>
+	{
+		public:
+			JEU();
+			JEU(const JEU& J) = default;
+			JEU& operator=(const JEU& J) = default;
+			bool end_of_game() const;
+			int value(std::uint8_t player) const;
+			bool won(std::uint8_t player) const;
+			bool lost(std::uint8_t player) const;
+			bool draw(std::uint8_t player) const;
+			uint8_t current_player() const;
+			std::uint16_t number_of_moves() const;
+			void play(std::uint16_t m);
+			void undo(std::uint16_t m) {}
+			std::string player_to_string(std::uint8_t player) const;
+			std::string move_to_string(std::uint16_t m) const;
+			std::string to_string() const;
+			void playout(std::mt19937& engine, int max_depth = -1);
+			std::set<int> to_input_vector() const;
+			void from_input_vector(const std::set<int>& input);
+			morpion_state get_state();
+			void set_state(const morpion_state& state);
+			std::shared_ptr<game<morpion_state>> do_copy() const;
+			std::uint64_t hash(std::uint16_t m) const;
+			std::uint64_t hash() const;
+		private:
+			[... Methodes utiles pour le jeu mais pas nécessaires pour le MCTS ...]
+
+	};
+	std::ostream& operator<<(std::ostream& os, const JEU& J);
+}
+```
+
+## Explication des différentes fonctions:
+
+### bool end_of_game()
+Est-ce que le jeu est terminé ? Soit parce que quelqu'un a gagné, soit parce que c'est égalité
+
+### int value (int player)
+Quelle est la valeur pour le joueur `player` dans l'état actuel du jeu ? Normalement 1 veut dire qu'il a gagné, -1 qu'il a perdu, 0 c'est égalité
+
+### bool won/lost/draw(int player)
+Est-ce que le joueur `player` a gagné/perdu/fait égalité ?
+
+### int current_player()
+C'est à quel joueur de jouer maintenant ? (Au début ce sera le joueur 0)
+
+### int number_of_moves()
+Nombre de coups que le joueur qui doit jouer maintenant peut jouer.
+
+### play(int move)
+Jouer le coup numéro `move` parmi les coups possibles: mets à jour l'état.  
+`move` represente la position du coup parmi tous les coups possibles, ce n'est pas la réprésentation du coup.
+
+### undo(int move)
+Pas implementé.
+
+### string player_to_string(int player)
+Representation d'un joueur de façon comprehensible par un humain
+
+### string move_to_string(int move)
+Representation d'un coup de façon comprehensible par un humain (par exemple B7).
+**Note:** est-ce que le coup doit être compris comme le coup numéro `move` dans la liste des coups possibles ou `move` est la representation que l'ordi a du coup ?
+
+### string to_string()
+Representation de l'état actuel du jeu (c'est à dire, dessiner l'état actuel du jeu)
+
+### playout(engine, max_depth)
+Joue le jeu en choisissant des coups au hasard jusqu'à la fin du jeu.
+
+### get/set_state()
+Retourne/charge l'état
+
+### Les autres
+Non utilisées
+
+## Fonction play(int move)
+Elle doit jouer le coup numéro `move` parmi les coups possibles. Algorithme:
+
+- Recuperer quel coup est le coup numéro `move` dans la liste des coups possibles
+- Mettre à jour le bon bitboard selon quel jouer doit jouer maintenant
+- Ajouter 1 au nombre de coups joués jusqu'à maintenant (si nécessaire)
+- Vérifier si un joueur a gagné et mettre à jour l'état
+- Mettre à jour la liste de tous les coups possibles
+
+## Fonction playout
+```C++
+void JEU::playout(mt19937& engine, int max_depth)
+	{
+		while (!end_of_game())
+		{
+			uniform_int_distribution<uint16_t> distribution(0, number_of_moves() -1);
+			uint16_t move = distribution(engine);
+			play(move);
+		}
+	}
+```
+
+Choisit un coup au hasard parmi les coups possibles et le joue.
+	
\ No newline at end of file