347 lines
13 KiB
TeX
347 lines
13 KiB
TeX
\documentclass{article}
|
||
|
||
|
||
\usepackage[T1]{fontenc} % encodage
|
||
\renewcommand{\familydefault}{\sfdefault} % police en sans-serif
|
||
|
||
\usepackage[french]{babel} % langue
|
||
\frenchsetup{SmallCapsFigTabCaptions=false}
|
||
|
||
\usepackage[hidelinks]{hyperref} % liens cliquable dans la table des matières
|
||
|
||
\usepackage{graphicx} % images
|
||
\usepackage{caption}
|
||
|
||
\usepackage[a4paper, left=20mm, top=20mm]{geometry} % dimensions de la page
|
||
|
||
\usepackage{minted} % intégration code
|
||
\usemintedstyle{emacs}
|
||
|
||
\title{Projet - IA pour le jeu d'Othello
|
||
\thanks{\href{https://jj.up8.site/AA/ProjetsAA.pdf}{Sujet 35}}}
|
||
\author{\href{mailto:anri.kennel@etud.univ-paris8.fr}{Anri Kennel}
|
||
\thanks{Numéro d'étudiant : 20010664}\, (L3-A)
|
||
\\Algorithmique avancée $\cdot$ Université Paris 8}
|
||
\date{Année universitaire 2022-2023}
|
||
|
||
\begin{document}
|
||
\maketitle
|
||
\tableofcontents
|
||
\clearpage
|
||
|
||
\section{Projet}
|
||
Ce projet présente une implémentation d'un jeu d’Othello ainsi que deux
|
||
intelligences artificielles jouant; l'une selon un algorithme minimax et l'autre
|
||
via élagage alpha-bêta. Il y a aussi une comparaison d'efficacité des IA à
|
||
différentes profondeurs de jeu.
|
||
|
||
\section{Implémentation}
|
||
\subsection{Othello}
|
||
\subsubsection{Règles du jeu}
|
||
L'Othello est un jeu qui se joue sur un plateau de 8x8 où deux couleurs, les noirs
|
||
et les blancs s'affrontent. Les noirs commencent la partie. Quand aucun joueur
|
||
ne peut jouer, la partie s'arrête.
|
||
|
||
Au début d'une partie le plateau ressemble à la \autoref{fig:init}.
|
||
|
||
\begin{figure}[h]
|
||
\centering
|
||
\includegraphics[width=0.35\textwidth]{imgs/othello_init.png}
|
||
\caption{Début d'une partie}
|
||
\label{fig:init}
|
||
\end{figure}
|
||
|
||
\subsubsection{Exemple d'une partie}
|
||
Chaque joueur doit poser un pion de sa couleur sur une case vide de l’othellier,
|
||
il faut prendre en sandwich les pions ennemis, peu importe la direction. Une fois
|
||
posé, les pions prient en sandwich sont récupérés par le joueur qui vient de jouer.
|
||
|
||
Dans la configuration du début, les cases pouvant être joué par les noirs sont
|
||
indiqués en rouge dans la \autoref{fig:prem}.
|
||
|
||
\begin{figure}[h]
|
||
\centering
|
||
\includegraphics[width=0.35\textwidth]{imgs/othello_premiercoup.png}
|
||
\caption{Possibilités au premier coup}
|
||
\label{fig:prem}
|
||
\end{figure}
|
||
|
||
Mon implémentation du jeu indique au joueur les coups possibles (c'est-à-dire les
|
||
cases rouges). Le joueur doit indiquer les coordonnées où il veut poser son jeton
|
||
et les changements se font automatiquement. Chaque joueur joue chacun son tour et
|
||
passe son tour si aucun coup lui est possible. La partie s'arrête si le plateau
|
||
est plein ou si aucun joueur ne peut jouer, cf. \autoref{fig:human}. Les jetons
|
||
blancs sont notés \texttt{B} et les jetons noirs \texttt{N}.
|
||
|
||
\begin{figure}[h]
|
||
\centering
|
||
\includegraphics[width=0.35\textwidth]{imgs/othello_impl_player.jpg}
|
||
\caption{Demande au joueur de jouer}
|
||
\label{fig:human}
|
||
\end{figure}
|
||
|
||
Si un coup illégale est joué, le jeu refuse le coup et demande au joueur de
|
||
choisir un autre coup.
|
||
|
||
\subsubsection{Problèmes rencontrés}
|
||
Mon enjeu numéro 1 était d'éviter tout problème de mémoire. Pour cela dans le
|
||
\texttt{Makefile} il y a un label \texttt{dev} qui permet d'ajouter plein de flags
|
||
pour \texttt{gcc}, notamment \texttt{fanalyzer} et \texttt{fsanitize=undefined} qui
|
||
permettent de trouver plein de problèmes relatifs à la mémoire. Aussi j'ai utilisé
|
||
\texttt{Valgrind} (avec les flags \texttt{g} et \texttt{Og} pour \texttt{gcc} et
|
||
les flags \texttt{leak-check=full}, \texttt{show-leak-kinds=all},
|
||
\texttt{track-origins=yes} et \texttt{s} pour \texttt{Valgrind}) me permettant
|
||
d'avoir un maximum d'avertissements et d'informations me permettant de débugger
|
||
tous les problèmes.
|
||
\\\\
|
||
Aussi, je voulais rendre mon code modulable, pour tester plus facilement. Ainsi
|
||
la taille du plateau est complètement modulable, aussi les couleurs des joueurs
|
||
(cf. \autoref{cod:plateau}).
|
||
|
||
\begin{figure}[h]
|
||
\centering
|
||
\begin{minipage}{0.8\textwidth}
|
||
\begin{minted}[autogobble,linenos]{c}
|
||
/* Une case est soit vide, soit occupé par un des joueurs, noir ou blanc */
|
||
enum CASE { VIDE = ' ', BLANC = 'B', NOIR = 'N' };
|
||
\end{minted}
|
||
|
||
\begin{minted}[autogobble,linenos,firstnumber=last]{c}
|
||
/* Propriété globale du jeu */
|
||
enum PLATEAU { LONGEUR = 8, LARGEUR = 8 };
|
||
\end{minted}
|
||
\end{minipage}
|
||
\caption{Début de \texttt{jeu.h}}
|
||
\label{cod:plateau}
|
||
\end{figure}
|
||
|
||
Enfin, sachant qu'il faut aussi implémenter des IAs, j'ai fait en sorte que le jeu
|
||
du joueur humain ne soit pas complètement lié au fonctionnement du jeu. Le projet
|
||
est donc séparé en plusieurs fichiers/fonctions (cf. \autoref{tree:project}).
|
||
\\\\
|
||
Grâce à ça, les fonctions relatives au jeu sont indifférentes par rapport à quelle
|
||
fonction "joueur" est appelée. Autrement dit, tout ce qui est relatif à un joueur
|
||
humain est dans \texttt{humain.h}. Le fichier \texttt{joueur.h} ne contient rien
|
||
spécifique à un joueur humain.
|
||
|
||
\begin{figure}[ht]
|
||
\centering
|
||
\begin{minipage}{0.15\textwidth}
|
||
\begin{minted}[autogobble,frame=lines,rulecolor=gray]{mcf}
|
||
- includes
|
||
|-- humain.h
|
||
|-- jeu.h
|
||
|-- joueur.h
|
||
|-- liste.h
|
||
|-- plateau.h
|
||
\-- utils.h
|
||
- src
|
||
|-- humain.c
|
||
|-- jeu.c
|
||
|-- joueur.c
|
||
|-- liste.c
|
||
|-- main.c
|
||
|-- plateau.c
|
||
\-- utils.c
|
||
\end{minted}
|
||
\end{minipage}
|
||
\caption{Arborescence du projet sans l'implémentation des IA}
|
||
\label{tree:project}
|
||
\end{figure}
|
||
|
||
\newpage
|
||
\subsection[Minimax]{Algorithme minimax}
|
||
\subsubsection{Algorithme}
|
||
L'idée de l'algorithme minimax est de calculer tous les coups possibles pour
|
||
chaque coup possible et d'aller le plus loin possible dans les "et si" pour faire
|
||
le coup qui nous rapportera le plus de points dans le futur.
|
||
|
||
Le problème de cet algorithme c'est qu'il est difficilement réalisable. En mémoire,
|
||
on doit copier le plateau plusieurs fois (pour chaque "et si"). La complexité est
|
||
de $\Theta(c^{n})$ avec $c$ les coups légaux et $n$ la profondeur de jeu, donc
|
||
lorsque l'on utilise cet algorithme on doit garder notre profondeur de test
|
||
relativement basse.
|
||
|
||
Aussi, l'algorithme est dépendant d'une fonction d'évaluation, c'est elle qui
|
||
décide si le coup est bien ou non, plus elle est précise plus le coup décidé sera
|
||
meilleur.
|
||
|
||
\subsubsection{Exemple d'utilisation}
|
||
L'utilisation de l'algorithme est simple. Il suffit d'appeler une seule fonction
|
||
et elle jouera un coup (cf. \autoref{cod:minimax_def}).
|
||
\begin{figure}[h]
|
||
\centering
|
||
\begin{minipage}{0.8\textwidth}
|
||
\begin{minted}[autogobble,linenos]{c}
|
||
/* Joue le tour d'après l'algorithme minimax */
|
||
void action_joueur_minimax(Jeu *jeu, const int couleur);
|
||
\end{minted}
|
||
|
||
\begin{minted}[autogobble,linenos,firstnumber=last]{c}
|
||
/* Auxiliaire : Décide d'une case à jouer via l'algorithme minimax */
|
||
void _action_joueur_minimax(Jeu *jeu, int profondeur, const int couleur,
|
||
const int gagnant, int *ligne, int *colonne,
|
||
int *score);
|
||
\end{minted}
|
||
\end{minipage}
|
||
\caption{Déclaration de minimax, dans \texttt{minimax.h}}
|
||
\label{cod:minimax_def}
|
||
\end{figure}
|
||
|
||
Pour l'utiliser, il faut l'appeler dans la fonction qui s'occupe du déroulement
|
||
du jeu (cf. \autoref{cod:minimax_play}).
|
||
|
||
\begin{figure}[ht]
|
||
\centering
|
||
\begin{minipage}{0.8\textwidth}
|
||
\begin{minted}[autogobble,linenos]{c}
|
||
while (!partie_finie(jeu)) {
|
||
Coups *possibilites =
|
||
action_possible_joueur(jeu->plateau, tour->couleur);
|
||
if (possibilites->taille_liste > 0) {
|
||
// Si le joueur peut jouer
|
||
if (tour->couleur == NOIR) {
|
||
// Tour du joueur minimax
|
||
action_joueur_minimax(jeu, tour->couleur);
|
||
} else {
|
||
// Tour du joueur humain
|
||
action_joueur_humain(jeu, tour->couleur);
|
||
}
|
||
}
|
||
|
||
// On passe la main à l'autre joueur
|
||
tour = jeu->j1->couleur == tour->couleur ? jeu->j2 : jeu->j1;
|
||
}
|
||
\end{minted}
|
||
\end{minipage}
|
||
\caption{Extrait modifié de \texttt{jeu.c}, avec minimax jouant les noirs et un humain les blancs}
|
||
\label{cod:minimax_play}
|
||
\end{figure}
|
||
|
||
\newpage
|
||
\subsubsection{Problèmes rencontrés}
|
||
Le plus dur était l'implémentation en elle-même et de pas s'emmêler entre les copies
|
||
de plateau. La fonction \texttt{action\_joueur\_minimax} appelle une fonction auxiliaire
|
||
\texttt{\_action\_joueur\_minimax} (cf. \autoref{cod:minimax_def}) qui fait implémente directement minimax. Elle se passe
|
||
en paramètre récursivement :
|
||
\begin{itemize}
|
||
\item la ligne choisie
|
||
\item la colonne choisie
|
||
\item le meilleur score
|
||
\item la profondeur actuellement évaluée
|
||
\item la couleur du joueur (soit MIN, soit MAX)
|
||
\end{itemize}
|
||
|
||
\subsection[Alpha-Bêta]{Élagage alpha-bêta}
|
||
\subsubsection{Algorithme}
|
||
Les coupures $\alpha - \beta$ permettent de réduire la taille en mémoire de minimax
|
||
en ne calculant pas certains scénarios en retirant ceux inutiles basé sur
|
||
les calculs précédents.
|
||
|
||
\subsubsection{Exemple d'utilisation}
|
||
L'utilisation est identique à celle de Minimax (cf. \autoref{cod:alphabeta_def}).
|
||
\begin{figure}[h]
|
||
\centering
|
||
\begin{minipage}{0.8\textwidth}
|
||
\begin{minted}[autogobble,linenos]{c}
|
||
/* Joue le tour d'après l'algorithme alpha-beta */
|
||
void action_joueur_alphabeta(Jeu *jeu, const int couleur);
|
||
\end{minted}
|
||
|
||
\begin{minted}[autogobble,linenos,firstnumber=last]{c}
|
||
/* Auxiliaire : Décide d'une case à jouer via l'algorithme alpha-beta */
|
||
void _action_joueur_alphabeta(Jeu *jeu, int profondeur, int couleur,
|
||
const int gagnant, int *ligne, int *colonne,
|
||
int *score, const int note, const int qui);
|
||
// qui => couleur associée
|
||
\end{minted}
|
||
\end{minipage}
|
||
\caption{Déclaration d'alphabeta, dans \texttt{alphabeta.h}}
|
||
\label{cod:alphabeta_def}
|
||
\end{figure}
|
||
|
||
\subsubsection{Problèmes rencontrés}
|
||
Pour l'implémentation je me passe en argument, en plus de ceux de minimax, le
|
||
meilleur score et sa couleur associée.
|
||
|
||
L'avantage avec cet algorithme est qu'il ressemble beaucoup à minimax vu que c'est
|
||
une amélioration de ce dernier, alors j'ai pu réutiliser le même code. En revanche
|
||
l'élagage était compliqué à placer dans le code.
|
||
|
||
Je fais l'élagage en passant des possibilités pour alpha (cf. \autoref{cod:elagage_alpha}),
|
||
même technique pour bêta (cf. \autoref{cod:elagage_beta}).
|
||
|
||
\begin{figure}[h]
|
||
\centering
|
||
\begin{minipage}{0.8\textwidth}
|
||
\begin{minted}[autogobble,linenos]{c}
|
||
while (i->suivant) {
|
||
if (i->suivant->suivant) {
|
||
i = i->suivant;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
*score = INT_MAX;
|
||
\end{minted}
|
||
\dots\, et \dots
|
||
\begin{minted}[autogobble,linenos,firstnumber=last]{c}
|
||
if (*score == INT_MAX) {
|
||
while (i->suivant) {
|
||
if (i->suivant->suivant) {
|
||
i = i->suivant;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
\end{minted}
|
||
\end{minipage}
|
||
\caption{Élagage $\alpha$, dans \texttt{alphabeta.h}}
|
||
\label{cod:elagage_alpha}
|
||
\end{figure}
|
||
|
||
\begin{figure}[h]
|
||
\centering
|
||
\begin{minipage}{0.8\textwidth}
|
||
\begin{minted}[autogobble,linenos]{c}
|
||
while (i->suivant) {
|
||
if (i->suivant->suivant) {
|
||
i = i->suivant;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
*score = INT_MIN;
|
||
\end{minted}
|
||
\dots\, et \dots
|
||
\begin{minted}[autogobble,linenos,firstnumber=last]{c}
|
||
if (*score == INT_MIN) {
|
||
while (i->suivant) {
|
||
if (i->suivant->suivant) {
|
||
i = i->suivant;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
\end{minted}
|
||
\end{minipage}
|
||
\caption{Élagage $\beta$, dans \texttt{alphabeta.h}}
|
||
\label{cod:elagage_beta}
|
||
\end{figure}
|
||
|
||
\section{Comparaison d'efficacité}
|
||
TODO!
|
||
|
||
\section{Discussion}
|
||
Le problème de mon implémentation est la fonction d'évaluation qui regarde juste
|
||
le nombre de points gagnés/perdus. En ne prenant pas en compte par exemple si le
|
||
pion placé est sur un coin ou non (le coin étant une position avantageuse).
|
||
|
||
\newpage
|
||
\appendix
|
||
\section*{Appendix}
|
||
\listoffigures
|
||
|
||
\end{document}
|