diff --git a/Sources/CoreLibrary/Core/Code.cs b/Sources/CoreLibrary/Core/Code.cs index 283de9f..fb6dbde 100644 --- a/Sources/CoreLibrary/Core/Code.cs +++ b/Sources/CoreLibrary/Core/Code.cs @@ -5,17 +5,44 @@ using System.Runtime.Serialization; namespace CoreLibrary.Core { + /// + /// Classe représentant un code composé de jetons et ses différentes méthodes. + /// [DataContract] public class Code { + /// + /// Collection observable de jetons. + /// [DataMember] public ObservableCollection Jetons { get; private init; } = new ObservableCollection(); + + /// + /// Obtient le nombre actuel de jetons dans le code. + /// public int Taille => Jetons.Count; + + /// + /// Taille maximale de jetons autorisée pour le code. + /// [DataMember] public int TailleMax { get; private init; } + + /// + /// Indique si le code est complet. + /// public bool Complet => Taille == TailleMax; + + /// + /// Indique si le code est vide. + /// public bool Vide => Taille == 0; + /// + /// Constructeur de code avec une taille maximale spécifiée. + /// + /// La taille maximale de jetons autorisée pour le code. + /// Exception lancée si la taille spécifiée est négative ou nulle. public Code(int taille) { if (taille < 0) @@ -24,6 +51,11 @@ namespace CoreLibrary.Core TailleMax = taille; } + /// + /// Ajoute un jeton au code. + /// + /// Le jeton à ajouter. + /// Lancée si le code est déjà complet. public void AjouterJeton(Jeton jeton) { if (Complet) @@ -32,6 +64,12 @@ namespace CoreLibrary.Core Jetons.Add(jeton); } + /// + /// Récupère le jeton à l'indice spécifié. + /// + /// L'indice du jeton à récupérer. + /// Renvoie le jeton à l'indice spécifié. + /// Lancée si l'indice est en dehors des limites de la collection de jetons. public Jeton RecupererJeton(int indice) { if (indice < 0 || indice >= Taille) @@ -40,6 +78,10 @@ namespace CoreLibrary.Core return Jetons.ElementAt(indice); } + /// + /// Supprime le dernier jeton du code. + /// + /// Lancée si le code est vide. public void SupprimerDernierJeton() { if (Vide) @@ -48,6 +90,13 @@ namespace CoreLibrary.Core Jetons.RemoveAt(Taille - 1); } + /// + /// Compare le code avec le code secret et retourne une liste d'indicateurs. + /// + /// Le code à comparer. + /// Renvoie une liste d'indicateurs représentant les résultats de la comparaison. + /// Lancée si le code n'est pas complet. + /// Lancée si le code est invalide. public IReadOnlyList Comparer(Code code) { // Je suis le bon code @@ -86,6 +135,10 @@ namespace CoreLibrary.Core return indicateurs; } + /// + /// Retourne la taille du code sous forme de chaîne de caractères. + /// + /// Renvoie une chaîne de caractères représentant la taille du code. public override string ToString() => $"Code({Taille})"; } } diff --git a/Sources/CoreLibrary/Core/Couleur.cs b/Sources/CoreLibrary/Core/Couleur.cs index 3631c88..4918a86 100644 --- a/Sources/CoreLibrary/Core/Couleur.cs +++ b/Sources/CoreLibrary/Core/Couleur.cs @@ -1,5 +1,8 @@ namespace CoreLibrary.Core { + /// + /// Enumération des différentes couleurs possibles pour un jeton. + /// public enum Couleur { Rouge, diff --git a/Sources/CoreLibrary/Core/Indicateur.cs b/Sources/CoreLibrary/Core/Indicateur.cs index ff4f443..6424537 100644 --- a/Sources/CoreLibrary/Core/Indicateur.cs +++ b/Sources/CoreLibrary/Core/Indicateur.cs @@ -1,5 +1,8 @@ namespace CoreLibrary.Core { + /// + /// Enumération des indicateurs de comparaison entre deux codes. + /// public enum Indicateur { BonnePlace, diff --git a/Sources/CoreLibrary/Core/Jeton.cs b/Sources/CoreLibrary/Core/Jeton.cs index ff3206b..06de24a 100644 --- a/Sources/CoreLibrary/Core/Jeton.cs +++ b/Sources/CoreLibrary/Core/Jeton.cs @@ -2,18 +2,33 @@ namespace CoreLibrary.Core { + /// + /// Structure représentant un jeton de couleur. + /// [DataContract] public readonly struct Jeton { + /// + /// Obtient la couleur du jeton. + /// [DataMember] public Couleur Couleur { get; private init; } + /// + /// Constructeur d'un jeton avec une couleur spécifiée. + /// + /// La couleur du jeton. public Jeton(Couleur couleur) { Couleur = couleur; } - public override readonly bool Equals(object? obj) + /// + /// Détermine si l'objet spécifié est égal à l'objet actuel. + /// + /// L'objet à comparer avec l'objet actuel. + /// Renvoie true si l'objet spécifié est égal à l'objet actuel. Sinon, false. + public override readonly bool Equals(object? objet) { if (obj is not Jeton) return false; @@ -21,10 +36,26 @@ namespace CoreLibrary.Core return Couleur == ((Jeton)obj).Couleur; } + /// + /// Détermine si deux jetons sont égaux. + /// + /// Le premier jeton à comparer. + /// Le deuxième jeton à comparer. + /// Renvoie true si les deux jetons sont égaux. Sinon, false. public static bool operator ==(Jeton gauche, Jeton droite) => gauche.Equals(droite); + /// + /// Détermine si deux jetons ne sont pas égaux. + /// + /// Le premier jeton à comparer. + /// Le deuxième jeton à comparer. + /// Renvoie true si les deux jetons ne sont pas égaux. Sinon, false. public static bool operator !=(Jeton gauche, Jeton droite) => gauche.Equals(droite); + /// + /// Fonction de hachage. + /// + /// Renvoie un code de hachage pour une couleur. public override readonly int GetHashCode() => Couleur.GetHashCode(); } } diff --git a/Sources/CoreLibrary/Core/Plateau.cs b/Sources/CoreLibrary/Core/Plateau.cs index f8b3321..ef64c2c 100644 --- a/Sources/CoreLibrary/Core/Plateau.cs +++ b/Sources/CoreLibrary/Core/Plateau.cs @@ -5,33 +5,79 @@ using System.Security.Cryptography; namespace CoreLibrary.Core { + /// + /// Classe représentant le plateau de jeu contenant les codes et les indicateurs. + /// [DataContract] public class Plateau { + /// + /// Événement déclenché lorsqu'un code est ajouté au plateau. + /// public event EventHandler? PlateauAjouterCode; private void QuandPlateauAjouterCode() => PlateauAjouterCode?.Invoke(this, new PlateauAjouterCodeEventArgs(this)); + /// + /// Le code secret à deviner. + /// [DataMember] private readonly Code codeSecret; + + /// + /// Liste des codes ajoutés au plateau. + /// [DataMember] private readonly List codes = new List(); + + /// + /// Liste des listes d'indicateurs pour chaque code ajouté. + /// [DataMember] private readonly List> indicateurs = new List>(); + /// + /// Obtient le nombre de codes sur le plateau. + /// public int Taille => codes.Count; + + /// + /// Obtient la taille maximale de codes autorisée sur le plateau. + /// [DataMember] public int TailleMax { get; private init; } + + /// + /// Obtient la taille maximale d'un code. + /// [DataMember] public int TailleMaxCode { get; private init; } + + /// + /// Indique si le plateau à atteint sa taille maximale. + /// public bool Complet => Taille == TailleMax; + + /// + /// Indique si la victoire est atteinte. + /// [DataMember] public bool Victoire { get; private set; } = false; + /// + /// Obtient la grille des codes et des indicateurs. + /// public (IEnumerable>, IEnumerable>) Grille => ( codes.Select(code => code.Jetons), indicateurs ); + /// + /// Constructeur de plateau avec une taille de code et une taille de plateau spécifiées. + /// + /// La taille maximale d'un code. + /// La taille maximale du plateau. + /// Lancée si la taille du code est négative ou nulle. + /// Lancée si la taille du plateau spécifiée est négative ou nulle. public Plateau(int tailleCode, int taillePlateau) { if (tailleCode < 0) @@ -46,6 +92,10 @@ namespace CoreLibrary.Core codeSecret = GenererCodeSecret(); } + /// + /// Génère un code secret aléatoire. + /// + /// Renvoie le code secret généré. private Code GenererCodeSecret() { Code code = new Code(TailleMaxCode); @@ -61,6 +111,12 @@ namespace CoreLibrary.Core return code; } + /// + /// Ajoute un code au plateau et compare avec le code secret. + /// + /// Le code à ajouter. + /// Lancée si le code à ajouter n'est pas complet. + /// Lancée si le plateau est déjà complet. public void AjouterCode(Code code) { if (!code.Complet) diff --git a/Sources/CoreLibrary/Evenements/JoueurJoueCodeEventArgs.cs b/Sources/CoreLibrary/Evenements/JoueurJoueCodeEventArgs.cs new file mode 100644 index 0000000..31583d2 --- /dev/null +++ b/Sources/CoreLibrary/Evenements/JoueurJoueCodeEventArgs.cs @@ -0,0 +1,9 @@ +namespace CoreLibrary.Evenements +{ + /// + /// Classe correspondant à l'événement JoueurJoueCode. + /// + public class JoueurJoueCodeEventArgs : EventArgs + { + } +} diff --git a/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs b/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs index 319c919..1c6282a 100644 --- a/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs @@ -2,10 +2,20 @@ namespace CoreLibrary.Evenements { + /// + /// Classe contenant les arguments passés en paramètres lors de l'événement JoueurSeConnecter. + /// public class JoueurSeConnecterEventArgs : EventArgs { + /// + /// Obtient le joueur qui s'est connecté. + /// public Joueur Joueur { get; private init; } + /// + /// Initialise une nouvelle instance de la classe . + /// + /// Le joueur qui s'est connecté. public JoueurSeConnecterEventArgs(Joueur joueur) { Joueur = joueur; diff --git a/Sources/CoreLibrary/Evenements/PartieDebutPartieEventArgs.cs b/Sources/CoreLibrary/Evenements/PartieDebutPartieEventArgs.cs index b05bdce..3fdf55c 100644 --- a/Sources/CoreLibrary/Evenements/PartieDebutPartieEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/PartieDebutPartieEventArgs.cs @@ -1,5 +1,8 @@ namespace CoreLibrary.Evenements { + /// + /// Classe correspondant à l'événement PartieDebutPartie. + /// public class PartieDebutPartieEventArgs : EventArgs { } diff --git a/Sources/CoreLibrary/Evenements/PartieDemanderJoueurEventArgs.cs b/Sources/CoreLibrary/Evenements/PartieDemanderJoueurEventArgs.cs index 419b023..46611fc 100644 --- a/Sources/CoreLibrary/Evenements/PartieDemanderJoueurEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/PartieDemanderJoueurEventArgs.cs @@ -2,11 +2,27 @@ namespace CoreLibrary.Evenements { + /// + /// Classe contenant les arguments passés en paramètres lors de l'événement PartieDemanderJoueur. + /// + /// . public class PartieDemanderJoueurEventArgs : EventArgs { + /// + /// Entier correspondant à l'indice du joueur. + /// public int Indice { get; private init; } + + /// + /// Le joueur qui est demandé. + /// public Joueur JoueurDemande { get; private init; } + /// + /// Constructeur de PartieDemanderJoueurEventArgs, avec l'indice du joueur et le joueur demandé spécifiés. + /// + /// Indice du joueur demandé. + /// Le joueur demandé. public PartieDemanderJoueurEventArgs(int indice, Joueur joueurDemande) { Indice = indice; diff --git a/Sources/CoreLibrary/Evenements/PartieDemanderJoueurJouerEventArgs.cs b/Sources/CoreLibrary/Evenements/PartieDemanderJoueurJouerEventArgs.cs index 4ae8775..c29ef7e 100644 --- a/Sources/CoreLibrary/Evenements/PartieDemanderJoueurJouerEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/PartieDemanderJoueurJouerEventArgs.cs @@ -2,14 +2,44 @@ namespace CoreLibrary.Evenements { + /// + /// Classe contenant les arguments passés en paramètres lors de l'événement PartieDemanderJoueurJouer. + /// public class PartieDemanderJoueurJouerEventArgs : EventArgs { + /// + /// Obtient le numéro du tour. + /// public int Tour { get; private init; } + + /// + /// Obtient le nom du joueur. + /// public string Nom { get; private init; } + + /// + /// Obtient le plateau actuel. + /// public Plateau Plateau { get; private init; } + + /// + /// Obtient le code en cours. + /// public Code Code { get; private init; } + + /// + /// Indique si le joueur est un joueur humain. + /// public bool EstJoueur { get; private init; } + /// + /// Initialise une nouvelle instance de la classe . + /// + /// Le numéro du tour. + /// Le nom du joueur. + /// Le plateau actuel. + /// Le code en cours. + /// Indique si le joueur est un joueur humain. public PartieDemanderJoueurJouerEventArgs(int tour, string nom, Plateau plateau, Code code, bool estJoueur) { Tour = tour; diff --git a/Sources/CoreLibrary/Evenements/PartieNouveauTourEventArgs.cs b/Sources/CoreLibrary/Evenements/PartieNouveauTourEventArgs.cs index d9f392a..4fab79f 100644 --- a/Sources/CoreLibrary/Evenements/PartieNouveauTourEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/PartieNouveauTourEventArgs.cs @@ -1,22 +1,52 @@ -using CoreLibrary.Core; - -namespace CoreLibrary.Evenements -{ - public class PartieNouveauTourEventArgs : EventArgs - { - public int Tour { get; private init; } - public string Nom { get; private init; } - public Plateau Plateau { get; private init; } - public Code Code { get; private init; } - public bool EstJoueur { get; private init; } - - public PartieNouveauTourEventArgs(int tour, string nom, Plateau plateau, Code code, bool estJoueur) - { - Tour = tour; - Nom = nom; - Plateau = plateau; - Code = code; - EstJoueur = estJoueur; - } - } -} +using CoreLibrary.Core; + +namespace CoreLibrary.Evenements +{ + /// + /// Classe contenant les arguments passés en paramètres lors de l'événement PartieNouveauTour. + /// + public class PartieNouveauTourEventArgs : EventArgs + { + /// + /// Obtient le numéro du tour. + /// + public int Tour { get; private init; } + + /// + /// Obtient le nom du joueur. + /// + public string Nom { get; private init; } + + /// + /// Obtient le plateau actuel. + /// + public Plateau Plateau { get; private init; } + + /// + /// Obtient le code en cours. + /// + public Code Code { get; private init; } + + /// + /// Indique si le joueur est un joueur humain. + /// + public bool EstJoueur { get; private init; } + + /// + /// Initialise une nouvelle instance de la classe . + /// + /// Le numéro du tour. + /// Le nom du joueur. + /// Le plateau actuel. + /// Le code en cours. + /// Indique si le joueur est un joueur humain. + public PartieNouveauTourEventArgs(int tour, string nom, Plateau plateau, Code code, bool estJoueur) + { + Tour = tour; + Nom = nom; + Plateau = plateau; + Code = code; + EstJoueur = estJoueur; + } + } +} diff --git a/Sources/CoreLibrary/Evenements/PartiePartieTermineeEventArgs.cs b/Sources/CoreLibrary/Evenements/PartiePartieTermineeEventArgs.cs index 7ef2542..4996b4b 100644 --- a/Sources/CoreLibrary/Evenements/PartiePartieTermineeEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/PartiePartieTermineeEventArgs.cs @@ -2,11 +2,26 @@ namespace CoreLibrary.Evenements { + /// + /// Classe contenant les arguments passés en paramètre lors de l'événement PartiePartieTerminee. + /// public class PartiePartieTermineeEventArgs : EventArgs { + /// + /// Liste des gagnants. + /// public IReadOnlyList Gagnants { get; private init; } + + /// + /// Liste des perdants. + /// public IReadOnlyList Perdants { get; private init; } + /// + /// Constructeur de PartiePartieTermineeEventArgs, avec la liste des gagnants et perdants spécifiés. + /// + /// Liste des gagnants. + /// Liste des perdants. public PartiePartieTermineeEventArgs(IReadOnlyList gagnants, IReadOnlyList perdants) { Gagnants = gagnants; diff --git a/Sources/CoreLibrary/Evenements/PartiePasserLaMainEventArgs.cs b/Sources/CoreLibrary/Evenements/PartiePasserLaMainEventArgs.cs index 557e8d6..8b5504a 100644 --- a/Sources/CoreLibrary/Evenements/PartiePasserLaMainEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/PartiePasserLaMainEventArgs.cs @@ -1,9 +1,19 @@ namespace CoreLibrary.Evenements { + /// + /// Classe contenant les arguments passés en paramètre, lors de l'événement PartiePasserLaMain. + /// public class PartiePasserLaMainEventArgs { + /// + /// Chaîne de caractère pour le joueur courant. + /// public string Joueur { get; private init; } + /// + /// Constructeur de PartiePasserLaMainEventArgs, avec le joueur spécifié. + /// + /// Chaîne de caractères représentant le joueur courant que nous souhaitons obtenir. public PartiePasserLaMainEventArgs(string joueur) { Joueur = joueur; diff --git a/Sources/CoreLibrary/Evenements/PlateauAjouterCodeEventArgs.cs b/Sources/CoreLibrary/Evenements/PlateauAjouterCodeEventArgs.cs index 5255fbd..ee7e4b6 100644 --- a/Sources/CoreLibrary/Evenements/PlateauAjouterCodeEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/PlateauAjouterCodeEventArgs.cs @@ -2,10 +2,20 @@ namespace CoreLibrary.Evenements { + /// + /// Classe contenant les arguments passés en paramètre lors de l'événement PlateauAjouterCode. + /// public class PlateauAjouterCodeEventArgs : EventArgs { + /// + /// Le plateau où nous souhaitons ajouté le code. + /// public Plateau Plateau { get; private init; } + /// + /// Constructeur de PlateauAjouterCodeEventArgs, avec le plateau spécifié. + /// + /// Le plateau que nous souhaitons avoir. public PlateauAjouterCodeEventArgs(Plateau plateau) { Plateau = plateau; diff --git a/Sources/CoreLibrary/Joueurs/Joueur.cs b/Sources/CoreLibrary/Joueurs/Joueur.cs index 8cc3cde..72f132e 100644 --- a/Sources/CoreLibrary/Joueurs/Joueur.cs +++ b/Sources/CoreLibrary/Joueurs/Joueur.cs @@ -8,11 +8,17 @@ using CoreLibrary.Core; namespace CoreLibrary.Joueurs { + /// + /// Représente un joueur. + /// [DataContract] [KnownType(typeof(ReglesClassiques))] [KnownType(typeof(ReglesDifficiles))] public class Joueur : IEstPersistant { + /// + /// Événement déclenché lorsqu'un joueur se connecte. + /// public event EventHandler? JoueurSeConnecter; private void QuandJoueurSeConnecter(Joueur joueur) => JoueurSeConnecter?.Invoke(this, new JoueurSeConnecterEventArgs(joueur)); @@ -20,19 +26,37 @@ namespace CoreLibrary.Joueurs [DataMember] private Dictionary<(IRegles, Statistique), int> statistiques = new Dictionary<(IRegles, Statistique), int>(); + /// + /// Obtient le nom du joueur. + /// [DataMember] public string Nom { get; private set; } = ""; + + /// + /// Indique si le joueur est connecté. + /// public bool EstConnecte { get; private set; } = false; + /// + /// Constructeur de joueur. + /// public Joueur() { } + /// + /// Constructeur de joueur avec le nom spécifié. + /// + /// Le nom du joueur. public Joueur(string nom) { Nom = nom; } + /// + /// Connecte le joueur. + /// + /// Le joueur à connecter. public void SeConnecter(Joueur joueur) { if (EstConnecte) @@ -41,19 +65,43 @@ namespace CoreLibrary.Joueurs QuandJoueurSeConnecter(joueur); } + /// + /// Permet au joueur de jouer une partie. + /// + /// La partie à jouer. public void JouerPartie(Partie partie) { partie.PartieDemanderJoueurJouer += QuandDemanderJoueurJouer; } + /// + /// Méthode appelée lorsque la partie demande à ce joueur de jouer. + /// + /// La source de l'événement. + /// Les arguments de l'événement. public virtual void QuandDemanderJoueurJouer(object? sender, PartieDemanderJoueurJouerEventArgs e) { } + /// + /// Retourne une représentation sous forme de chaîne de caractères. + /// + /// Renvoie une chaîne de caractères du nom du joueur. public override string ToString() => Nom; + /// + /// Obtient la statistique spécifiée pour les règles données. + /// + /// Les règles du jeu. + /// Le type de statistique. + /// La valeur de la statistique. public int Statistique(IRegles regles, Statistique statistique) => statistiques.GetValueOrDefault((regles, statistique),0); + /// + /// Incrémente la valeur de la statistique spécifiée pour les règles données. + /// + /// Les règles du jeu. + /// Le type de statistique. public void IncrementerStatistique(IRegles regles, Statistique statistique) => statistiques[(regles, statistique)] = Statistique(regles, statistique) + 1; } diff --git a/Sources/CoreLibrary/Joueurs/Robot.cs b/Sources/CoreLibrary/Joueurs/Robot.cs index 2c539a0..174005c 100644 --- a/Sources/CoreLibrary/Joueurs/Robot.cs +++ b/Sources/CoreLibrary/Joueurs/Robot.cs @@ -3,28 +3,38 @@ using CoreLibrary.Evenements; namespace CoreLibrary.Joueurs { + /// + /// Représente un joueur automatique (robot). + /// public class Robot : Joueur { private static int nbRobots; private List? codesPossibles; - static Robot() - { - nbRobots = 0; - } - + /// + /// Initialise une nouvelle instance de la classe . + /// public Robot() : base($"Naps {nbRobots + 1}") { ++nbRobots; } + /// + /// Initialise une nouvelle instance de la classe avec le nom spécifié. + /// + /// Le nom du robot. public Robot(string nom) : base(nom) { } + /// + /// Méthode appelée lorsqu'un joueur doit jouer dans une partie. + /// + /// La source de l'événement. + /// Les arguments de l'événement. public override void QuandDemanderJoueurJouer(object? sender, PartieDemanderJoueurJouerEventArgs e) { if (e.Nom != Nom) @@ -35,76 +45,108 @@ namespace CoreLibrary.Joueurs SupprimerCodesImpossibles(codesPossibles, e.Plateau); - for(int i = 0; i < e.Code.TailleMax; ++i) + for (int i = 0; i < e.Code.TailleMax; ++i) e.Code.AjouterJeton(codesPossibles.ElementAt(0).Jetons[i]); } - private static List GenererTousCodesPossibles(int tailleCode) + /// + /// Génère tous les codes possibles pour une taille de code donnée. + /// + /// La taille du code. + private void GenererTousCodesPossibles(int tailleCode) { + // Obtient toutes les valeurs de l'énumération Couleur Couleur[] couleurs = Enum.GetValues(); + + // Calcule le nombre total de combinaisons possibles int nbLignes = (int)Math.Pow(couleurs.Length, tailleCode); + + // Crée une matrice pour stocker les jetons de chaque combinaison Jeton?[,] jetons = new Jeton?[nbLignes, tailleCode]; - for(int indiceColonne = 0; indiceColonne < jetons.GetLength(1); ++indiceColonne) + // Pour chaque colonne de la matrice + for (int indiceColonne = 0; indiceColonne < jetons.GetLength(1); ++indiceColonne) { + // Calcule le nombre de répétitions pour chaque couleur int repetition = nbLignes / (int)Math.Pow(couleurs.Length, (indiceColonne + 1)); + // Pour chaque ligne de la matrice for (int indiceLigne = 0; indiceLigne < jetons.GetLength(0); ++indiceLigne) { - jetons[indiceLigne, indiceColonne] = new Jeton(couleurs[(indiceLigne / repetition) % couleurs.Length]); + // Calcule l'indice de la couleur à utiliser dans cette colonne + int couleurIndex = (indiceLigne / repetition) % couleurs.Length; + + // Crée un jeton avec la couleur correspondante et l'ajoute à la matrice + jetons[indiceLigne, indiceColonne] = new Jeton(couleurs[couleurIndex]); } } - List codes = new List(); + // Pour chaque combinaison de jetons générée for (int i = 0; i < jetons.GetLength(0); ++i) { + // Crée un nouveau code avec les jetons de la combinaison Code code = new Code(tailleCode); for (int j = 0; j < jetons.GetLength(1); ++j) { code.AjouterJeton(jetons[i, j]!.Value); } - codes!.Add(code); + + // Ajoute le code à la liste des codes possibles + codesPossibles!.Add(code); } return codes; } + /// + /// Vérifie si un code est possible sur le plateau. + /// + /// Le plateau de jeu. + /// Le code à vérifier. + /// True si le code est possible, sinon False. private static bool EstCodePossible(Plateau plateau, Code code) { - for(int i = 0; i < plateau.Taille; ++i) + for (int i = 0; i < plateau.Taille; ++i) { Code sonCode = new Code(code.TailleMax); - for(int j = 0; j < code.TailleMax; ++j) + for (int j = 0; j < code.TailleMax; ++j) { sonCode.AjouterJeton(plateau.Grille.Item1.ElementAt(i).ElementAt(j)); } IReadOnlyList indicateurs = sonCode.Comparer(code); - if ( - - indicateurs.Count(indicateur => indicateur == Indicateur.BonnePlace) != plateau.Grille.Item2.ElementAt(i).Count(indicateur => indicateur == Indicateur.BonnePlace) || - indicateurs.Count(indicateur => indicateur == Indicateur.BonneCouleur) != plateau.Grille.Item2.ElementAt(i).Count(indicateur => indicateur == Indicateur.BonneCouleur) - ) + // Vérifie si les indicateurs du code correspondent aux indicateurs du plateau + if (indicateurs.Count(indicateur => indicateur == Indicateur.BonnePlace) != plateau.Grille.Item2.ElementAt(i).Count(indicateur => indicateur == Indicateur.BonnePlace) || + indicateurs.Count(indicateur => indicateur == Indicateur.BonneCouleur) != plateau.Grille.Item2.ElementAt(i).Count(indicateur => indicateur == Indicateur.BonneCouleur)) + { return false; + } } return true; } - private static void SupprimerCodesImpossibles(List codes, Plateau plateau) + /// + /// Supprime les codes impossibles du plateau. + /// + /// Le plateau de jeu. + private static void SupprimerCodesImpossibles(Plateau plateau) { if (codes == null) return; List indicesASupprimer = new List(); - for(int i = codes.Count - 1; i >= 0; --i) + // Pour chaque code possible + for (int i = codesPossibles.Count - 1; i >= 0; --i) { - if(!EstCodePossible(plateau, codes.ElementAt(i))) + // Vérifie s'il est possible sur le plateau + if (!EstCodePossible(plateau, codesPossibles.ElementAt(i))) indicesASupprimer.Add(i); } + // Supprime les codes impossibles de la liste foreach (int indice in indicesASupprimer) codes.RemoveAt(indice); } diff --git a/Sources/CoreLibrary/Manageurs/Manageur.cs b/Sources/CoreLibrary/Manageurs/Manageur.cs index b9a3461..fa7df5d 100644 --- a/Sources/CoreLibrary/Manageurs/Manageur.cs +++ b/Sources/CoreLibrary/Manageurs/Manageur.cs @@ -5,16 +5,45 @@ using CoreLibrary.Statistiques; namespace CoreLibrary.Manageurs { + /// + /// Classe représentant un manager. + /// public class Manageur { + /// + /// Attribut privé pour la persistance. + /// private readonly IPersistance persistance; + + /// + /// Liste des joueurs enregistrés. + /// private readonly List joueurs; + + /// + /// Liste des parties enregistrées. + /// private readonly List parties; + /// + /// Obtient la liste des joueurs enregistrés. + /// public IReadOnlyList Joueurs => joueurs; + + /// + /// Obtient la liste des parties enregistrées terminés. + /// public IReadOnlyList Parties => parties; - public IEnumerable PartiesNonTerminees => parties.Where(partie => !partie.Termine).Reverse(); + /// + /// Obtient la liste des parties non terminées. + /// + public IEnumerable PartiesNonTerminees => parties.Where(partie => !partie.Termine).Reverse().ToList(); + + /// + /// Constructeur de manager avec la persistance spécifiée. + /// + /// Persistance permettant le chargement des joueurs et parties. public Manageur(IPersistance persistance) { this.persistance = persistance; @@ -23,12 +52,20 @@ namespace CoreLibrary.Manageurs parties = persistance.Charger().ToList(); } + /// + /// Sauvegarde les joueurs et les parties. + /// private void Sauvegarder() { persistance.Enregistrer(joueurs.ToArray()); persistance.Enregistrer(parties.ToArray()); } + /// + /// Charge une partie avec la partie à charger spécifiée. + /// + /// La partie que l'on veut charger. + /// Renvoie la partie. public Partie ChargerPartie(Partie partie) { parties.Remove(partie); @@ -41,6 +78,11 @@ namespace CoreLibrary.Manageurs return nouvellePartie; } + /// + /// Créer une nouvelle partie avec les règles spécifiée. + /// + /// Regle permettant la création de la partie. + /// Renvoie la nouvelle partie créée. public Partie NouvellePartie(IRegles regles) { Partie partie = new Partie(regles); @@ -51,6 +93,11 @@ namespace CoreLibrary.Manageurs return partie; } + /// + /// Suivre le cour d'une partie avec la partie spécifiée. + /// Sauvegarde quand certains événements sont appelés dans la partie. + /// + /// La partie à écouter. private void EcouterPartie(Partie partie) { partie.PartieDemanderJoueur += (sender, e) => Sauvegarder(); @@ -82,6 +129,11 @@ namespace CoreLibrary.Manageurs Sauvegarder(); }; } + /// + /// Recherche un joueur existant par son nom. + /// + /// Le nom du joueur à rechercher. + /// Le joueur s'il existe, sinon null. private Joueur? DemanderJoueurExistant(string nom) { @@ -96,6 +148,11 @@ namespace CoreLibrary.Manageurs return null; } + /// + /// Recherche un joueur par son nom ou le crée s'il n'existe pas. + /// + /// Le nom du joueur. + /// Le joueur trouvé ou créé. public Joueur DemanderJoueur(string nom) { Joueur? joueur = DemanderJoueurExistant(nom); diff --git a/Sources/CoreLibrary/Partie.cs b/Sources/CoreLibrary/Partie.cs index 8bd712a..63bda93 100644 --- a/Sources/CoreLibrary/Partie.cs +++ b/Sources/CoreLibrary/Partie.cs @@ -7,47 +7,138 @@ using System.Runtime.Serialization; namespace CoreLibrary { + /// + /// Classe représentant une partie. + /// [DataContract] [KnownType(typeof(ReglesClassiques))] [KnownType(typeof(ReglesDifficiles))] public class Partie : IEstPersistant { + /// + /// Evénement déclenché lorsqu'il faut ajouter un joueur à la partie. + /// public event EventHandler? PartieDemanderJoueur; + + /// + /// Evénement déclenché lors du commencement de la partie. + /// public event EventHandler? PartieDebutPartie; + + /// + /// Evénement déclenché lorsqu'il faut demander à un joueur de jouer. + /// public event EventHandler? PartieDemanderJoueurJouer; + + /// + /// Evénement déclenché lorsqu'un nouveau tour commence. + /// public event EventHandler? PartieNouveauTour; + + /// + /// Evénement déclenché lorsqu'on passe la main au joueur suivant. + /// public event EventHandler? PartiePasserLaMain; + + /// + /// Evénement déclenché lorsque la partie est terminée. + /// public event EventHandler? PartiePartieTerminee; + /// + /// Méthode pour déclencher l'événement qui demande le joueur. + /// + /// . private void QuandPartieDemanderJoueur(Joueur joueurDemande) => PartieDemanderJoueur?.Invoke(this, new PartieDemanderJoueurEventArgs(joueurs.Count + 1, joueurDemande)); + + /// + /// Méthode pour déclencher l'événement de début de partie. + /// private void QuandPartieDebutPartie() => PartieDebutPartie?.Invoke(this, new PartieDebutPartieEventArgs()); + + /// + /// Méthode pour déclencher l'événement demandant à un joueur de jouer. + /// + /// Le code à utiliser pour jouer. private void QuandPartieDemanderJoueurJouer(Code code) => PartieDemanderJoueurJouer?.Invoke(this, new PartieDemanderJoueurJouerEventArgs(Tour, Joueurs.ElementAt(courant), plateaux.ElementAt(courant), code, joueurs[Joueurs.ElementAt(courant)])); + + /// + /// Méthode pour déclencher l'événement d'un nouveau tour. + /// + /// Le code utilisé pour le nouveau tour. private void QuandPartieNouveauTour(Code code) => PartieNouveauTour?.Invoke(this, new PartieNouveauTourEventArgs(Tour, Joueurs.ElementAt(courant), plateaux.ElementAt(courant), code, joueurs[Joueurs.ElementAt(courant)])); + + /// + /// Méthode pour déclencher l'événement de passer la main au joueur suivant. + /// private void QuandPartiePasserLaMain() => PartiePasserLaMain?.Invoke(this, new PartiePasserLaMainEventArgs(Joueurs.ElementAt(courant))); + + /// + /// Méthode pour déclencher l'événement de fin de partie. + /// + /// Liste des noms des joueurs gagnants. + /// Liste des noms des joueurs perdants. private void QuandPartiePartieTerminee(IReadOnlyList gagnants, IReadOnlyList perdants) => PartiePartieTerminee?.Invoke(this, new PartiePartieTermineeEventArgs(gagnants, perdants)); - + + /// + /// Dictionnaire des joueurs, avec leur nom et le statut de leur joueur (humain ou robot). + /// [DataMember] private readonly Dictionary joueurs = new Dictionary(); + + /// + /// Liste des plateaux de jeu. + /// plateaux = new List(); + + /// + /// Indice correspondant au joueur courant. + /// [DataMember] private int courant = 0; + /// + /// Liste des noms des joueurs. + /// public IEnumerable Joueurs => joueurs.Keys; + + /// + /// Liste des noms des robots. + /// public IEnumerable Robots => joueurs.Where(joueur => joueur.Value).Select(joueur => joueur.Key); + + /// + /// Indique si la partie est terminée. + /// [DataMember] public bool Termine { get; private set; } = false; + + /// + /// Numéro du tour actuel. + /// [DataMember] public int Tour { get; private set; } = 0; + /// + /// Règles utilisées dans la partie. + /// [DataMember] public IRegles Regles { get; private init; } + /// + /// Premier constructeur de la partie. + /// + /// Les règles de la partie. public Partie(IRegles regles) { Regles = regles; } + /// + /// Deuxième constructeur de la partie. + /// + /// La partie à reprendre en cours. public Partie(Partie partie) { joueurs = partie.joueurs; @@ -67,6 +158,9 @@ namespace CoreLibrary (joueurs[joueur] ? new Joueur(joueur) : new Robot(joueur)).JouerPartie(this); } + /// + /// Lance le déroulement de la partie. + /// public void Jouer() { if (joueurs.Count != Regles.NbJoueurs) @@ -75,6 +169,9 @@ namespace CoreLibrary DebutPartie(); } + /// + /// Demande un joueur. + /// private void DemanderJoueur() { Joueur joueurDemande = new Joueur(); @@ -83,6 +180,11 @@ namespace CoreLibrary QuandPartieDemanderJoueur(joueurDemande); } + /// + /// Connecte les joueurs à la partie. + /// + /// La classe qui appelle l'événement, ici Joueur. + /// L'instance de l'événement JoueurSeConnecterEventArgs créée par Joueur. private void JoueurConnecte(object? sender, JoueurSeConnecterEventArgs e) { joueurs.Add(e.Joueur.Nom, e.Joueur.GetType().Equals(typeof(Joueur))); @@ -100,6 +202,9 @@ namespace CoreLibrary } } + /// + /// Lance le début de la partie. + /// private void DebutPartie() { if (Tour == 0) @@ -115,6 +220,9 @@ namespace CoreLibrary NouveauTour(); } + /// + /// Passe au tour suivant. + /// private void NouveauTour() { Code code = new Code(Regles.TailleCode); @@ -123,6 +231,11 @@ namespace CoreLibrary QuandPartieNouveauTour(code); } + /// + /// Ajoute un code au plateau. + /// + /// La classe qui appelle l'événement, ici Plateau. + /// L'instance de l'événement PlateauAjouterCodeEventArgs créée par Plateau. private void PlateauAjouterCode(object? sender, PlateauAjouterCodeEventArgs e) { QuandPartiePasserLaMain(); @@ -145,6 +258,9 @@ namespace CoreLibrary } } + /// + /// La partie est terminée. + /// private void PartieTerminee() { Termine = true; diff --git a/Sources/CoreLibrary/Persistance/IEstPersistant.cs b/Sources/CoreLibrary/Persistance/IEstPersistant.cs index 2e0128e..3a4c8df 100644 --- a/Sources/CoreLibrary/Persistance/IEstPersistant.cs +++ b/Sources/CoreLibrary/Persistance/IEstPersistant.cs @@ -1,4 +1,7 @@ namespace CoreLibrary.Persistance { + /// + /// Interface IEstPersistant. + /// public interface IEstPersistant; } diff --git a/Sources/CoreLibrary/Persistance/IPersistance.cs b/Sources/CoreLibrary/Persistance/IPersistance.cs index d3ebed8..6529c65 100644 --- a/Sources/CoreLibrary/Persistance/IPersistance.cs +++ b/Sources/CoreLibrary/Persistance/IPersistance.cs @@ -1,9 +1,22 @@ namespace CoreLibrary.Persistance { + /// + /// Interface IPersistance permettant de charger et d'enregistrer. + /// public interface IPersistance { + /// + /// Charge les objets de type T. + /// + /// Le type d'objet à charger. + /// Un tableau d'objets chargés. public T[] Charger() where T : IEstPersistant; + /// + /// Enregistre les éléments spécifiés. + /// + /// Le type d'objet à enregistrer. + /// Le tableau d'objets à enregistrer. public void Enregistrer(T[] elements) where T : IEstPersistant; } } diff --git a/Sources/CoreLibrary/Persistance/PersistanceJSON.cs b/Sources/CoreLibrary/Persistance/PersistanceJSON.cs index 99de553..02a5c36 100644 --- a/Sources/CoreLibrary/Persistance/PersistanceJSON.cs +++ b/Sources/CoreLibrary/Persistance/PersistanceJSON.cs @@ -4,18 +4,39 @@ using System.Xml; namespace CoreLibrary.Persistance { + /// + /// Classe PersistanceJSON, implémentant l'interface IPersistance, pour la persistance des données au format JSON. + /// public class PersistanceJson : IPersistance { + /// + /// Chaîne de caractères représentant le nom du dossier pour sauvegarder et charger. + /// private readonly string nomDossier = "Fichiers"; + + /// + /// Chaîne de caractères représentant le nom du doissier à la racine. + /// private readonly string nomRacine = "Sources"; + + /// + /// Chaîne de caractères représentant le nom du dossier courant. + /// private readonly string dossier = AppDomain.CurrentDomain.BaseDirectory; + /// + /// Constructeur de PersistanceJSON. + /// public PersistanceJson() { while (new DirectoryInfo(dossier).Name != nomRacine) dossier = Path.GetFullPath(Path.Combine(dossier, @"../")); } + /// + /// Charge les données trouvées dans le fichier de sauvegarde au format JSON. + /// + /// Renvoie un tableau de tous les éléments chargés. public T[] Charger() where T : IEstPersistant { string fichier = $"{typeof(T).Name.ToLower()}s.json"; @@ -41,6 +62,10 @@ namespace CoreLibrary.Persistance return elements != null ? elements : Array.Empty(); } + /// + /// Enregistre les éléments spécifiés dans le fichier de sauvegarde au format JSON. + /// + /// Elements à enregistrer dans le fichier de sauvegarde. public void Enregistrer(T[] elements) where T : IEstPersistant { string fichier = $"{typeof(T).Name.ToLower()}s.json"; diff --git a/Sources/CoreLibrary/Regles/IRegles.cs b/Sources/CoreLibrary/Regles/IRegles.cs index 3e2c299..b844d6a 100644 --- a/Sources/CoreLibrary/Regles/IRegles.cs +++ b/Sources/CoreLibrary/Regles/IRegles.cs @@ -1,14 +1,42 @@ namespace CoreLibrary.Regles { + /// + /// Interface pour créer des règles. + /// public interface IRegles { int Indice { get; } + /// + /// Obtient le nom des règles. + /// string Nom { get; } string Description { get; } + + /// + /// Obtient le nombre de joueurs. + /// int NbJoueurs { get; } + + /// + /// Obtient le nombre de tour. + /// int NbTour { get; } + + /// + /// Obtient la taille d'un code. + /// int TailleCode { get; } + + /// Détermine si les règles sont égales à un objet spécifié. + /// + /// L'objet à comparer avec les règles. + /// True si les règles sont égales à l'objet spécifié, sinon false. bool Equals(object? obj); + + /// + /// Obtient le code de hachage pour les règles. + /// + /// Code de hachage des règles. int GetHashCode(); } } diff --git a/Sources/CoreLibrary/Regles/ReglesClassiques.cs b/Sources/CoreLibrary/Regles/ReglesClassiques.cs index 0c6ef38..3960b0d 100644 --- a/Sources/CoreLibrary/Regles/ReglesClassiques.cs +++ b/Sources/CoreLibrary/Regles/ReglesClassiques.cs @@ -2,16 +2,53 @@ namespace CoreLibrary.Regles { + /// + /// Classe pour les règles classiques, implémente IRegles. + /// [DataContract] public class ReglesClassiques : IRegles { + /// + /// Obtient l'indice des règles classiques. + /// public int Indice => 1; + + /// + /// Chaîne de caractères pour le nom des règles classiques. + /// public string Nom => "Règles classiques"; + + /// + /// Obtient la description des règles classiques. + /// public string Description => "Le but du jeu est de découvrir la combinaison. On génère aléatoirement deux combinaisons de 4 couleurs (six couleurs au total : jaune, bleu, rouge, vert, blanc et noir), une combinaison pour chaque joueur. Deux joueurs se battent pour trouver la combinaison en premier, il y a douze tours. Le premier joueur à trouver la combinaison à gagner, chaque joueur a le même nombre de coups à réaliser. Donc si le joueur un à trouvé la solution au bout de huit coups, le joueur deux doit finir son huitième coup. Si le joueur deux trouve la combinaison, les deux joueurs sont à égalité. Sinon, le joueur un gagne. Pour trouver la combinaison, les joueurs disposent de quatre indicateurs. Ces indicateurs sont quatre ronds qui représentent les quatre couleurs sélectionnées par le joueur. Un rond noir signifie qu’une couleur est à la bonne place, un rond blanc correspond à une mauvaise place et s'il n’y a pas d’indicateur aucune des couleurs n’est présentent dans la combinaison."; + + /// + /// Nombre de joueurs autorisé pour les règles classiques. + /// public int NbJoueurs => 2; + + /// + /// Nombre de tour maximum pour des règles classiques. + /// public int NbTour => 12; + + /// + /// Taille du code maximale pour des règles classiques. + /// public int TailleCode => 4; + + /// + /// Détermine si les règles classiques sont égales à un objet spécifié. + /// + /// L'objet à comparer avec les règles classiques. + /// True si les règles classiques sont égales à l'objet spécifié, sinon false. public override bool Equals(object? obj) => obj is ReglesClassiques; + + /// + /// Obtient le code de hachage pour les règles classiques. + /// + /// Le code de hachage des règles classiques. public override int GetHashCode() => Nom.GetHashCode(); } } diff --git a/Sources/CoreLibrary/Regles/ReglesDifficiles.cs b/Sources/CoreLibrary/Regles/ReglesDifficiles.cs index 2e124df..f93c923 100644 --- a/Sources/CoreLibrary/Regles/ReglesDifficiles.cs +++ b/Sources/CoreLibrary/Regles/ReglesDifficiles.cs @@ -2,16 +2,54 @@ namespace CoreLibrary.Regles { + /// + /// Classe définissant les règles difficiles du jeu. + /// + [DataContract] public class ReglesDifficiles : IRegles { + /// + /// Obtient l'indice des règles difficiles. + /// public int Indice => 2; + + /// + /// Obtient le nom des règles difficiles. + /// public string Nom => "Règles difficiles"; + + /// + /// Obtient la description des règles difficiles. + /// public string Description => "Le but du jeu est de découvrir la combinaison. On génère aléatoirement deux combinaisons de 6 couleurs (six couleurs au total : jaune, bleu, rouge, vert, blanc et noir), une combinaison pour chaque joueur. Deux joueurs se battent pour trouver la combinaison en premier, il y a douze tours. Le premier joueur à trouver la combinaison à gagner, chaque joueur a le même nombre de coups à réaliser. Donc si le joueur un à trouvé la solution au bout de huit coups, le joueur deux doit finir son huitième coup. Si le joueur deux trouve la combinaison, les deux joueurs sont à égalité. Sinon, le joueur un gagne. Pour trouver la combinaison, les joueurs disposent de quatre indicateurs. Ces indicateurs sont quatre ronds qui représentent les 6 couleurs sélectionnées par le joueur. Un rond noir signifie qu’une couleur est à la bonne place, un rond blanc correspond à une mauvaise place et s'il n’y a pas d’indicateur aucune des couleurs n’est présentent dans la combinaison."; + + /// + /// Obtient le nombre de joueurs autorisé pour les règles difficiles. + /// public int NbJoueurs => 2; + + /// + /// Obtient le nombre de tours maximum pour les règles difficiles. + /// public int NbTour => 12; + + /// + /// Obtient la taille maximale du code pour les règles difficiles. + /// public int TailleCode => 6; + + /// + /// Détermine si les règles difficiles sont égales à un objet spécifié. + /// + /// L'objet à comparer avec les règles difficiles. + /// True si les règles difficiles sont égales à l'objet spécifié, sinon false. public override bool Equals(object? obj) => obj is ReglesDifficiles; + + /// + /// Obtient le code de hachage pour les règles difficiles. + /// + /// Le code de hachage des règles difficiles. public override int GetHashCode() => Nom.GetHashCode(); } } diff --git a/Sources/CoreLibrary/Statistiques/Statistique.cs b/Sources/CoreLibrary/Statistiques/Statistique.cs index e32c738..70dfcba 100644 --- a/Sources/CoreLibrary/Statistiques/Statistique.cs +++ b/Sources/CoreLibrary/Statistiques/Statistique.cs @@ -1,5 +1,8 @@ namespace CoreLibrary.Statistiques { + /// + /// Enumération des statistiques. + /// public enum Statistique { PartieGagnee, diff --git a/Sources/MauiSpark/Pages/AccueilPage.xaml.cs b/Sources/MauiSpark/Pages/AccueilPage.xaml.cs index 13ef29c..e935c9a 100644 --- a/Sources/MauiSpark/Pages/AccueilPage.xaml.cs +++ b/Sources/MauiSpark/Pages/AccueilPage.xaml.cs @@ -1,22 +1,42 @@ -namespace MauiSpark.Pages; +namespace MauiSpark.Pages; + +/// +/// Page d'accueil de l'application. +/// +public partial class AccueilPage : ContentPage +{ -public partial class AccueilPage : ContentPage -{ - public AccueilPage() - { - NavigationPage.SetHasBackButton(this, false); - NavigationPage.SetHasNavigationBar(this, false); - - InitializeComponent(); - } - - private void QuandJouerClique(Object? sender, EventArgs e) - { - Navigation.PushAsync(new ModePage()); + /// + /// Constructeur de la page d'accueil. + /// Initialise les paramètres de navigation et les composants de la page. + /// + public AccueilPage() + { + NavigationPage.SetHasBackButton(this, false); + NavigationPage.SetHasNavigationBar(this, false); + + InitializeComponent(); + } + + /// + /// Méthode déclenchée lorsque le bouton "Jouer" est cliqué. + /// Navigue vers la page Mode. + /// + /// L'objet qui appelle l'événement ; dans ce cas, le bouton "Jouer". + /// L'instance de l'événement EventArgs créée par le système. + private void QuandJouerClique(Object? sender, EventArgs e) + { + Navigation.PushAsync(new ModePage()); } + /// + /// Méthode déclenchée lorsque le bouton "Reprendre" est cliqué. + /// Navigue vers la page Reprendre. + /// + /// L'objet qui appelle l'événement ; dans ce cas, le bouton "Reprendre". + /// L'instance de l'événement EventArgs créée par le système. private void QuandReprendreClique(Object? sender, EventArgs e) { Navigation.PushAsync(new ReprendrePage()); - } + } } \ No newline at end of file diff --git a/Sources/MauiSpark/Pages/ClassementPage.xaml.cs b/Sources/MauiSpark/Pages/ClassementPage.xaml.cs index 96e352c..2e9d803 100644 --- a/Sources/MauiSpark/Pages/ClassementPage.xaml.cs +++ b/Sources/MauiSpark/Pages/ClassementPage.xaml.cs @@ -6,24 +6,49 @@ using System.Runtime.CompilerServices; namespace MauiSpark.Pages { + /// + /// Représente un joueur dans le classement. + /// partial class Enfant { private readonly Classement classement; + /// + /// Obtient ou définit le joueur associé à cet enfant. + /// public Joueur Joueur { get; set; } + + /// + /// Obtient la place du joueur dans le classement. + /// public int Place => classement.Enfants.ToList().IndexOf(this) + 1; + + /// + /// Obtient les statistiques du joueur dans le classement. + /// public IEnumerable Statistiques => Enum.GetValues() .Select(statistique => Joueur.Statistique(classement.Regles, statistique)); + /// + /// Obtient une liste des objets de cet enfant dans le classement (Son nom et sa place). + /// public IEnumerable Objets => new List([$"{Place}", Joueur.Nom]) .Concat(Statistiques.Select(statistique => $"{statistique}")); + /// + /// Initialise une nouvelle instance de la classe . + /// + /// Le joueur associé à cet enfant. + /// Le classement auquel cet enfant appartient. public Enfant(Joueur joueur, Classement classement) { this.classement = classement; Joueur = joueur; } + /// + /// Détermine si l'objet spécifié est égal à l'objet actuel. + /// public override bool Equals(object? obj) { if (obj == null || obj is not Enfant) @@ -32,21 +57,42 @@ namespace MauiSpark.Pages return Joueur == ((Enfant)obj).Joueur; } + /// + /// Retourne le code de hachage de cet objet. + /// public override int GetHashCode() => Joueur.GetHashCode(); } + /// + /// Représente le classement des joueurs. + /// partial class Classement : INotifyPropertyChanged { + /// + /// Se produit lorsque la valeur d'une propriété de l'objet change. + /// public event PropertyChangedEventHandler? PropertyChanged; + /// + /// Déclenche l'événement pour notifier les modifications de propriété. + /// + /// Le nom de la propriété qui a changé. public void QuandProprieteChangee([CallerMemberName] string? propriete = null) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propriete)); private int indiceRegles = 0; + + /// + /// Obtient les règles actuelles du classement. + /// public IRegles Regles => ClassementPage.ToutesRegles.ElementAt(indiceRegles); private Statistique statistique = Enum.GetValues().First(); + + /// + /// Obtient ou définit la statistique utilisée pour classer les joueurs. + /// public Statistique Statistique { get => statistique; @@ -58,6 +104,10 @@ namespace MauiSpark.Pages } private bool inverser = true; + + /// + /// Obtient ou définit une valeur indiquant si le classement est inversé. + /// public bool Inverser { get => inverser; set @@ -67,6 +117,9 @@ namespace MauiSpark.Pages } } + /// + /// Obtient les titres des colonnes du classement. + /// public IEnumerable Titres => new List(["Place", "Nom"]).Concat( Enum.GetValues().Select( statistique => string.Concat((Enum.GetName(typeof(Statistique), statistique) ?? "").Select( @@ -75,6 +128,9 @@ namespace MauiSpark.Pages ) ); + /// + /// Obtient la liste des enfants (joueurs) dans le classement, triée en fonction de la statistique et des règles actuelles. + /// public IEnumerable Enfants => Inverser ? MauiProgram.Manageur.Joueurs .OrderBy(joueur => joueur.Statistique(Regles, Statistique)) @@ -83,6 +139,10 @@ namespace MauiSpark.Pages .OrderBy(joueur => joueur.Statistique(Regles, Statistique)) .Select(joueur => new Enfant(joueur, this)); + /// + /// Incrémente l'indice des règles du classement selon une valeur spécifiée. + /// + /// La valeur à ajouter à l'indice des règles. public void IncrementerRegles(int valeur) { if ((indiceRegles += valeur) < 0) @@ -95,13 +155,24 @@ namespace MauiSpark.Pages } } + /// + /// Partie de la logique de l'interface utilisateur de la page de classement. + /// Gère les calculs de classement, l'affichage des statistiques et le changement des règles de jeu. + /// public partial class ClassementPage : ContentPage { + /// + /// Obtient toutes les règles de jeu disponibles. + /// public static IEnumerable ToutesRegles => typeof(IRegles).Assembly.GetTypes() .Where(type => typeof(IRegles).IsAssignableFrom(type) && type.IsClass) .Select(type => (Activator.CreateInstance(type) as IRegles)!) .OrderBy(regles => regles.Indice); + /// + /// Constructeur de la page de classement des joueurs. + /// Initialise les paramètres de navigation et les composants de la page. + /// public ClassementPage() { InitializeComponent(); @@ -111,11 +182,19 @@ namespace MauiSpark.Pages BindingContext = new Classement(); } + /// + /// Méthode appelée lorsqu'un bouton de changement de règles est pressé. + /// Augmente ou diminue l'indice des règles selon le bouton pressé. + /// public void ChangerReglesPresse(object sender, EventArgs e) { ((Classement)BindingContext).IncrementerRegles(sender == DiminuerRegles ? -1 : 1); } + /// + /// Méthode appelée lorsqu'un bouton statistique est pressée. + /// Modifie la statistique de classement ou inverse l'ordre du classement si la même statistique est déjà sélectionnée. + /// public void StatistiquePressee(object sender, EventArgs e) { if (sender is not Label || !Enum.IsDefined(typeof(Statistique), ((Label)sender).Text.Replace(" ", ""))) diff --git a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs index 318a7d8..8e86105 100644 --- a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs +++ b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs @@ -3,12 +3,25 @@ using CoreLibrary.Joueurs; namespace MauiSpark.Pages; - +/// +/// Page de connexion où les joueurs de la partie sont entrés. +/// public partial class ConnexionPage : ContentPage { - private int? indice; + /// + /// Indice du joueur à entrer. + /// + private int? indice; + + /// + /// Le joueur demandé. + /// private Joueur? joueurDemande; - + + /// + /// Constructeur de la page de connexion. + /// Initialise les paramètres de navigation et les composants de la page. + /// public ConnexionPage() { NavigationPage.SetHasNavigationBar(this, false); @@ -16,7 +29,12 @@ public partial class ConnexionPage : ContentPage InitializeComponent(); } - public async void QuandDemanderNom(Object? sender, PartieDemanderJoueurEventArgs e) + /// + /// Méthode déclenchée lorsque l'événement DemanderNom de partie est appelée. + /// + /// La classe qui appelle l'événement ; ici Partie. + /// L'instance de l'événement PartieDemanderJoueurEventArgs créée par Partie. + public async void QuandDemanderNom(Object? sender, PartieDemanderJoueurEventArgs e) { if(Application.Current != null && Application.Current.MainPage != null && ((NavigationPage)Application.Current.MainPage).CurrentPage != this) await Application.Current.MainPage.Navigation.PushAsync(this); @@ -27,7 +45,12 @@ public partial class ConnexionPage : ContentPage BindingContext = $"Joueur {e.Indice}"; } - private void QuandSeConnecterPresse(Object sender, EventArgs e) + /// + /// Méthode déclenchée lorsque le bouton "Se Connecter" est cliqué. + /// + /// L'objet qui appelle l'événement ; ici le bouton SeConnecterPresse. + /// L'instance de l'événement EventArgs créée par le système. + private void QuandSeConnecterPresse(Object sender, EventArgs e) { if (joueurDemande == null || indice == null) return; @@ -45,6 +68,11 @@ public partial class ConnexionPage : ContentPage joueurDemande.SeConnecter(joueur); } + /// + /// Méthode déclenchée lorsque le bouton "Robot" est cliqué. + /// + /// L'objet qui appelle l'événement ; ici le bouton RobotPresse. + /// L'instance de l'événement EventArgs créée par le système. private void QuandRobotPresse(object sender, EventArgs e) { if (joueurDemande == null || indice == null) diff --git a/Sources/MauiSpark/Pages/ModePage.xaml.cs b/Sources/MauiSpark/Pages/ModePage.xaml.cs index a54d434..61b5d9f 100644 --- a/Sources/MauiSpark/Pages/ModePage.xaml.cs +++ b/Sources/MauiSpark/Pages/ModePage.xaml.cs @@ -1,18 +1,26 @@ -using CoreLibrary.Regles; - -namespace MauiSpark.Pages; - -public partial class ModePage : ContentPage -{ - public ModePage() - { - NavigationPage.SetHasNavigationBar(this, false); - - BindingContext = typeof(IRegles).Assembly.GetTypes() - .Where(type => typeof(IRegles).IsAssignableFrom(type) && type.IsClass) - .Select(type => (Activator.CreateInstance(type) as IRegles)!) - .OrderBy(regles => regles.Indice); - - InitializeComponent(); - } +using CoreLibrary.Regles; + +namespace MauiSpark.Pages; + +/// +/// Page de sélection des modes de jeux. +/// +public partial class ModePage : ContentPage +{ + /// + /// Constructeur de la page mode. + /// Initialise les paramètres de navigation et les composants de la page. + /// Initialise le binding contexte avec une liste de règles. + /// + public ModePage() + { + NavigationPage.SetHasNavigationBar(this, false); + + BindingContext = typeof(IRegles).Assembly.GetTypes() + .Where(type => typeof(IRegles).IsAssignableFrom(type) && type.IsClass) + .Select(type => (Activator.CreateInstance(type) as IRegles)!) + .OrderBy(regles => regles.Indice); + + InitializeComponent(); + } } \ No newline at end of file diff --git a/Sources/MauiSpark/Pages/PlateauPage.xaml.cs b/Sources/MauiSpark/Pages/PlateauPage.xaml.cs index 25419b7..1d46afa 100644 --- a/Sources/MauiSpark/Pages/PlateauPage.xaml.cs +++ b/Sources/MauiSpark/Pages/PlateauPage.xaml.cs @@ -4,14 +4,37 @@ using CoreLibrary.Exceptions; namespace MauiSpark.Pages; +/// +/// Représente un tour de jeu, avec le plateau actuel, le joueur en cours, le numéro de tour et le code. +/// internal class Tour { + + /// + /// Obtient ou définit le plateau de jeu pour ce tour. + /// public IEnumerable<(IEnumerable, IEnumerable)> Plateau { get; private init; } + + /// + /// Obtient ou définit le nom du joueur pour ce tour. + /// public string Joueur { get; private init; } + + /// + /// Obtient ou définit le numéro de tour. + /// public string Numero { get; private init; } + + /// + /// Obtient ou définit le code pour ce tour. + /// public Code Code { get; private init; } public bool EstJoueur { get; private init; } + /// + /// Initialise un tour à partir des arguments de l'événement de nouveau tour de jeu. + /// + /// Les arguments de l'événement PartieNouveauTourEventArgs. public Tour(PartieNouveauTourEventArgs e) { Numero = $"Tour {e.Tour}"; @@ -38,12 +61,19 @@ internal class Tour } } +/// +/// Page affichant le plateau de jeu et permettant aux joueurs d'interagir avec celui-ci. +/// public partial class PlateauPage : ContentPage { private Code? code; private Plateau? plateau; private bool? estJoueur; + /// + /// Constructeur de la page du plateau de jeu. + /// Initialise les paramètres de navigation et les composants de la page. + /// public PlateauPage() { NavigationPage.SetHasNavigationBar(this, false); @@ -51,6 +81,12 @@ public partial class PlateauPage : ContentPage InitializeComponent(); } + /// + /// Méthode appelée lorsqu'un nouveau tour de jeu commence. + /// Affiche le nouveau tour de jeu sur le plateau. + /// + /// La source de l'événement ; dans ce cas, la partie. + /// Les arguments de l'événement PartieNouveauTourEventArgs. public async void QuandNouveauTour(object? sender, PartieNouveauTourEventArgs e) { if (Application.Current == null || Application.Current.MainPage == null) @@ -76,6 +112,12 @@ public partial class PlateauPage : ContentPage BindingContext = new Tour(e); } + /// + /// Supprime le dernier jeton ajouté au code en cours. + /// Affiche une alerte si le code est vide. + /// + /// La source de l'événement ; ici, le bouton de suppression de jeton. + /// Les arguments de l'événement EventArgs. private void SupprimerDernierJeton(Object sender, EventArgs e) { try @@ -89,6 +131,12 @@ public partial class PlateauPage : ContentPage } } + /// + /// Valide le code actuel et l'ajoute au plateau de jeu. + /// Affiche une alerte si le code est incomplet. + /// + /// La source de l'événement ; ici, le bouton de validation de code. + /// Les arguments de l'événement EventArgs. private void ValiderCode(Object sender, EventArgs e) { try @@ -102,6 +150,12 @@ public partial class PlateauPage : ContentPage } } + + /// + /// Ouvre la page des règles du jeu. + /// + /// La source de l'événement ; ici, le bouton de règles du jeu. + /// Les arguments de l'événement EventArgs. private async void QuandReglesClique(object sender, EventArgs e) { await Navigation.PushAsync(new ReglesPage()); diff --git a/Sources/MauiSpark/Pages/ReglesPage.xaml.cs b/Sources/MauiSpark/Pages/ReglesPage.xaml.cs index b353245..f2ec1b5 100644 --- a/Sources/MauiSpark/Pages/ReglesPage.xaml.cs +++ b/Sources/MauiSpark/Pages/ReglesPage.xaml.cs @@ -2,17 +2,25 @@ using CoreLibrary.Regles; namespace MauiSpark.Pages; +/// +/// Page affichant les règles disponibles. +/// public partial class ReglesPage : ContentPage -{ +{ + /// + /// Constructeur de la page des règles. + /// Initialise les paramètres de navigation et les composants de la page. + /// Initialise le contexte de liaison avec une liste de règles disponibles. + /// public ReglesPage() { NavigationPage.SetHasNavigationBar(this, false); - BindingContext = typeof(IRegles).Assembly.GetTypes() - .Where(type => typeof(IRegles).IsAssignableFrom(type) && type.IsClass) - .Select(type => (Activator.CreateInstance(type) as IRegles)!) - .OrderBy(regles => regles.Indice); - + BindingContext = typeof(IRegles).Assembly.GetTypes() + .Where(type => typeof(IRegles).IsAssignableFrom(type) && type.IsClass) + .Select(type => (Activator.CreateInstance(type) as IRegles)!) + .OrderBy(regles => regles.Indice); + InitializeComponent(); } } \ No newline at end of file diff --git a/Sources/MauiSpark/Pages/ReprendrePage.xaml.cs b/Sources/MauiSpark/Pages/ReprendrePage.xaml.cs index 87d7d72..6300f4e 100644 --- a/Sources/MauiSpark/Pages/ReprendrePage.xaml.cs +++ b/Sources/MauiSpark/Pages/ReprendrePage.xaml.cs @@ -1,8 +1,16 @@ namespace MauiSpark.Pages; +/// +/// Page permettant de reprendre les parties en cours. +/// public partial class ReprendrePage : ContentPage { - public ReprendrePage() + /// + /// Constructeur de la page de reprise. + /// Initialise les paramètres de navigation et les composants de la page. + /// Initialise le contexte de liaison avec les parties non terminées. + /// + public ReprendrePage() { NavigationPage.SetHasNavigationBar(this, false); diff --git a/Sources/MauiSpark/Pages/VictoirePage.xaml.cs b/Sources/MauiSpark/Pages/VictoirePage.xaml.cs index 8d7eb84..566617d 100644 --- a/Sources/MauiSpark/Pages/VictoirePage.xaml.cs +++ b/Sources/MauiSpark/Pages/VictoirePage.xaml.cs @@ -11,17 +11,29 @@ partial class Message public string Image { get; init; } = ""; } - +/// +/// Page affichée lorsque la partie est terminée, montrant le résultat de la partie. +/// public partial class VictoirePage : ContentPage { - public VictoirePage() + /// + /// Constructeur de la page de victoire. + /// Initialise les paramètres de navigation et les composants de la page. + /// + public VictoirePage() { NavigationPage.SetHasNavigationBar(this, false); InitializeComponent(); } + /// + /// Méthode déclenchée lorsque la partie est terminée. + /// Affiche le résultat de la partie en fonction des gagnants et des perdants. + /// + /// La classe qui appelle l'événement ; ici Partie. + /// L'instance de l'événement PartiePartieTermineeEventArgs créée par Partie. public async void QuandPartieTerminee(object? sender, PartiePartieTermineeEventArgs e) { if (Application.Current == null || Application.Current.MainPage == null) @@ -43,6 +55,7 @@ public partial class VictoirePage : ContentPage IReadOnlyList gagnants = e.Gagnants; IReadOnlyList perdants = e.Perdants; + // Affichage du message en fonction du résultat de la partie if (gagnants.Count == 1) BindingContext = new Message() { @@ -66,6 +79,12 @@ public partial class VictoirePage : ContentPage }; } + /// + /// Méthode déclenchée lorsque le bouton de retour au menu est pressé. + /// Retourne à la page précédente. + /// + /// L'objet qui appelle l'événement ; ici le bouton de retour au menu. + /// L'instance de l'événement EventArgs créée par le système. public async void QuandMenuPresse(object sender, EventArgs e) { await Navigation.PopAsync(); diff --git a/Sources/MauiSpark/Vues/BoutonClassementVue.xaml.cs b/Sources/MauiSpark/Vues/BoutonClassementVue.xaml.cs index 91671dd..3add4be 100644 --- a/Sources/MauiSpark/Vues/BoutonClassementVue.xaml.cs +++ b/Sources/MauiSpark/Vues/BoutonClassementVue.xaml.cs @@ -2,13 +2,26 @@ using MauiSpark.Pages; namespace MauiSpark.Vues; +/// +/// Vue représentant un bouton pour accéder à la page de classement. +/// public partial class BoutonClassementVue : ContentView { - public BoutonClassementVue() + /// + /// Constructeur de la vue du bouton de classement. + /// Initialise les composants de la vue. + /// + public BoutonClassementVue() { InitializeComponent(); } + /// + /// Méthode déclenchée lorsque le bouton de classement est cliqué. + /// Navigue vers la page de classement. + /// + /// L'objet qui appelle l'événement ; ici le bouton de classement. + /// L'instance de l'événement EventArgs créée par le système. private void QuandClassementClique(Object? sender, EventArgs e) { Navigation.PushAsync(new ClassementPage()); diff --git a/Sources/MauiSpark/Vues/BoutonReglesVue.xaml.cs b/Sources/MauiSpark/Vues/BoutonReglesVue.xaml.cs index a657680..c218270 100644 --- a/Sources/MauiSpark/Vues/BoutonReglesVue.xaml.cs +++ b/Sources/MauiSpark/Vues/BoutonReglesVue.xaml.cs @@ -2,13 +2,26 @@ using MauiSpark.Pages; namespace MauiSpark.Vues; +/// +/// Vue représentant un bouton pour accéder à la page des règles. +/// public partial class BoutonReglesVue : ContentView { + /// + /// Constructeur de la vue du bouton des règles. + /// Initialise les composants de la vue. + /// public BoutonReglesVue() { InitializeComponent(); } + /// + /// Méthode déclenchée lorsque le bouton des règles est cliqué. + /// Navigue vers la page des règles. + /// + /// L'objet qui appelle l'événement ; ici le bouton des règles. + /// L'instance de l'événement EventArgs créée par le système. private void QuandReglesClique(Object? sender, EventArgs e) { Navigation.PushAsync(new ReglesPage()); diff --git a/Sources/MauiSpark/Vues/ImageResultatVue.xaml.cs b/Sources/MauiSpark/Vues/ImageResultatVue.xaml.cs index a687257..accf035 100644 --- a/Sources/MauiSpark/Vues/ImageResultatVue.xaml.cs +++ b/Sources/MauiSpark/Vues/ImageResultatVue.xaml.cs @@ -1,15 +1,28 @@ namespace MauiSpark.Vues; +/// +/// Vue représentant une image de résultat. +/// public partial class ImageResultatVue : ContentView { + /// + /// Propriété attachée à l'image affichée dans la vue. + /// public static readonly BindableProperty ImageProperty = BindableProperty.Create(nameof(Image), typeof(ImageSource), typeof(ImageResultatVue), null); + /// + /// Obtient ou définit l'image affichée dans la vue. + /// public ImageSource Image { get => (ImageSource)GetValue(ImageProperty); set => SetValue(ImageProperty, value); } + /// + /// Constructeur de la vue de l'image de résultat. + /// Initialise les composants de la vue et lie le contexte de liaison à cette instance. + /// public ImageResultatVue() { InitializeComponent(); diff --git a/Sources/MauiSpark/Vues/IndicateurVue.xaml.cs b/Sources/MauiSpark/Vues/IndicateurVue.xaml.cs index 205819f..f0ffa34 100644 --- a/Sources/MauiSpark/Vues/IndicateurVue.xaml.cs +++ b/Sources/MauiSpark/Vues/IndicateurVue.xaml.cs @@ -4,22 +4,42 @@ using System.Globalization; namespace MauiSpark.Vues; +/// +/// Vue représentant un indicateur coloré. +/// public partial class IndicateurVue : ContentView { + /// + /// Propriété attachée à la couleur de l'indicateur. + /// public static readonly BindableProperty CouleurProperty = BindableProperty.Create(nameof(Couleur), typeof(Color), typeof(IndicateurVue), default(Color)); - public Color Couleur + /// + /// Obtient ou définit la couleur de l'indicateur. + /// + public Color Couleur { get => (Color)GetValue(CouleurProperty); set => SetValue(CouleurProperty, value); } - public IndicateurVue() + + /// + /// Constructeur de la vue de l'indicateur. + /// Initialise les composants de la vue et lie le contexte de liaison à cette instance. + /// + public IndicateurVue() { InitializeComponent(); BindingContext = this; } + /// + /// Méthode déclenchée lorsque la taille de l'indicateur est modifiée. + /// Réajuste la taille du carré représentant l'indicateur pour qu'il soit toujours carré. + /// + /// L'objet qui a déclenché l'événement ; ici, le carré représentant l'indicateur. + /// Les arguments de l'événement. private void QuandTailleChangee(object sender, EventArgs e) { double taille = Math.Min(Grid.Width, Grid.Height) / 2; diff --git a/Sources/MauiSpark/Vues/JetonVue.xaml.cs b/Sources/MauiSpark/Vues/JetonVue.xaml.cs index b841032..bc8f6a6 100644 --- a/Sources/MauiSpark/Vues/JetonVue.xaml.cs +++ b/Sources/MauiSpark/Vues/JetonVue.xaml.cs @@ -5,42 +5,82 @@ using System.Globalization; namespace MauiSpark.Vues; +/// +/// Vue représentant un jeton coloré. +/// public partial class JetonVue : ContentView { + /// + /// Propriété attachée à la couleur du jeton. + /// public static readonly BindableProperty CouleurProperty = BindableProperty.Create(nameof(Couleur), typeof(Color), typeof(JetonVue), default(Color)); + + /// + /// Propriété attachée au code associé au jeton. + /// public static readonly BindableProperty CodeProperty = BindableProperty.Create(nameof(Code), typeof(Code), typeof(JetonVue), null); + + /// + /// Propriété attachée indiquant si le jeton est associé à un joueur. + /// public static readonly BindableProperty EstJoueurProperty = BindableProperty.Create(nameof(EstJoueur), typeof(bool), typeof(JetonVue), true); + /// + /// Obtient ou définit la couleur du jeton. + /// public Color Couleur { get => (Color)GetValue(CouleurProperty); set => SetValue(CouleurProperty, value); } + /// + /// Obtient ou définit le code associé au jeton. + /// public Code? Code { get => (Code?)GetValue(CodeProperty); set => SetValue(CodeProperty, value); } + /// + /// Obtient ou définit une valeur indiquant si le jeton est associé à un joueur. + /// public bool EstJoueur { get => (bool)GetValue(EstJoueurProperty); set => SetValue(EstJoueurProperty, value); } + /// + /// Constructeur de la vue du jeton. + /// Initialise les composants de la vue et lie le contexte de liaison à cette instance. + /// public JetonVue() { InitializeComponent(); BindingContext = this; } + /// + /// Méthode déclenchée lorsque la taille du jeton est modifiée. + /// Réajuste la taille du cercle représentant le jeton pour qu'il soit toujours circulaire. + /// + /// L'objet qui a déclenché l'événement ; ici, le cercle représentant le jeton. + /// Les arguments de l'événement, s'il y en a. private void QuandTailleChangee(object sender, EventArgs e) { double taille = Math.Min(Grid.Width, Grid.Height) / 2; Cercle.WidthRequest = Cercle.HeightRequest = taille; } + /// + /// Méthode déclenchée lorsque le jeton est pressé. + /// Ajoute un jeton à un code si celui-ci est associé à un joueur. + /// Affiche une alerte si le code est déjà complet. + /// + /// L'objet qui a déclenché l'événement ; ici, le cercle représentant le jeton. + /// Les arguments de l'événement, s'il y en a. private void JetonPresse(object sender, EventArgs e) { if (Cercle == null || !sender.Equals(Cercle) || Code == null || Application.Current == null || Application.Current.MainPage == null || !EstJoueur) diff --git a/Sources/MauiSpark/Vues/ModeVue.xaml.cs b/Sources/MauiSpark/Vues/ModeVue.xaml.cs index a30f109..b47ff3e 100644 --- a/Sources/MauiSpark/Vues/ModeVue.xaml.cs +++ b/Sources/MauiSpark/Vues/ModeVue.xaml.cs @@ -4,21 +4,38 @@ using MauiSpark.Pages; namespace MauiSpark.Vues; +/// +/// Vue permettant de sélectionner un mode de jeu. +/// public partial class ModeVue : ContentView { + /// + /// Propriété de dépendance pour les règles du jeu. + /// public static readonly BindableProperty ReglesProperty = BindableProperty.Create(nameof(Regles), typeof(IRegles), typeof(ModeVue), null); + /// + /// Les règles du jeu sélectionnées. + /// public IRegles Regles { get => (IRegles)GetValue(ReglesProperty); set => SetValue(ReglesProperty, value); } + /// + /// Constructeur par défaut de la vue du mode de jeu. + /// public ModeVue() { InitializeComponent(); } + /// + /// Méthode déclenchée lorsque le bouton de sélection des règles est pressé. + /// + /// L'objet qui a déclenché l'événement ; ici, le bouton de sélection des règles. + /// Les arguments de l'événement EventArgs. private void QuandReglesPresse(Object sender, EventArgs e) { Partie partie = MauiProgram.Manageur.NouvellePartie(Regles); diff --git a/Sources/MauiSpark/Vues/PartieCommenceeVue.xaml.cs b/Sources/MauiSpark/Vues/PartieCommenceeVue.xaml.cs index 36f7ee1..99dd437 100644 --- a/Sources/MauiSpark/Vues/PartieCommenceeVue.xaml.cs +++ b/Sources/MauiSpark/Vues/PartieCommenceeVue.xaml.cs @@ -4,33 +4,57 @@ using System.ComponentModel; namespace MauiSpark.Vues; +/// +/// Vue affichant les détails d'une partie en cours. +/// public partial class PartieCommenceeVue : ContentView, INotifyPropertyChanged { + /// + /// Propriété de dépendance pour la partie en cours. + /// public static readonly BindableProperty PartieProperty = BindableProperty.Create(nameof(Partie), typeof(Partie), typeof(PartieCommenceeVue), null, propertyChanged: QuandPartieChangee); + /// + /// La partie en cours. + /// public Partie Partie { get => (Partie)GetValue(PartieProperty); set => SetValue(PartieProperty, value); } + /// + /// Le nom des règles de la partie. + /// public string NomRegles { get => Partie != null ? Partie.Regles.Nom : ""; } + /// + /// Le tour actuel de la partie. + /// public string TourActuel { get => $"Tour : {(Partie != null ? Partie.Tour : 0)} / {(Partie != null ? Partie.Regles.NbTour : 0)}"; } + /// + /// Les joueurs participant à la partie. + /// public string[] Joueurs { get => Partie != null ? Partie.Joueurs.ToArray() : []; } + /// + /// Le nombre de joueurs participant à la partie. + /// public string NombreJoueurs => $"Joueurs : {Joueurs.Length} / {(Partie != null ? Partie.Regles.NbJoueurs : 0)}"; + /// + /// Méthode déclenchée lorsqu'une propriété de la partie change. + /// private static void QuandPartieChangee(BindableObject bindable, object ancienneValeur, object nouvelleValeur) { ((PartieCommenceeVue)bindable).OnPropertyChanged(nameof(NomRegles)); @@ -39,6 +63,9 @@ public partial class PartieCommenceeVue : ContentView, INotifyPropertyChanged ((PartieCommenceeVue)bindable).OnPropertyChanged(nameof(NombreJoueurs)); } + /// + /// Méthode déclenchée lorsqu'un utilisateur appuie sur la vue de la partie. + /// private void PartiePressee(object? sender, EventArgs e) { if (Partie == null) @@ -53,6 +80,9 @@ public partial class PartieCommenceeVue : ContentView, INotifyPropertyChanged partie.Jouer(); } + /// + /// Constructeur par défaut de la vue de la partie en cours. + /// public PartieCommenceeVue() { InitializeComponent(); diff --git a/Sources/MauiSpark/Vues/ReglesVue.xaml.cs b/Sources/MauiSpark/Vues/ReglesVue.xaml.cs index 4a903f1..c179692 100644 --- a/Sources/MauiSpark/Vues/ReglesVue.xaml.cs +++ b/Sources/MauiSpark/Vues/ReglesVue.xaml.cs @@ -1,22 +1,41 @@ namespace MauiSpark.Vues; +/// +/// Vue pour afficher le titre et la description des règles. +/// public partial class ReglesVue : ContentView { + /// + /// Identifie la propriété de dépendance pour le titre des règles. + /// public static readonly BindableProperty TitreProperty = BindableProperty.Create(nameof(Titre), typeof(string), typeof(ReglesVue), default(string)); + + /// + /// Identifie la propriété de dépendance pour la description des règles. + /// public static readonly BindableProperty DescriptionProperty = BindableProperty.Create(nameof(Description), typeof(string), typeof(ReglesVue), default(string)); + /// + /// Obtient ou définit le titre des règles. + /// public string Titre { get => (string)GetValue(TitreProperty); set => SetValue(TitreProperty, value); } + /// + /// Obtient ou définit la description des règles. + /// public string Description { get => (string)GetValue(DescriptionProperty); set => SetValue(DescriptionProperty, value); } + /// + /// Initialise une nouvelle instance de la classe . + /// public ReglesVue() { InitializeComponent(); diff --git a/Sources/MauiSpark/Vues/TitreVue.xaml.cs b/Sources/MauiSpark/Vues/TitreVue.xaml.cs index 3185bb6..1f6a106 100644 --- a/Sources/MauiSpark/Vues/TitreVue.xaml.cs +++ b/Sources/MauiSpark/Vues/TitreVue.xaml.cs @@ -1,15 +1,27 @@ namespace MauiSpark.Vues; +/// +/// Vue pour afficher un titre. +/// public partial class TitreVue : ContentView { + /// + /// Identifie la propriété de dépendance pour le texte du titre. + /// public static readonly BindableProperty TexteProperty = BindableProperty.Create(nameof(Texte), typeof(string), typeof(TitreVue), default(string)); + /// + /// Obtient ou définit le texte du titre. + /// public string Texte { get => (string)GetValue(TexteProperty); set => SetValue(TexteProperty, value); } + /// + /// Initialise une nouvelle instance de la classe . + /// public TitreVue() { InitializeComponent();