diff --git a/Program.cs b/Program.cs
index 740fc6d..1c5cf73 100644
--- a/Program.cs
+++ b/Program.cs
@@ -1,5 +1,7 @@
 namespace P4
 {
+
+    // Création d'un enum pour les jetons
     public enum Token
     {
         None,
@@ -7,50 +9,84 @@
         SecondPlayer,
     }
 
+    /// <summary>
+    /// Classe programme c'est la class qui est éxécutée par le programme
+    /// </summary>
     public class Program
     {
-        /*public readonly ConsoleColor FIRSTPLAYERCOLOR = ConsoleColor.Magenta;
-        public readonly ConsoleColor SECONDPLAYERCOLOR = ConsoleColor.DarkMagenta;
-
-        const ConsoleColor backgroundColor = ConsoleColor.DarkYellow;
-        const ConsoleColor foregroundColor = ConsoleColor.Black;*/
-
+        // Déclaration des couleurs des joueurs
         public readonly ConsoleColor FIRSTPLAYERCOLOR = ConsoleColor.Red;
         public readonly ConsoleColor SECONDPLAYERCOLOR = ConsoleColor.Yellow;
 
+        // Déclaration des couleurs de la console
         const ConsoleColor BACKGROUND_COLOR = ConsoleColor.Black;
         const ConsoleColor FOREGROUND_COLOR = ConsoleColor.White;
 
+        /// <summary>
+        /// Méthode qui change les couleurs de la console
+        /// </summary>
+        /// <param name="backgroundColor">couleur de fond</param>
+        /// <param name="foregroundColor">couleur du texte</param>
         public void SetColor(ConsoleColor backgroundColor = BACKGROUND_COLOR, ConsoleColor foregroundColor = FOREGROUND_COLOR)
         {
             Console.ForegroundColor = foregroundColor;
             Console.BackgroundColor = backgroundColor;
         }
 
+        /// <summary>
+        /// Méthode Main la méthode qui s'éxécute au lancement du programme
+        /// </summary>
+        /// <param name="args">tableau des arguments données au programme</param>
         static void Main(string[] args)
         {
+            // on définit les couleurs par défaut de la console
             new Program().SetColor();
+
+            // on vide la console
             Console.Clear();
+
+            // on dessine le titre
             new Draw().DrawTitle();
+
+            // on enleve le curseur
             Console.CursorVisible = false;
+
+            // on récupère la taille du plateau
             int[] boardSize = new Board().BoardSize();
+
+            // on crée un tableau de jetons
             Token[,] board = new Token[boardSize[0], boardSize[1]];
+
+            // on lance le jeu
             new Game().Start(board);
+
+            // on demande si les joueurs veulent rejouer
             new Game().Replay();
         }
     }
 
+    /// <summary>
+    /// Classe Game qui contient tout les méthodes pour jouer
+    /// </summary>
     public class Game
     {
+        // on crée des instances d'autres classes
         private Draw _draw = new Draw();
         private Program _program = new Program();
 
+        /// <summary>
+        /// Méthode Replay qui demande si les joueurs veulent rejouer et relance le jeu si c'est le cas
+        /// </summary>
         public void Replay()
         {
+            // on demande si l'utilisateur veut rejouer
             Console.WriteLine("Voulez-vous rejouer ? (o/n)");
+
+            // on regarde quelle touche a été pressée
             switch (Console.ReadKey().Key)
             {
                 case ConsoleKey.O:
+                    // si c'est oui on relance le jeu
                     new Program().SetColor();
                     Console.Clear();
                     new Draw().DrawTitle();
@@ -60,77 +96,112 @@
                     new Game().Replay();
                     break;
                 case ConsoleKey.N:
+                    // si c'est non on quitte le programme
                     return;
                 default:
+                    // sinon on demande de réessayer
                     Console.WriteLine("Entrée invalide");
                     Replay();
                     break;
 
             }
         }
+        
+        /// <summary>
+        /// Méthode Start qui lance la boucle principale du jeu
+        /// </summary>
+        /// <param name="board">tableau de jetons en 2 dimensions</param>
         public void Start(Token[,] board)
         {
-            int currentPosition = 0;
-            Token currentPlayer = Token.FirstPlayer;
-            bool placed = false;
 
+            // initialisation des variables
+            int currentPosition = 0; // position actuelle
+            Token currentPlayer = Token.FirstPlayer; // joueur actuel
+            bool placed = false; // vérification s'il on peut placer un jeton
+
+            // on vide la console
             Console.Clear();
+
+            // on efface le curseur au cas où la taille de la fenêtre aurait changé
             Console.CursorVisible = false;
+
+            // on dessine le titre l'espace de jeu le plateau et l'aide
             _draw.DrawTitle(_draw.leftSpacing);
             _draw.DrawPlayGroundBorder(board);
             _draw.DrawBorder(board);
             _draw.DrawHelp(board);
 
+            // boucle principale du jeu
             while (!CheckWin(board))
             {
+                // on check si c'est une égalité
                 if (CheckDraw(board))
                     break;
+
+                // on dessine les jetons dans l'espace de jeu et le plateau
                 _draw.DrawBoard(board);
                 _draw.DrawPlayGround(board, currentPlayer, currentPosition);
 
+                // on récupère la touche pressée
                 ConsoleKey key = Console.ReadKey(true).Key;
+
+                // on regarde si la touche est escape
                 if (key == ConsoleKey.Escape)
                 {
+                    // s'il le joueur appuie sur escape il n'y a pas de gagnant donc on set le currentPlayer à None
                     currentPlayer = Token.None;
                     break;
                 }
+
+                // on regarde les actions des joueurs
                 switch (key)
                 {
                     case ConsoleKey.RightArrow:
+                        // on incrémente la position actuelle si elle est inférieure à la taille du plateau
                         if (currentPosition < board.GetLength(0) - 1)
                             currentPosition++;
                         else
+                            // on loop si on est à la fin du plateau
                             currentPosition = 0;
                         break;
 
                     case ConsoleKey.LeftArrow:
+                        // on decremente la position actuelle si elle est superieure à 0
                         if (currentPosition > 0)
                             currentPosition--;
                         else
+                            // on loop si on est à le début du plateau
                             currentPosition = board.GetLength(0) - 1;
                         break;
 
                     case ConsoleKey.Enter:
                     case ConsoleKey.Spacebar:
+                        // on place le jeton et on change de joueur
                         placed = PlaceToken(board, currentPlayer, currentPosition);
                         if (placed && currentPlayer == Token.FirstPlayer)
                             currentPlayer = Token.SecondPlayer;
                         else if (placed && currentPlayer == Token.SecondPlayer)
                             currentPlayer = Token.FirstPlayer;
-
                         break;
                 }
             }
+
+            // on dessine les derniers jetons
             _draw.DrawBoard(board);
             _draw.DrawPlayGround(board, currentPlayer, currentPosition);
+
+            // on reset les couleurs
             _program.SetColor();
-            //Console.Clear();
+
+            // on place le curseur en bas du tableau avec le bon spacing
             Console.SetCursorPosition(0, board.GetLength(1) * 2 + _draw.topSpacing + 4);
-            // currentplayer est inversé
+
+            // on verifie s'il y a une égalité
             if (CheckDraw(board))
                 Console.WriteLine("il y a eu une égalité");
             else if (currentPlayer == Token.FirstPlayer)
             {
+                // si le joueur acctuel est le joueur 1 cela signifie que le joueur 2 a gagné
                 Console.Write("Le ");
                 _program.SetColor(foregroundColor: _program.SECONDPLAYERCOLOR);
                 Console.Write("joueur 2");
@@ -140,19 +211,28 @@
             }
             else if (currentPlayer == Token.SecondPlayer)
             {
+                // si le joueur acctuel est le joueur 2 cela signifie que le joueur 1 a gagné
                 Console.Write("Le ");
                 _program.SetColor(foregroundColor: _program.FIRSTPLAYERCOLOR);
                 Console.Write("joueur 1");
                 _program.SetColor();
                 Console.WriteLine(" a gagné");
-            } else if (currentPlayer == Token.None)
+            } 
+            else if (currentPlayer == Token.None)
             {
+                // si le joueur acctuel est None cela signifie que la partie a été arrêtée
                 Console.WriteLine("La partie à été arrêtée");
             }
+            // on affiche le nombre de tours
             Console.WriteLine("La partie à duré " + Turn(board) + " tours");
         }
 
-        static int Turn(Token[,] board)
+        /// <summary>
+        /// Méthode Turn qui compte le nombre de jetons sur le plateau
+        /// </summary>
+        /// <param name="board">tableau de jetons</param>
+        /// <returns>nombre de jetons sur le plateau</returns>
+        int Turn(Token[,] board)
         {
             int count = 0; // compteur
             for (int y = 0; y < board.GetLength(1); y++)
@@ -161,12 +241,19 @@
                 {
                     if (board[x, y] != 0)
                     {
+                        // ajoute 1 s'il le jeton n'est pas égal à 0
                         count++;
                     }
                 }
             }
             return count;
         }
+
+        /// <summary>
+        /// Méthode qui vérifie s'il y a une égalité
+        /// </summary>
+        /// <param name="board">tableau de jetons</param>
+        /// <returns>return false t'en qu'il y a au moins 1 0 sur le plateau</returns>
         private bool CheckDraw(Token[,] board)
         {
             for (int y = 0; y < board.GetLength(1); y++)
@@ -182,8 +269,14 @@
             return true;
         }
 
+        /// <summary>
+        /// Méthode qui vérifie si un joueur a gagné
+        /// </summary>
+        /// <param name="board">tableau de jetons</param>
+        /// <returns>return true s'il y a une combinaison gagnante</returns>
         private bool CheckWin(Token[,] board)
         {
+            // tableau des joueurs
             Token[] players = {Token.FirstPlayer, Token.SecondPlayer};
             // boucle qui alterne entre les joueurs 1 et 2
             foreach (var j in players)
@@ -254,14 +347,27 @@
             return false;
         }
 
+        /// <summary>
+        /// Méthode qui place un jeton sur le plateau
+        /// </summary>
+        /// <param name="board">plateau de jetons</param>
+        /// <param name="currentPlayer">joueur acctuel</param>
+        /// <param name="currentPosition">position du joueur</param>
+        /// <returns></returns>
         private bool PlaceToken(Token[,] board, Token currentPlayer, int currentPosition)
         {
             for (int i = board.GetLength(1) - 1; i >= 0; i--)
             {
+                // si la case est déjà occupée on continue
                 if (board[currentPosition, i] != Token.None) continue;
+
+                // sinon on place le jeton
                 board[currentPosition, i] = currentPlayer;
+
+                // on revoie vrai s'il on a placé le jeton
                 return true;
             }
+            // on revoie faux s'il on n'a pas placé le jeton
             return false;
         }
     }
@@ -312,15 +418,27 @@
         }
     }
 
-
+    /// <summary>
+    /// Classe Draw qui contient toutes les méthodes pour render
+    /// </summary>
     public class Draw
     {
+        // on instancie la classe Program
         private Program _program = new Program();
+
+        // on définit les espacements
         public int topSpacing = 4;
         public int leftSpacing = 10;
+
+        /// <summary>
+        /// Méthode DrawPlayGroundBorder qui dessine le terrain de jeu
+        /// </summary>
+        /// <param name="board">plateau de jetons</param>
         public void DrawPlayGroundBorder(Token[,] board)
         {
+            // on place le curseur en haut du terrain de jeu après le titre
             Console.SetCursorPosition(leftSpacing, topSpacing);
+            // on dessine la première ligne du terrain de jeu
             Console.Write("╔═══");
             for (int x = 0; x < board.GetLength(0) - 1; x++)
             {
@@ -328,6 +446,8 @@
             }
             Console.Write("╗");
 
+
+            // on dessine les autres lignes du terrain de jeu
             for (int y = 0; y < board.GetLength(1); y++)
             {
                 for (int x = 0; x < board.GetLength(0); x++)
@@ -338,6 +458,7 @@
                 Console.Write("   ║");
             }
 
+            // on dessine la dernière ligne du terrain de jeu
             Console.SetCursorPosition(leftSpacing, topSpacing + 2);
             Console.Write("╚═══");
             for (int x = 0; x < board.GetLength(0) - 1; x++)
@@ -347,21 +468,38 @@
             Console.Write("╝");
         }
 
+        /// <summary>
+        /// Méthode DrawPlayGround qui dessine les jetons dans le terrain de jeu
+        /// </summary>
+        /// <param name="board">tableau de jetons</param>
+        /// <param name="currentPlayer">joueur acctuel</param>
+        /// <param name="currentPosition">position du joueur acctuel</param>
         public void DrawPlayGround(Token[,] board, Token currentPlayer, int currentPosition)
         {
             for (int x = 0; x < board.GetLength(0); x++)
             {
+                // on place le curseur dans chaque case du terrain de jeu
                 Console.SetCursorPosition(leftSpacing + x * 4+2, topSpacing + 1);
 
+                // on dessine le jeton du joueur actuel si la position actuelle est égale à la position x sinon on ne dessine rien
                 if (currentPosition == x) Console.Write(DrawToken(currentPlayer));
                 else Console.Write(DrawToken(Token.None));
             }
         }
 
+        /// <summary>
+        /// Méthode DrawBorder qui dessine les bordures du plateau
+        /// </summary>
+        /// <param name="board">tableau de jetons</param>
         public void DrawBorder(Token[,] board)
         {
+            // déclaration de l'espacement du plateau
             int playgroundSpacing = topSpacing + 3;
+
+            // on place le curseur en haut du plateau
             Console.SetCursorPosition(leftSpacing, playgroundSpacing);
+
+            // on dessine la première ligne du plateau
             Console.Write("╔═══");
             for (int x = 0; x < board.GetLength(0) - 1; x++)
             {
@@ -369,6 +507,7 @@
             }
             Console.Write("╗");
 
+            // on dessine les autres lignes du plateau
             for (int y = 0; y < board.GetLength(1); y++)
             {
                 for (int x = 0; x < board.GetLength(0); x++)
@@ -379,6 +518,7 @@
                 Console.Write("   ║");
             }
 
+            // on dessine les interligne du plateau
             for (int y = 0; y < board.GetLength(1) - 1; y++)
             {
                 Console.SetCursorPosition(leftSpacing, y * 2 + playgroundSpacing + 2);
@@ -391,6 +531,7 @@
                 Console.Write("╣");
             }
 
+            // on dessine la dernière ligne du plateau
             Console.SetCursorPosition(leftSpacing, board.GetLength(1) * 2 + playgroundSpacing);
             Console.Write("╚═══");
             for (int x = 0; x < board.GetLength(0) - 1; x++)
@@ -400,37 +541,61 @@
             Console.Write("╝");
         }
 
+        /// <summary>
+        /// Méthode DrawBoard qui dessine les jetons sur le plateau
+        /// </summary>
+        /// <param name="board">tableau de jetons</param>
         public void DrawBoard(Token[,] board)
         {
-            int playgroundSpacing = topSpacing + 3;
+            // déclaration de l'espacement du plateau
+            int playgroundSpacing = topSpacing + 3
             for (int y = 0; y < board.GetLength(1); y++)
                 for (int x = 0; x < board.GetLength(0); x++)
                 {
+                    // on place le curseur dans chaque case du plateau
                     Console.SetCursorPosition(leftSpacing + x * 4+2, y*2 + playgroundSpacing + 1);
+                    // on dessine le jeton qui correspond à la case
                     Console.Write("{0}", DrawToken(board[x, y]));
                 }
         }
 
+        /// <summary>
+        /// Méthode DrawToken qui transforme un jeton en string
+        /// </summary>
+        /// <param name="token">jeton à transformer</param>
+        /// <returns>jeton transformé</returns>
         public string DrawToken(Token token)
         {
             switch (token)
             {
                 case Token.FirstPlayer:
+                    // on set la couleur du premier joueur
                     _program.SetColor(foregroundColor: _program.FIRSTPLAYERCOLOR);
+                    // on retourne le jeton
                     return "■";
                 case Token.SecondPlayer:
+                    // on set la couleur du deuxième joueur
                     _program.SetColor(foregroundColor: _program.SECONDPLAYERCOLOR);
+                    // on retourne le jeton
                     return "■";
                 case Token.None:
+                    // on set la couleur par défaut
                     _program.SetColor(foregroundColor: ConsoleColor.DarkGray);
+                    // on retourne le jeton
                     return "≡";
                 default:
+                    // revoye le rest au cas où
                     return default;
             }
         }
 
+        /// <summary>
+        /// Méthode DrawTitle qui dessine le titre du jeu
+        /// </summary>
+        /// <param name="spacing">espacement entre le bord et le titre</param>
         public void DrawTitle(int spacing = 0)
         {
+            // on met le curseur à la bonne position avant d'écrire chaques lignes
             Console.SetCursorPosition(spacing, 0);
             Console.WriteLine("╔═══════════════════════════════════╗");
             Console.SetCursorPosition(spacing, 1);
@@ -441,8 +606,14 @@
             Console.WriteLine("╚═══════════════════════════════════╝");
 
         }
+
+        /// <summary>
+        /// Méthode DrawHelp qui dessine l'aide du jeu
+        /// </summary>
+        /// <param name="board">tableau de jetons</param>
         public void DrawHelp(Token[,] board)
         {
+            // on dessine l'aide relative au plateau et qu'avec des positions
             WriteHelp(board, 0, 0, "Mode d'utilisation");
             WriteHelp(board, 0, 1, "-------------------");
             WriteHelp(board, 4, 2, "Déplacement");
@@ -461,6 +632,13 @@
             WriteHelp(board, 28, 6, " ");
         }
 
+        /// <summary>
+        /// Méthode WriteHelp qui écrit les phrases de l'aide
+        /// </summary>
+        /// <param name="board">tableau de jetons</param>
+        /// <param name="x">position x</param>
+        /// <param name="y">position y</param>
+        /// <param name="text">text à écrire à cette position</param>
         private void WriteHelp(Token[,] board, int x, int y, string text)
         {
             Console.SetCursorPosition(leftSpacing + board.GetLength(0) * 4 + 8 + x, topSpacing + y);