diff --git a/report/document.tex b/report/document.tex
index aa0cb8b..2449ce3 100644
--- a/report/document.tex
+++ b/report/document.tex
@@ -118,8 +118,13 @@ la taille du plateau est complètement modulable, aussi les couleurs des joueurs
 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}[h]
+\begin{figure}[ht]
     \centering
     \begin{minipage}{0.15\textwidth}
         \begin{minted}[autogobble,frame=lines,rulecolor=gray]{mcf}
@@ -144,9 +149,6 @@ est donc séparé en plusieurs fichiers/fonctions (cf. \autoref{tree:project}).
     \label{tree:project}
 \end{figure}
 
-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.
-
 \newpage
 \subsection[Minimax]{Algorithme minimax}
 \subsubsection{Algorithme}
@@ -165,7 +167,7 @@ décide si le coup est bien ou non, plus elle est précise plus le coup décidé
 meilleur.
 
 \subsubsection{Exemple d'utilisation}
-L'utilisation de l'algorithme est simple. Il suffit d'appeller une seule fonction
+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
@@ -174,20 +176,66 @@ et elle jouera un coup (cf. \autoref{cod:minimax_def}).
             /* 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'appeller dans la fonction qui s'occupe du déroulement
-du jeu.
+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}
-% TODO avec code d'illustration
+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}
-% TODO expliquer fonctionnement alphabeta
+Les coupures $\alpha - \beta$ permettent de réduire la taille en mémoire de minimax
+en ne calculant pas certains scénarios.
 
 \subsubsection{Exemple d'utilisation}
 % TODO expliquer comment l'utiliser