AI/tools/board2Bitboard.py

+#!/usr/bin/env python3
+#-*- encoding: utf-8 -*-
+
+def board2Bitboard(board):
+	"""
+	Convert a real board to its bitboard representation.
+	
+	:param board: a sequence of 1, 2 and 3 that tells how many fish are in every tile. A character that isn't 1, 2 or 3 is considered water. Newlines, pipes and spaces are ignored.
+	:type board: str
+	"""
+	board = board.replace("\n", "")
+	board = board.replace("|", "")
+	board = board.replace(" ", "")
+	print(board)
+	
+	if len(board) != 60:
+		print("Warning: board is not 60 char long!")
+	ones = 0
+	twos = 0
+	threes = 0
+	for c in board:
+		if c == '1':
+			ones |= 1
+		elif c == '2':
+			twos |= 1
+		elif c == '3':
+			threes |= 1
+		ones = ones << 1
+		twos = twos << 1
+		threes = threes << 1
+	ones = ones >> 1
+	twos = twos >> 1
+	threes = threes >> 1
+	return (ones, twos, threes)
+	
+if __name__ == "__main__":
+	try:
+		while True:
+			board = input("Enter board: ")
+			ones, twos, threes = board2Bitboard(board)
+			print("one_fish: {}\ntwo_fish: {}\nthree_fish: {}".format(ones, twos, threes))
+	except KeyboardInterrupt:
+		print("\nMay the fish be with you.")

tools/drawState.py → AI/tools/drawState.py

@@ -30,9 +30,10 @@ def drawPenguin(penguin):
 		"D" : str((penguin >> 21) & 7), 
 		"E" : str((penguin >> 24) & 7), 
 		"F" : str((penguin >> 27) & 7), 
-		"tot" : str((penguin >> 6) & 63).rjust(2)
+		"tot" : str((penguin >> 6) & 63).rjust(2),
+		"tot-1": str(max(((penguin >> 6) & 63)-1, 0)).rjust(2)
 	}
-	print("Pos: {pos}, A:{A}, B:{B}, C:{C}, D:{D}, E:{E}, F:{F}, Tot: {tot}".format(**args))
+	print("Pos: {pos}, A:{A}, B:{B}, C:{C}, D:{D}, E:{E}, F:{F}, Tot: {tot} [0..{tot-1}]".format(**args))
 
 if __name__ == "__main__":
 	try:

Doc/fr/Doc_technique/Doc_technique.tex

+\documentclass[a4paper]{article}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% PACKAGES
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage[french]{babel}
+\usepackage{graphicx}
+\usepackage[hidelinks]{hyperref}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\title{\textbf{Jeu du Pingouin: documentation technique}}
+\author{Francesco Bariatti \and Adrien Gasté \and Mikaël Le \and Romain Lebouc \\ Encadrant: Pascal Garcia}
+\date{2015-2016}
+
+\begin{document}
+\pagenumbering{gobble}
+\maketitle
+\tableofcontents
+
+\newpage
+\pagenumbering{arabic}
+
+\section{Introduction}
+Ce document est la documentation technique du projet d'études pratiques ``Jeu du Pingouin'' réalisé dans le cadre de la 3\ieme année de formation à l'\textsc{insa} de Rennes.
+
+Le projet est composé de deux parties: une intelligence artificielle codée en C++ et une interface graphique codée en JavaFX. Dans ce document, les abréviations IA ou MCTS (pour Monte Carlo Tree Search, le nom de l'algorithme de recherche utilisé) vont être souvent utilisées pour évoquer l'intelligence artificielle.
+
+Dans la section dédiée à l'IA, nous allons voir comment implémenter un jeu pour qu'il puisse utiliser le MCTS pour jouer contre un humain. Ensuite, nous présenterons comment le Jeu du Pingouin est implémenté.
+
+\subsection*{Auteurs et license}
+La partie MCTS a été codée par Pascal \textsc{Garcia}, notre encadrant. Notre groupe a codé la partie Jeu du Pinguin (\verb|penguin.cpp penguin.hpp|) et la partie Interface Graphique (dossier \verb|GUI|).
+
+Toutes les parties sont sous licence MIT, avec attribution aux auteur respectifs.
+
+Dans l'interface graphique, une bibliothèque JSON pour Java est utilisée: org.json. La librairie est accessible à l'adresse \url{http://mvnrepository.com/artifact/org.json/json}: \verb|Copyright (c) 2002 JSON.org|
+le copyright complet est présent dans le fichier \verb|GUI/main/Main.java|
+
+\newpage
+\section{Implémentation d'un jeu}
+\subsection{Implémentation d'un nouveau jeu: l'interface game}
+Tous les fichiers évoqués dans cette section se situent dans le dossier \verb|AI/src|.
+
+\paragraph*{}Un jeu jouable par le MCTS n'est rien d'autre qu'une classe qui implémente l'interface \verb|game|, définie dans \verb|game/game.hpp|.
+Une fois la nouvelle classe codée, il suffit de changer une ligne dans le fichier \verb|main/main.cpp| pour lancer le jeu. Deux façons sont possibles pour lancer le jeu:
+\begin{itemize}
+ \item \verb|game::run_test_two_players_game(game::MaClasse());| pour lancer un test à deux joueur: le MCTS ne va pas se lancer.
+ \item \verb|mcts::run_test_mcts_two_players(game::MaClasse());| pour lancer une partie contre le MCTS.
+\end{itemize}
+
+\paragraph*{} Dans l'interface, un joueur est représenté par un nombre sur 8bits (le premier joueur est le joueur 0, le deuxième le joueur 1). Chaque fin de partie
+a une valeur qui est utilisée dans la construction de l'arbre de décision (classiquement 1 si le MCTS gagne, -1 s'il perd).
+
+\paragraph*{} Pour implémenter l'interface, il faut implémenter toutes ses fonctions. Elles ne sont pas toutes indispensables ou dépendantes du nouveau jeu, c'est pourquoi
+une partie d'entre elles pourront être directement copiées du fichier \verb|penguin.cpp|.
+Les explications des fonctions indispensables sont listées ci-dessous:
+
+\paragraph*{}
+\begin{itemize}
+	\item \verb|bool end_of_game()| Indique si le jeu est terminé. Indépendamment de son résultat.
+	\item \verb|int value (uint8 player)| La valeur pour le joueur \verb|player| dans l'état actuel du jeu.
+	\item \verb|bool won/lost/draw(uint8 player)| Si le joueur \verb|player| a gagné/perdu/fait égalité.
+	\item \verb|uint8 current_player()| Le joueur dont c'est le tour.
+	\item \verb|uint16 number_of_moves()| Le nombre total de coups que le joueur actuel peut jouer.
+	\item \verb|play(uint16 move)| Joue le coup numéro \verb|move| pour le joueur actuel.
+	\item \verb|string player_to_string(uint8 player)| Représentation d'un joueur de façon compréhensible pour un humain.
+	\item \verb|string move_to_string(uint16 m)| Représentation d'un coup jouable de façon compréhensible pour un humain.
+	\item \verb|string to_string()| Représentation de l'état actuel du jeu de façon compréhensible pour un humain.
+\end{itemize}
+La fonction \verb|move_to_string| est importante car c'est la représentation que l'humain devra utiliser pour spécifier le coup qu'il veut jouer.
+
+\paragraph*{} Il ne faut pas oublier d'ajouter les nouveaux fichiers dans le makefile!
+
+\subsection{Notre implémentation: le Jeu du Pingouin}
+Pour plus d'informations sur les structures et méthodes utilisées pour modéliser le Jeu du Pingouin, regarder le rapport du projet, qui se trouve dans le dossier \verb|Doc/fr/Rapport|.
+
+\paragraph*{} Le fichier \verb|penguin.hpp| définit la structure \verb|penguin_state|, qui décrit un état du jeu. Cette structure définit les bitboards des poissons,
+les bitboards des pingouins des 2 joueurs, les scores, le joueur courant et le nombre de coups de chaque joueur.
+
+Les fichiers \verb|penguin.hpp| et \verb|penguin.cpp| définissent la classe \verb|penguin|, implémentant l'interface \verb|game|, qui décrit un jeu.
+En plus des méthodes de l'interface, cette classe implémente les méthodes suivantes:
+\begin{itemize}
+	\item \verb|penguin_state get_state()| Retourne l'état du jeu
+	\item \verb|void move_penguin(uint32_t* p, uint16_t rel_move)| Déplace le pingouin \verb|p| lui faisant faire son coup numéro \verb|rel_move|. À la fin de la fonction, le pingouin n'est plus composé que de sa nouvelle position (tous les autres bits sont à 0).
+	\item \verb|uint64_t create_obstacles_bitboard()| Crée le bitboard des obstacles : pour chaque case, le bit correspondant est à 1 s'il y a un obstacle, 0 sinon.
+	\item \verb|int update_penguin_moves(uint32_t* p, uint64_t obstacles)| Met à jour tous les coups du pingouin \verb|p| en fonction de sa position et du bitboard des obstacles. Retourne le nombre total de coups du pingouin.
+\end{itemize}
+
+Par ailleurs, le constructeur de la classe \verb|penguin| gère le chargement d'un état via l'entrée standard du programme.
+
+\newpage
+\section{L'interface graphique}
+Tous les fichiers évoqués dans cette section se situent dans le dossier \verb|GUI/src|. L'interface graphique est développée en Java 1.8 (elle utilise notamment des lambda-expressions) et JavaFX.
+
+L'interface graphique est codée suivant un modèle MVC (Modèle - Vue - Contrôleur).
+
+\paragraph{Le modèle:} il sert à stocker toutes les données du jeu. Les classes sont utilisées comme conteneurs pour stocker les valeurs nécessaires au jeu.
+
+La classe principale est la classe \verb|GameState| qui contient la plupart des informations relatives au jeu. Les valeurs sont stockés en forme de bitboards et utilise des opérations
+binaires sont utilisées pour les extraire quand nécessaire.
+
+Une méthode permet de mettre à jour un object \verb|GameState| à partir du JSON renvoyé par le MCTS.
+
+\paragraph{La vue:} Le visuel de l'application est décrit dans le fichier \verb|view.fxml|, les différentes cases sont définies avec un positionnement absolu et
+ont un id qui vont de \verb|tile0| à \verb|tile59|. Les autres éléments sont aussi positionnés de façon absolue.
+
+Cette façon de faire n'est pas celle préconisée (elle n'est pas "propre", nous nous en excusons). L'interface graphique n'étant pas l'objectif initial du projet, nous y avons alloué moins de temps.
+
+\paragraph{Le contrôleur:} il s'occupe de faire le lien entre le modèle, la vue et le programme en C++. Pour ce faire, à l'initialisation, l'IA sera exécutée comme sous-processus. Un \verb|UpdateThread| s'occupera de modifier le modèle à chaque fois que le sous-processus va écrire quelque chose dans sa sortie standard, et ensuite notifier la vue
+de se mettre à jour aussi.
+
+La classe \verb|Controller| est la classe ``principale'' du programme: elle s'occupe de créer le plateau, lancer la partie, écouter les clics du joueur au travers du \verb|EventHandler|, et de gérer la fin de partie (à la demande de l'\verb|UpdateThread|).
+
+Lorsque l'interface graphique est fermée (peu importe le moment) le sous-processus est tué. Ceci se fait grâce à la fonction Java:
+\begin{verbatim}
+	Runtime.getRuntime().addShutdownHook(new Thread()
+	{
+	    public void run()
+	    {
+	        gameProcess.destroy();
+	    }
+	});
+\end{verbatim}
+
+
+\end{document}

Doc/fr/Doc_utilisateur/Doc_utilisateur.tex

+\documentclass[a4paper]{article}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% PACKAGES
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage[french]{babel}
+\usepackage{graphicx} %images
+\usepackage[hidelinks]{hyperref}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\title{\textbf{Jeu du Pingouin: documentation utilisateur}}
+\author{Francesco Bariatti \and Adrien Gasté \and Mikaël Le \and Romain Lebouc \\ Encadrant: Pascal Garcia}
+\date{2015-2016}
+
+\begin{document}
+\pagenumbering{gobble}
+\maketitle
+
+\tableofcontents
+
+\newpage
+\pagenumbering{arabic}
+\section{Introduction}
+Le Jeu du Pingouin est un projet étudiant INSA de département Informatique, dans le cadres des études pratiques de 3\ieme année. Il est principalement composé de deux parties majeures : l'intelligence artificielle (en \emph{C++}) et l'interface graphique (en \emph{JavaFX}).
+
+	\subsection{Règles du jeu}
+	
+	\subsubsection{Matériel}
+	Le plateau de jeu est composé d'une grille de 60 tuiles hexagonales, représentant la banquise. Chaque tuile comporte un nombre de
+	poissons compris entre 1 et 3. À 2 joueurs, chaque joueur possède 4 jetons de pingouins.
+	
+	\subsubsection{Mise en place}
+	On crée le plateau de départ en répartissant les tuiles aléatoirement. Chaque joueur place ensuite ses pingouins tour à tour sur
+	les cases "1 Poisson". Dans notre implémentation, le joueur choisit l'emplacement de ses 4 pingouins, puis de ceux de l'ordinateur.
+	
+	\subsubsection{Objectif}
+	Avoir mangé plus de poissons que son adversaire.
+	
+	\subsubsection{Actions}
+	Les joueurs jouent chacun leur tour. Pendant son tour, un joueur doit choisir un de ses pingouins, et le déplacer sur une des cases qui lui sont accessibles.
+	Un pingouin peut se déplacer dans n'importe laquelle des 6 directions possibles, tant qu'il ne rencontre pas d'obstacles.
+	Un obstacle peut être un autre pingouin ou une case vide.
+
+	Quand le coup est joué, le joueur retire la case depuis laquelle le pingouin est parti, et gagne un nombre de points égal au nombre de poissons sur cette case.
+	La case devient alors une case vide, et le tour se termine.
+	
+	\subsubsection{À noter}
+	Dans les règles officielles, à la fin de la partie, chaque joueur gagne le nombre de points des tuiles finales sur lesquelles sont leurs pingouins.
+	Pour des raisons d'implémentation, on ignorera cette règle.
+
+\newpage
+\section{Installation}
+Le projet est disponible sous Gitlab à l'adresse \url{https://gitlab.insa-rennes.fr/francesco-bariatti/pingouins.git}; Sous Linux, il suffit de télécharger les sources et de les compiler.
+
+	\subsection{Dépendances}
+	
+	\paragraph{IA} Une version de g++ 4.9 minimum est nécessaire.
+	
+	\paragraph{GUI} L'interface graphique utilisant JavaFX, une version de Java supérieure (ou égale) à 1.8 est nécessaire. Par ailleurs, si le jeu est lancé à partir d'un IDE, le niveau de langage doit être de 8 minimum (utilisation des \emph{lambdas}) et le jar JSON doit être dans le java build path.
+	
+	\subsection{Compilation et lancement}
+	Modifier le fichier \verb|AI/src/mcts/MCTS_SETTINGS.hpp| pour changer la quantité de mémoire allouée et le temps de réflexion de l'IA.
+	Il faudra sûrement ajouter de la mémoire pour que le jeu puisse s’exécuter jusqu'à la fin: si la mémoire n'est pas suffisante un message d'erreur disant ``That's it! I ragequit!'' s'affiche et le jeu s'arrête. L'idéal est de tester en lançant une partie jusqu'au moment de réflexion du pc et lancer une commande \verb|free -h| pour visualiser la quantité de mémoire utilisée.
+	En général 1 ou 2 Go suffisent.
+
+	Pour compiler, exécuter la commande \verb|make|.
+	En cas d'erreur avec la version du compilateur g++ ou java, changer la valeur des variables en début du \verb|Makefile|.
+
+	Pour lancer le jeu, exécuter la commande \verb|make run|.
+	Attention au volume du son au lancement !
+	
+\section{Utilisation}
+Au démarrage du programme une boite de dialogue propose de charger un état (formaté en JSON). Si l'état est invalide, ou laissé vide, le plateau de départ est généré aléatoirement.
+Le joueur peut alors placer successivement les 4 pingouins rouges, puis les 4 pingouins bleus en cliquant sur les cases.
+Le joueur choisit ensuite sa couleur, et le jeu démarre par le tour des rouges.
+
+À chaque tour, le joueur peut choisir un pingouin en cliquant dessus et le déplacer sur une des cases mises en relief. Il faut alors attendre que l'IA joue avant de continuer.
+
+À chaque coup joué, l'état apparaît dans la console. Il est possible de copier n'importe lequel de ces états et de le recharger en démarrant une partie.
+
+\section{Contact}
+Si vous trouvez des bugs, n'hésitez pas à ouvrir des issues sur Gitlab (\url{https://gitlab.insa-rennes.fr/francesco-bariatti/pingouins.git})
+	
+\end{document}

Doc/fr/Rapport/Rapport.tex

+\documentclass[a4paper,11pt]{article}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%    PACKAGES
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\usepackage{exptech} %style demandé pour l'exposé
+\usepackage[hidelinks]{hyperref}
+\usepackage{float}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
+
+
+
+\title{ \textbf{Étude Pratique : Développement d'une Intelligence Artificielle
+à base de l'algorithme Monte Carlo Tree Search} }
+
+\markright{Intelligence Artificielle - Monte Carlo Tree Search}
+
+\author{Francesco \textsc{Bariatti} \and Adrien \textsc{Gasté} \and Mikael \textsc{Le} \and Romain \textsc{Lebouc}
+        \\
+        Encadrant : Pascal \textsc{Garcia}}
+
+\date{Année scolaire 2015/16}
+
+
+\begin{document}
+
+\maketitle
+\thispagestyle{empty}
+
+\begin{abstract}
+Ce document est un compte-rendu du projet d'études pratiques réalisé dans le cadre de la 3\ieme année de formation à l'\textsc{insa} de Rennes.
+
+Ce projet consiste à programmer une Intelligence Artificielle (IA) pour jouer à un jeu de plateau (le Jeu du Pingouin), et une interface graphique pour interagir avec le jeu. Le projet s'étale sur toute la durée d'une année scolaire.
+\end{abstract}
+
+
+\section{Introduction}
+	\subsection{Le Jeu du Pingouin}
+Le Jeu du Pingouin est un jeu de plateau confrontant 2 à 4 joueurs sur un plateau de 60 cases hexagonales, sur lesquelles se trouvent de 1 à 3 poissons, comme présenté dans la figure \ref{fig:plateau}.
+
+Chaque joueur place 4 pingouins sur le plateau en début de partie. À chaque tour, il en déplace un dans l'une des 6 directions possibles, en récupérant la case sur laquelle le pingouin se trouvait. Il gagne alors autant de points qu'il y a de poissons dessus. 
+
+Les pingouins ne peuvent pas passer à travers des autres pingouins (y compris ceux du même joueur) et des trous crées par les déplacements des pions. Lorsqu'un joueur ne peut pas jouer, ceux
+pouvant encore jouer continuent. 
+
+Le jeu se termine lorsque aucun des pingouins ne peut se déplacer, et le joueur avec le plus de points remporte la partie. 
+
+\FigureEPS{H}{200px}{fig/Plateau_Pingouin}{Plateau du Jeu du Pingouin}{fig:plateau}
+
+	\subsection{L'algorithme Monte-Carlo Tree Search (MCTS)}
+Le \textit{Monte-Carlo Tree Search} est un algorithme de recherche de décision, utilisé dans les jeux tel que le Go ou encore Ms. Pacman.
+Son principe repose sur la simulation de plusieurs millions de parties qui permettent de construire progressivement un arbre et d'ensuite choisir le meilleur chemin pour le tour courant du joueur.
+
+Les implémentations peuvent avoir des différences (comme le score donné à une partie gagnante ou perdante, ou les valeurs stockées dans les noeuds), mais le principe de base est toujours le même est il est composé de 4 étapes qui sont répétées pour construire l'arbre du jeu:
+\begin{itemize}
+	\item \textbf{Sélection} : En considérant un arbre partiellement construit suite à plusieurs simulations, un chemin est alors choisi par un calcul se servant des valuations aux n½uds, permettant ainsi d'explorer les meilleurs chemins en priorité, jusqu'à une feuille. Ce principe repose sur le tirage aléatoire pondéré.
+	\item \textbf{Expansion} : À partir du n½ud considéré, ses enfants sont alors développés puis un est choisi au hasard pour la suite.
+	\item \textbf{Simulation} : Une simulation des prises de décision pour chacun des joueurs est alors faite aléatoirement depuis cet enfant jusqu'à la fin du jeu. Le résultat de cette simulation est alors observé.
+	\item \textbf{Rétropropagation} : À chaque n½ud est associé un score de 2 nombres : le premier est le nombre de parties gagnées par l'IA, le deuxième est le nombre total de parties jouées sur la branche courante.
+	Le score des n½uds se trouvant sur le chemin entre la racine et le fils choisi par l'expansion est alors mis à jour pour prendre en compte le résultat de la simulation.
+\end{itemize}
+
+\FigureEPS{H}{\linewidth}{fig/MCTS}{Étapes du MCTS}{fig:MCTS}
+
+L'un des avantages indéniables de l'algorithme est qu'il peut être interrompu à tout moment: le choix de la branche optimale sera fait à partir de l'arbre construit jusqu'à ce moment là. De plus, c'est un algorithme sans heuristique, c'est à dire qu'il n'a pas besoin de connaître au préalable les règles du jeu pour bien jouer.
+
+
+\section{Tâche à réaliser}
+La tâche à réaliser est de programmer le jeu du Pingouin en Langage C++ et y implémenter le MCTS comme IA. Le mode Joueur contre IA est imposé. Il faut également créer une interface utilisateur pour rendre le programme accessible à tous.
+	
+	\subsection{Implémentation du jeu}
+L'algorithme à implémenter dans le programme est le MCTS. L'algorithme a déjà été programmé par notre encadrant Pascal GARCIA en C++, mais il nécessite d'une représentation efficace du jeu pour pouvoir faire ses simulations. \\
+C'est donc à nous de faire cette représentation de sorte à qu'elle respecte l'interface définie par Pascal GARCIA et qu'elle comporte des calculs rapides pour passer d'une étape à l'autre du jeu.	
+	\subsection{Création d'une interface graphique}
+Pour permettre de rendre l'application facile à utiliser, une interface graphique doit être programmée; les interactions Homme-Machine se font à la souris. Il n'y a pas de restriction sur la méthode utilisée.
+Il va de soi que l'interface graphique doit pouvoir lancer le jeu et communiquer les coups du joueur à l'IA et inversement.
+
+\newpage
+\section{Réalisation}	
+A chaque séance, nous nous sommes généralement divisés en 2 équipes de 2 afin d'avancer plus rapidement le projet sur deux points différents. 
+Lorsque nous avions l'occasion, nous rencontrions notre encadrant afin qu'il donne son avis ainsi que des conseils pour des problèmes que nous n'arrivions pas à résoudre. 
+
+Le projet a été effectué à l'aide de \href{https://fr.wikipedia.org/wiki/Git}{\emph{Git}} pour faciliter l'accès aux différentes versions du code.
+
+	\subsection{Prise en main du MCTS avec le Tic-Tac-Toe}
+Afin de comprendre et tester le fonctionnement du MCTS, nous avons décidé, pendant le 1er semestre, de l'implémenter sur un jeu simple: le Tic-Tac-Toe.
+Cela nous a également permis d'apprendre à programmer en C++, langage qu'on ne connaissait pas, et dans lequel le MCTS est codé.
+
+Pascal GARCIA nous a conseillé de représenter la grille sous forme de \textit{bitboards\footnote{Une bitboard est juste un nombre entier classique, dans lequel chaque bit est interprété de façon particulière. Souvent chaque bit représente la présence, ou l'absence, d'un élément dans une case du plateau}} de 16 bits pour optimiser les calculs, l'un représentant les croix et l'autre les cercles.
+Les états gagnants étaient des \textit{bitboards}, définis dans le code comme des entiers. Lorsque l'un des \textit{bitboards} satisfaisait(selon certaines opérations bit à bit) un de ces états, la partie se terminait.
+
+	\subsection{Le Jeu du Pingouin}
+La deuxième étape du projet consiste à coder le Jeu du Pingouin de telle sorte que l'IA respecte les règles et comprenne la condition de victoire et que les calculs pour effectuer chaque coup soient rapides, pour que le MCTS puisse simuler énormement de parties dans le temps imparti.
+
+		\subsubsection{Choix de représentation}
+Chacun des pingouins a été modélisé par un \textit{bitboard} de 32 bits.
+Le plateau a été représenté à l'aide de 3 \textit{bitboards} de 64 bits (chacun représentant la présence de 1,2 ou 3 poissons sur les cases): la présence d'obstacles sur une case est calculée grâce à des opérations bit à bit(\textit{and, or, not})
+
+Il a fallu confronter le problème du déplacement des pions qui n'existait pas dans le Tic-Tac-Toe : en effet, il n'a pas été évident de relier le déplacement sur le plateau(en six directions possibles) avec la représentation du plateau en \textit{bitboard}. La solution retenue a été de numéroter les 60 cases du plateau et de faire correspondre le déplacement de chacune des 6 directions par un calcul arithmétique.
+
+De plus, la modélisation optimale des pingouins a été trouvée difficilement car il a fallu associer plusieurs types d'informations différentes à chacun des pingouins (par exemple, le nombre de déplacements possibles dans une direction).
+
+\FigureEPS{H}{\linewidth}{fig/Structure_Pingouin}{Découpage du \textit{bitboard} pour un pingouin}{fig:pingouin}
+
+Une solution envisagée a été de mettre chaque type d'informations dans un \textit{bitboard} en particulier, mais cela s'est révélé trop difficile à gérer. Nous avons alors opté pour stocker toutes les informations concernant un pingouin dans un \textit{bitboard} personnel.
+		
+		\subsubsection{Avantage de la représentation en bitboards}
+L'enjeu principal pour l'implémentation du jeu était la rapidité: plus un coup était rapide plus de parties le MCTS pourrait simuler pendant son tour. c'était donc nécessaire que pour avoir le contenu d'une case, ou la position d'un pingouin le calcul soit rapide. Il était donc hors de question de stocker les valeurs dans un tableau dans la mémoire, les \textit{bitboards} permettent d'utiliser la puissance des calculs bit à bit(exécutables en un cycle de processeur).
+
+La recherche d'information se fait avec des masques appliqués sur les variables: par exemple l'entier 63 (les 6 bits de poids faible à 1) appliqué sur un pingouin permet d'obtenir sa position.
+Le \textit{bitboard} des obstacles (un 1 dans les cases où il y a soit de l'eau, soit un pingouin) est calculé dynamiquement à chaque tour en combinant les trois \textit{bitboards} des poissons et les positions des pingouins, ce qui permet d'avoir une valeur en moins à stocker et mettre à jour.
+	
+
+
+		
+	\subsection{L'interface graphique}
+L'IA nécessite d'avoir le coups qu'on veut jouer exprimés comme numéro par rapport aux coups totaux disponibles pour un joueur: cette partie de conversion nécessaire était la raison principale pour le développement d'une interface graphique, vu que c'était un travail fastidieux et très difficile à faire à la main à chaque fois qu'on veut jouer un coup.
+
+Le choix du langage pour implémenter l'interface graphique est tombé vers un langage qu'on maîtrise mieux que le C++: le Java. elle est donc développée avec la bibliothèque \textit{javafx} qui permet d'avoir un modèle \textit{Modèle, Vue, Contrôleur} qui va faciliter la reprise dans le futur. \\
+L'interface devait être facile à l'utilisation et "jolie". On n'avait pas de bases ni d'indications particulières, on a donc commencé de zéro pour cette partie.
+
+\FigureEPS{H}{250px}{fig/Interface}{Interface graphique du Jeu du Pingouin}{fig:interface}
+
+\paragraph{Communication avec l'IA}Les deux programmes étant indépendant, il faut une façon pour que les données du jeu passent du programme en C++, qui gère le jeu et l'IA, à l'interface en Java. Pour ce faire on a décidé d'utiliser une représentation en \href{https://fr.wikipedia.org/wiki/JavaScript_Object_Notation}{JSON}, et de transmettre l'état entier du jeu après chaque coup.
+L'interface graphique fait le travail inverse de l'IA: elle convertit les différentes valeurs des \textit{bitboards} de l'état en tableaux et objets qui sont ensuite utilisés pour l'affichage.
+
+\paragraph{Difficultés}La principale difficulté dans le développement de l'interface graphique a été la mise en place du plateau et de l'architecture MVC: une période de recherche d'informations sur le javafx a été nécessaire. Une fois les bases mises en place l'implémentation des différentes fonctionnalités (comme le fait que les mouvements possibles apparaissent en une couleur différente) a été plus rapide.
+
+\newpage
+\section{Conclusion}
+Il y a eu quelques difficultés rencontrées au début du projet: me langage utilisé par Pascal GARCIA pour coder l'IA, à savoir le C++, nous était inconnu, et la complexité de transcrire les règles d'un jeu de plateau de tel sorte que le programme puisse les comprendre était importante. 
+Nous avons alors consacré notre 1er semestre à implémenter ce programme dans un jeu plus simple, le Tic-Tac-Toe, afin de se familiariser avec ces concepts. Cette décision nous a permis d'avoir un développement beaucoup plus rapide pour l'IA du jeu du pingouin, ce qui nous a laissé le temps nécessaire pour développer une interface graphique conventionnelle.
+
+Le produit obtenu satisfait entièrement le cahier des charges : le mode Joueur vs IA a été implémentée avec succès, ce dernier possédant le niveau d'un joueur expérimenté. Il serait intéressant de rajouter des fonctionnalités supplémentaires, tel que choisir le niveau de difficulté, voire même utiliser notre expérience acquise sur un autre jeu.
+	
+Nous remercions Pascal GARCIA, notre encadrant, pour sa disponibilité et ses conseils.
+
+\end{document}

Doc/fr/Rapport/exptech.sty

+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%     STYLE POUR LES EXPOSS TECHNIQUES 
+%         3e anne INSA de Rennes
+%
+%             NE PAS MODIFIER
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\usepackage[dvips]{graphicx}
+\usepackage[T1]{fontenc}
+\usepackage[latin1]{inputenc}
+\usepackage[french]{babel} 
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Dimensions du document :
+
+\setlength{\voffset} {-0.54cm}
+\setlength{\hoffset} {-0,04cm}
+\setlength{\textwidth} {14cm}
+\setlength{\textheight} {24cm}
+\setlength{\oddsidemargin} {1cm}
+\setlength{\evensidemargin} {1cm}
+\setlength{\marginparsep} {0cm}
+\setlength{\marginparwidth} {0cm}
+\setlength{\topmargin} {0cm}
+\setlength{\headheight} {0,45cm}
+\setlength{\headsep} {0,57cm}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Commande simplifiant l'inclusion de figures :
+
+%------------------------------------------------------------------------------
+%       \FigureEPS{h,t,b,p}{largeur}{nom_fichier}{titre}{nom_symbolique} 
+%------------------------------------------------------------------------------
+
+\newcommand{\FigureEPS}[5] {
+  \begin{figure}[#1] 
+    $$ %pour centrer
+    \includegraphics[width=#2]{#3}
+    $$
+    \caption{#4}
+    \label{#5}   
+  \end{figure}
+  }
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Style du document :
+
+\pagestyle{myheadings}
+\bibliographystyle{plain-fr}
+
+\setcounter{tocdepth}{3}   % Niveau jusqu'o numroter les titres (table des mat)
+\setcounter{secnumdepth}{3}% Niveau jusqu'o numroter les titres (dans texte)
+
+\sloppy % Baisse le taux des csures
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%