Merge branch 'Partie' into DBCamille

Sources/ConsoleApp/Evenements.cs

@@ -14,19 +14,19 @@ namespace ConsoleApp
         /// <summary>
         /// Ecoute l'événement en rapport avec la demande du nom d'un joueur.
         /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-        /// <param name="e">L'instance de l'événement DemanderJoueurEventArgs créée par Partie.</param>
+        /// <param name="e">L'instance de l'événement DemanderNomEventArgs créée par Partie.</param>
         /// <returns>Le nom du joueur.</returns>
         /// </summary>
-        public static string? DemanderJoueur(Object? sender, DemanderJoueurEventArgs e)
+        public static void DemanderNom(Object? sender, DemanderNomEventArgs e)
         {
-            Console.WriteLine($"Joueur {e.Numero}");
+            Console.WriteLine($"Joueur {e.Indice}");
             Console.Write(">>> ");
 
             string? nom = Console.ReadLine();
 
             Console.WriteLine();
 
-            return nom;
+            e.JoueurBuilder.Nom(nom);
         }
 
 
@@ -57,84 +57,23 @@ namespace ConsoleApp
 
             Console.WriteLine();
 
-        }
-
-        /// <summary>
-        /// Ecoute l'événement en rapport avec la demande d'un jeton.
-        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-        /// <param name="e">L'instance de l'événement DemanderJetonEventArgs créée par Partie.</param>
-        /// <returns>Le jeton choisi par le joueur.</returns>
-        /// </summary>
-        public static Jeton? DemanderJeton(Object? sender, DemanderJetonEventArgs e)
+            Code code = e.Code;
+            while(!code.EstComplet())
             {
-            Console.TreatControlCAsInput = true;
-            Console.CursorVisible = false;
-
-            bool aChoisi = false;
-            int indice = 0;
-            Couleur[] couleurs = (Couleur[])Enum.GetValues(typeof(Couleur));
-
-            while (!aChoisi)
+                Jeton? jeton = Utils.SaisirJeton(code.NbJetons);
+                if (jeton.HasValue)
                 {
-                Utils.DessinerPion(couleurs[indice]);
-                Console.Write("\b\b\b");
-
-                switch (Console.ReadKey(true).Key)
-                {
-                    case ConsoleKey.Enter:
-                        aChoisi = true;
-                        break;
-
-                    case ConsoleKey.LeftArrow:
-                        --indice;
-                        break;
-
-                    case ConsoleKey.RightArrow:
-                        ++indice;
-                        break;
-
-                    case ConsoleKey.Escape:
-                        if (e.Indice != 0)
-                        {
-                            aChoisi = true;
-                            indice = -2;
-                        }
-                        break;
-
-                    default:
-                        break;
+                    Utils.DessinerPion(jeton.Value.Couleur);
+                    code.AjouterJeton(jeton.Value);
                 }
-
-                if (indice == -1)
-                    indice = couleurs.Length - 1;
-                else if (indice == couleurs.Length)
-                    indice = 0;
-            }
-
-            Console.TreatControlCAsInput = false;
-            Console.CursorVisible = true;
-
-            return indice != -2 ? new Jeton(couleurs[indice]) : null;
-        }
-
-        /// <summary>
-        /// Ecoute l'événement en rapport avec l'ajout d'un jeton dans le code.
-        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-        /// <param name="e">L'instance de l'événement AjouterJetonEventArgs créée par Partie.</param>
-        /// </summary>
-        public static void AjouterJeton(Object? sender, AjouterJetonEventArgs e)
+                else
                 {
-            Utils.DessinerPion(e.Jeton.Couleur);
+                    Utils.SupprimerDernierJeton();
+                    code.SupprimerDernierJeton();
+                }
             }
 
-        /// <summary>
-        /// Ecoute l'événement en rapport avec la suppression du dernier jeton ajouté dans le code.
-        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-        /// <param name="e">L'instance de l'événement SupprimerDernierJetonEventArgs créée par Partie.</param>
-        /// </summary>
-        public static void SupprimerDernierJeton(Object? sender, SupprimerDernierJetonEventArgs e)
-        {
-            Console.Write("\b\b\b      \b\b\b\b\b\b");
+            e.Joueur.Code(code);
         }
 
         /// <summary>

Sources/ConsoleApp/Program.cs

@@ -17,12 +17,9 @@ namespace ConsoleApp
 
             Partie maPartie = new Partie(new ReglesClassiques());
 
-            maPartie.DemanderJoueur += Evenements.DemanderJoueur;
+            maPartie.DemanderNom += Evenements.DemanderNom;
             maPartie.DebutPartie += Evenements.CommencerLaPartie;
             maPartie.NouveauTour += Evenements.NouveauTour;
-            maPartie.DemanderJeton += Evenements.DemanderJeton;
-            maPartie.AjouterJeton += Evenements.AjouterJeton;
-            maPartie.SupprimerDernierJeton += Evenements.SupprimerDernierJeton;
             maPartie.AjouterCode += Evenements.AjouterCode;
             maPartie.PartieTerminee += Evenements.PartieTerminee;
 

Sources/ConsoleApp/Utils.cs

@@ -137,5 +137,71 @@ namespace ConsoleApp
             Console.WriteLine("│              │   │              │");
             Console.WriteLine("────────────────   ────────────────");
         }
+
+        /// <summary>
+        /// Permet à l'utilisateur de choisir un jeton
+        /// <param name="indiceCode">L'indice du jeton à ajouter dans le code.</param>
+        /// <returns>Le jeton choisi par le joueur.</returns>
+        /// </summary>
+        public static Jeton? SaisirJeton(int indiceCode)
+        {
+            Console.TreatControlCAsInput = true;
+            Console.CursorVisible = false;
+
+            bool aChoisi = false;
+            int indice = 0;
+            Couleur[] couleurs = (Couleur[])Enum.GetValues(typeof(Couleur));
+
+            while (!aChoisi)
+            {
+                DessinerPion(couleurs[indice]);
+                Console.Write("\b\b\b");
+
+                switch (Console.ReadKey(true).Key)
+                {
+                    case ConsoleKey.Enter:
+                        aChoisi = true;
+                        break;
+
+                    case ConsoleKey.LeftArrow:
+                        --indice;
+                        break;
+
+                    case ConsoleKey.RightArrow:
+                        ++indice;
+                        break;
+
+                    case ConsoleKey.Escape:
+                        if (indiceCode != 0)
+                        {
+                            aChoisi = true;
+                            indice = -2;
+                        }
+                        break;
+
+                    default:
+                        break;
+                }
+
+                if (indice == -1)
+                    indice = couleurs.Length - 1;
+                else if (indice == couleurs.Length)
+                    indice = 0;
+            }
+
+            Console.TreatControlCAsInput = false;
+            Console.CursorVisible = true;
+
+            return indice != -2 ? new Jeton(couleurs[indice]) : null;
+        }
+
+
+        /// <summary>
+        /// Permet de supprimer le dernier jeton saisi
+        /// </summary>
+        public static void SupprimerDernierJeton()
+        {
+            Console.Write("\b\b\b      \b\b\b\b\b\b");
+        }
     }
 }

Sources/CoreLibrary/Events/AjouterJetonEventArgs.cs

@@ -1,24 +0,0 @@
-using CoreLibrary.Core;
-
-namespace CoreLibrary.Events
-{
-    /// <summary>
-    /// Classe contenant les arguments passées en paramètre lors de l'événement AjouterJeton.
-    /// </summary>
-    public class AjouterJetonEventArgs : EventArgs
-    {
-        /// <summary>
-        /// Le jeton ajouté.
-        /// </summary>
-        public Jeton Jeton { get; private set; }
-
-        /// <summary>
-        /// Initialise une nouvelle instance de la classe <see cref="AjouterJetonEventArgs"/> avec le jeton spécifié.
-        /// </summary>
-        /// <param name="jeton">Le jeton qui a été ajouté.</param>
-        public AjouterJetonEventArgs(Jeton jeton) 
-        {
-            Jeton = jeton;
-        }
-    }
-}

Sources/CoreLibrary/Events/AjouterJoueurEventArgs.cs

@@ -5,7 +5,7 @@ namespace CoreLibrary.Events
     /// <summary>
     /// Classe contenant les arguments passées en paramètre lors de l'événement AjouterJoueur.
     /// </summary>
-    public class AjouterJoueursEventArgs : EventArgs
+    public class AjouterJoueurEventArgs : EventArgs
     {
         /// <summary>
         /// Le joueur ajouté.
@@ -13,10 +13,10 @@ namespace CoreLibrary.Events
         public Joueur Joueur { get; private set; }
 
         /// <summary>
-        /// Initialise une nouvelle instance de la classe <see cref="AjouterJoueursEventArgs"/> avec le joueur spécifié.
+        /// Initialise une nouvelle instance de la classe <see cref="AjouterJoueurEventArgs"/> avec le joueur spécifié.
         /// </summary>
         /// <param name="joueur">Le joueur qui a été ajouté.</param>
-        public AjouterJoueursEventArgs(Joueur joueur) 
+        public AjouterJoueurEventArgs(Joueur joueur) 
         {
             Joueur = joueur;
         }

Sources/CoreLibrary/Events/ConstruireJoueurEventArgs.cs

@@ -0,0 +1,22 @@
+namespace CoreLibrary.Events
+{
+    /// <summary>
+    /// Classe contenant les arguments passées en paramètre lors de l'événement ConstruireJoueurEventArgs.
+    /// </summary>
+    public class ConstruireJoueurEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Le nom du joueur à ajouter.
+        /// </summary>
+        public string? Nom { get; private set; }
+
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="ConstruireJoueurEventArgs"/> avec les informations spécifiées.
+        /// </summary>
+        /// <param name="code">Le nom du joueur à ajouter.</param>
+        public ConstruireJoueurEventArgs(string? nom)
+        {
+            Nom = nom;
+        }
+    }
+}

Sources/CoreLibrary/Events/DemanderJetonEventArgs.cs

@@ -1,22 +0,0 @@
-namespace CoreLibrary.Events
-{
-    /// <summary>
-    /// Classe contenant les arguments passées en paramètre lors de l'événement DemanderJeton.
-    /// </summary>
-    public class DemanderJetonEventArgs : EventArgs
-    {
-        /// <summary>
-        /// L'indice du code où le jeton va être ajouté.
-        /// </summary>
-        public int Indice {  get; private set; }
-
-        /// <summary>
-        /// Initialise une nouvelle instance de la classe <see cref="DemanderJetonEventArgs"/> avec l'indice spécifié.
-        /// </summary>
-        /// <param name="joueur">L'indice du jeton qui va été ajouté.</param>
-        public DemanderJetonEventArgs(int indice) 
-        {
-            Indice = indice;
-        }
-    }
-}

Sources/CoreLibrary/Events/DemanderJoueurEventArgs.cs

@@ -1,23 +0,0 @@
-namespace CoreLibrary.Events
-{
-    /// <summary>
-    /// Classe contenant les arguments passées en paramètre lors de l'événement DemanderJoueur.
-    /// </summary>
-    public class DemanderJoueurEventArgs : EventArgs
-    {
-        /// <summary>
-        /// Le numéro du joueur (Joueur 1 ou 2, 3..).
-        /// </summary>
-        public int Numero { get; private set; }
-
-
-        /// <summary>
-        /// Initialise une nouvelle instance de la classe <see cref="DemanderJoueurEventArgs"/> avec le numéro du joueur spécifié.
-        /// </summary>
-        /// <param name="numero">Le numéro du joueur qui va être ajouté.</param>
-        public DemanderJoueurEventArgs(int numero)
-        {
-            Numero = numero;
-        }
-    }
-}

Sources/CoreLibrary/Events/DemanderNomEventArgs.cs

@@ -0,0 +1,31 @@
+using CoreLibrary.Joueurs;
+
+namespace CoreLibrary.Events
+{
+    /// <summary>
+    /// Classe contenant les arguments passées en paramètre lors de l'événement DemanderNom.
+    /// </summary>
+    public class DemanderNomEventArgs : EventArgs
+    {
+        /// <summary>
+        /// L'indice du joueur
+        /// </summary>
+        public int Indice { get; private set; }
+
+        /// <summary>
+        /// Le constructeur de joueur dans lequel il faut renseigner le nom du joueur
+        /// </summary>
+        public JoueurBuilder JoueurBuilder { get; private set; }
+
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="DemanderNomEventArgs"/> avec les informations spécifiées.
+        /// </summary>
+        /// <param name="code">L'indice du joueur.</param>
+        /// <param name="code">La classe dans laquelle on attend la réponse du joueur.</param>
+        public DemanderNomEventArgs(int indice, JoueurBuilder joueurBuilder)
+        {
+            Indice = indice;
+            JoueurBuilder = joueurBuilder;
+        }
+    }
+}

Sources/CoreLibrary/Events/JouerCodeEventArgs.cs

@@ -0,0 +1,24 @@
+using CoreLibrary.Core;
+
+namespace CoreLibrary.Events
+{
+    /// <summary>
+    /// Classe contenant les arguments passées en paramètre lors de l'événement JouerCode.
+    /// </summary>
+    public class JouerCodeEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Le code joué par le joueur
+        /// </summary>
+        public Code Code { get; private set; }
+
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="JouerCodeEventArgs"/> avec les informations spécifiées.
+        /// </summary>
+        /// <param name="code">Le code joué par le joueur dont c'est le tour.</param>
+        public JouerCodeEventArgs(Code code)
+        {
+            Code = code;
+        }
+    }
+}

Sources/CoreLibrary/Events/NouveauJoueurEventArgs.cs

@@ -0,0 +1,22 @@
+namespace CoreLibrary.Events
+{
+    /// <summary>
+    /// Classe contenant les arguments passées en paramètre lors de l'événement NouveauJoueur.
+    /// </summary>
+    public class NouveauJoueurEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Le nom du joueur
+        /// </summary>
+        public string Nom { get; private set; }
+
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="NouveauJoueurEventArgs"/> avec les informations spécifiées.
+        /// </summary>
+        /// <param name="nom">Le nom du joueur.</param>
+        public NouveauJoueurEventArgs(string nom)
+        {
+            Nom = nom;
+        }
+    }
+}

Sources/CoreLibrary/Events/NouveauTourEventArgs.cs

@@ -18,6 +18,11 @@ namespace CoreLibrary.Events
         /// </summary>
         public int Tour {  get; private set; }
 
+        /// <summary>
+        /// Le code où ajouter les jetons
+        /// </summary>
+        public Code Code { get; private set; }
+
         /// <summary>
         /// La grille du joueur actuelle.
         /// </summary>
@@ -35,10 +40,11 @@ namespace CoreLibrary.Events
         /// <param name="tour">Le numéro du tour.</param>
         /// <param name="grille">La grille du joueur actuelle.</param>
         /// <param name="indicateurs">Les indicateurs de la grille de jeu.</param>
-        public NouveauTourEventArgs(Joueur joueur, int tour, IEnumerable<IEnumerable<Jeton?>> grille, IEnumerable<IEnumerable<Indicateur>> indicateurs) 
+        public NouveauTourEventArgs(Joueur joueur, int tour, Code code, IEnumerable<IEnumerable<Jeton?>> grille, IEnumerable<IEnumerable<Indicateur>> indicateurs) 
         {
             Joueur = joueur;
             Tour = tour;
+            Code = code;
             Grille = grille;
             Indicateurs = indicateurs;
         }

Sources/CoreLibrary/Events/SupprimerDernierJetonEventArgs.cs

@@ -1,9 +0,0 @@
-namespace CoreLibrary.Events
-{
-    /// <summary>
-    /// Classe contenant les arguments passées en paramètre lors de l'événement SupprimerDernierJeton.
-    /// </summary>
-    public class SupprimerDernierJetonEventArgs : EventArgs
-    {
-    }
-}

Sources/CoreLibrary/Joueurs/Joueur.cs

@@ -1,4 +1,7 @@
-namespace CoreLibrary.Joueurs
+using CoreLibrary.Core;
+using CoreLibrary.Events;
+
+namespace CoreLibrary.Joueurs
 {
     /// <summary>
     /// Classe représentant un joueur.
@@ -17,6 +20,17 @@
 
         /// <summary>
         /// Crée une nouvelle instance de joueur avec un nom
+        /// Evénement appelé pour jouer un code.
+        /// </summary>
+        public event EventHandler<JouerCodeEventArgs>? JouerCode;
+
+        /// <summary>
+        /// Appel de l'événement JouerCode.
+        /// </summary>
+        private void QuandJouerCode(Code code) => JouerCode?.Invoke(this, new JouerCodeEventArgs(code));
+       
+        /// <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>
         public Joueur(string nom)
@@ -36,5 +50,10 @@
             NbPartieEgalite = nbPartieEgalite;
             NbPartiePerdue = nbPartiePerdue;
         }
+
+        public void Code(Code code)
+        {
+            QuandJouerCode(code);
+        }
     }
 }

Sources/CoreLibrary/Joueurs/JoueurBuilder.cs

@@ -0,0 +1,16 @@
+using CoreLibrary.Events;
+
+namespace CoreLibrary.Joueurs
+{
+    public class JoueurBuilder
+    {
+        public event EventHandler<ConstruireJoueurEventArgs>? ConstruireJoueur;
+
+        private void QuandConstruireJoueur(string? nom) => ConstruireJoueur?.Invoke(this, new ConstruireJoueurEventArgs(nom));
+
+        public void Nom(string? nom)
+        {
+            QuandConstruireJoueur(nom);
+        }
+    }
+}

Sources/CoreLibrary/Manager/IPersistanceManager.cs

@@ -1,11 +1,13 @@
-namespace CoreLibrary.Manager
+using CoreLibrary.Joueurs;
+
+namespace CoreLibrary.Manager
 {
     public interface IPersistanceManager
     {
-        public void Charger();
-
-        public void Enregistrer();
+        public bool EstEnregistre { get; }
 
+        public IEnumerable<Joueur> Charger();
 
+        public void Enregistrer(IEnumerable<Joueur> donnees);
     }
 }

Sources/CoreLibrary/Manager/Manager.cs

@@ -1,28 +1,41 @@
 using CoreLibrary.Joueurs;
-using CoreLibrary.Regles;
+using System.Runtime.InteropServices;
 
 namespace CoreLibrary.Manager
 {
-    public class Manager : IPersistanceManager
+    public class Manager : IDisposable
     {
-        private Joueur[] joueurs = [];
-        public IReadOnlyList<Joueur> Joueurs => Array.AsReadOnly(joueurs);
+        private bool estDetruit;
 
-        public void Charger()
+        private readonly IPersistanceManager persistance;
+
+        private readonly IEnumerable<Joueur> joueurs;
+        public IEnumerable<Joueur> Joueurs => joueurs;
+
+        public Manager(IPersistanceManager persistance)
         {
-            joueurs = [
-                new Joueur("Pauline", 50, 5, 2, 0),
-                new Joueur("Céleste", 40, 6, 2, 0),
-                new Joueur("Camille", 55, 8, 0, 1),
-                new Joueur("Toto", 70, 0, 0, 10),
-            ];
+            this.persistance = persistance;
+            joueurs = this.persistance.Charger();
         }
 
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
 
-        public void Enregistrer()
+        protected virtual void Dispose(bool detruire)
         {
-            throw new NotImplementedException();
+            if (estDetruit) return;
+
+            persistance.Enregistrer(joueurs);
+
+            estDetruit = true;
         }
 
+        ~Manager()
+        {
+            Dispose(false);
+        }
     }
 }

Sources/CoreLibrary/Manager/Stub.cs

@@ -0,0 +1,26 @@
+using CoreLibrary.Joueurs;
+using System.Diagnostics.CodeAnalysis;
+
+namespace CoreLibrary.Manager
+{
+    public class Stub : IPersistanceManager
+    {
+        public bool EstEnregistre { get; private set; } = false;
+
+        public IEnumerable<Joueur> Charger()
+        {
+            return [
+                new Joueur("Pauline", 50, 5, 2, 0),
+                new Joueur("Céleste", 40, 6, 2, 0),
+                new Joueur("Camille", 55, 8, 0, 1),
+                new Joueur("Toto", 70, 0, 0, 10),
+            ];
+        }
+
+        [SuppressMessage("SonarAnalyzer", "S1186", Justification = "This method is intentionally left blank.")]
+        public void Enregistrer(IEnumerable<Joueur> donnees)
+        {
+            EstEnregistre = true;
+        }
+    }
+}

Sources/CoreLibrary/Partie.cs

@@ -12,31 +12,15 @@ namespace CoreLibrary
     {
         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;
+        public event EventHandler<DemanderNomEventArgs>? DemanderNom;
 
         /// <summary>
         /// Événement déclenché lorsqu'il est nécessaire d'ajouter un joueur.
         /// </summary>
-        public event EventHandler<AjouterJoueursEventArgs>? AjouterJoueur;
+        public event EventHandler<AjouterJoueurEventArgs>? AjouterJoueur;
 
         /// <summary>
         /// Événement déclenché lorsqu'une partie commence.
@@ -48,17 +32,6 @@ namespace CoreLibrary
         /// </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>
@@ -75,55 +48,38 @@ namespace CoreLibrary
         public event EventHandler<PartieTermineeEventArgs>? PartieTerminee;
 
         /// <summary>
-        /// Méthode pour déclencher l'événement de demande d'ajout d'un joueur.
+        /// Méthode pour déclencher l'événement de demande du nom 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));
-
-        /// <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(int indice) => DemanderJeton?.Invoke(this, new DemanderJetonEventArgs(indice));
+        /// <param name="joueurBuilder">La classe dans laquelle le nom doit être défini</param>
+        private void QuandDemanderNom(int numero, JoueurBuilder joueurBuilder) => DemanderNom?.Invoke(this, new DemanderNomEventArgs(numero, joueurBuilder));
 
         /// <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));
+        private void QuandAjouterJoueur(Joueur joueur) => AjouterJoueur?.Invoke(this, new AjouterJoueurEventArgs(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="code">Le code dans lequel il faut ajouter les jetons.</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());
+        private void QuandNouveauTour(Joueur joueur, int tour, Code code, IEnumerable<IEnumerable<Jeton?>> grille, IEnumerable<IEnumerable<Indicateur>> indicateurs) => NouveauTour?.Invoke(this, new NouveauTourEventArgs(joueur, tour, code, grille, indicateurs));
 
         /// <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));
+        /// <param name="code">Le code ajouté.</param>
+        private void QuandAjouterCode(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.
@@ -151,71 +107,74 @@ namespace CoreLibrary
         /// </summary>
         public void Jouer()
         {
-            /// Ajout des joueurs jusqu'à atteindre le nombre maximum de joueurs défini par les règles
-            AjouterJoueurs();
-
-            regles.CommencerLaPartie();
-            QuandDebutPartie();
-
-            // Boucle principale du jeu qui dure jusqu'à qu'une condition de fin soit déclenchée
-            while (!regles.EstTerminee())
-            {
-                (Joueur joueurCourant, Plateau plateauCourant) = regles.JoueurCourant();
-
-                QuandNouveauTour(joueurCourant, plateauCourant.Tour, plateauCourant.Grille(), plateauCourant.Indicateurs());
-
-                Code code = regles.GenererCode();
-
-                CreerCode(code);
+            JoueurBuilder joueurBuilder = new JoueurBuilder();
+            joueurBuilder.ConstruireJoueur += Joueur;
 
-                // Phase de saisie du code par le joueur jusqu'à que le code soit complet.
-
-                plateauCourant.AjouterCode(code);
-                QuandNouveauCode(code);
-
-                regles.PasserLaMain();
-                QuandPasserMain();
+            QuandDemanderNom(regles.NbJoueurs + 1, joueurBuilder);
         }
 
+        /// <summary>
+        /// Un joueur a saisi son nom
+        /// </summary>
+        private void Joueur(Object? sender, ConstruireJoueurEventArgs e)
+        {
+            Joueur joueur = regles.AjouterJoueur(e.Nom ?? $"Joueur {regles.NbJoueurs + 1}");
+            QuandAjouterJoueur(joueur);
+            joueur.JouerCode += Tour;
 
-            regles.Gagnants();
-            regles.Perdants();
-
-            QuandPartieTerminee(regles.Gagnants(), regles.Perdants());
-        }
-
-        private void AjouterJoueurs()
+            if (regles.NbJoueurs != regles.NbJoueursMaximum)
             {
-            while (regles.NbJoueurs != regles.NbJoueursMaximum)
+                JoueurBuilder joueurBuilder = new JoueurBuilder();
+                joueurBuilder.ConstruireJoueur += Joueur;
+                QuandDemanderNom(regles.NbJoueurs + 1, joueurBuilder);
+            }
+            else
             {
-                string nom = QuandDemanderJoueur(regles.NbJoueurs + 1) ?? $"Joueur {regles.NbJoueurs + 1}";
-                Joueur joueur = regles.AjouterJoueur(nom);
-                QuandAjouterJoueur(joueur);
+                Commencer();
             }
         }
 
-        private void CreerCode(Code code)
-        {
-            while (!code.EstComplet())
+        /// <summary>
+        /// La partie démarre
+        /// </summary>
+        private void Commencer()
         {
-                Jeton? jeton = QuandDemanderJeton(code.NbJetons);
+            regles.CommencerLaPartie();
+            QuandDebutPartie();
 
-                if (DemanderJeton == null)
-                {
-                    jeton = new Jeton();
+            (Joueur joueurCourant, Plateau plateauCourant) = regles.JoueurCourant();
+            QuandNouveauTour(joueurCourant, plateauCourant.Tour, regles.GenererCode(), plateauCourant.Grille(), plateauCourant.Indicateurs());
         }
 
-                if(!jeton.HasValue)
+        /// <summary>
+        /// Un joueur a joué son tour
+        /// </summary>
+        private void Tour(Object? sender, JouerCodeEventArgs e)
+        {
+            (Joueur joueurCourant, Plateau plateauCourant) = regles.JoueurCourant();
+            plateauCourant.AjouterCode(e.Code);
+            QuandAjouterCode(e.Code);
+
+            if(regles.EstTerminee())
             {
-                    code.SupprimerDernierJeton();
-                    QuandSupprimerDernierJeton();
+                Terminee();
             }
             else
             {
-                    code.AjouterJeton(jeton.Value);
-                    QuandNouveauJeton(jeton.Value);
+                regles.PasserLaMain();
+                QuandPasserMain();
+
+                (joueurCourant, plateauCourant) = regles.JoueurCourant();
+                QuandNouveauTour(joueurCourant, plateauCourant.Tour, regles.GenererCode(), plateauCourant.Grille(), plateauCourant.Indicateurs());
             }
         }
+
+        /// <summary>
+        /// La partie est terminée
+        /// </summary>
+        private void Terminee()
+        {
+            QuandPartieTerminee(regles.Gagnants(), regles.Perdants());
         }
     }
 }

Sources/MauiSpark/MauiProgram.cs

@@ -5,12 +5,10 @@ namespace MauiSpark
 {
     public static class MauiProgram
     {
-        public static Manager Manager { get; private set; } = new Manager();
+        public static Manager Manager { get; private set; } = new Manager(new Stub());
 
         public static MauiApp CreateMauiApp()
         {
-            Manager.Charger();
-
             var builder = MauiApp.CreateBuilder();
             builder
                 .UseMauiApp<App>()

Sources/UnitTesting/AjouterJetonEventArgsUT.cs

@@ -1,20 +0,0 @@
-using CoreLibrary.Core;
-using CoreLibrary.Events;
-using Xunit;
-
-namespace UnitTesting
-{
-    public class AjouterJetonEventArgsUT
-    {
-        [Fact]
-        public void TestConstructeurValide()
-        {
-            Jeton monJeton = new Jeton(Couleur.JAUNE);
-
-            AjouterJetonEventArgs evenement = new AjouterJetonEventArgs(monJeton);
-
-            Assert.Equal(monJeton, evenement.Jeton);
-        }
-
-    }
-}

Sources/UnitTesting/AjouterJoueurEventArgs.cs

@@ -12,7 +12,7 @@ namespace UnitTesting
         {
             Joueur monJoueur = new Joueur("Céleste");
 
-            AjouterJoueursEventArgs evenement = new AjouterJoueursEventArgs(monJoueur);
+            AjouterJoueurEventArgs evenement = new AjouterJoueurEventArgs(monJoueur);
 
             Assert.Equal(monJoueur, evenement.Joueur);
         }

Sources/UnitTesting/ConstruireJoueurEventArgsUT.cs

@@ -0,0 +1,20 @@
+using CoreLibrary.Core;
+using CoreLibrary.Events;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class ConstruireJoueurEventArgsUT
+    {
+        [Fact]
+        public void TestConstructeurValide()
+        {
+            ConstruireJoueurEventArgs evenement = new ConstruireJoueurEventArgs("Bonjour");
+            ConstruireJoueurEventArgs evenement2 = new ConstruireJoueurEventArgs(null);
+
+            Assert.Equal("Bonjour", evenement.Nom);
+            Assert.Null(evenement2.Nom);
+        }
+
+    }
+}

Sources/UnitTesting/DemanderJoueurEventArgsUT.cs

@@ -1,16 +0,0 @@
-using CoreLibrary.Events;
-using Xunit;
-
-namespace UnitTesting
-{
-    public class DemanderJoueurEventArgsUT
-    {
-        [Fact]
-        public void TestConstructeurValide()
-        {
-            DemanderJoueurEventArgs evenement = new DemanderJoueurEventArgs(3);
-
-            Assert.Equal(3, evenement.Numero);
-        }
-    }
-}

Sources/UnitTesting/DemanderNomEventArgsUT.cs

@@ -0,0 +1,22 @@
+using CoreLibrary.Events;
+using CoreLibrary.Joueurs;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class DemanderNomEventArgsUT
+    {
+        [Fact]
+        public void TestConstructeurValide()
+        {
+            JoueurBuilder joueurBuilder = new JoueurBuilder();
+            int indice = 15;
+
+            DemanderNomEventArgs evenement = new DemanderNomEventArgs(indice, joueurBuilder);
+
+            Assert.Equal(joueurBuilder, evenement.JoueurBuilder);
+            Assert.Equal(indice, evenement.Indice);
+        }
+
+    }
+}

Sources/UnitTesting/JouerCodeEventArgsUT.cs

@@ -0,0 +1,19 @@
+using CoreLibrary.Core;
+using CoreLibrary.Events;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class JouerCodeEventArgsUT
+    {
+        [Fact]
+        public void TestConstructeurValide()
+        {
+            Code monCode = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.BLEU)]);
+
+            JouerCodeEventArgs evenement = new JouerCodeEventArgs(monCode);
+
+            Assert.Equal(monCode, evenement.Code);
+        }
+    }
+}

Sources/UnitTesting/JoueurBuilderUT.cs

@@ -0,0 +1,50 @@
+using CoreLibrary.Core;
+using CoreLibrary.Events;
+using CoreLibrary.Joueurs;
+using System.Reflection;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class JoueurBuilderUT
+    {
+        [Fact]
+        public void JoueurBuilderTest()
+        {
+            string nom = "Céleste";
+            string? nomEvenement = "";
+
+            JoueurBuilder builder = new JoueurBuilder();
+            builder.ConstruireJoueur += (Object? sender, ConstruireJoueurEventArgs e) => nomEvenement = e.Nom;
+
+            builder.Nom(nom);
+
+            Assert.Equal(nom, nomEvenement);
+        }
+
+        [Fact]
+        public void JoueurBuilderQuandConstruireJoueur()
+        {
+            string nom = "Céleste";
+            string? nomEvenement = "";
+
+            JoueurBuilder builder = new JoueurBuilder();
+            builder.ConstruireJoueur += (Object? sender, ConstruireJoueurEventArgs e) => nomEvenement = e.Nom;
+
+            Type type = typeof(JoueurBuilder);
+            MethodInfo? methodInfo = type.GetMethod("QuandConstruireJoueur", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(methodInfo);
+            methodInfo.Invoke(builder, [nom]);
+
+            Assert.Equal(nom, nomEvenement);
+        }
+
+        [Fact]
+        public void JoueurBuilderQuandConstruireJoueurSansBranchement()
+        {
+            JoueurBuilder builder = new JoueurBuilder();
+
+            Assert.Null(Record.Exception(() => builder.Nom("Pauline")));
+        }
+    }
+}

Sources/UnitTesting/JoueurUT.cs

@@ -1,5 +1,7 @@
 using CoreLibrary.Core;
+using CoreLibrary.Events;
 using CoreLibrary.Joueurs;
+using System.Reflection;
 using Xunit;
 
 namespace UnitTesting
@@ -40,5 +42,55 @@ namespace UnitTesting
             Assert.Equal(nbPartiePerdue, joueur.NbPartiePerdue);
         }
 
+        [Fact]
+        public void TestEvenement()
+        {
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.JAUNE), new Jeton(Couleur.VERT)]);
+            Code? codeEvenement = null;
+
+            Joueur j = new Joueur("Céleste");
+            j.JouerCode += (Object? sender, JouerCodeEventArgs e) => codeEvenement = e.Code;
+
+            j.Code(code);
+
+            Assert.NotNull(codeEvenement);
+            Assert.Equal(code, codeEvenement);
+        }
+
+        [Fact]
+        public void JoueurQuandJouerCode()
+        {
+            Code code = new Code(4);
+            code.AjouterJeton(new Jeton(Couleur.ROUGE));
+            code.AjouterJeton(new Jeton(Couleur.BLANC));
+            code.AjouterJeton(new Jeton(Couleur.BLEU));
+            code.AjouterJeton(new Jeton(Couleur.NOIR));
+
+            Code? codeEvenement = null;
+
+            Joueur joueur = new Joueur("Céleste");
+            joueur.JouerCode += (Object? sender, JouerCodeEventArgs e) => codeEvenement = e.Code;
+
+            Type type = typeof(Joueur);
+            MethodInfo? methodInfo = type.GetMethod("QuandJouerCode", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(methodInfo);
+            methodInfo.Invoke(joueur, [code]);
+
+            Assert.NotNull(codeEvenement);
+            Assert.Equal(code, codeEvenement);
+        }
+
+        [Fact]
+        public void JoueurQuandJouerCodeSansBranchement()
+        {
+            Joueur joueur = new Joueur("Pauline");
+            Code code = new Code(4);
+            code.AjouterJeton(new Jeton(Couleur.ROUGE));
+            code.AjouterJeton(new Jeton(Couleur.BLANC));
+            code.AjouterJeton(new Jeton(Couleur.BLEU));
+            code.AjouterJeton(new Jeton(Couleur.NOIR));
+
+            Assert.Null(Record.Exception(() => joueur.Code(code)));
+        }
     }
 }

Sources/UnitTesting/ManagerUT.cs

@@ -0,0 +1,25 @@
+using CoreLibrary.Manager;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class ManagerUT
+    {
+        [Fact]
+        public void TestConstruteur()
+        {
+            Manager manager = new Manager(new Stub());
+            Assert.NotNull(manager.Joueurs);
+            Assert.NotEmpty(manager.Joueurs);
+        }
+
+        [Fact]
+        public void TestDispose()
+        {
+            Stub stub = new Stub();
+            Manager manager = new Manager(stub);
+            manager.Dispose();
+            Assert.True(stub.EstEnregistre);
+        }
+    }
+}

Sources/UnitTesting/NouveauJoueurEventArgsUT.cs

@@ -0,0 +1,16 @@
+using CoreLibrary.Events;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class NouveauJoueurEventArgsUT
+    {
+        [Fact]
+        public void TestConstructeurValide()
+        {
+            NouveauJoueurEventArgs evenement = new NouveauJoueurEventArgs("Céleste");
+
+            Assert.Equal("Céleste", evenement.Nom);
+        }
+    }
+}

Sources/UnitTesting/NouveauTourEventArgsUT.cs

@@ -1,6 +1,6 @@
-using CoreLibrary.Joueurs;
-using CoreLibrary.Core;
+using CoreLibrary.Core;
 using CoreLibrary.Events;
+using CoreLibrary.Joueurs;
 using Xunit;
 
 namespace UnitTesting
@@ -10,17 +10,20 @@ namespace UnitTesting
         [Fact]
         public void TestConstructeurValide()
         {
-            Plateau monPlateau = new Plateau(4, 12);
-            Joueur monJoueur = new Joueur("Céleste");
+            Joueur joueur = new Joueur("Céleste");
+            Plateau plateau = new Plateau(4, 12);
+            int tour = 10;
+            Code code = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.ROUGE), new Jeton(Couleur.ROUGE), new Jeton(Couleur.JAUNE)]);
 
-            NouveauTourEventArgs evenement = 
-                new NouveauTourEventArgs(monJoueur, 5, monPlateau.Grille(), monPlateau.Indicateurs());
+            NouveauTourEventArgs evenement = new NouveauTourEventArgs(
+                   joueur, tour, code, plateau.Grille(), plateau.Indicateurs()
+            );
 
-            Assert.Equal(monJoueur, evenement.Joueur);
-            Assert.Equal(5, evenement.Tour);
-            Assert.Equal(monPlateau.Grille(), evenement.Grille);
-            Assert.Equal(monPlateau.Indicateurs(), evenement.Indicateurs);
+            Assert.Equal(joueur, evenement.Joueur);
+            Assert.Equal(tour, evenement.Tour);
+            Assert.Equal(code, evenement.Code);
+            Assert.Equal(plateau.Grille(), evenement.Grille);
+            Assert.Equal(plateau.Indicateurs(), evenement.Indicateurs);
         }
-
     }
 }

Sources/UnitTesting/PartieUT.cs

@@ -1,207 +0,0 @@
-using CoreLibrary;
-using CoreLibrary.Regles;
-using CoreLibrary.Core;
-using Xunit;
-using System.Reflection;
-using CoreLibrary.Events;
-
-namespace UnitTesting
-{
-    public class PartieUT
-    {
-        [Fact]
-        public void TestPartieInitialiseCorrectement()
-        {
-            
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-
-            Assert.NotNull(partie);
-        }
-
-        [Fact]
-        public void TestJouerAppelleDemanderJoueurEvent()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool eventAppelle = false;
-
-
-            partie.DemanderJoueur += (sender, e) =>
-            {
-                eventAppelle = true;
-                return $"Joueur {e.Numero}";
-            };
-
-            partie.Jouer();
-            Assert.True(eventAppelle);
-        }
-
-
-        [Fact]
-        public void TestJouerAppelleDemanderJetonEvent()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool eventAppelle = false;
-
-            partie.DemanderJeton += (sender, e) =>
-            {
-                eventAppelle = true;
-                return new Jeton();
-            };
-              
-            partie.Jouer();
-            Assert.True(eventAppelle);
-        }
-
-        [Fact]
-        public void TestJouerAppelleAjouterJoueurEvent()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool eventAppelle = false;
-
-            partie.AjouterJoueur += (sender, e) =>
-            {
-                eventAppelle = true;
-               
-            };
-            partie.Jouer();
-            Assert.True(eventAppelle);
-
-        }
-
-        [Fact]
-        public void TestJouerAppelleDebutPartieEvent()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool eventAppelle = false;
-
-            partie.DebutPartie += (sender, e) =>
-            {
-                eventAppelle = true;
-            };
-            partie.Jouer();
-            Assert.True(eventAppelle);
-        }
-
-        [Fact]
-        public void TestJouerAppelleNouveauTourEvent()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool eventAppelle = false;
-
-            partie.NouveauTour += (sender, e) =>
-            {
-                eventAppelle = true;
-            };
-
-            partie.Jouer();
-            Assert.True(eventAppelle);
-        }
-
-        [Fact]
-        public void TestJouerAppelleNouveauJetonEvent()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool eventAppelle = false;
-
-            partie.AjouterJeton += (sender, e) =>
-            {
-                eventAppelle = true;
-            };
-
-            partie.Jouer();
-            Assert.True(eventAppelle);
-        }
-      
-        [Fact]
-        public void TestJouerAppelleNouveauCodeEvent()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool eventAppelle = false;
-
-            partie.AjouterCode += (sender, e) =>
-            {
-                eventAppelle = true;
-            };
-
-            partie.Jouer();
-            Assert.True(eventAppelle);
-        }
-
-        [Fact]
-        public void TestJouerAppellePasserMainEvent()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool eventAppelle = false;
-
-            partie.PasserMain += (sender, e) =>
-            {
-                eventAppelle = true;
-            };
-
-            partie.Jouer();
-            Assert.True(eventAppelle);
-        }
-
-        [Fact]
-        public void TestJouerAppellePartieTermineeEvent()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool eventAppelle = false;
-
-            partie.PartieTerminee += (sender, e) =>
-            {
-                eventAppelle = true;
-            };
-
-            partie.Jouer();
-            Assert.True(eventAppelle);
-        }
-
-
-        [Fact]
-        public void TestSupprimerDernierJeton()
-        {
-            IRegles regles = new ReglesClassiques();
-            Partie partie = new Partie(regles);
-            bool appele = false;
-
-            partie.DemanderJeton += (sender, e) =>
-            {
-                if (e.Indice == 0 || appele)
-                    return new Jeton();
-                return null;
-            };
-
-            partie.SupprimerDernierJeton += (sender, e) =>
-            {
-                appele = true;
-            };
-
-            partie.Jouer();
-
-            Assert.True(appele);
-        }
-
-        [Fact]
-        public void TestSupprimerDernierJetonNull()
-        {
-            Partie partie = new Partie(new ReglesClassiques());
-
-            MethodInfo? methode = typeof(Partie).GetMethod("QuandSupprimerDernierJeton", BindingFlags.NonPublic | BindingFlags.Instance);
-
-            Assert.NotNull(methode);
-
-            methode.Invoke(partie, null);
-        }
-    }
-}

Sources/UnitTesting/ReglesClassiquesUT.cs

@@ -16,6 +16,25 @@ namespace UnitTesting
             Assert.Equal("Règles classiques", new ReglesClassiques().Nom);
         }
 
+        [Fact]
+        public void TestNbJoueur()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            Assert.Equal(0, regles.NbJoueurs);
+            regles.AjouterJoueur("Bonjour");
+            Assert.Equal(1, regles.NbJoueurs);
+            regles.AjouterJoueur("Bonsoir");
+            Assert.Equal(2, regles.NbJoueurs);
+        }
+
+        [Fact]
+        public void GenererCode()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            Assert.Equal(new Code(4).NbJetons, regles.GenererCode().NbJetons);
+            Assert.Equal(4, regles.GenererCode().TailleMaximale());
+        }
+
         [Fact]
         public void TestJoueurCourantPartieNonCommencee()
         {
@@ -145,5 +164,93 @@ namespace UnitTesting
             Assert.Single(gagnants);
             Assert.Contains(regles.JoueurCourant().Item1, gagnants);
         }
+
+        [Fact]
+        public void TestPerdants()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+
+            regles.AjouterJoueur("joueur1");
+            regles.AjouterJoueur("joueur2");
+
+            regles.CommencerLaPartie();
+
+            Plateau plateauj1 = regles.JoueurCourant().Item2;
+
+            Type type = typeof(Plateau);
+            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(fieldInfo);
+            Code? codeSecret = (Code?)fieldInfo.GetValue(plateauj1);
+            Assert.NotNull(codeSecret);
+
+            regles.JoueurCourant().Item2.AjouterCode(codeSecret);
+
+            regles.PasserLaMain();
+
+            IEnumerable<Joueur> perdants = regles.Perdants();
+            Assert.Single(perdants);
+            Assert.Contains(regles.JoueurCourant().Item1, perdants);
+        }
+
+
+        [Fact]
+        public void EstTermineeMaxTour()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            regles.AjouterJoueur("1");
+            regles.AjouterJoueur("2");
+            regles.CommencerLaPartie();
+
+            for (int i = 0; i < 24; ++i)
+            {
+                Plateau plateau = regles.JoueurCourant().Item2;
+                Code code = new Code(4);
+                code.AjouterJeton(new Jeton(Couleur.ROUGE));
+                code.AjouterJeton(new Jeton(Couleur.ROUGE));
+                code.AjouterJeton(new Jeton(Couleur.ROUGE));
+                code.AjouterJeton(new Jeton(Couleur.ROUGE));
+                plateau.AjouterCode(code);
+
+                regles.PasserLaMain();
+            } 
+
+            Assert.True(regles.EstTerminee());
+        }
+
+        [Fact]
+        public void EstTermineeNon()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            regles.AjouterJoueur("1");
+            regles.AjouterJoueur("2");
+            regles.CommencerLaPartie();
+
+            for (int i = 0; i < 12; ++i)
+                regles.PasserLaMain();
+
+            Assert.False(regles.EstTerminee());
+        }
+
+        [Fact]
+        public void EstTermineeCodeTrouve()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            regles.AjouterJoueur("1");
+            regles.AjouterJoueur("2");
+            regles.CommencerLaPartie();
+
+            Plateau plateauj1 = regles.JoueurCourant().Item2;
+
+            Type type = typeof(Plateau);
+            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(fieldInfo);
+            Code? codeSecret = (Code?)fieldInfo.GetValue(plateauj1);
+            Assert.NotNull(codeSecret);
+
+            regles.JoueurCourant().Item2.AjouterCode(codeSecret);
+
+            Assert.True(regles.EstTerminee());
+        }
     }
 }

Sources/UnitTesting/StubUT.cs

@@ -0,0 +1,21 @@
+using CoreLibrary.Manager;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class StubUT
+    {
+        [Fact]
+        public void ChargerTest()
+        {
+            Assert.NotEmpty(new Stub().Charger());
+        }
+
+        [Fact]
+        public void EnregistrerTest()
+        {
+            Assert.Null(Record.Exception(() => new Stub().Enregistrer([])));
+        }
+
+    }
+}