Fusion de la partie consoleapp

Sources/ConsoleApp/Evenements.cs

@@ -0,0 +1,121 @@
+using CoreLibrary.Events;
+using CoreLibrary;
+
+namespace ConsoleApp
+{
+    public class Evenements
+    {
+        public static string? DemanderJoueur(Object? sender, DemanderJoueurEventArgs e)
+        {
+            Console.WriteLine($"Joueur {e.Numero}");
+            Console.Write(">>> ");
+
+            string? nom = Console.ReadLine();
+
+            Console.WriteLine();
+
+            return nom;
+        }
+
+
+        public static void CommencerLaPartie(Object? sender, DebutPartieEventArgs e)
+        {
+            Utils.DessinerSeparateur();
+
+            Console.WriteLine("La partie commence, bonne chance à tous !\n");
+        }
+
+
+        public static void NouveauTour(Object? sender, NouveauTourEventArgs e)
+        {
+            Utils.DessinerSeparateur();
+
+            Console.WriteLine($"Tour {e.Tour} - {e.Joueur.Nom}\n");
+
+            Utils.DessinerPlateau(e.Grille, e.Indicateurs);
+
+            Console.WriteLine();
+
+        }
+
+        public static Jeton? DemanderJeton(Object? sender, DemanderJetonEventArgs e)
+        {
+            Console.TreatControlCAsInput = true;
+
+            bool aChoisi = false;
+            int indice = 0;
+            Couleur[] couleurs = (Couleur[])Enum.GetValues(typeof(Couleur));
+
+            while (!aChoisi)
+            {
+                Utils.DessinerPion(couleurs[indice]);
+                Console.Write("\b\b\b");
+
+                switch (Console.ReadKey(true).Key)
+                {
+                    case ConsoleKey.Enter:
+                        aChoisi = true;
+                        break;
+
+                    case ConsoleKey.LeftArrow:
+                        --indice;
+                        break;
+
+                    case ConsoleKey.RightArrow:
+                        ++indice;
+                        break;
+
+                    case ConsoleKey.Escape:
+                        return null;
+
+                    default:
+                        break;
+                }
+
+                if (indice < 0)
+                    indice = couleurs.Length - 1;
+                else if (indice >= couleurs.Length)
+                    indice = 0;
+            }
+
+            Console.TreatControlCAsInput = false;
+
+            return new Jeton(couleurs[indice]);
+        }
+
+        public static void AjouterJeton(Object? sender, AjouterJetonEventArgs e)
+        {
+            Utils.DessinerPion(e.Jeton.Couleur);
+        }
+
+        public static void SupprimerDernierJeton(Object? sender, SupprimerDernierJetonEventArgs e)
+        {
+            Console.Write("\b\b\b      \b\b\b\b\b\b");
+        }
+
+        public static void AjouterCode(Object? sender, AjouterCodeEventArgs e)
+        {
+            Console.WriteLine();
+
+            Utils.DessinerSeparateur();
+        }
+
+        public static void PartieTerminee(Object? sender, PartieTermineeEventArgs e)
+        {
+            Joueur[] gagnants = e.Gagnants.ToArray();
+
+            if (gagnants.Length > 1)
+            {
+                Console.WriteLine("C'est une égalité !");
+            }
+            else if (gagnants.Length == 1)
+            {
+                Console.WriteLine($"C'est une victoire de {gagnants[0].Nom}.");
+            }
+            else
+            {
+                Console.WriteLine("C'est une défaite des deux joueurs...");
+            }
+        }
+    }
+}

Sources/ConsoleApp/Program.cs

@@ -1 +1,20 @@
-Console.WriteLine("Hello");
+using ConsoleApp;
+using CoreLibrary;
+
+
+Console.OutputEncoding = System.Text.Encoding.UTF8;
+
+Utils.DessinerTitre();
+
+Partie maPartie = new Partie(new ReglesClassiques());
+
+maPartie.DemanderJoueur += Evenements.DemanderJoueur;
+maPartie.DebutPartie += Evenements.CommencerLaPartie;
+maPartie.NouveauTour += Evenements.NouveauTour;
+maPartie.DemanderJeton += Evenements.DemanderJeton;
+maPartie.AjouterJeton += Evenements.AjouterJeton;
+maPartie.SupprimerDernierJeton += Evenements.SupprimerDernierJeton;
+maPartie.AjouterCode += Evenements.AjouterCode;
+maPartie.PartieTerminee += Evenements.PartieTerminee;
+
+maPartie.Jouer();

Sources/ConsoleApp/Utils.cs

@@ -0,0 +1,122 @@
+using CoreLibrary;
+
+namespace ConsoleApp
+{
+    public class Utils
+    {
+        private readonly static Dictionary<Couleur, ConsoleColor> couleursTerminal = new Dictionary<Couleur, ConsoleColor>()
+        {
+            {Couleur.NOIR, ConsoleColor.Black },
+            {Couleur.BLANC, ConsoleColor.White },
+            {Couleur.ROUGE, ConsoleColor.Red },
+            {Couleur.VERT, ConsoleColor.Green },
+            {Couleur.BLEU, ConsoleColor.Blue },
+            {Couleur.JAUNE, ConsoleColor.DarkYellow }
+        };
+
+        private readonly static Dictionary<Indicateur, ConsoleColor> indicateursTerminal = new Dictionary<Indicateur, ConsoleColor>()
+        {
+            {Indicateur.BONNEPLACE, ConsoleColor.Black },
+            {Indicateur.BONNECOULEUR, ConsoleColor.White }
+        };
+
+        public static void DessinerTitre()
+        {
+            Console.WriteLine("""
+             __  __            _                     _           _
+            |  \/  | __ _  ___| |_  ___  _ _  _ __  (_) _ _   __| |
+            | |\/| |/ _` |(_-<|  _|/ -_)| '_|| '  \ | || ' \ / _` |
+            |_|  |_|\__,_|/__/ \__|\___||_|  |_|_|_||_||_||_|\__,_|
+            """);
+
+            DessinerSeparateur();
+        }
+
+
+        public static void DessinerSeparateur()
+        {
+            Console.WriteLine("""
+
+            ───────────────────────────────────────────────────────
+
+
+            """);
+        }
+
+        public static void DessinerPion(Enum pion)
+        {
+            Console.Write(" ");
+
+            Console.ForegroundColor = pion.GetType().Equals(typeof(Couleur)) ?
+                couleursTerminal.GetValueOrDefault((Couleur)pion) :
+                indicateursTerminal.GetValueOrDefault((Indicateur)pion);
+
+            Console.BackgroundColor = Console.ForegroundColor.Equals(ConsoleColor.Black) ? ConsoleColor.White : ConsoleColor.Black;
+
+            Console.Write("⬤");
+
+            Console.ResetColor();
+
+            Console.Write(" ");
+        }
+
+        public static void DessinerPlateau(IEnumerable<IEnumerable<Jeton?>> grille, IEnumerable<IEnumerable<Indicateur>> indicateurs)
+        {
+            IEnumerable<Jeton?>[] grilleTableau = (IEnumerable<Jeton?>[])grille.ToArray();
+            IEnumerable<Indicateur>[] indicateursTableau = (IEnumerable<Indicateur>[])indicateurs.ToArray();
+
+            Console.WriteLine("     Codes           Indicateurs   ");
+            Console.WriteLine("────────────────   ────────────────");
+            Console.WriteLine("│              │   │              │");
+
+            for (int i = 0; i < grille.Count(); ++i)
+            {
+                Console.Write("│ ");
+
+                Jeton?[] ligneGrille = grilleTableau[i].ToArray();
+
+                for (int j = 0; j < ligneGrille.Length; ++j)
+                {
+                    Jeton? jeton = ligneGrille[j];
+
+                    if (jeton.HasValue)
+                    {
+                        DessinerPion(jeton.Value.Couleur);
+                    }
+                    else
+                    {
+                        Console.Write("   ");
+                    }
+
+                }
+
+                Console.Write(" │   │ ");
+
+                if (indicateursTableau[i] != null)
+                {
+                    Indicateur[] ligneIndicateurs = indicateursTableau[i].ToArray();
+
+                    for (int j = 0; j < ligneIndicateurs.Length; ++j)
+                    {
+                        DessinerPion(ligneIndicateurs[j]);
+                    }
+
+                    if (ligneIndicateurs.Length < 4)
+                    {
+                        Console.Write("".PadLeft((4 - ligneIndicateurs.Length) * 3));
+                    }
+                }
+                else
+                {
+                    Console.Write("            ");
+                }
+
+                Console.WriteLine(" │");
+            }
+
+
+            Console.WriteLine("│              │   │              │");
+            Console.WriteLine("────────────────   ────────────────");
+        }
+    }
+}

Sources/CoreLibrary/Code.cs

@@ -1,28 +1,13 @@
 using CoreLibrary.Exceptions;
 
-
-
-
-
 namespace CoreLibrary
 {
-    /// <summary>
-    /// Représente un code composé de jetons.
-    /// </summary>
     public class Code
     {
         private readonly Jeton?[] lesJetons;
 
-        /// <summary>
-        /// Obtenir le nombre de jetons dans le code.
-        /// </summary>
         public int NbJetons { get; private set; } = 0;
 
-        /// <summary>
-        /// Initialise une nouvelle instance de la classe <see cref="Code"/> avec la longueur de code spécifiée.
-        /// </summary>
-        /// <param name="tailleCode">La longueur du code.</param>
-        /// <exception cref="TailleCodeException">Levée lorsque la longueur du code spécifiée est inférieure ou égale à zéro.</exception>
         public Code(int tailleCode)
         {       
             if(tailleCode <= 0)
@@ -33,11 +18,6 @@ namespace CoreLibrary
             lesJetons = new Jeton?[tailleCode];
         }
 
-        /// <summary>
-        /// Initialise une nouvelle instance de la class <see cref="Code"/> avec les jetons spécifiés.
-        /// </summary>
-        /// <param name="jetons">Les jetons pour initaliser le code.</param>
-        /// <exception cref="TailleCodeException">Levée lorsque la collection de jetons spécifiée est vide.</exception>
         public Code(IEnumerable<Jeton> jetons)
         {
             if (jetons.Count() == 0)
@@ -52,11 +32,6 @@ namespace CoreLibrary
             }
         }
 
-        /// <summary>
-        /// Ajoute un jeton au code.
-        /// </summary>
-        /// <param name="jeton">Le jeton à ajouter</param>
-        /// <exception cref="CodeCompletException">Levée lorsque le code est plein.</exception>
         public void AjouterJeton(Jeton jeton)
         {
             if (NbJetons == TailleMaximale())
@@ -67,10 +42,6 @@ namespace CoreLibrary
             lesJetons[NbJetons++] = jeton;
         }
 
-        /// <summary>
-        /// Supprime le dernier jeton ajouté au code.
-        /// </summary>
-        /// <exception cref="CodeVideException">Levée lorsque le code est vide.</exception>
         public void SupprimerDernierJeton()
         {
             if(NbJetons == 0)
@@ -81,12 +52,6 @@ namespace CoreLibrary
             lesJetons[--NbJetons] = null;
         }
 
-        /// <summary>
-        /// Récupère le jeton à l'indice spécifié dans le code.
-        /// </summary>
-        /// <param name="indice">L'indice du jeton a récupéré.</param>
-        /// <returns>Le jeton situé à l'indice spécifié.</returns>
-        /// <exception cref="IndiceCodeException">Levée lorsque l'indice est supérieur à la taille maximale du code, inférieur à 0 ou qu'il n'y a pas de jeton à l'indice spécifié</exception>
         public Jeton RecupererJeton(int indice)
         {
             if(indice < 0 || indice > TailleMaximale())
@@ -100,57 +65,34 @@ namespace CoreLibrary
             return jeton.Value;
         }
 
-        /// <summary>
-        /// Récupère une énumération des jetons dans le code.
-        /// </summary>
-        /// <returns>Enumération des jetons du code</returns>
         public IEnumerable<Jeton?> Jetons()
         {
             return lesJetons;
         }
 
-
-
-        /// <summary>
-        /// Vérifie si le code est complet.
-        /// </summary>
-        /// <returns>True si le code est complet, sinon False.</returns>
         public bool EstComplet()
         {
             return NbJetons == lesJetons.Length;
         }
 
-        /// <summary>
-        /// Recupère la taille maximal du code.
-        /// </summary>
-        /// <returns>Taille maximal du code.</returns>
         public int TailleMaximale()
         {
             return lesJetons.Length;
         }
 
-
-        /// <summary>
-        /// Compare le code avec un autre code et génère des indcateurs de correspondance.
-        /// </summary>
-        /// <param name="autreCode">Le code à comparer avec le code actuel</param>
-        /// <returns>Enumération d'indicateurs de correspondance entre les deux codes.</returns>
         public IEnumerable<Indicateur> Comparer(Code autreCode)
         {
             // Mon code est le code correct, l'autre code est celui qui teste
 
+
             Indicateur[] indicateurs = [];
 
-            /// Vérifie si les deux codes sont complets
             if (!EstComplet() || !autreCode.EstComplet())
                 return indicateurs;
 
-            /// Convertie les jetons des codes en tableaux.
             Jeton?[] mesJetons = Jetons().ToArray();
             Jeton?[] sesJetons = autreCode.Jetons().ToArray();
 
-            /// Compare les jetons pour détecter les ceux à la bonnes places
-            /// S'ils sont à la bonne place alors ils sont enlever du tableau et un indicateur BONNEPLACE est ajouter au tableau des indicateurs.
             for (int i = 0; i < mesJetons.Length; ++i)
             {
                 Jeton? monJeton = mesJetons[i];
@@ -165,8 +107,6 @@ namespace CoreLibrary
             }
 
 
-            /// Compare les jetons pour détecter ceux qui ont la bonne couleur.
-            /// S'ils ont la bonne couleur alors ils sont enlever du tableau et un indicateur BONNECOULEUR est ajouter au tableau des indicateurs.
             for (int i = 0; i < sesJetons.Length; ++i)
             {
                 Jeton? sonJeton = sesJetons[i];

Sources/CoreLibrary/Events/AjouterCodeEventArgs.cs

@@ -0,0 +1,12 @@
+
+namespace CoreLibrary.Events
+{
+    public class AjouterCodeEventArgs : EventArgs
+    {
+        public Code Code { get; private set; } 
+        public AjouterCodeEventArgs(Code code) 
+        {
+            Code = code;
+        }
+    }
+}

Sources/CoreLibrary/Events/AjouterJetonEventArgs.cs

@@ -0,0 +1,13 @@
+
+
+namespace CoreLibrary.Events
+{
+    public class AjouterJetonEventArgs : EventArgs
+    {
+        public Jeton Jeton { get; private set; }
+        public AjouterJetonEventArgs(Jeton jeton) 
+        {
+            Jeton = jeton;
+        }
+    }
+}

Sources/CoreLibrary/Events/AjouterJoueursEventArgs.cs

@@ -0,0 +1,12 @@
+namespace CoreLibrary.Events
+{
+    public class AjouterJoueursEventArgs : EventArgs
+    {
+        public Joueur Joueur { get; private set; }
+
+        public AjouterJoueursEventArgs(Joueur joueur) 
+        {
+            Joueur = joueur;
+        }
+    }
+}

Sources/CoreLibrary/Events/DebutPartieEventArgs.cs

@@ -0,0 +1,6 @@
+namespace CoreLibrary.Events
+{
+    public class DebutPartieEventArgs : EventArgs
+    {
+    }
+}

Sources/CoreLibrary/Events/DemanderJetonEventArgs.cs

@@ -0,0 +1,7 @@
+
+namespace CoreLibrary.Events
+{
+    public class DemanderJetonEventArgs : EventArgs
+    {
+    }
+}

Sources/CoreLibrary/Events/DemanderJoueurEventArgs.cs

@@ -0,0 +1,12 @@
+namespace CoreLibrary.Events
+{
+    public class DemanderJoueurEventArgs : EventArgs
+    {
+        public int Numero { get; private set; }
+
+        public DemanderJoueurEventArgs(int numero)
+        {
+            Numero = numero;
+        }
+    }
+}

Sources/CoreLibrary/Events/NouveauTourEventArgs.cs

@@ -0,0 +1,20 @@
+using CoreLibrary.Exceptions;
+
+namespace CoreLibrary.Events
+{
+    public class NouveauTourEventArgs : EventArgs
+    {
+        public Joueur Joueur { get; private set; }
+        public int Tour {  get; private set; }
+        public IEnumerable<IEnumerable<Jeton?>> Grille { get; private set; }
+        public IEnumerable<IEnumerable<Indicateur>> Indicateurs { get; private set; }
+
+        public NouveauTourEventArgs(Joueur joueur, int tour, IEnumerable<IEnumerable<Jeton?>> grille, IEnumerable<IEnumerable<Indicateur>> indicateurs) 
+        {
+            Joueur = joueur;
+            Tour = tour;
+            Grille = grille;
+            Indicateurs = indicateurs;
+        }
+    }
+}

Sources/CoreLibrary/Events/PartieTermineeEventArgs.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CoreLibrary.Events
+{
+    public class PartieTermineeEventArgs : EventArgs
+    {
+        public IEnumerable<Joueur> Gagnants { get; private set; }
+        public IEnumerable<Joueur> Perdants { get; private set; }
+
+        public PartieTermineeEventArgs(IEnumerable<Joueur> gagnants, IEnumerable<Joueur> perdants)
+        {
+            Gagnants = gagnants;
+            Perdants = perdants;
+        }
+    }
+}

Sources/CoreLibrary/Events/PasserMainEventArgs.cs

@@ -0,0 +1,6 @@
+namespace CoreLibrary.Events
+{
+    public class PasserMainEventArgs : EventArgs
+    {
+    }
+}

Sources/CoreLibrary/Events/SupprimerDernierJetonEventArgs.cs

@@ -0,0 +1,6 @@
+namespace CoreLibrary.Events
+{
+    public class SupprimerDernierJetonEventArgs : EventArgs
+    {
+    }
+}

Sources/CoreLibrary/Partie.cs

@@ -0,0 +1,108 @@
+using CoreLibrary.Events;
+using CoreLibrary.Exceptions;
+
+namespace CoreLibrary
+{
+    public class Partie
+    {
+        private readonly IRegles regles;
+
+        public delegate string? StringEventHandler<TEventArgs>(Object? sender, TEventArgs e);
+        public delegate Jeton? JetonEventHandler<TEventArgs>(Object? sender, TEventArgs e);
+
+        public event StringEventHandler<DemanderJoueurEventArgs>? DemanderJoueur;
+        public event JetonEventHandler<DemanderJetonEventArgs>? DemanderJeton;
+
+        public event EventHandler<AjouterJoueursEventArgs>? AjouterJoueur;
+        public event EventHandler<DebutPartieEventArgs>? DebutPartie;
+        public event EventHandler<NouveauTourEventArgs>? NouveauTour;
+        public event EventHandler<AjouterJetonEventArgs>? AjouterJeton;
+        public event EventHandler<SupprimerDernierJetonEventArgs>? SupprimerDernierJeton;
+        public event EventHandler<AjouterCodeEventArgs>? AjouterCode;
+        public event EventHandler<PasserMainEventArgs>? PasserMain;
+        public event EventHandler<PartieTermineeEventArgs>? PartieTerminee;
+
+        private string? QuandDemanderJoueur(int numero) => DemanderJoueur?.Invoke(this, new DemanderJoueurEventArgs(numero));
+        private Jeton? QuandDemanderJeton() => DemanderJeton?.Invoke(this, new DemanderJetonEventArgs());
+
+
+        private void QuandAjouterJoueur(Joueur joueur) => AjouterJoueur?.Invoke(this, new AjouterJoueursEventArgs(joueur));
+        private void QuandDebutPartie() => DebutPartie?.Invoke(this, new DebutPartieEventArgs());
+        private void QuandNouveauTour(Joueur joueur, int tour, IEnumerable<IEnumerable<Jeton?>> grille, IEnumerable<IEnumerable<Indicateur>> indicateurs) => NouveauTour?.Invoke(this, new NouveauTourEventArgs(joueur, tour, grille, indicateurs));
+        private void QuandNouveauJeton(Jeton jeton) => AjouterJeton?.Invoke(this, new AjouterJetonEventArgs(jeton));
+        private void QuandSupprimerDernierJeton() => SupprimerDernierJeton?.Invoke(this, new SupprimerDernierJetonEventArgs());
+        private void QuandNouveauCode(Code code) => AjouterCode?.Invoke(this, new AjouterCodeEventArgs(code));
+        private void QuandPasserMain() => PasserMain?.Invoke(this, new PasserMainEventArgs());
+        private void QuandPartieTerminee(IEnumerable<Joueur> gagnants, IEnumerable<Joueur> perdants) => PartieTerminee?.Invoke(this, new PartieTermineeEventArgs(gagnants, perdants));
+
+
+        public Partie(IRegles regles)
+        {
+            this.regles = regles;
+        }
+
+        public void Jouer()
+        {
+            while (regles.NbJoueurs != regles.NbJoueursMaximum)
+            {
+                string nom = QuandDemanderJoueur(regles.NbJoueurs + 1) ?? $"Joueur {regles.NbJoueurs+1}";
+                Joueur joueur = regles.AjouterJoueur(nom);
+                QuandAjouterJoueur(joueur);
+            }
+
+            regles.CommencerLaPartie();
+            QuandDebutPartie();
+
+            while (!regles.EstTerminee())
+            {
+                Joueur joueurCourant = regles.JoueurCourant();
+                Plateau plateauCourant = joueurCourant.Plateau; 
+
+                QuandNouveauTour(joueurCourant, plateauCourant.Tour, plateauCourant.Grille(), plateauCourant.Indicateurs());
+
+                Code code = regles.GenererCode();
+
+                while (!code.EstComplet())
+                {
+                    Jeton? jeton = QuandDemanderJeton();
+
+                    if(jeton == null)
+                    {
+                        if(DemanderJeton != null)
+                        {
+                            // Si quelqu'un écoute l'événement mais ne renvoie rien, alors on supprime le dernier jeton
+                            try
+                            {
+                                code.SupprimerDernierJeton();
+                                QuandSupprimerDernierJeton();
+                            }
+                            catch(CodeVideException){}
+                        }
+                        else
+                        {
+                            // Si personne n'écoute l'évenment, on met un jeton aléatoire
+                            jeton = new Jeton();
+                        }
+                    }
+
+                    if(jeton != null)
+                    {
+                        code.AjouterJeton(jeton.Value);
+                        QuandNouveauJeton(jeton.Value);
+                    }
+                }
+                plateauCourant.AjouterCode(code);
+                QuandNouveauCode(code);
+
+                regles.PasserLaMain();
+                QuandPasserMain();
+            }
+
+
+            regles.Gagnants();
+            regles.Perdants();
+
+            QuandPartieTerminee(regles.Gagnants(), regles.Perdants());
+        }
+    }
+}

Sources/CoreLibrary/ReglesClassiques.cs

@@ -2,53 +2,26 @@
 
 namespace CoreLibrary
 {
-    /// <summary>
-    /// Implémente les règles du jeu.
-    /// </summary>
     public class ReglesClassiques : IRegles
     {
         private int nbJoueurs = 0;
         private int? joueurCourant;
         private readonly Joueur[] joueurs;
 
-        /// <summary>
-        /// Obtient le nom des règles.
-        /// </summary>
         public string Nom { get => "Règles classiques"; }
 
-        /// <summary>
-        /// Obtient le nombre maximum de tours.
-        /// </summary>
         public int TourMaximum { get => 12; }
-
-        /// <summary>
-        /// Obtient la taille maximale d'un code.
-        /// </summary>
         public int TailleCodeMaximum { get => 4; }
-
-        /// <summary>
-        /// Obtient le nombre de joueurs actuels dans le jeu.
-        /// </summary>
         public int NbJoueurs { get => nbJoueurs; }
-
-        /// <summary>
-        /// Obtient le nombre maximum de joueurs possible pour le jeu.
-        /// </summary>
         public int NbJoueursMaximum { get => 2; }
 
-        /// <summary>
+
-        /// Initialise une nouvelle instance de la classe <see cref="ReglesClassiques"/> en initialisant un tableau de joueurs avec la taille maximale de joueurs autorisée.
-        /// </summary>
         public ReglesClassiques()
         {
             joueurs = new Joueur[NbJoueursMaximum];
         }
 
-        /// <summary>
+
-        /// Ajoute un joueur avec le nom spécifié.
-        /// </summary>
-        /// <param name="nom">Le nom du joueur à ajouter.</param>
-        /// <returns>Le joueur ajouté.</returns>
         public Joueur AjouterJoueur(string nom)
         {
             Joueur joueur = new Joueur(nom, new Plateau(TailleCodeMaximum, TourMaximum));
@@ -56,11 +29,6 @@ namespace CoreLibrary
             return joueur;
         }
 
-        /// <summary>
-        /// Obtient le joueur dont c'est actuellement le tour.
-        /// </summary>
-        /// <returns>Le joueur actuel.</returns>
-        /// <exception cref="PartieNonCommenceeException">Levée lorsqu'il n'y a pas de joueur courant.</exception>
         public Joueur JoueurCourant()
         {
             if (!joueurCourant.HasValue)
@@ -69,10 +37,6 @@ namespace CoreLibrary
             return joueurs[joueurCourant.Value];
         }
 
-        /// <summary>
-        /// Passe la main au joueur suivant.
-        /// </summary>
-        /// <exception cref="PartieNonCommenceeException">Levée lorsqu'il n'y a pas de joueur courant.</exception>
         public void PasserLaMain()
         {
             if (!joueurCourant.HasValue)
@@ -88,27 +52,19 @@ namespace CoreLibrary
 
         }
 
-        /// <summary>
+
-        /// Génère un nouveau code.
-        /// </summary>
-        /// <returns>Le code généré</returns>
         public Code GenererCode()
         {
             return new Code(TailleCodeMaximum);
         }
 
-        /// <summary>
+
-        /// Initialise le premier joueur à jouer.
-        /// </summary>
         public void CommencerLaPartie()
         {
             joueurCourant = 0;
         }
 
-        /// <summary>
+
-        /// Vérifie si la partie est terminée.
-        /// </summary>
-        /// <returns>True si la partie est terminée, sinon False.</returns>
         public bool EstTerminee()
         {
             if (!joueurCourant.HasValue || joueurCourant != 0)
@@ -127,10 +83,6 @@ namespace CoreLibrary
         }
 
 
-        /// <summary>
-        /// Obtient les joueurs gagnants de la partie.
-        /// </summary>
-        /// <returns>La liste des joueurs gagnants.</returns>
         public IEnumerable<Joueur> Gagnants()
         {
             Joueur[] gagnants = [];
@@ -145,10 +97,6 @@ namespace CoreLibrary
             return gagnants;
         }
 
-        /// <summary>
-        /// Obtient les joueurs perdants de la partie.
-        /// </summary>
-        /// <returns>La liste des joueurs perdants.</returns>
         public IEnumerable<Joueur> Perdants()
         {
             Joueur[] perdants = [];