diff --git a/Sources/ConsoleApp/Evenements.cs b/Sources/ConsoleApp/Evenements.cs index 2d96edc..a8e073c 100644 --- a/Sources/ConsoleApp/Evenements.cs +++ b/Sources/ConsoleApp/Evenements.cs @@ -14,19 +14,19 @@ namespace ConsoleApp /// /// Ecoute l'événement en rapport avec la demande du nom d'un joueur. /// La classe qui appelle l'événement; ici Partie. - /// L'instance de l'événement DemanderJoueurEventArgs créée par Partie. + /// L'instance de l'événement DemanderNomEventArgs créée par Partie. /// Le nom du joueur. /// - 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(); - } - - /// - /// Ecoute l'événement en rapport avec la demande d'un jeton. - /// La classe qui appelle l'événement; ici Partie. - /// L'instance de l'événement DemanderJetonEventArgs créée par Partie. - /// Le jeton choisi par le joueur. - /// - 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; - } - - /// - /// Ecoute l'événement en rapport avec l'ajout d'un jeton dans le code. - /// La classe qui appelle l'événement; ici Partie. - /// L'instance de l'événement AjouterJetonEventArgs créée par Partie. - /// - public static void AjouterJeton(Object? sender, AjouterJetonEventArgs e) - { - Utils.DessinerPion(e.Jeton.Couleur); - } - - /// - /// Ecoute l'événement en rapport avec la suppression du dernier jeton ajouté dans le code. - /// La classe qui appelle l'événement; ici Partie. - /// L'instance de l'événement SupprimerDernierJetonEventArgs créée par Partie. - /// - public static void SupprimerDernierJeton(Object? sender, SupprimerDernierJetonEventArgs e) - { - Console.Write("\b\b\b \b\b\b\b\b\b"); + e.Joueur.Code(code); } /// diff --git a/Sources/ConsoleApp/Program.cs b/Sources/ConsoleApp/Program.cs index 1ee6d17..5bfe329 100644 --- a/Sources/ConsoleApp/Program.cs +++ b/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; diff --git a/Sources/ConsoleApp/Utils.cs b/Sources/ConsoleApp/Utils.cs index be5c0ea..788b9bd 100644 --- a/Sources/ConsoleApp/Utils.cs +++ b/Sources/ConsoleApp/Utils.cs @@ -137,5 +137,71 @@ namespace ConsoleApp Console.WriteLine("│ │ │ │"); Console.WriteLine("──────────────── ────────────────"); } + + /// + /// Permet à l'utilisateur de choisir un jeton + /// L'indice du jeton à ajouter dans le code. + /// Le jeton choisi par le joueur. + /// + 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; + } + + + /// + /// Permet de supprimer le dernier jeton saisi + /// + public static void SupprimerDernierJeton() + { + Console.Write("\b\b\b \b\b\b\b\b\b"); + } } } diff --git a/Sources/CoreLibrary/Events/AjouterJetonEventArgs.cs b/Sources/CoreLibrary/Events/AjouterJetonEventArgs.cs deleted file mode 100644 index b9624e4..0000000 --- a/Sources/CoreLibrary/Events/AjouterJetonEventArgs.cs +++ /dev/null @@ -1,24 +0,0 @@ -using CoreLibrary.Core; - -namespace CoreLibrary.Events -{ - /// - /// Classe contenant les arguments passées en paramètre lors de l'événement AjouterJeton. - /// - public class AjouterJetonEventArgs : EventArgs - { - /// - /// Le jeton ajouté. - /// - public Jeton Jeton { get; private set; } - - /// - /// Initialise une nouvelle instance de la classe avec le jeton spécifié. - /// - /// Le jeton qui a été ajouté. - public AjouterJetonEventArgs(Jeton jeton) - { - Jeton = jeton; - } - } -} diff --git a/Sources/CoreLibrary/Events/AjouterJoueursEventArgs.cs b/Sources/CoreLibrary/Events/AjouterJoueurEventArgs.cs similarity index 74% rename from Sources/CoreLibrary/Events/AjouterJoueursEventArgs.cs rename to Sources/CoreLibrary/Events/AjouterJoueurEventArgs.cs index 0788931..b0efe7d 100644 --- a/Sources/CoreLibrary/Events/AjouterJoueursEventArgs.cs +++ b/Sources/CoreLibrary/Events/AjouterJoueurEventArgs.cs @@ -1,24 +1,24 @@ -using CoreLibrary.Joueurs; - -namespace CoreLibrary.Events -{ - /// - /// Classe contenant les arguments passées en paramètre lors de l'événement AjouterJoueur. - /// - public class AjouterJoueursEventArgs : EventArgs - { - /// - /// Le joueur ajouté. - /// - public Joueur Joueur { get; private set; } - - /// - /// Initialise une nouvelle instance de la classe avec le joueur spécifié. - /// - /// Le joueur qui a été ajouté. - public AjouterJoueursEventArgs(Joueur joueur) - { - Joueur = joueur; - } - } -} +using CoreLibrary.Joueurs; + +namespace CoreLibrary.Events +{ + /// + /// Classe contenant les arguments passées en paramètre lors de l'événement AjouterJoueur. + /// + public class AjouterJoueurEventArgs : EventArgs + { + /// + /// Le joueur ajouté. + /// + public Joueur Joueur { get; private set; } + + /// + /// Initialise une nouvelle instance de la classe avec le joueur spécifié. + /// + /// Le joueur qui a été ajouté. + public AjouterJoueurEventArgs(Joueur joueur) + { + Joueur = joueur; + } + } +} diff --git a/Sources/CoreLibrary/Events/ConstruireJoueurEventArgs.cs b/Sources/CoreLibrary/Events/ConstruireJoueurEventArgs.cs new file mode 100644 index 0000000..ce7f62b --- /dev/null +++ b/Sources/CoreLibrary/Events/ConstruireJoueurEventArgs.cs @@ -0,0 +1,22 @@ +namespace CoreLibrary.Events +{ + /// + /// Classe contenant les arguments passées en paramètre lors de l'événement ConstruireJoueurEventArgs. + /// + public class ConstruireJoueurEventArgs : EventArgs + { + /// + /// Le nom du joueur à ajouter. + /// + public string? Nom { get; private set; } + + /// + /// Initialise une nouvelle instance de la classe avec les informations spécifiées. + /// + /// Le nom du joueur à ajouter. + public ConstruireJoueurEventArgs(string? nom) + { + Nom = nom; + } + } +} diff --git a/Sources/CoreLibrary/Events/DemanderJetonEventArgs.cs b/Sources/CoreLibrary/Events/DemanderJetonEventArgs.cs deleted file mode 100644 index a8f3bae..0000000 --- a/Sources/CoreLibrary/Events/DemanderJetonEventArgs.cs +++ /dev/null @@ -1,22 +0,0 @@ -namespace CoreLibrary.Events -{ - /// - /// Classe contenant les arguments passées en paramètre lors de l'événement DemanderJeton. - /// - public class DemanderJetonEventArgs : EventArgs - { - /// - /// L'indice du code où le jeton va être ajouté. - /// - public int Indice { get; private set; } - - /// - /// Initialise une nouvelle instance de la classe avec l'indice spécifié. - /// - /// L'indice du jeton qui va été ajouté. - public DemanderJetonEventArgs(int indice) - { - Indice = indice; - } - } -} diff --git a/Sources/CoreLibrary/Events/DemanderJoueurEventArgs.cs b/Sources/CoreLibrary/Events/DemanderJoueurEventArgs.cs deleted file mode 100644 index f297f25..0000000 --- a/Sources/CoreLibrary/Events/DemanderJoueurEventArgs.cs +++ /dev/null @@ -1,23 +0,0 @@ -namespace CoreLibrary.Events -{ - /// - /// Classe contenant les arguments passées en paramètre lors de l'événement DemanderJoueur. - /// - public class DemanderJoueurEventArgs : EventArgs - { - /// - /// Le numéro du joueur (Joueur 1 ou 2, 3..). - /// - public int Numero { get; private set; } - - - /// - /// Initialise une nouvelle instance de la classe avec le numéro du joueur spécifié. - /// - /// Le numéro du joueur qui va être ajouté. - public DemanderJoueurEventArgs(int numero) - { - Numero = numero; - } - } -} diff --git a/Sources/CoreLibrary/Events/DemanderNomEventArgs.cs b/Sources/CoreLibrary/Events/DemanderNomEventArgs.cs new file mode 100644 index 0000000..d014733 --- /dev/null +++ b/Sources/CoreLibrary/Events/DemanderNomEventArgs.cs @@ -0,0 +1,31 @@ +using CoreLibrary.Joueurs; + +namespace CoreLibrary.Events +{ + /// + /// Classe contenant les arguments passées en paramètre lors de l'événement DemanderNom. + /// + public class DemanderNomEventArgs : EventArgs + { + /// + /// L'indice du joueur + /// + public int Indice { get; private set; } + + /// + /// Le constructeur de joueur dans lequel il faut renseigner le nom du joueur + /// + public JoueurBuilder JoueurBuilder { get; private set; } + + /// + /// Initialise une nouvelle instance de la classe avec les informations spécifiées. + /// + /// L'indice du joueur. + /// La classe dans laquelle on attend la réponse du joueur. + public DemanderNomEventArgs(int indice, JoueurBuilder joueurBuilder) + { + Indice = indice; + JoueurBuilder = joueurBuilder; + } + } +} diff --git a/Sources/CoreLibrary/Events/JouerCodeEventArgs.cs b/Sources/CoreLibrary/Events/JouerCodeEventArgs.cs new file mode 100644 index 0000000..fb6f41b --- /dev/null +++ b/Sources/CoreLibrary/Events/JouerCodeEventArgs.cs @@ -0,0 +1,24 @@ +using CoreLibrary.Core; + +namespace CoreLibrary.Events +{ + /// + /// Classe contenant les arguments passées en paramètre lors de l'événement JouerCode. + /// + public class JouerCodeEventArgs : EventArgs + { + /// + /// Le code joué par le joueur + /// + public Code Code { get; private set; } + + /// + /// Initialise une nouvelle instance de la classe avec les informations spécifiées. + /// + /// Le code joué par le joueur dont c'est le tour. + public JouerCodeEventArgs(Code code) + { + Code = code; + } + } +} diff --git a/Sources/CoreLibrary/Events/NouveauJoueurEventArgs.cs b/Sources/CoreLibrary/Events/NouveauJoueurEventArgs.cs new file mode 100644 index 0000000..a646a8a --- /dev/null +++ b/Sources/CoreLibrary/Events/NouveauJoueurEventArgs.cs @@ -0,0 +1,22 @@ +namespace CoreLibrary.Events +{ + /// + /// Classe contenant les arguments passées en paramètre lors de l'événement NouveauJoueur. + /// + public class NouveauJoueurEventArgs : EventArgs + { + /// + /// Le nom du joueur + /// + public string Nom { get; private set; } + + /// + /// Initialise une nouvelle instance de la classe avec les informations spécifiées. + /// + /// Le nom du joueur. + public NouveauJoueurEventArgs(string nom) + { + Nom = nom; + } + } +} diff --git a/Sources/CoreLibrary/Events/NouveauTourEventArgs.cs b/Sources/CoreLibrary/Events/NouveauTourEventArgs.cs index c1024de..30ac6e2 100644 --- a/Sources/CoreLibrary/Events/NouveauTourEventArgs.cs +++ b/Sources/CoreLibrary/Events/NouveauTourEventArgs.cs @@ -18,6 +18,11 @@ namespace CoreLibrary.Events /// public int Tour { get; private set; } + /// + /// Le code où ajouter les jetons + /// + public Code Code { get; private set; } + /// /// La grille du joueur actuelle. /// @@ -35,10 +40,11 @@ namespace CoreLibrary.Events /// Le numéro du tour. /// La grille du joueur actuelle. /// Les indicateurs de la grille de jeu. - public NouveauTourEventArgs(Joueur joueur, int tour, IEnumerable> grille, IEnumerable> indicateurs) + public NouveauTourEventArgs(Joueur joueur, int tour, Code code, IEnumerable> grille, IEnumerable> indicateurs) { Joueur = joueur; Tour = tour; + Code = code; Grille = grille; Indicateurs = indicateurs; } diff --git a/Sources/CoreLibrary/Events/SupprimerDernierJetonEventArgs.cs b/Sources/CoreLibrary/Events/SupprimerDernierJetonEventArgs.cs deleted file mode 100644 index ddf9cc4..0000000 --- a/Sources/CoreLibrary/Events/SupprimerDernierJetonEventArgs.cs +++ /dev/null @@ -1,9 +0,0 @@ -namespace CoreLibrary.Events -{ - /// - /// Classe contenant les arguments passées en paramètre lors de l'événement SupprimerDernierJeton. - /// - public class SupprimerDernierJetonEventArgs : EventArgs - { - } -} diff --git a/Sources/CoreLibrary/Joueurs/Joueur.cs b/Sources/CoreLibrary/Joueurs/Joueur.cs index 7838b76..201b9f8 100644 --- a/Sources/CoreLibrary/Joueurs/Joueur.cs +++ b/Sources/CoreLibrary/Joueurs/Joueur.cs @@ -1,4 +1,7 @@ -namespace CoreLibrary.Joueurs +using CoreLibrary.Core; +using CoreLibrary.Events; + +namespace CoreLibrary.Joueurs { /// /// Classe représentant un joueur. @@ -17,6 +20,17 @@ /// /// Crée une nouvelle instance de joueur avec un nom + /// Evénement appelé pour jouer un code. + /// + public event EventHandler? JouerCode; + + /// + /// Appel de l'événement JouerCode. + /// + private void QuandJouerCode(Code code) => JouerCode?.Invoke(this, new JouerCodeEventArgs(code)); + + /// + /// Crée une nouvelle instance de joueur avec un nom et un plateau spécifié. /// /// Le nom du joueur. public Joueur(string nom) @@ -36,5 +50,10 @@ NbPartieEgalite = nbPartieEgalite; NbPartiePerdue = nbPartiePerdue; } + + public void Code(Code code) + { + QuandJouerCode(code); + } } } diff --git a/Sources/CoreLibrary/Joueurs/JoueurBuilder.cs b/Sources/CoreLibrary/Joueurs/JoueurBuilder.cs new file mode 100644 index 0000000..b136b7b --- /dev/null +++ b/Sources/CoreLibrary/Joueurs/JoueurBuilder.cs @@ -0,0 +1,16 @@ +using CoreLibrary.Events; + +namespace CoreLibrary.Joueurs +{ + public class JoueurBuilder + { + public event EventHandler? ConstruireJoueur; + + private void QuandConstruireJoueur(string? nom) => ConstruireJoueur?.Invoke(this, new ConstruireJoueurEventArgs(nom)); + + public void Nom(string? nom) + { + QuandConstruireJoueur(nom); + } + } +} diff --git a/Sources/CoreLibrary/Manager/IPersistanceManager.cs b/Sources/CoreLibrary/Manager/IPersistanceManager.cs index 5795d3a..501b80b 100644 --- a/Sources/CoreLibrary/Manager/IPersistanceManager.cs +++ b/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 Charger(); + public void Enregistrer(IEnumerable donnees); } } diff --git a/Sources/CoreLibrary/Manager/Manager.cs b/Sources/CoreLibrary/Manager/Manager.cs index 55ad615..619d180 100644 --- a/Sources/CoreLibrary/Manager/Manager.cs +++ b/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 Joueurs => Array.AsReadOnly(joueurs); + private bool estDetruit; - public void Charger() + private readonly IPersistanceManager persistance; + + private readonly IEnumerable joueurs; + public IEnumerable 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); + } } } diff --git a/Sources/CoreLibrary/Manager/Stub.cs b/Sources/CoreLibrary/Manager/Stub.cs new file mode 100644 index 0000000..dfebedb --- /dev/null +++ b/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 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 donnees) + { + EstEnregistre = true; + } + } +} diff --git a/Sources/CoreLibrary/Partie.cs b/Sources/CoreLibrary/Partie.cs index c56a8bd..8378db6 100644 --- a/Sources/CoreLibrary/Partie.cs +++ b/Sources/CoreLibrary/Partie.cs @@ -12,31 +12,15 @@ namespace CoreLibrary { private readonly IRegles regles; - - /// - /// Définit le délégué pour gérer les événements avec des arguments de type string. - /// - public delegate string? StringEventHandler(Object? sender, TEventArgs e); - - /// - /// Définit le délégué pour gérer les événements avec des arguments de type Jeton. - /// - public delegate Jeton? JetonEventHandler(Object? sender, TEventArgs e); - /// /// Événement déclenché lorsqu'il est nécessaire de d'ajouter un joueur. /// - public event StringEventHandler? DemanderJoueur; - - /// - /// Événement déclenché lorsqu'il est nécessaire d'ajouter un jeton. - /// - public event JetonEventHandler? DemanderJeton; + public event EventHandler? DemanderNom; /// /// Événement déclenché lorsqu'il est nécessaire d'ajouter un joueur. /// - public event EventHandler? AjouterJoueur; + public event EventHandler? AjouterJoueur; /// /// Événement déclenché lorsqu'une partie commence. @@ -48,17 +32,6 @@ namespace CoreLibrary /// public event EventHandler? NouveauTour; - /// - /// Événement déclenché lorsqu'il est nécessaire d'ajouter un jeton. - /// - public event EventHandler? AjouterJeton; - - - /// - /// Événement déclenché lorsqu'un jeton est supprimé. - /// - public event EventHandler? SupprimerDernierJeton; - /// /// Événement déclenché lorsqu'un code est ajouté. /// @@ -75,55 +48,38 @@ namespace CoreLibrary public event EventHandler? PartieTerminee; /// - /// 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. /// /// Le numéro du joueur à ajouter - /// Le nom du joueur demandé - private string? QuandDemanderJoueur(int numero) => DemanderJoueur?.Invoke(this, new DemanderJoueurEventArgs(numero)); - - /// - /// Méthode pour déclencher l'événement de demande d'ajout d'un jeton. - /// - /// Le jeton demandé - private Jeton? QuandDemanderJeton(int indice) => DemanderJeton?.Invoke(this, new DemanderJetonEventArgs(indice)); + /// La classe dans laquelle le nom doit être défini + private void QuandDemanderNom(int numero, JoueurBuilder joueurBuilder) => DemanderNom?.Invoke(this, new DemanderNomEventArgs(numero, joueurBuilder)); /// /// Méthode pour déclencher l'événement d'ajout d'un joueur. /// /// Le joueur à ajouter. - private void QuandAjouterJoueur(Joueur joueur) => AjouterJoueur?.Invoke(this, new AjouterJoueursEventArgs(joueur)); + private void QuandAjouterJoueur(Joueur joueur) => AjouterJoueur?.Invoke(this, new AjouterJoueurEventArgs(joueur)); /// /// Méthode pour déclencher l'événement du début d'un partie. /// private void QuandDebutPartie() => DebutPartie?.Invoke(this, new DebutPartieEventArgs()); - /// /// Méthode pour déclencher l'événement d'un nouveau tour. /// /// Le joueur dont c'est le tour. /// Le numéro du tour. + /// Le code dans lequel il faut ajouter les jetons. /// La grille de jeu. /// Les indicateurs de jeu. - private void QuandNouveauTour(Joueur joueur, int tour, IEnumerable> grille, IEnumerable> indicateurs) => NouveauTour?.Invoke(this, new NouveauTourEventArgs(joueur, tour, grille, indicateurs)); - - /// - /// Méthode pour déclencher l'événement d'ajout d'un nouveau jeton. - /// - /// Le jeton à ajouter. - private void QuandNouveauJeton(Jeton jeton) => AjouterJeton?.Invoke(this, new AjouterJetonEventArgs(jeton)); - - /// - /// Méthode pour déclencher l'événement de suppression du dernier jeton du code. - /// - private void QuandSupprimerDernierJeton() => SupprimerDernierJeton?.Invoke(this, new SupprimerDernierJetonEventArgs()); + private void QuandNouveauTour(Joueur joueur, int tour, Code code, IEnumerable> grille, IEnumerable> indicateurs) => NouveauTour?.Invoke(this, new NouveauTourEventArgs(joueur, tour, code, grille, indicateurs)); /// /// Méthode pour déclencher l'événement d'ajout d'un nouveau code. /// - /// Le code à ajouter. - private void QuandNouveauCode(Code code) => AjouterCode?.Invoke(this, new AjouterCodeEventArgs(code)); + /// Le code ajouté. + private void QuandAjouterCode(Code code) => AjouterCode?.Invoke(this, new AjouterCodeEventArgs(code)); /// /// Méthode pour déclencher l'événement de passage de la main au joueur suivant. @@ -151,71 +107,74 @@ namespace CoreLibrary /// 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()); + JoueurBuilder joueurBuilder = new JoueurBuilder(); + joueurBuilder.ConstruireJoueur += Joueur; - Code code = regles.GenererCode(); - - CreerCode(code); - - // Phase de saisie du code par le joueur jusqu'à que le code soit complet. + QuandDemanderNom(regles.NbJoueurs + 1, joueurBuilder); + } - plateauCourant.AjouterCode(code); - QuandNouveauCode(code); + /// + /// Un joueur a saisi son nom + /// + private void Joueur(Object? sender, ConstruireJoueurEventArgs e) + { + Joueur joueur = regles.AjouterJoueur(e.Nom ?? $"Joueur {regles.NbJoueurs + 1}"); + QuandAjouterJoueur(joueur); + joueur.JouerCode += Tour; - regles.PasserLaMain(); - QuandPasserMain(); + if (regles.NbJoueurs != regles.NbJoueursMaximum) + { + JoueurBuilder joueurBuilder = new JoueurBuilder(); + joueurBuilder.ConstruireJoueur += Joueur; + QuandDemanderNom(regles.NbJoueurs + 1, joueurBuilder); } + else + { + Commencer(); + } + } + /// + /// La partie démarre + /// + private void Commencer() + { + regles.CommencerLaPartie(); + QuandDebutPartie(); - regles.Gagnants(); - regles.Perdants(); - - QuandPartieTerminee(regles.Gagnants(), regles.Perdants()); + (Joueur joueurCourant, Plateau plateauCourant) = regles.JoueurCourant(); + QuandNouveauTour(joueurCourant, plateauCourant.Tour, regles.GenererCode(), plateauCourant.Grille(), plateauCourant.Indicateurs()); } - private void AjouterJoueurs() + /// + /// Un joueur a joué son tour + /// + private void Tour(Object? sender, JouerCodeEventArgs e) { - while (regles.NbJoueurs != regles.NbJoueursMaximum) + (Joueur joueurCourant, Plateau plateauCourant) = regles.JoueurCourant(); + plateauCourant.AjouterCode(e.Code); + QuandAjouterCode(e.Code); + + if(regles.EstTerminee()) + { + Terminee(); + } + else { - string nom = QuandDemanderJoueur(regles.NbJoueurs + 1) ?? $"Joueur {regles.NbJoueurs + 1}"; - Joueur joueur = regles.AjouterJoueur(nom); - QuandAjouterJoueur(joueur); + regles.PasserLaMain(); + QuandPasserMain(); + + (joueurCourant, plateauCourant) = regles.JoueurCourant(); + QuandNouveauTour(joueurCourant, plateauCourant.Tour, regles.GenererCode(), plateauCourant.Grille(), plateauCourant.Indicateurs()); } } - private void CreerCode(Code code) + /// + /// La partie est terminée + /// + private void Terminee() { - while (!code.EstComplet()) - { - Jeton? jeton = QuandDemanderJeton(code.NbJetons); - - if (DemanderJeton == null) - { - jeton = new Jeton(); - } - - if(!jeton.HasValue) - { - code.SupprimerDernierJeton(); - QuandSupprimerDernierJeton(); - } - else - { - code.AjouterJeton(jeton.Value); - QuandNouveauJeton(jeton.Value); - } - } + QuandPartieTerminee(regles.Gagnants(), regles.Perdants()); } } } diff --git a/Sources/MauiSpark/MauiProgram.cs b/Sources/MauiSpark/MauiProgram.cs index be3b5b2..82d1290 100644 --- a/Sources/MauiSpark/MauiProgram.cs +++ b/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() diff --git a/Sources/MauiSpark/MauiSpark.csproj b/Sources/MauiSpark/MauiSpark.csproj index 01cba09..526a3d2 100644 --- a/Sources/MauiSpark/MauiSpark.csproj +++ b/Sources/MauiSpark/MauiSpark.csproj @@ -1,99 +1,99 @@ - - - - net8.0-android; - $(TargetFrameworks);net8.0-windows10.0.19041.0 - - - - - - - Exe - MauiSpark - true - true - enable - enable - - - MauiSpark - - - fr.mastermind.mauispark - - - 1.0 - 1 - - 11.0 - 13.1 - 21.0 - 10.0.17763.0 - 10.0.17763.0 - 6.5 - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + net8.0-android; + $(TargetFrameworks);net8.0-windows10.0.19041.0 + + + + + + + Exe + MauiSpark + true + true + enable + enable + + + MauiSpark + + + fr.mastermind.mauispark + + + 1.0 + 1 + + 11.0 + 13.1 + 21.0 + 10.0.17763.0 + 10.0.17763.0 + 6.5 + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - MSBuild:Compile - - - MSBuild:Compile - - - MSBuild:Compile - - - MSBuild:Compile - - - MSBuild:Compile - - - MSBuild:Compile - - - MSBuild:Compile - - - MSBuild:Compile - - - MSBuild:Compile - - - - + + + + + MSBuild:Compile + + + MSBuild:Compile + + + MSBuild:Compile + + + MSBuild:Compile + + + MSBuild:Compile + + + MSBuild:Compile + + + MSBuild:Compile + + + MSBuild:Compile + + + MSBuild:Compile + + + + diff --git a/Sources/UnitTesting/AjouterJetonEventArgsUT.cs b/Sources/UnitTesting/AjouterJetonEventArgsUT.cs deleted file mode 100644 index f621091..0000000 --- a/Sources/UnitTesting/AjouterJetonEventArgsUT.cs +++ /dev/null @@ -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); - } - - } -} diff --git a/Sources/UnitTesting/AjouterJoueurEventArgs.cs b/Sources/UnitTesting/AjouterJoueurEventArgs.cs index f614d6b..740f0c6 100644 --- a/Sources/UnitTesting/AjouterJoueurEventArgs.cs +++ b/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); } diff --git a/Sources/UnitTesting/ConstruireJoueurEventArgsUT.cs b/Sources/UnitTesting/ConstruireJoueurEventArgsUT.cs new file mode 100644 index 0000000..909e8a9 --- /dev/null +++ b/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); + } + + } +} diff --git a/Sources/UnitTesting/DemanderJoueurEventArgsUT.cs b/Sources/UnitTesting/DemanderJoueurEventArgsUT.cs deleted file mode 100644 index 0aca2be..0000000 --- a/Sources/UnitTesting/DemanderJoueurEventArgsUT.cs +++ /dev/null @@ -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); - } - } -} diff --git a/Sources/UnitTesting/DemanderNomEventArgsUT.cs b/Sources/UnitTesting/DemanderNomEventArgsUT.cs new file mode 100644 index 0000000..272b79e --- /dev/null +++ b/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); + } + + } +} diff --git a/Sources/UnitTesting/JouerCodeEventArgsUT.cs b/Sources/UnitTesting/JouerCodeEventArgsUT.cs new file mode 100644 index 0000000..bde4742 --- /dev/null +++ b/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); + } + } +} diff --git a/Sources/UnitTesting/JoueurBuilderUT.cs b/Sources/UnitTesting/JoueurBuilderUT.cs new file mode 100644 index 0000000..ffafcdc --- /dev/null +++ b/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"))); + } + } +} diff --git a/Sources/UnitTesting/JoueurUT.cs b/Sources/UnitTesting/JoueurUT.cs index 147f3ee..10846b5 100644 --- a/Sources/UnitTesting/JoueurUT.cs +++ b/Sources/UnitTesting/JoueurUT.cs @@ -1,5 +1,7 @@ using CoreLibrary.Core; +using CoreLibrary.Events; using CoreLibrary.Joueurs; +using System.Reflection; using Xunit; namespace UnitTesting @@ -13,7 +15,7 @@ namespace UnitTesting Joueur joueur = new Joueur(nom); - + Assert.Equal(nom, joueur.Nom); Assert.Equal(0, joueur.NbCoutTotal); Assert.Equal(0, joueur.NbPartieGagnee); @@ -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))); + } } } diff --git a/Sources/UnitTesting/ManagerUT.cs b/Sources/UnitTesting/ManagerUT.cs new file mode 100644 index 0000000..ef2d401 --- /dev/null +++ b/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); + } + } +} diff --git a/Sources/UnitTesting/NouveauJoueurEventArgsUT.cs b/Sources/UnitTesting/NouveauJoueurEventArgsUT.cs new file mode 100644 index 0000000..edc81a9 --- /dev/null +++ b/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); + } + } +} diff --git a/Sources/UnitTesting/NouveauTourEventArgsUT.cs b/Sources/UnitTesting/NouveauTourEventArgsUT.cs index d1f877a..f3ee7da 100644 --- a/Sources/UnitTesting/NouveauTourEventArgsUT.cs +++ b/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); } - } } diff --git a/Sources/UnitTesting/PartieUT.cs b/Sources/UnitTesting/PartieUT.cs deleted file mode 100644 index 3a2c993..0000000 --- a/Sources/UnitTesting/PartieUT.cs +++ /dev/null @@ -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); - } - } -} diff --git a/Sources/UnitTesting/ReglesClassiquesUT.cs b/Sources/UnitTesting/ReglesClassiquesUT.cs index b58aa1c..030c8b4 100644 --- a/Sources/UnitTesting/ReglesClassiquesUT.cs +++ b/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 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()); + } } } diff --git a/Sources/UnitTesting/StubUT.cs b/Sources/UnitTesting/StubUT.cs new file mode 100644 index 0000000..8fe5f4a --- /dev/null +++ b/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([]))); + } + + } +}