Ajout de la doc pour Plateau, RegleClassique, Exception

Sources/CoreLibrary/Exceptions/CodeCompletException.cs

@@ -1,7 +1,13 @@
 namespace CoreLibrary.Exceptions
 {
+    /// <summary>
+    /// Exception levée lorsqu'un jeton est ajouté à un code déjà complet.
+    /// </summary>
     public class CodeCompletException : Exception
     {
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeCompletException"/>.
+        /// </summary>
         public CodeCompletException() :
             base("Le code dans lequel vous essayez d'ajouter un jeton est déjà complet.")
         { }

Sources/CoreLibrary/Exceptions/CodeIncompletException.cs

@@ -1,7 +1,13 @@
 namespace CoreLibrary.Exceptions
 {
+    /// <summary>
+    /// Exception levée lorsqu'un code incomplet est ajouté à la grille.
+    /// </summary>
     public class CodeIncompletException : Exception
     {
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeIncompletException"/>.
+        /// </summary>
         public CodeIncompletException() :
             base("Le code que vous essayez d'ajouter dans la grille n'est pas complet.")
         { }

Sources/CoreLibrary/Exceptions/CodeInvalideException.cs

@@ -1,7 +1,15 @@
 namespace CoreLibrary.Exceptions
 {
+    /// <summary>
+    /// Exception levée lorsqu'un code avec une taille invalide est ajouté à la grille.
+    /// </summary>
     public class CodeInvalideException : Exception
     {
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeInvalideException"/>.
+        /// </summary>
+        /// <param name="tailleCodeAjoute">La taille du code que vous essayez d'ajouter.</param>
+        /// <param name="tailleCodePlateau">La taille du code que le plateau attend.</param>
         public CodeInvalideException(int tailleCodeAjoute, int tailleCodePlateau) :
             base($"Le code que vous essayez d'ajouter est un code de taille {tailleCodeAjoute}, or le plateau attend un code de {tailleCodePlateau}.")
         { }

Sources/CoreLibrary/Exceptions/CodeVideException.cs

@@ -1,7 +1,13 @@
 namespace CoreLibrary.Exceptions
 {
+    /// <summary>
+    /// Exception levée lorsqu'un jeton est supprimé d'un code qui est déjà vide.
+    /// </summary>
     public class CodeVideException : Exception
     {
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeVideException"/>.
+        /// </summary>
         public CodeVideException() :
             base("Le code dans lequel vous essayez de supprimer un jeton est déjà vide.")
         { }

Sources/CoreLibrary/Exceptions/GrilleCompleteException.cs

@@ -1,7 +1,13 @@
 namespace CoreLibrary.Exceptions
 {
+    /// <summary>
+    /// Exception levée lorsqu'un code est ajouté à une grille qui est déjà complète.
+    /// </summary>
     public class GrilleCompleteException : Exception
     {
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="GrilleCompleteException"/>.
+        /// </summary>
         public GrilleCompleteException() :
             base("La grille dans laquelle vous essayez d'ajouter un code est déjà complète.")
         { }

Sources/CoreLibrary/Exceptions/IndiceCodeException.cs

@@ -1,7 +1,15 @@
 namespace CoreLibrary.Exceptions
 {
+    /// <summary>
+    /// Exception levée lorsqu'un indice de jeton est invalide.
+    /// </summary>
     public class IndiceCodeException : Exception
     {
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="IndiceCodeException"/>.
+        /// </summary>
+        /// <param name="indice">L'indice incorrect qui a été spécifié.</param>
+        /// <param name="indiceMax">L'indice maximum permis.</param>
         public IndiceCodeException(int indice, int indiceMax) :
             base($"Vous avez essayé de récupérer le jeton à la place {indice}, mais son indice doit être compris entre 0 et {indiceMax}.")
         { }

Sources/CoreLibrary/Exceptions/PartieNonCommenceeException.cs

@@ -1,7 +1,13 @@
 namespace CoreLibrary.Exceptions
 {
+    /// <summary>
+    /// Exception levée lorsqu'une opération est tentée alors que la partie n'a pas encore commencé.
+    /// </summary>
     public class PartieNonCommenceeException : Exception
     {
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="PartieNonCommenceeException"/>.
+        /// </summary>
         public PartieNonCommenceeException() :
             base("La partie n'a pas encore commencée.")
         { }

Sources/CoreLibrary/Exceptions/TailleCodeException.cs

@@ -1,7 +1,14 @@
 namespace CoreLibrary.Exceptions
 {
+    /// <summary>
+    /// Exception levée lorsqu'une taille de code invalide est spécifiée.
+    /// </summary>
     public class TailleCodeException : Exception
     {
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleCodeException"/>.
+        /// </summary>
+        /// <param name="taille">La taille du code spécifiée.</param>
         public TailleCodeException(int taille) : 
             base($"Un code doit avoir une taille positive non nulle, or il a reçu {taille}.")
         { }

Sources/CoreLibrary/Exceptions/TailleGrilleException.cs

@@ -1,7 +1,14 @@
 namespace CoreLibrary.Exceptions
 {
+    /// <summary>
+    /// Exception levée lorsqu'une taille de grille invalide est spécifiée.
+    /// </summary>
     public class TailleGrilleException : Exception
     {
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleGrilleException"/>.
+        /// </summary>
+        /// <param name="taille">La taille de grille spécifiée.</param>
         public TailleGrilleException(int taille) : 
             base($"Une grille doit avoir une taille positive non nulle, or elle a reçu {taille}.")
         { }

Sources/CoreLibrary/Plateau.cs

@@ -2,6 +2,9 @@
 
 namespace CoreLibrary
 {
+    /// <summary>
+    /// Représente un plateau de jeu composer de code
+    /// </summary>
     public class Plateau
     {
         private static Random random = new Random();
@@ -12,9 +15,23 @@ namespace CoreLibrary
 
         private readonly int tailleCode;
 
+        /// <summary>
+        /// Obtient le numéro de tour actuel.
+        /// </summary>
         public int Tour { get; private set; } = 1;
+
+        /// <summary>
+        /// Obtient True si le joueur a gagné sinon False
+        /// </summary>
         public bool Victoire { get; private set; } = false;
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="Plateau"/>.
+        /// </summary>
+        /// <param name="tailleCode">Taille des codes du plateau</param>
+        /// <param name="tailleGrille">Taille du plateau de jeu</param>
+        /// <exception cref="TailleCodeException">Levée lorsque la tailleCode est inférieur ou égal à 0.</exception>
+        /// <exception cref="TailleGrilleException">Levée lorsque la tailleGrille est inférieur ou égal à 0.</exception>
         public Plateau(int tailleCode, int tailleGrille)
         {
             if(tailleCode <= 0)
@@ -36,6 +53,9 @@ namespace CoreLibrary
             GenererCodeAleatoire();
         }
 
+        /// <summary>
+        /// Génère un code secret aléatoire en utilisant des jetons de couleurs aléatoire. 
+        /// </summary>
         private void GenererCodeAleatoire()
         {
             Couleur[] couleurs = (Couleur[])Enum.GetValues(typeof(Couleur));
@@ -46,11 +66,21 @@ namespace CoreLibrary
             }
         }
 
+        /// <summary>
+        /// Vérifie si le plateau de jeu est plein.
+        /// </summary>
+        /// <returns>True si la tableau est plein, sinon False.</returns>
         public bool EstComplet()
         {
             return Tour - 1 == grille.Length;
         }
 
+        /// <summary>
+        ///  Ajoute le code fourni au plateau de jeu.
+        /// </summary>
+        /// <param name="code">Le code à ajouter au plateau de jeu.</param>
+        /// <exception cref="CodeInvalideException">Levée lorsque le code fourni à une taille invalide.</exception>
+        /// <exception cref="CodeIncompletException">Levée lorsque le code fourni est incomplet.</exception>
         public void AjouterCode(Code code)
         {
             if (code.TailleMaximale() != tailleCode) 
@@ -73,6 +103,13 @@ namespace CoreLibrary
             }
         }
 
+        /// <summary>
+        /// Vérifie si le code fourni correspond au code secret.
+        /// </summary>
+        /// <param name="code">Le code à vérifier.</param>
+        /// <returns>True si le code fourni correspond au code secret, sinon False </returns>
+        /// <exception cref="CodeInvalideException">Levée lorsque le code fourni à une taille invalide.</exception>
+        /// <exception cref="CodeIncompletException">Levée lorsque le code fourni est incomplet.</exception>
         public bool EstBonCode(Code code)
         {
             if (code.TailleMaximale() != tailleCode)
@@ -103,6 +140,10 @@ namespace CoreLibrary
             return true;
         }
 
+        /// <summary>
+        /// Récupère le plateau de jeu.
+        /// </summary>
+        /// <returns>Le plateau de jeu représenté sous forme d'une collections de jetons.</returns>
         public IEnumerable<IEnumerable<Jeton?>> Grille()
         {
             IEnumerable<Jeton?>[] grilleJetons = new IEnumerable<Jeton?>[grille.Length];
@@ -115,6 +156,10 @@ namespace CoreLibrary
             return grilleJetons;
         }
 
+        /// <summary>
+        /// Récupère les indicateurs pour chaque tour.
+        /// </summary>
+        /// <returns>Les indicateurs pour chaque tour représentés sous forme d'une collections d'indicateurs.</returns>
         public IEnumerable<IEnumerable<Indicateur>> Indicateurs()
         {
             return indicateurs;

Sources/CoreLibrary/ReglesClassiques.cs

@@ -2,26 +2,53 @@
 
 namespace CoreLibrary
 {
+    /// <summary>
+    /// Implémente les règles classiques 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; }
-        public int NbJoueursMaximum { get => 2; }
 
+        /// <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));
@@ -29,6 +56,11 @@ 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)
@@ -37,6 +69,10 @@ 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)
@@ -52,19 +88,27 @@ 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)
@@ -83,6 +127,10 @@ namespace CoreLibrary
         }
 
 
+        /// <summary>
+        /// Obtient les joueurs gagnants de la partie.
+        /// </summary>
+        /// <returns>La liste des joueurs gagnants.</returns>
         public IEnumerable<Joueur> Gagnants()
         {
             Joueur[] gagnants = [];
@@ -97,6 +145,10 @@ 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 = [];