Documentations des classes

Sources/CoreLibrary/Code.cs

@@ -2,10 +2,14 @@
 
 namespace CoreLibrary
 {
+    /// <summary>
+    /// Classe représentant un code, composé des jetons et méthodes
+    /// </summary>
     public class Code
     {
         private readonly Jeton?[] lesJetons;
 
+
         public int NbJetons { get; private set; } = 0;
 
         public Code(int tailleCode)

Sources/CoreLibrary/Couleur.cs

@@ -1,7 +1,7 @@
 namespace CoreLibrary
 {
     /// <summary>
-    /// Représente les couleurs disponible pour les jetons.
+    /// Enumération des couleurs disponibles pour les jetons.
     /// </summary>
     public enum Couleur
     {

Sources/CoreLibrary/IRegles.cs

@@ -6,34 +6,34 @@
     public interface IRegles
     {
         /// <summary>
-        /// Obtient le nom des règles du jeu.
+        /// Le nom des règles du jeu.
         /// </summary>
         string Nom { get; }
 
         /// <summary>
-        /// Obtient le nombre de maximum de tours. 
+        /// Le nombre de maximum de tours. 
         /// </summary>
         int TourMaximum { get; }
 
         /// <summary>
-        /// Obtient la taille maximal du code.
+        /// La taille maximal du code.
         /// </summary>
         int TailleCodeMaximum { get; }
 
         /// <summary>
-        /// Obtient le nombre de joueurs actuels.
+        /// Le nombre de joueurs actuels.
         /// </summary>
         int NbJoueurs { get; }
 
         /// <summary>
-        /// Obtient le nombre de maximum de joueurs.
+        /// Le nombre maximum de joueurs.
         /// </summary>
         int NbJoueursMaximum { get; }
 
         /// <summary>
-        /// Ajoute un joueur avec le nom spécifié.
+        /// Ajoute un joueur à partir de son nom.
         /// </summary>
-        /// <param name="nom">Nom du joueur à ajouter</param>
+        /// <param name="nom">Nom du joueur à ajouter.</param>
         /// <returns>Le joueur ajouté.</returns>
         Joueur AjouterJoueur(string nom);
 
@@ -55,7 +55,7 @@
         Code GenererCode();
 
         /// <summary>
-        /// Initialise le premier joueur à jouer.
+        /// Démarre la partie.
         /// </summary>
         void CommencerLaPartie();
 
@@ -68,13 +68,13 @@
         /// <summary>
         /// Récupère les joueurs gagnants.
         /// </summary>
-        /// <returns>Enumération des joueurs gagnants.</returns>
+        /// <returns>Les joueurs gagnants.</returns>
         IEnumerable<Joueur> Gagnants();
 
         /// <summary>
         /// Récupère les joueurs perdants.
         /// </summary>
-        /// <returns>Enumération des joueurs perdants.</returns>
+        /// <returns>Les joueurs perdants.</returns>
         IEnumerable<Joueur> Perdants();
     }
 }

Sources/CoreLibrary/Indicateur.cs

@@ -1,7 +1,7 @@
 namespace CoreLibrary
 {
     /// <summary>
-    /// Représente les couleurs disponibles pour les indicateurs.
+    /// Enumération des indicateurs disponibles pour les jetons.
     /// </summary>
     public enum Indicateur
     {

Sources/CoreLibrary/Jeton.cs

@@ -1,12 +1,12 @@
 namespace CoreLibrary
 {
     /// <summary>
-    /// Représente un jetons de couleur.
+    /// Structure représentant un jeton de couleur
     /// </summary>
     public struct Jeton
     {
         /// <summary>
-        /// Obtient la couleur du jeton.
+        /// La couleur du jeton.
         /// </summary>
         public readonly Couleur Couleur { get; private init; }
 

Sources/CoreLibrary/Joueur.cs

@@ -1,24 +1,24 @@
 namespace CoreLibrary
 {
     /// <summary>
-    /// Représente un joueur.
+    /// Classe représentant un joueur.
     /// </summary>
     public class Joueur
     {
         /// <summary>
-        /// Obtient le nom du joueur.
+        /// Le nom du joueur.
         /// </summary>
         public string Nom { get; private init; }
         /// <summary>
-        /// Obtient le plateau du joueur.
+        /// Le plateau du joueur.
         /// </summary>
         public Plateau Plateau { get; private init; }
 
         /// <summary>
         /// Crée une nouvelle instance de joueur avec un nom et un plateau spécifié. 
         /// </summary>
-        /// <param name="nom">Le nom du joueur</param>
-        /// <param name="plateau">Le plateau du joueur</param>
+        /// <param name="nom">Le nom du joueur.</param>
+        /// <param name="plateau">Le plateau du joueur.</param>
         public Joueur(string nom, Plateau plateau)
         {
             Nom = nom;

Sources/CoreLibrary/Partie.cs

@@ -1,5 +1,4 @@
 using CoreLibrary.Events;
-using CoreLibrary.Exceptions;
 
 namespace CoreLibrary
 {

Sources/CoreLibrary/Plateau.cs

@@ -4,7 +4,7 @@ using System.Security.Cryptography;
 namespace CoreLibrary
 {
     /// <summary>
-    /// Représente un plateau de jeu composer de code
+    /// Classe représentant un plateau de jeu composé de codes et leurs indicateurs ainsi que les méthodes associées.
     /// </summary>
     public class Plateau
     {
@@ -15,22 +15,22 @@ namespace CoreLibrary
         private readonly int tailleCode;
 
         /// <summary>
-        /// Obtient le numéro de tour actuel.
+        /// Le numéro de tour actuel.
         /// </summary>
         public int Tour { get; private set; } = 1;
 
         /// <summary>
-        /// Obtient True si le joueur a gagné sinon False
+        /// La victoire du joueur, 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>
+        /// <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érieure ou égale à 0.</exception>
+        /// <exception cref="TailleGrilleException">Levée lorsque la tailleGrille est inférieure ou égale à 0.</exception>
         public Plateau(int tailleCode, int tailleGrille)
         {
             if(tailleCode <= 0)
@@ -53,7 +53,7 @@ namespace CoreLibrary
         }
 
         /// <summary>
-        /// Génère un code secret aléatoire en utilisant des jetons de couleurs aléatoire. 
+        /// Génère un code secret aléatoire en utilisant des jetons de couleurs aléatoires. 
         /// </summary>
         private void GenererCodeAleatoire()
         {
@@ -75,7 +75,7 @@ namespace CoreLibrary
         }
 
         /// <summary>
-        ///  Ajoute le code fourni au plateau de jeu.
+        /// 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>
@@ -106,7 +106,7 @@ namespace CoreLibrary
         /// 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>
+        /// <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)
@@ -142,7 +142,7 @@ namespace CoreLibrary
         /// <summary>
         /// Récupère le plateau de jeu.
         /// </summary>
-        /// <returns>Le plateau de jeu représenté sous forme d'une collections de jetons.</returns>
+        /// <returns>Le plateau de jeu représenté sous forme d'un tableau de tableau de jetons.</returns>
         public IEnumerable<IEnumerable<Jeton?>> Grille()
         {
             IEnumerable<Jeton?>[] grilleJetons = new IEnumerable<Jeton?>[grille.Length];
@@ -158,7 +158,7 @@ namespace CoreLibrary
         /// <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>
+        /// <returns>Les indicateurs pour chaque tour représentés sous forme d'un tableau de tableau d'indicateurs.</returns>
         public IEnumerable<IEnumerable<Indicateur>> Indicateurs()
         {
             return indicateurs;

Sources/CoreLibrary/ReglesClassiques.cs

@@ -3,7 +3,7 @@
 namespace CoreLibrary
 {
     /// <summary>
-    /// Implémente les règles du jeu.
+    /// Classe définissant les règles classiques du jeu.
     /// </summary>
     public class ReglesClassiques : IRegles
     {
@@ -12,39 +12,40 @@ namespace CoreLibrary
         private readonly Joueur[] joueurs;
 
         /// <summary>
-        /// Obtient le nom des règles.
+        /// Le nom des règles.
         /// </summary>
         public string Nom { get => "Règles classiques"; }
 
         /// <summary>
-        /// Obtient le nombre maximum de tours.
+        /// Le nombre maximum de tour.
         /// </summary>
         public int TourMaximum { get => 12; }
 
         /// <summary>
-        /// Obtient la taille maximale d'un code.
+        /// La taille maximale d'un code.
         /// </summary>
+
         public int TailleCodeMaximum { get => 4; }
         /// <summary>
-        /// Obtient le nombre de joueurs actuels dans le jeu.
+        /// 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.
+        /// Me nombre maximum de joueurs possibles 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.
+        /// Initialise une nouvelle instance de la classe <see cref="ReglesClassiques"/>
         /// </summary>
         public ReglesClassiques()
         {
             joueurs = new Joueur[NbJoueursMaximum];
         }
 
-
-
         /// <summary>
         /// Ajoute un joueur avec le nom spécifié.
         /// </summary>
@@ -61,7 +62,7 @@ namespace CoreLibrary
         /// 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>
+        /// <exception cref="PartieNonCommenceeException">Levée lorsque la partie n'a pas commencée.</exception>
 
         public Joueur JoueurCourant()
         {
@@ -74,7 +75,7 @@ namespace CoreLibrary
         /// <summary>
         /// Passe la main au joueur suivant.
         /// </summary>
-        /// <exception cref="PartieNonCommenceeException">Levée lorsqu'il n'y a pas de joueur courant.</exception>
+        /// <exception cref="PartieNonCommenceeException">Levée lorsque la partie n'a pas commmencée.</exception>
         public void PasserLaMain()
         {
             if (!joueurCourant.HasValue)
@@ -91,24 +92,22 @@ namespace CoreLibrary
         }
 
         /// <summary>
-        /// Génère un nouveau code.
+        /// Génère un nouveau code respectant les règles classiques.
         /// </summary>
-        /// <returns>Le code généré</returns>
-
+        /// <returns>Le code généré.</returns>
         public Code GenererCode()
         {
             return new Code(TailleCodeMaximum);
         }
 
         /// <summary>
-        /// Initialise le premier joueur à jouer.
+        /// Démarre la partie en décidant que le premier joueur commence.
         /// </summary>
         public void CommencerLaPartie()
         {
             joueurCourant = 0;
         }
 
-
         /// <summary>
         /// Vérifie si la partie est terminée.
         /// </summary>