Ajout de la doc pour util, code, partie , Evenement

Sources/ConsoleApp/Evenements.cs

@@ -4,7 +4,7 @@ using CoreLibrary;
 namespace ConsoleApp
 {
     /// <summary>
-    /// Fournit des gestionnaires d'événements les événements liés au déroulement de la partie.
+    /// Fournit des gestionnaires d'événements pour les événements liés au déroulement de la partie.
     /// </summary>
     public static class Evenements
     {

Sources/ConsoleApp/Utils.cs

@@ -2,8 +2,12 @@
 
 namespace ConsoleApp
 {
+    /// <summary>
+    /// Classe utilitaire contenant des méthodes pour dessiner des éléments dans la console.
+    /// </summary>
     public static class Utils
     {
+        // Dictionnaires associant les valeurs des énumérations avec les couleurs de la console
         private readonly static Dictionary<Couleur, ConsoleColor> couleursTerminal = new Dictionary<Couleur, ConsoleColor>()
         {
             {Couleur.NOIR, ConsoleColor.Black },
@@ -20,6 +24,9 @@ namespace ConsoleApp
             {Indicateur.BONNECOULEUR, ConsoleColor.White }
         };
 
+        /// <summary>
+        /// Dessine le titre du jeu dans la console.
+        /// </summary>
         public static void DessinerTitre()
         {
             Console.WriteLine(@"
@@ -31,7 +38,9 @@ namespace ConsoleApp
             DessinerSeparateur();
         }
 
-
+        /// <summary>
+        /// Dessine un séparateur dans la console.
+        /// </summary>
         public static void DessinerSeparateur()
         {
             Console.WriteLine(@"
@@ -42,14 +51,20 @@ namespace ConsoleApp
             ");
         }
 
+        /// <summary>
+        /// Dessine un pion dans la console.
+        /// </summary>
+        /// <param name="pion">Le pion à dessiner (une couleur ou un indicateur).</param>
         public static void DessinerPion(Enum pion)
         {
             Console.Write(" ");
 
+            // Sélectionne la couleur appropriée en fonction du type de pion (une couleur ou un indicateur)
             Console.ForegroundColor = pion.GetType().Equals(typeof(Couleur)) ?
                 couleursTerminal.GetValueOrDefault((Couleur)pion) :
                 indicateursTerminal.GetValueOrDefault((Indicateur)pion);
 
+            // Définit la couleur de fond en fonction de la couleur de premier plan
             Console.BackgroundColor = Console.ForegroundColor.Equals(ConsoleColor.Black) ? ConsoleColor.White : ConsoleColor.Black;
 
             Console.Write("⬤");
@@ -59,6 +74,10 @@ namespace ConsoleApp
             Console.Write(" ");
         }
 
+        /// <summary>
+        /// Dessine une ligne de pions sur la console.
+        /// </summary>
+        /// <param name="ligne">Un tableau d'énumérations représentant les pions à dessiner.</param>
         private static void DessinerLigne(Enum[] ligne)
         {
             foreach(Enum pion in ligne)
@@ -67,6 +86,11 @@ namespace ConsoleApp
             Console.Write("".PadLeft((4 - ligne.Length) * 3));
         }
 
+        /// <summary>
+        /// Dessine un plateau de jeu dans la console, affichant les jetons et les indicateurs.
+        /// </summary>
+        /// <param name="grille">La grille de jeu.</param>
+        /// <param name="indicateurs">Les indicateurs associés à chaque ligne.</param>
         public static void DessinerPlateau(IEnumerable<IEnumerable<Jeton?>> grille, IEnumerable<IEnumerable<Indicateur>> indicateurs)
         {
             IEnumerable<Jeton?>[] grilleTableau = grille.ToArray();

Sources/CoreLibrary/Code.cs

@@ -2,12 +2,23 @@
 
 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)
@@ -18,6 +29,11 @@ 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.Any())
@@ -32,6 +48,11 @@ 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())
@@ -42,6 +63,10 @@ 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)
@@ -52,6 +77,12 @@ 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())
@@ -65,33 +96,57 @@ 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;
 
             List<Jeton?> mesJetons = new List<Jeton?>(Jetons());
             List<Jeton?> sesJetons = new List<Jeton?>(autreCode.Jetons());
 
+
+            /// 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.Count; ++i)
             {
                 Jeton? monJeton = mesJetons[i];
@@ -105,6 +160,8 @@ 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.Count; ++i)
             {

Sources/CoreLibrary/Partie.cs

@@ -3,56 +3,166 @@ using CoreLibrary.Exceptions;
 
 namespace CoreLibrary
 {
+    /// <summary>
+    /// Représente une partie de jeu.
+    /// </summary>
     public class Partie
     {
         private readonly IRegles regles;
 
+
+        /// <summary>
+        /// Définit le délégué pour gérer les événements avec des arguments de type string.
+        /// </summary>
         public delegate string? StringEventHandler<in TEventArgs>(Object? sender, TEventArgs e);
+
+        /// <summary>
+        /// Définit le délégué pour gérer les événements avec des arguments de type Jeton.
+        /// </summary>
         public delegate Jeton? JetonEventHandler<in TEventArgs>(Object? sender, TEventArgs e);
 
+        /// <summary>
+        /// Événement déclenché lorsqu'il est nécessaire de d'ajouter un joueur.
+        /// </summary>
         public event StringEventHandler<DemanderJoueurEventArgs>? DemanderJoueur;
+
+        /// <summary>
+        /// Événement déclenché lorsqu'il est nécessaire d'ajouter un jeton.
+        /// </summary>
         public event JetonEventHandler<DemanderJetonEventArgs>? DemanderJeton;
 
+        /// <summary>
+        /// Événement déclenché lorsqu'il est nécessaire d'ajouter un joueur.
+        /// </summary>
         public event EventHandler<AjouterJoueursEventArgs>? AjouterJoueur;
+
+        /// <summary>
+        /// Événement déclenché lorsqu'une partie commence.
+        /// </summary>
         public event EventHandler<DebutPartieEventArgs>? DebutPartie;
+
+        /// <summary>
+        /// Événement déclenché lorsqu'un nouveau tour commence.
+        /// </summary>
         public event EventHandler<NouveauTourEventArgs>? NouveauTour;
+
+        /// <summary>
+        /// Événement déclenché lorsqu'il est nécessaire d'ajouter un jeton.
+        /// </summary>
         public event EventHandler<AjouterJetonEventArgs>? AjouterJeton;
+
+
+        /// <summary>
+        /// Événement déclenché lorsqu'un jeton est supprimé.
+        /// </summary>
         public event EventHandler<SupprimerDernierJetonEventArgs>? SupprimerDernierJeton;
+
+        /// <summary>
+        /// Événement déclenché lorsqu'un code est ajouté.
+        /// </summary>
         public event EventHandler<AjouterCodeEventArgs>? AjouterCode;
+
+        /// <summary>
+        /// Événement déclenché lorsque la main est passée au joueur suivant.
+        /// </summary>
         public event EventHandler<PasserMainEventArgs>? PasserMain;
+
+        /// <summary>
+        /// Événement déclenché lorsque la partie est terminée.
+        /// </summary>
         public event EventHandler<PartieTermineeEventArgs>? PartieTerminee;
 
+        /// <summary>
+        /// Méthode pour déclencher l'événement de demande d'ajout d'un joueur.
+        /// </summary>
+        /// <param name="numero">Le numéro du joueur à ajouter</param>
+        /// <returns>Le nom du joueur demandé</returns></returns>
         private string? QuandDemanderJoueur(int numero) => DemanderJoueur?.Invoke(this, new DemanderJoueurEventArgs(numero));
-        private Jeton? QuandDemanderJeton() => DemanderJeton?.Invoke(this, new DemanderJetonEventArgs());
 
+        /// <summary>
+        /// Méthode pour déclencher l'événement de demande d'ajout d'un jeton.
+        /// </summary>
+        /// <returns>Le jeton demandé</returns>
+        private Jeton? QuandDemanderJeton() => DemanderJeton?.Invoke(this, new DemanderJetonEventArgs());
 
+        /// <summary>
+        /// Méthode pour déclencher l'événement d'ajout d'un joueur.
+        /// </summary>
+        /// <param name="joueur">Le joueur à ajouter.</param>
         private void QuandAjouterJoueur(Joueur joueur) => AjouterJoueur?.Invoke(this, new AjouterJoueursEventArgs(joueur));
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement du début d'un partie.
+        /// </summary>
         private void QuandDebutPartie() => DebutPartie?.Invoke(this, new DebutPartieEventArgs());
+
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement d'un nouveau tour.
+        /// </summary>
+        /// <param name="joueur">Le joueur dont c'est le tour.</param>
+        /// <param name="tour">Le numéro du tour.</param>
+        /// <param name="grille">La grille de jeu.</param>
+        /// <param name="indicateurs">Les indicateurs de jeu.</param>
         private void QuandNouveauTour(Joueur joueur, int tour, IEnumerable<IEnumerable<Jeton?>> grille, IEnumerable<IEnumerable<Indicateur>> indicateurs) => NouveauTour?.Invoke(this, new NouveauTourEventArgs(joueur, tour, grille, indicateurs));
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement d'ajout d'un nouveau jeton.
+        /// </summary>
+        /// <param name="jeton">Le jeton à ajouter.</param>
         private void QuandNouveauJeton(Jeton jeton) => AjouterJeton?.Invoke(this, new AjouterJetonEventArgs(jeton));
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement de suppression du dernier jeton du code.
+        /// </summary>
         private void QuandSupprimerDernierJeton() => SupprimerDernierJeton?.Invoke(this, new SupprimerDernierJetonEventArgs());
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement d'ajout d'un nouveau code.
+        /// </summary>
+        /// <param name="code">Le code à ajouter.</param>
         private void QuandNouveauCode(Code code) => AjouterCode?.Invoke(this, new AjouterCodeEventArgs(code));
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement de passage de la main au joueur suivant.
+        /// </summary>
         private void QuandPasserMain() => PasserMain?.Invoke(this, new PasserMainEventArgs());
-        private void QuandPartieTerminee(IEnumerable<Joueur> gagnants, IEnumerable<Joueur> perdants) => PartieTerminee?.Invoke(this, new PartieTermineeEventArgs(gagnants, perdants));
 
+        /// <summary>
+        /// Méthode pour déclencher l'événement de fin de partie.
+        /// </summary>
+        /// <param name="gagnants">La liste des joueurs gagnants.</param>
+        /// <param name="perdants">La liste des joueurs perdants.</param>
+        private void QuandPartieTerminee(IEnumerable<Joueur> gagnants, IEnumerable<Joueur> perdants) => PartieTerminee?.Invoke(this, new PartieTermineeEventArgs(gagnants, perdants));
 
+        /// <summary>
+        /// Crée une nouvelle instance de la classe Partie.
+        /// </summary>
+        /// <param name="regles">Les règles de la partie.</param>
         public Partie(IRegles regles)
         {
             this.regles = regles;
         }
 
+        /// <summary>
+        /// Lance le déroulement de la partie.
+        /// </summary>
         public void Jouer()
         {
+            /// Ajout des joueurs jusqu'à atteindre le nombre maximum de joueurs défini par les règles
             while (regles.NbJoueurs != regles.NbJoueursMaximum)
+                while (regles.NbJoueurs != regles.NbJoueursMaximum)
             {
                 string nom = QuandDemanderJoueur(regles.NbJoueurs + 1) ?? $"Joueur {regles.NbJoueurs+1}";
                 Joueur joueur = regles.AjouterJoueur(nom);
                 QuandAjouterJoueur(joueur);
             }
 
+            /// Début de la partie
             regles.CommencerLaPartie();
             QuandDebutPartie();
 
+            /// Boucle principale du jeu qui dure jusqu'à qu'une condition de fin soit déclenchée
             while (!regles.EstTerminee())
             {
                 Joueur joueurCourant = regles.JoueurCourant();
@@ -62,6 +172,7 @@ namespace CoreLibrary
 
                 Code code = regles.GenererCode();
 
+                /// Phase de saisie du code par le joueur jusqu'à que le code soit complet. 
                 while (!code.EstComplet())
                 {
                     Jeton? jeton = QuandDemanderJeton();