diff --git a/Sources/ConsoleApp/Evenements.cs b/Sources/ConsoleApp/Evenements.cs index bd611d2..33f9151 100644 --- a/Sources/ConsoleApp/Evenements.cs +++ b/Sources/ConsoleApp/Evenements.cs @@ -4,7 +4,7 @@ using CoreLibrary; namespace ConsoleApp { /// - /// Fournit des gestionnaires d'événements les événements liés au déroulement de la partie. + /// Fournit des gestionnaires d'événements pour les événements liés au déroulement de la partie. /// public static class Evenements { diff --git a/Sources/ConsoleApp/Utils.cs b/Sources/ConsoleApp/Utils.cs index 5b09d8f..f768e8b 100644 --- a/Sources/ConsoleApp/Utils.cs +++ b/Sources/ConsoleApp/Utils.cs @@ -2,8 +2,12 @@ namespace ConsoleApp { + /// + /// Classe utilitaire contenant des méthodes pour dessiner des éléments dans la console. + /// public static class Utils { + // Dictionnaires associant les valeurs des énumérations avec les couleurs de la console private readonly static Dictionary couleursTerminal = new Dictionary() { {Couleur.NOIR, ConsoleColor.Black }, @@ -20,6 +24,9 @@ namespace ConsoleApp {Indicateur.BONNECOULEUR, ConsoleColor.White } }; + /// + /// Dessine le titre du jeu dans la console. + /// public static void DessinerTitre() { Console.WriteLine(@" @@ -31,7 +38,9 @@ namespace ConsoleApp DessinerSeparateur(); } - + /// + /// Dessine un séparateur dans la console. + /// public static void DessinerSeparateur() { Console.WriteLine(@" @@ -42,14 +51,20 @@ namespace ConsoleApp "); } + /// + /// Dessine un pion dans la console. + /// + /// Le pion à dessiner (une couleur ou un indicateur). public static void DessinerPion(Enum pion) { Console.Write(" "); + // Sélectionne la couleur appropriée en fonction du type de pion (une couleur ou un indicateur) Console.ForegroundColor = pion.GetType().Equals(typeof(Couleur)) ? couleursTerminal.GetValueOrDefault((Couleur)pion) : indicateursTerminal.GetValueOrDefault((Indicateur)pion); + // Définit la couleur de fond en fonction de la couleur de premier plan Console.BackgroundColor = Console.ForegroundColor.Equals(ConsoleColor.Black) ? ConsoleColor.White : ConsoleColor.Black; Console.Write("⬤"); @@ -59,6 +74,10 @@ namespace ConsoleApp Console.Write(" "); } + /// + /// Dessine une ligne de pions sur la console. + /// + /// Un tableau d'énumérations représentant les pions à dessiner. private static void DessinerLigne(Enum[] ligne) { foreach(Enum pion in ligne) @@ -67,6 +86,11 @@ namespace ConsoleApp Console.Write("".PadLeft((4 - ligne.Length) * 3)); } + /// + /// Dessine un plateau de jeu dans la console, affichant les jetons et les indicateurs. + /// + /// La grille de jeu. + /// Les indicateurs associés à chaque ligne. public static void DessinerPlateau(IEnumerable> grille, IEnumerable> indicateurs) { IEnumerable[] grilleTableau = grille.ToArray(); diff --git a/Sources/CoreLibrary/Code.cs b/Sources/CoreLibrary/Code.cs index 8720ed3..053303a 100644 --- a/Sources/CoreLibrary/Code.cs +++ b/Sources/CoreLibrary/Code.cs @@ -2,12 +2,23 @@ namespace CoreLibrary { + /// + /// Représente un code composé de jetons. + /// public class Code { private readonly Jeton?[] lesJetons; + /// + /// Obtenir le nombre de jetons dans le code. + /// public int NbJetons { get; private set; } = 0; + /// + /// Initialise une nouvelle instance de la classe avec la longueur de code spécifiée. + /// + /// La longueur du code. + /// Levée lorsque la longueur du code spécifiée est inférieure ou égale à zéro. public Code(int tailleCode) { if(tailleCode <= 0) @@ -18,6 +29,11 @@ namespace CoreLibrary lesJetons = new Jeton?[tailleCode]; } + /// + /// Initialise une nouvelle instance de la class avec les jetons spécifiés. + /// + /// Les jetons pour initaliser le code. + /// Levée lorsque la collection de jetons spécifiée est vide. public Code(IEnumerable jetons) { if (jetons.Any()) @@ -32,6 +48,11 @@ namespace CoreLibrary } } + /// + /// Ajoute un jeton au code. + /// + /// Le jeton à ajouter + /// Levée lorsque le code est plein. public void AjouterJeton(Jeton jeton) { if (NbJetons == TailleMaximale()) @@ -42,6 +63,10 @@ namespace CoreLibrary lesJetons[NbJetons++] = jeton; } + /// + /// Supprime le dernier jeton ajouté au code. + /// + /// Levée lorsque le code est vide. public void SupprimerDernierJeton() { if(NbJetons == 0) @@ -52,6 +77,12 @@ namespace CoreLibrary lesJetons[--NbJetons] = null; } + /// + /// Récupère le jeton à l'indice spécifié dans le code. + /// + /// L'indice du jeton a récupéré. + /// Le jeton situé à l'indice spécifié. + /// Levée lorsque l'indice est supérieur à la taille maximale du code, inférieur à 0 ou qu'il n'y a pas de jeton à l'indice spécifié public Jeton RecupererJeton(int indice) { if(indice < 0 || indice > TailleMaximale()) @@ -65,33 +96,57 @@ namespace CoreLibrary return jeton.Value; } + /// + /// Récupère une énumération des jetons dans le code. + /// + /// Enumération des jetons du code public IEnumerable Jetons() { return lesJetons; } + + /// + /// Vérifie si le code est complet. + /// + /// True si le code est complet, sinon False. public bool EstComplet() { return NbJetons == lesJetons.Length; } + /// + /// Recupère la taille maximal du code. + /// + /// Taille maximal du code. + public int TailleMaximale() { return lesJetons.Length; } + /// + /// Compare le code avec un autre code et génère des indcateurs de correspondance. + /// + /// Le code à comparer avec le code actuel + /// Enumération d'indicateurs de correspondance entre les deux codes. public IEnumerable Comparer(Code autreCode) { // Mon code est le code correct, l'autre code est celui qui teste Indicateur[] indicateurs = []; + /// Vérifie si les deux codes sont complets if (!EstComplet() || !autreCode.EstComplet()) return indicateurs; List mesJetons = new List(Jetons()); List sesJetons = new List(autreCode.Jetons()); + + /// Compare les jetons pour détecter les ceux à la bonnes places + /// S'ils sont à la bonne place alors ils sont enlever du tableau et un indicateur BONNEPLACE est ajouter au tableau des indicateurs. + for (int i = 0; i < mesJetons.Count; ++i) { Jeton? monJeton = mesJetons[i]; @@ -105,6 +160,8 @@ namespace CoreLibrary } } + /// Compare les jetons pour détecter ceux qui ont la bonne couleur. + /// S'ils ont la bonne couleur alors ils sont enlever du tableau et un indicateur BONNECOULEUR est ajouter au tableau des indicateurs. for (int i = 0; i < sesJetons.Count; ++i) { diff --git a/Sources/CoreLibrary/Partie.cs b/Sources/CoreLibrary/Partie.cs index a6488a6..4ac30cf 100644 --- a/Sources/CoreLibrary/Partie.cs +++ b/Sources/CoreLibrary/Partie.cs @@ -3,56 +3,166 @@ using CoreLibrary.Exceptions; namespace CoreLibrary { + /// + /// Représente une partie de jeu. + /// public class Partie { 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; + /// + /// Événement déclenché lorsqu'il est nécessaire d'ajouter un joueur. + /// public event EventHandler? AjouterJoueur; + + /// + /// Événement déclenché lorsqu'une partie commence. + /// public event EventHandler? DebutPartie; + + /// + /// Événement déclenché lorsqu'un nouveau tour commence. + /// 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é. + /// public event EventHandler? AjouterCode; + + /// + /// Événement déclenché lorsque la main est passée au joueur suivant. + /// public event EventHandler? PasserMain; + + /// + /// Événement déclenché lorsque la partie est terminée. + /// public event EventHandler? PartieTerminee; + /// + /// Méthode pour déclencher l'événement de demande d'ajout 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)); - private Jeton? QuandDemanderJeton() => DemanderJeton?.Invoke(this, new DemanderJetonEventArgs()); + /// + /// Méthode pour déclencher l'événement de demande d'ajout d'un jeton. + /// + /// Le jeton demandé + private Jeton? QuandDemanderJeton() => DemanderJeton?.Invoke(this, new DemanderJetonEventArgs()); + /// + /// 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)); + + /// + /// 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. + /// 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()); + + /// + /// 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)); + + /// + /// Méthode pour déclencher l'événement de passage de la main au joueur suivant. + /// private void QuandPasserMain() => PasserMain?.Invoke(this, new PasserMainEventArgs()); - private void QuandPartieTerminee(IEnumerable gagnants, IEnumerable perdants) => PartieTerminee?.Invoke(this, new PartieTermineeEventArgs(gagnants, perdants)); + /// + /// Méthode pour déclencher l'événement de fin de partie. + /// + /// La liste des joueurs gagnants. + /// La liste des joueurs perdants. + private void QuandPartieTerminee(IEnumerable gagnants, IEnumerable perdants) => PartieTerminee?.Invoke(this, new PartieTermineeEventArgs(gagnants, perdants)); + /// + /// Crée une nouvelle instance de la classe Partie. + /// + /// Les règles de la partie. public Partie(IRegles regles) { this.regles = regles; } + /// + /// Lance le déroulement de la partie. + /// public void Jouer() { + /// Ajout des joueurs jusqu'à atteindre le nombre maximum de joueurs défini par les règles while (regles.NbJoueurs != regles.NbJoueursMaximum) + while (regles.NbJoueurs != regles.NbJoueursMaximum) { string nom = QuandDemanderJoueur(regles.NbJoueurs + 1) ?? $"Joueur {regles.NbJoueurs+1}"; Joueur joueur = regles.AjouterJoueur(nom); QuandAjouterJoueur(joueur); } + /// Début de la partie regles.CommencerLaPartie(); QuandDebutPartie(); + /// Boucle principale du jeu qui dure jusqu'à qu'une condition de fin soit déclenchée while (!regles.EstTerminee()) { Joueur joueurCourant = regles.JoueurCourant(); @@ -62,6 +172,7 @@ namespace CoreLibrary Code code = regles.GenererCode(); + /// Phase de saisie du code par le joueur jusqu'à que le code soit complet. while (!code.EstComplet()) { Jeton? jeton = QuandDemanderJeton();