diff --git a/Sources/CoreLibrary/Partie.cs b/Sources/CoreLibrary/Partie.cs
index f793400..0709495 100644
--- a/Sources/CoreLibrary/Partie.cs
+++ b/Sources/CoreLibrary/Partie.cs
@@ -7,43 +7,120 @@ using System.Runtime.Serialization;
 
 namespace CoreLibrary
 {
+    /// <summary>
+    /// Classe représentant une partie.
+    /// </summary>
     [DataContract]
     [KnownType(typeof(ReglesClassiques))]
     public class Partie : IEstPersistant
     {
+        /// <summary>
+        /// Evénement déclencher quand il faut ajouter un joueur.
+        /// </summary>
         public event EventHandler<PartieDemanderJoueurEventArgs>? PartieDemanderJoueur;
+
+        /// <summary>
+        /// Evénement déclencher lors du commencement d'une partie.
+        /// </summary>
         public event EventHandler<PartieDebutPartieEventArgs>? PartieDebutPartie;
+
+        /// <summary>
+        /// Evénement déclencher quand il s'agit d'un nouveau tour.
+        /// </summary>
         public event EventHandler<PartieNouveauTourEventArgs>? PartieNouveauTour;
+
+        /// <summary>
+        /// Evénement déclencher quand on passe la main au joueur suivant.
+        /// </summary>
         public event EventHandler<PartiePasserLaMainEventArgs>? PartiePasserLaMain;
+
+        /// <summary>
+        /// Evénement déclencher quand la partie est terminée.
+        /// </summary>
         public event EventHandler<PartiePartieTermineeEventArgs>? PartiePartieTerminee;
 
+        /// <summary>
+        /// Méthode pour déclencher l'événement qui demande le joueur.
+        /// </summary>
+        /// <param name="joueurDemande">.</param>
         private void QuandPartieDemanderJoueur(Joueur joueurDemande) => PartieDemanderJoueur?.Invoke(this, new PartieDemanderJoueurEventArgs(joueurs.Count + 1, joueurDemande));
+
+        /// <summary>
+        /// 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 de nouveau tour.
+        /// </summary>
         private void QuandPartieNouveauTour() => PartieNouveauTour?.Invoke(this, new PartieNouveauTourEventArgs(Tour, joueurs.ElementAt(courant), plateaux.ElementAt(courant), new Code(Regles.TailleCode)));
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement pour passer la main.
+        /// </summary>
         private void QuandPartiePasserLaMain() => PartiePasserLaMain?.Invoke(this, new PartiePasserLaMainEventArgs(joueurs.ElementAt(courant)));
+
+        /// <summary>
+        /// Méthode pour déclencher l'événement si la partie est terminée.
+        /// </summary>
+        /// <param name="gagnants">Liste des joueurs gagnants.</param>
+        /// <param name="perdants">Liste des joueurs perdants.</param>
         private void QuandPartiePartieTerminee(IReadOnlyList<string> gagnants, IReadOnlyList<string> perdants) => PartiePartieTerminee?.Invoke(this, new PartiePartieTermineeEventArgs(gagnants, perdants));
-        
+
+        /// <summary>
+        /// Liste des joueurs.
+        /// </summary>
         [DataMember]
         private readonly List<string> joueurs = new List<string>();
+
+        /// <summary>
+        /// Liste des plateaux.
+        /// </summary>
         [DataMember]
         private readonly List<Plateau> plateaux = new List<Plateau>();
+
+        /// <summary>
+        /// Entier correspondant au joueur courant.
+        /// </summary>
         [DataMember]
         private int courant = 0;
 
+        /// <summary>
+        /// La liste des joueurs remplit.
+        /// </summary>
         public IReadOnlyList<string> Joueurs => joueurs;
+
+        /// <summary>
+        /// Booléen pour suivre le statut de la partie.
+        /// </summary>
         [DataMember]
         public bool Termine { get; private set; } = false;
+
+        /// <summary>
+        /// Entier correspondant au nombre de tour.
+        /// </summary>
         [DataMember]
         public int Tour { get; private set; } = 0;
 
+        /// <summary>
+        /// Regles utiliser dans la partie.
+        /// </summary>
         [DataMember]
         public IRegles Regles { get; private init; }
 
+        /// <summary>
+        /// Premier constructeur de partie.
+        /// </summary>
+        /// <param name="regles">Les règles de la partie.</param>
         public Partie(IRegles regles)
         {
             Regles = regles;
         }
 
+        /// <summary>
+        /// Deuxième constructeur de partie.
+        /// </summary>
+        /// <param name="partie">La partie à reprendre en cours.</param>
         public Partie(Partie partie)
         {
             joueurs = partie.joueurs;
@@ -59,6 +136,9 @@ namespace CoreLibrary
             partie.PartiePartieTerminee = null;
         }
 
+        /// <summary>
+        /// Lance le déroulement de la partie.
+        /// </summary>
         public void Jouer()
         {
             if (joueurs.Count != Regles.NbJoueurs)
@@ -67,6 +147,9 @@ namespace CoreLibrary
                 DebutPartie();
         }
 
+        /// <summary>
+        /// Demande un joueur.
+        /// </summary>
         private void DemanderJoueur()
         {
             Joueur joueurDemande = new Joueur();
@@ -75,6 +158,11 @@ namespace CoreLibrary
             QuandPartieDemanderJoueur(joueurDemande);
         }
 
+        /// <summary>
+        /// Connecte les joueurs à la partie.
+        /// </summary>
+        /// <param name="sender">.</param>
+        /// <param name="e">.</param>
         private void JoueurConnecte(object? sender, JoueurSeConnecterEventArgs e)
         {
             joueurs.Add(e.Nom);
@@ -90,6 +178,9 @@ namespace CoreLibrary
             }
         }
 
+        /// <summary>
+        /// Lance le début de la partie.
+        /// </summary>
         private void DebutPartie()
         {
             if (Tour == 0)
@@ -105,11 +196,19 @@ namespace CoreLibrary
             NouveauTour();
         }
 
+        /// <summary>
+        /// Permet de changer de tour.
+        /// </summary>
         private void NouveauTour()
         {
             QuandPartieNouveauTour();
         }
 
+        /// <summary>
+        /// Ajoute un code au plateau.
+        /// </summary>
+        /// <param name="sender">.</param>
+        /// <param name="e">.</param>
         private void PlateauAjouterCode(object? sender, PlateauAjouterCodeEventArgs e)
         {
             QuandPartiePasserLaMain();
@@ -132,6 +231,9 @@ namespace CoreLibrary
             }
         }
 
+        /// <summary>
+        /// La partie est terminée.
+        /// </summary>
         private void PartieTerminee()
         {
             Termine = true;