Fin de partie et correction jeux de tests, documentation, et consoleapp

Sources/ConsoleApp/Evenements.cs

@@ -14,20 +14,20 @@ 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);
+        }
 
 
         /// <summary>
@@ -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)
-        {
-            Console.TreatControlCAsInput = true;
-            Console.CursorVisible = false;
-
-            bool aChoisi = false;
-            int indice = 0;
-            Couleur[] couleurs = (Couleur[])Enum.GetValues(typeof(Couleur));
-
-            while (!aChoisi)
+            Code code = e.Code;
+            while(!code.EstComplet())
             {
-                Utils.DessinerPion(couleurs[indice]);
-                Console.Write("\b\b\b");
-
-                switch (Console.ReadKey(true).Key)
+                Jeton? jeton = Utils.SaisirJeton(code.NbJetons);
+                if (jeton.HasValue)
                 {
-                    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);
+                }
+                else
+                {
+                    Utils.SupprimerDernierJeton();
+                    code.SupprimerDernierJeton();
                 }
-
-                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)
-        {
-            Utils.DessinerPion(e.Jeton.Couleur);
-        }
-
-        /// <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

@@ -1,12 +1,20 @@
-using CoreLibrary.Joueurs;
-
-namespace CoreLibrary.Events
+namespace CoreLibrary.Events
 {
+    /// <summary>
+    /// Classe contenant les arguments passées en paramètre lors de l'événement ConstruireJoueurEventArgs.
+    /// </summary>
     public class ConstruireJoueurEventArgs : EventArgs
     {
-        public string Nom { get; private set; }
+        /// <summary>
+        /// Le nom du joueur à ajouter.
+        /// </summary>
+        public string? Nom { get; private set; }
 
-        public ConstruireJoueurEventArgs(string nom)
+        /// <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/DemanderNomEventArgs.cs

@@ -2,11 +2,26 @@
 
 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;

Sources/CoreLibrary/Events/JouerCodeEventArgs.cs

@@ -3,12 +3,19 @@
 namespace CoreLibrary.Events
 {
     /// <summary>
-    /// Classe contenant les arguments passées en paramètre lors de l'événement NouveauTour.
+    /// 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

@@ -1,9 +1,19 @@
 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

@@ -50,5 +50,10 @@ namespace CoreLibrary.Joueurs
             NbPartieEgalite = nbPartieEgalite;
             NbPartiePerdue = nbPartiePerdue;
         }
+
+        public void Code(Code code)
+        {
+            QuandJouerCode(code);
+        }
     }
 }

Sources/CoreLibrary/Joueurs/JoueurBuilder.cs

@@ -6,9 +6,9 @@ namespace CoreLibrary.Joueurs
     {
         public event EventHandler<ConstruireJoueurEventArgs>? ConstruireJoueur;
 
-        private void QuandConstruireJoueur(string nom) => ConstruireJoueur?.Invoke(this, new ConstruireJoueurEventArgs(nom));
+        private void QuandConstruireJoueur(string? nom) => ConstruireJoueur?.Invoke(this, new ConstruireJoueurEventArgs(nom));
 
-        public void Nom(string nom)
+        public void Nom(string? nom)
         {
             QuandConstruireJoueur(nom);
         }

Sources/CoreLibrary/Partie.cs

@@ -12,26 +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<DemanderNomEventArgs>? DemanderNom;
+        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.
@@ -43,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>
@@ -70,49 +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? QuandDemanderNom(int numero, JoueurBuilder joueurBuilder) => DemanderNom?.Invoke(this, new DemanderNomEventArgs(numero, joueurBuilder));
+        /// <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.
@@ -146,9 +113,12 @@ namespace CoreLibrary
             QuandDemanderNom(regles.NbJoueurs + 1, joueurBuilder);
         }
 
-        public void Joueur(Object? sender, ConstruireJoueurEventArgs e)
+        /// <summary>
+        /// Un joueur a saisi son nom
+        /// </summary>
+        private void Joueur(Object? sender, ConstruireJoueurEventArgs e)
         {
-            Joueur joueur = regles.AjouterJoueur(e.Nom);
+            Joueur joueur = regles.AjouterJoueur(e.Nom ?? $"Joueur {regles.NbJoueurs + 1}");
             QuandAjouterJoueur(joueur);
             joueur.JouerCode += Tour;
 
@@ -164,20 +134,26 @@ namespace CoreLibrary
             }
         }
 
-        public void Commencer()
+        /// <summary>
+        /// La partie démarre
+        /// </summary>
+        private void Commencer()
         {
             regles.CommencerLaPartie();
             QuandDebutPartie();
 
             (Joueur joueurCourant, Plateau plateauCourant) = regles.JoueurCourant();
-            QuandNouveauTour(joueurCourant, plateauCourant.Tour, plateauCourant.Grille(), plateauCourant.Indicateurs());
+            QuandNouveauTour(joueurCourant, plateauCourant.Tour, regles.GenererCode(), plateauCourant.Grille(), plateauCourant.Indicateurs());
         }
 
+        /// <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);
-            QuandNouveauCode(e.Code);
+            QuandAjouterCode(e.Code);
 
             if(regles.EstTerminee())
             {
@@ -187,9 +163,15 @@ namespace CoreLibrary
             {
                 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/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/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/NouveauTourEventArgsUT.cs

@@ -1,26 +0,0 @@
-using CoreLibrary.Joueurs;
-using CoreLibrary.Core;
-using CoreLibrary.Events;
-using Xunit;
-
-namespace UnitTesting
-{
-    public class NouveauTourEventArgsUT
-    {
-        [Fact]
-        public void TestConstructeurValide()
-        {
-            Plateau monPlateau = new Plateau(4, 12);
-            Joueur monJoueur = new Joueur("Céleste");
-
-            NouveauTourEventArgs evenement = 
-                new NouveauTourEventArgs(monJoueur, 5, monPlateau.Grille(), monPlateau.Indicateurs());
-
-            Assert.Equal(monJoueur, evenement.Joueur);
-            Assert.Equal(5, evenement.Tour);
-            Assert.Equal(monPlateau.Grille(), evenement.Grille);
-            Assert.Equal(monPlateau.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);
-        }
-    }
-}