doc Partie

Sources/CoreLibrary/Partie.cs

@@ -16,28 +16,32 @@ namespace CoreLibrary
     public class Partie : IEstPersistant
     {
         /// <summary>
-        /// Evénement déclencher quand il faut ajouter un joueur.
+        /// Evénement déclenché lorsqu'il faut ajouter un joueur à la partie.
         /// </summary>
         public event EventHandler<PartieDemanderJoueurEventArgs>? PartieDemanderJoueur;
 
         /// <summary>
-        /// Evénement déclencher lors du commencement d'une partie.
+        /// Evénement déclenché lors du commencement de la partie.
         /// </summary>
         public event EventHandler<PartieDebutPartieEventArgs>? PartieDebutPartie;
+
+        /// <summary>
+        /// Evénement déclenché lorsqu'il faut demander à un joueur de jouer.
+        /// </summary>
         public event EventHandler<PartieDemanderJoueurJouerEventArgs>? PartieDemanderJoueurJouer;
 
         /// <summary>
-        /// Evénement déclencher quand il s'agit d'un nouveau tour.
+        /// Evénement déclenché lorsqu'un nouveau tour commence.
         /// </summary>
         public event EventHandler<PartieNouveauTourEventArgs>? PartieNouveauTour;
 
         /// <summary>
-        /// Evénement déclencher quand on passe la main au joueur suivant.
+        /// Evénement déclenché lorsqu'on passe la main au joueur suivant.
         /// </summary>
         public event EventHandler<PartiePasserLaMainEventArgs>? PartiePasserLaMain;
 
         /// <summary>
-        /// Evénement déclencher quand la partie est terminée.
+        /// Evénement déclenché lorsque la partie est terminée.
         /// </summary>
         public event EventHandler<PartiePartieTermineeEventArgs>? PartiePartieTerminee;
 
@@ -51,44 +55,79 @@ namespace CoreLibrary
         /// Méthode pour déclencher l'événement de début de partie.
         /// </summary>
         private void QuandPartieDebutPartie() => PartieDebutPartie?.Invoke(this, new PartieDebutPartieEventArgs());
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement demandant à un joueur de jouer.
+        /// </summary>
+        /// <param name="code">Le code à utiliser pour jouer.</param>
         private void QuandPartieDemanderJoueurJouer(Code code) => PartieDemanderJoueurJouer?.Invoke(this, new PartieDemanderJoueurJouerEventArgs(Tour, Joueurs.ElementAt(courant), plateaux.ElementAt(courant), code, joueurs[Joueurs.ElementAt(courant)]));
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement d'un nouveau tour.
+        /// </summary>
+        /// <param name="code">Le code utilisé pour le nouveau tour.</param>
         private void QuandPartieNouveauTour(Code code) => PartieNouveauTour?.Invoke(this, new PartieNouveauTourEventArgs(Tour, Joueurs.ElementAt(courant), plateaux.ElementAt(courant), code, joueurs[Joueurs.ElementAt(courant)]));
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement de passer la main au joueur suivant.
+        /// </summary>
         private void QuandPartiePasserLaMain() => PartiePasserLaMain?.Invoke(this, new PartiePasserLaMainEventArgs(Joueurs.ElementAt(courant)));
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement de fin de partie.
+        /// </summary>
+        /// <param name="gagnants">Liste des noms des joueurs gagnants.</param>
+        /// <param name="perdants">Liste des noms des joueurs perdants.</param>
         private void QuandPartiePartieTerminee(IReadOnlyList<string> gagnants, IReadOnlyList<string> perdants) => PartiePartieTerminee?.Invoke(this, new PartiePartieTermineeEventArgs(gagnants, perdants));
 
         /// <summary>
-        /// Liste des joueurs.
+        /// Dictionnaire des joueurs, avec leur nom et le statut de leur joueur (humain ou robot).
         /// </summary>
         [DataMember]
         private readonly Dictionary<string, bool> joueurs = new Dictionary<string, bool>();
+
+        /// <summary>
+        /// Liste des plateaux de jeu.
+        /// </summary
         [DataMember]
         private readonly List<Plateau> plateaux = new List<Plateau>();
 
         /// <summary>
-        /// Entier correspondant au joueur courant.
+        /// Indice correspondant au joueur courant.
         /// </summary>
         [DataMember]
         private int courant = 0;
 
+        /// <summary>
+        /// Liste des noms des joueurs.
+        /// </summary>
         public IReadOnlyList<string> Joueurs => joueurs.Keys.ToList();
+
+        /// <summary>
+        /// Liste des noms des robots.
+        /// </summary>
         public IReadOnlyList<string> Robots => joueurs.Where(joueur => joueur.Value).Select(joueur => joueur.Key).ToList();
+
+        /// <summary>
+        /// Indique si la partie est terminée.
+        /// </summary>
         [DataMember]
         public bool Termine { get; private set; } = false;
 
         /// <summary>
-        /// Entier correspondant au nombre de tour.
+        /// Numéro du tour actuel.
         /// </summary>
         [DataMember]
         public int Tour { get; private set; } = 0;
 
         /// <summary>
-        /// Regles utiliser dans la partie.
+        /// Règles utilisées dans la partie.
         /// </summary>
         [DataMember]
         public IRegles Regles { get; private init; }
 
         /// <summary>
-        /// Premier constructeur de partie.
+        /// Premier constructeur de la partie.
         /// </summary>
         /// <param name="regles">Les règles de la partie.</param>
         public Partie(IRegles regles)
@@ -97,7 +136,7 @@ namespace CoreLibrary
         }
 
         /// <summary>
-        /// Deuxième constructeur de partie.
+        /// Deuxième constructeur de la partie.
         /// </summary>
         /// <param name="partie">La partie à reprendre en cours.</param>
         public Partie(Partie partie)
@@ -144,8 +183,8 @@ namespace CoreLibrary
         /// <summary>
         /// Connecte les joueurs à la partie.
         /// </summary>
-        /// <param name="sender">La class qui appelle l'évenement; ici Joueur.</param>
-        /// <param name="e">L'instance de l'événement PlateauAjouterCodeEventArgs créée par Joueur.</param>
+        /// <param name="sender">La classe qui appelle l'événement, ici Joueur.</param>
+        /// <param name="e">L'instance de l'événement JoueurSeConnecterEventArgs créée par Joueur.</param>
         private void JoueurConnecte(object? sender, JoueurSeConnecterEventArgs e)
         {
             joueurs.Add(e.Joueur.Nom, e.Joueur.GetType().Equals(typeof(Joueur)));
@@ -182,7 +221,7 @@ namespace CoreLibrary
         }
 
         /// <summary>
-        /// Permet de changer de tour.
+        /// Passe au tour suivant.
         /// </summary>
         private void NouveauTour()
         {
@@ -195,7 +234,7 @@ namespace CoreLibrary
         /// <summary>
         /// Ajoute un code au plateau.
         /// </summary>
-        /// <param name="sender">La class qui appelle l'évenement; ici Plateau </param>
+        /// <param name="sender">La classe qui appelle l'événement, ici Plateau.</param>
         /// <param name="e">L'instance de l'événement PlateauAjouterCodeEventArgs créée par Plateau.</param>
         private void PlateauAjouterCode(object? sender, PlateauAjouterCodeEventArgs e)
         {