Le but de notre projet était de concevoir un algorithme de recherche performant sur un jeu d' \textit{Othello}. Le jeu est le plus abstrait possible, la partie nous intéressant étant la réalisation d'un algorithme de recherche efficace. Il est ainsi impossible de jouer au jeu, on ne peut que regarder le résultat d'une partie entre deux joueurs artificiels.\\
Une fois le jeu et l'algorithme de recherche implémentés, nous serons en mesure d'analyser ce dernier pour définir ses paramètres de fonctionnement optimaux. Nous aborderons dans un premier temps l'implémentation du jeu, puis celle de l'algorithme et enfin la présentation et l'analyse des mesures observées.
Notre code se compose de plusieurs classes dont nous allons détailler les rôles ci-dessous.
\begin{itemize}
\item La classe STATE: \\ Cette classe représente un état du jeu à un moment donné avec différents paramètres comme le nombre de pions de chaque joueur et leur position sur un plateau de jeu. Elle possède plusieurs méthodes lui permettant de créer une copie d'elle-même, de s'afficher, de trouver les coups possibles pour un joueur ou encore de jouer un coup.
\item La classe PAIR: \\ Cette classe nous a permis de représenter les coups possibles par une paire pion de départ, pion d'arrivée.
\item Les classes PLAYER: \\ Elles permettent de simuler un joueur, il en existe 4, la classe mère PLAYER et les classes filles NEGAMAXPLAYER, RANDOMPLAYER et ALPHABETAPLAYER. La classe RANDOMPLAYER renvoie un coup au hasard parmi les coups possibles. Pour le fonctionnement des deux autres classes, il est détaillé dans les pages qui suivent.
\item La classe POINT: \\ Elle nous permet simplement de représenter un point du plateau de jeu avec une coordonnée X et une coordonnée Y.
Tous les tests incluant un temps ont été fait sur la même machine et en même temps : Raspberry pi 3 avec un processeur Quad Core 1.2GHz 64bit sous Raspbian OS 32 bits sans Bureau.
Le joueur 1 obtient assez vite (tour 5) un avantage (il possède plus de possibilités) qui augmente au fur et à mesure des tours. À son maximum (fin de la partie) cet avantage est 69\% plus important par rapport au second joueur.\\
Malgré qu’il soit second à jouer, joueur 2 obtient un avantage au niveau du tour 10 environ. Cet avantage augmente jusqu’au tour 30, avec un pic à 30\% par rapport au joueur 1, mais reste marginal. Il se réduit ensuite jusqu’à la fin de la partie.\\
Le nombre de tours est largement inférieur par rapport au précédent graphique. La complexité du joueur 1 est deux fois moins importante que sur le graphique précédent, malgré la profondeur plus importante.\\
Être le premier à jouer semble donner un avantage, et le nombre de possibilités du joueur 2 plus important n’était pas suffisant pour le résorber. La profondeur ne semble pas forcément augmenter le nombre de possibilités.
Comme pour la profondeur 1, le joueur 1 a tôt, au tour 5 environ, un avantage qui augmente également au fur et à mesure de la partie et gagne cette dernière.\\
La situation est similaire à AlphaBeta de profondeur 1.
Similaire au graphique de profondeur 2, le second joueur possède un avantage à partir du tour 5 environ. Mais au tour 20 cet avantage augmente drastiquement pour atteindre 100\% de plus, en fin de partie, par rapport au joueur 1. La complexité du premier joueur est particulièrement basse, presque 70\% moins importante qu’avec la profondeur de 1.\\
Pour la première fois, c’est le second joueur qui gagne la partie.\\
L’avantage très important du joueur 2 lui a permis de l’emporter, malgré son désavantage de joueur en second.\\
Pour 3 094 nœuds visités, l’algorithme dure 6 minutes et 54 secondes.
\subsubsection{Conclusion d’Alphabeta}
Jouer en premier donne un avantage. Il faut au second joueur un avantage conséquent (situé entre 30\% et 100\% par rapport au premier) pour lui permettre de l’emporter.\\
De plus, c’est sur les profondeurs paires que le second joueur semble posséder un avantage.\\
L’augmentation de la profondeur de l’algorithme AlphaBeta n’augmente pas forcément la complexité de ce dernier. Cependant l’augmentation de la complexité en fonction du nombre de tours est relativement linéaire.\\
Le temps de résolution des algorithmes pour des petites profondeurs (1, 2, 3) est de quelques secondes, mais augmente drastiquement avec la profondeur, AlphaBeta(5) s’exécute pendant plusieurs minutes.
Aucun joueur n’a davantage majeur au cours de la partie. Le second joueur a un petit avantage qui commence au tour 15 et qui finit au tour 33 où le premier prend l’avantage, qui reste faible, jusqu’à la fin de la partie. \\
Cependant, c’est le second joueur qui l’emporte, alors qu’il n’avait pas un grand avantage. Cela différencie cet algorithme de AlphaBeta.
Le joueur 2 commence à avoir un avantage au tour 23, avantage qui augmente un peu jusqu’à la fin de la partie. Cependant, cet avantage n’est pas suffisant et c’est le premier joueur qui gagne.\\
La complexité est environ 11 fois supérieur à Negamax de profondeur 3. Le premier joueur possède un avantage au tour 10 qui augmente jusqu’au tour 22 et se réduit ensuite jusqu’à la fin de la partie.\\
Nous avons essayé de le lancer, mais après 28 heures d’exécution sur le Raspberry Pi celui-ci n’était pas terminé, de plus la complexité stockée comme attribut de la classe Player est stocké sur un entier signé 32 bits dont la limite positive est $2^{31}-1$ soit inférieur à 8 milliards.
\item Lors du clonage toutes les cases même inoccupées étaient modifiées.
\item Le saut était possible même quand il n'y avait pas de pion en dessous et ne transformait pas les pions adverses.
\end{itemize}
\section{Expérimentations}
Nous avons mis en place un logger afin de pouvoir exporter plus facilement les données notamment pour faire les graphiques.\\
Le flux s'ouvre au lancement du programme et se ferme à sa fermeture ce qui fait que les fichiers de log resteront vides pendant le fonctionnement du programme, ce qui rend impossible la lecture de la complexité durant le fonctionnement du programme notamment pour le negamax de profondeur 5 ou plus qui demande beaucoup de performances et de temps de calcul.
