From 720a600da0cb11b18406931a73771037357efde3 Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Mon, 3 Jun 2024 21:29:56 +0200 Subject: [PATCH 01/31] Documentation Code --- Sources/CoreLibrary/Core/Code.cs | 53 ++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/Sources/CoreLibrary/Core/Code.cs b/Sources/CoreLibrary/Core/Code.cs index 38e98b1..6971b89 100644 --- a/Sources/CoreLibrary/Core/Code.cs +++ b/Sources/CoreLibrary/Core/Code.cs @@ -4,17 +4,44 @@ using System.Runtime.Serialization; namespace CoreLibrary.Core { + /// + /// Classe qui représente un code composé de jetons. + /// [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) @@ -23,6 +50,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) @@ -31,6 +63,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) @@ -39,6 +77,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) @@ -47,6 +89,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 @@ -85,6 +134,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})"; } } From beff2646ba7b16b592b10dfbebfb71497dbbd19d Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Mon, 3 Jun 2024 21:33:59 +0200 Subject: [PATCH 02/31] Documentation Couleur --- Sources/CoreLibrary/Core/Couleur.cs | 3 +++ 1 file changed, 3 insertions(+) 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, From c6a1fb4a17702fbd364716e92faf35d0771ea62b Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Mon, 3 Jun 2024 21:37:18 +0200 Subject: [PATCH 03/31] Documentation Indicateur --- Sources/CoreLibrary/Core/Indicateur.cs | 3 +++ 1 file changed, 3 insertions(+) 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, From 8d293abd2b54e2277850a7c587a03f31ce3db23b Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Mon, 3 Jun 2024 21:59:12 +0200 Subject: [PATCH 04/31] Documentation Plateau --- Sources/CoreLibrary/Core/Plateau.cs | 57 +++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/Sources/CoreLibrary/Core/Plateau.cs b/Sources/CoreLibrary/Core/Plateau.cs index 02a38a4..4991164 100644 --- a/Sources/CoreLibrary/Core/Plateau.cs +++ b/Sources/CoreLibrary/Core/Plateau.cs @@ -5,33 +5,80 @@ 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 (IReadOnlyList>, IReadOnlyList>) Grille => ( codes.Select(code => code.Jetons).ToList(), 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 +93,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 +112,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) From 4d76d5fecce41f374cca606236cf2feba8e181c6 Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Mon, 3 Jun 2024 22:08:11 +0200 Subject: [PATCH 05/31] Documentation Jeton --- Sources/CoreLibrary/Core/Jeton.cs | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/Sources/CoreLibrary/Core/Jeton.cs b/Sources/CoreLibrary/Core/Jeton.cs index b6cefe4..6eca676 100644 --- a/Sources/CoreLibrary/Core/Jeton.cs +++ b/Sources/CoreLibrary/Core/Jeton.cs @@ -2,17 +2,32 @@ 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; } + /// + /// 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 (objet == null || objet is not Jeton) @@ -21,10 +36,26 @@ namespace CoreLibrary.Core return Couleur == ((Jeton)objet).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(); } } From 548fe94eac5f4c17d622147547cc495b3d681603 Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Mon, 3 Jun 2024 22:18:36 +0200 Subject: [PATCH 06/31] Documentation Joueur --- Sources/CoreLibrary/Joueurs/Joueur.cs | 44 +++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/Sources/CoreLibrary/Joueurs/Joueur.cs b/Sources/CoreLibrary/Joueurs/Joueur.cs index 2956f4d..a7f0979 100644 --- a/Sources/CoreLibrary/Joueurs/Joueur.cs +++ b/Sources/CoreLibrary/Joueurs/Joueur.cs @@ -7,30 +7,59 @@ using System.Runtime.Serialization; namespace CoreLibrary.Joueurs { + /// + /// Classe représentant un joueur. + /// [DataContract] [KnownType(typeof(ReglesClassiques))] public class Joueur : IEstPersistant { + /// + /// Événement déclenché lorsque le joueur se connecte. + /// public event EventHandler? JoueurSeConnecter; private void QuandJoueurSeConnecter() => JoueurSeConnecter?.Invoke(this, new JoueurSeConnecterEventArgs(Nom)); + /// + /// Dictionnaire des statistiques du joueur avec les règles et les statistiques. + /// [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 actuel avec les informations d'un autre joueur. + /// + /// Le joueur à partir duquel copier les informations. + /// Renvoie le joueur actuel connecté. + /// Lancée si le joueur est déjà connecté. public Joueur SeConnecter(Joueur joueur) { if (EstConnecte) @@ -45,11 +74,26 @@ namespace CoreLibrary.Joueurs return this; } + /// + /// 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 valeur de la statistique spécifiée pour les règles données. + /// + /// Les règles du jeu. + /// Le type de statistique. + /// Renvoie 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; } From ac8cb3902e48ecba774edfb490e7af8598ff843e Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Tue, 4 Jun 2024 13:41:20 +0200 Subject: [PATCH 07/31] Documentation Manager --- Sources/CoreLibrary/Manageurs/Manageur.cs | 51 +++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/Sources/CoreLibrary/Manageurs/Manageur.cs b/Sources/CoreLibrary/Manageurs/Manageur.cs index b9210b0..5d2c145 100644 --- a/Sources/CoreLibrary/Manageurs/Manageur.cs +++ b/Sources/CoreLibrary/Manageurs/Manageur.cs @@ -6,16 +6,45 @@ using System.Text.RegularExpressions; 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; + + /// + /// Obtient la liste des parties non terminées. + /// public IReadOnlyList 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; @@ -24,12 +53,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); @@ -42,6 +79,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); @@ -52,6 +94,10 @@ namespace CoreLibrary.Manageurs return partie; } + /// + /// Suivre le cour d'une partie avec la partie spécifiée. + /// + /// La partie à écouter. private void EcouterPartie(Partie partie) { partie.PartieDemanderJoueur += (sender, e) => Sauvegarder(); @@ -85,6 +131,11 @@ namespace CoreLibrary.Manageurs }; } + /// + /// Demande un joueur avec son nom spécifié. + /// + /// Nom du joueur que l'on souhaite trouver. + /// Renvoie le joueur s'il a été trouvé. Sinon, crée un joueur avec le nom passé en paramètre. public Joueur DemanderJoueur(string nom) { foreach (Joueur joueur in joueurs) From 9ec52a354df42ea6f05e088d9bca9a958cf540a7 Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Tue, 4 Jun 2024 13:59:23 +0200 Subject: [PATCH 08/31] Documentation Persistance --- .../CoreLibrary/Persistance/IEstPersistant.cs | 3 +++ .../CoreLibrary/Persistance/IPersistance.cs | 11 ++++++++ .../Persistance/PersistanceJSON.cs | 25 +++++++++++++++++++ 3 files changed, 39 insertions(+) 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..a15bf3e 100644 --- a/Sources/CoreLibrary/Persistance/IPersistance.cs +++ b/Sources/CoreLibrary/Persistance/IPersistance.cs @@ -1,9 +1,20 @@ namespace CoreLibrary.Persistance { + /// + /// Interface IPersistance permettant de charger et d'enregistrer. + /// public interface IPersistance { + /// + /// Charge les objets qui lui sont donnés. + /// + /// Renvoie un tableau. public T[] Charger() where T : IEstPersistant; + /// + /// Enregistre les elements qui lui sont spécifiés. + /// + /// Tableau d'élements à enregistrer. public void Enregistrer(T[] elements) where T : IEstPersistant; } } diff --git a/Sources/CoreLibrary/Persistance/PersistanceJSON.cs b/Sources/CoreLibrary/Persistance/PersistanceJSON.cs index 1640fde..419ae9c 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. + /// 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és dans le fichier de sauvegarde. + /// + /// 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; } + /// + /// Enragistre dans le fichier de sauvegarde, les éléments spécifiés. + /// + /// Elements à enregistrer dans le fichier de sauvegarde. public void Enregistrer(T[] elements) where T : IEstPersistant { string fichier = $"{typeof(T).Name.ToLower()}s.json"; From 7d9f22147eaa41d27a34fa22e0e0808befe44cfe Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Tue, 4 Jun 2024 14:04:37 +0200 Subject: [PATCH 09/31] Documentation regles --- Sources/CoreLibrary/Regles/IRegles.cs | 18 ++++++++++++++++++ Sources/CoreLibrary/Regles/ReglesClassiques.cs | 18 ++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/Sources/CoreLibrary/Regles/IRegles.cs b/Sources/CoreLibrary/Regles/IRegles.cs index 27ab32e..9bd3825 100644 --- a/Sources/CoreLibrary/Regles/IRegles.cs +++ b/Sources/CoreLibrary/Regles/IRegles.cs @@ -1,10 +1,28 @@ namespace CoreLibrary.Regles { + /// + /// Interface pour créer des règles. + /// public interface IRegles { + /// + /// Obtient le nom des règles. + /// string Nom { 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; } } } diff --git a/Sources/CoreLibrary/Regles/ReglesClassiques.cs b/Sources/CoreLibrary/Regles/ReglesClassiques.cs index 6a8723c..c571f64 100644 --- a/Sources/CoreLibrary/Regles/ReglesClassiques.cs +++ b/Sources/CoreLibrary/Regles/ReglesClassiques.cs @@ -2,12 +2,30 @@ namespace CoreLibrary.Regles { + /// + /// Classe pour les règles classiques, implémente IRegles. + /// [DataContract] public class ReglesClassiques : IRegles { + /// + /// Chaîne de caractères pour le nom des règles classiques. + /// public string Nom => "Règles classiques"; + + /// + /// 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; } } From 318214dbaa0bff7d57644a76e3877900615b5d60 Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Tue, 4 Jun 2024 14:06:16 +0200 Subject: [PATCH 10/31] Documentation Statistique --- Sources/CoreLibrary/Statistiques/Statistique.cs | 3 +++ 1 file changed, 3 insertions(+) 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, From 797871031348da0e902a733fe1effab84ae6abc4 Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Tue, 4 Jun 2024 14:41:06 +0200 Subject: [PATCH 11/31] Documentation Evenements --- .../Evenements/JoueurJoueCodeEventArgs.cs | 3 +++ .../Evenements/JoueurSeConnecterEventArgs.cs | 10 ++++++++ .../Evenements/PartieDebutPartieEventArgs.cs | 3 +++ .../PartieDemanderJoueurEventArgs.cs | 16 ++++++++++++ .../Evenements/PartieNouveauTourEventArgs.cs | 25 +++++++++++++++++++ .../PartiePartieTermineeEventArgs.cs | 15 +++++++++++ .../Evenements/PartiePasserLaMainEventArgs.cs | 10 ++++++++ .../Evenements/PlateauAjouterCodeEventArgs.cs | 10 ++++++++ 8 files changed, 92 insertions(+) diff --git a/Sources/CoreLibrary/Evenements/JoueurJoueCodeEventArgs.cs b/Sources/CoreLibrary/Evenements/JoueurJoueCodeEventArgs.cs index fcd9e98..31583d2 100644 --- a/Sources/CoreLibrary/Evenements/JoueurJoueCodeEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/JoueurJoueCodeEventArgs.cs @@ -1,5 +1,8 @@ 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 2cfa7d2..ee2a27f 100644 --- a/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs @@ -1,9 +1,19 @@ namespace CoreLibrary.Evenements { + /// + /// Classe contenant les arguments passés en paramètres lors de l'événement JoueurSeConnecter. + /// public class JoueurSeConnecterEventArgs : EventArgs { + /// + /// Nom du joueur se connectant. + /// public string Nom { get; private init; } + /// + /// Constructeur de JoueurSeConnecterEventArgs. + /// + /// Nom du joueur qui se connecte. public JoueurSeConnecterEventArgs(string nom) { Nom = nom; 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/PartieNouveauTourEventArgs.cs b/Sources/CoreLibrary/Evenements/PartieNouveauTourEventArgs.cs index b64b5c9..187b905 100644 --- a/Sources/CoreLibrary/Evenements/PartieNouveauTourEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/PartieNouveauTourEventArgs.cs @@ -3,13 +3,38 @@ using CoreLibrary.Joueurs; namespace CoreLibrary.Evenements { + /// + /// Classe contenant les arguments passés en paramètres lors de l'événement PartieNouveauTour. + /// public class PartieNouveauTourEventArgs : EventArgs { + /// + /// Entier correspondant au nombre de tour. + /// public int Tour { get; private init; } + + /// + /// Chaîne de caractères correspondant au joueur courant. + /// public string Joueur { get; private init; } + + /// + /// Plateau du jeu en cours. + /// public Plateau Plateau { get; private init; } + + /// + /// Code du jeu en cours. + /// public Code Code { get; private init; } + /// + /// Constructeur de PartieNouveauTourEventArgs, avec le tour, le joueur, le plateau et le code spécifiés. + /// + /// Le nombre de tour passé. + /// Le joueur courant. + /// Le plateau actuel de la partie. + /// Le dernier code ajouté. public PartieNouveauTourEventArgs(int tour, string joueur, Plateau plateau, Code code) { Tour = tour; 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; From a02124f89d5aa168d01747f08fcca6dfa60b2e6e Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Tue, 4 Jun 2024 15:13:41 +0200 Subject: [PATCH 12/31] Documentation Partie, ajouter e et sender description. --- Sources/CoreLibrary/Partie.cs | 104 +++++++++++++++++++++++++++++++++- 1 file changed, 103 insertions(+), 1 deletion(-) diff --git a/Sources/CoreLibrary/Partie.cs b/Sources/CoreLibrary/Partie.cs index f793400..0709495 100644 --- a/Sources/CoreLibrary/Partie.cs +++ b/Sources/CoreLibrary/Partie.cs @@ -7,43 +7,120 @@ using System.Runtime.Serialization; namespace CoreLibrary { + /// + /// Classe représentant une partie. + /// [DataContract] [KnownType(typeof(ReglesClassiques))] public class Partie : IEstPersistant { + /// + /// Evénement déclencher quand il faut ajouter un joueur. + /// public event EventHandler? PartieDemanderJoueur; + + /// + /// Evénement déclencher lors du commencement d'une partie. + /// public event EventHandler? PartieDebutPartie; + + /// + /// Evénement déclencher quand il s'agit d'un nouveau tour. + /// public event EventHandler? PartieNouveauTour; + + /// + /// Evénement déclencher quand on passe la main au joueur suivant. + /// public event EventHandler? PartiePasserLaMain; + + /// + /// Evénement déclencher quand 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 de nouveau tour. + /// private void QuandPartieNouveauTour() => PartieNouveauTour?.Invoke(this, new PartieNouveauTourEventArgs(Tour, joueurs.ElementAt(courant), plateaux.ElementAt(courant), new Code(Regles.TailleCode))); + + /// + /// Méthode pour déclencher l'événement pour passer la main. + /// private void QuandPartiePasserLaMain() => PartiePasserLaMain?.Invoke(this, new PartiePasserLaMainEventArgs(joueurs.ElementAt(courant))); + + /// + /// Méthode pour déclencher l'événement si la partie est terminée. + /// + /// Liste des joueurs gagnants. + /// Liste des joueurs perdants. private void QuandPartiePartieTerminee(IReadOnlyList gagnants, IReadOnlyList perdants) => PartiePartieTerminee?.Invoke(this, new PartiePartieTermineeEventArgs(gagnants, perdants)); - + + /// + /// Liste des joueurs. + /// [DataMember] private readonly List joueurs = new List(); + + /// + /// Liste des plateaux. + /// [DataMember] private readonly List plateaux = new List(); + + /// + /// Entier correspondant au joueur courant. + /// [DataMember] private int courant = 0; + /// + /// La liste des joueurs remplit. + /// public IReadOnlyList Joueurs => joueurs; + + /// + /// Booléen pour suivre le statut de la partie. + /// [DataMember] public bool Termine { get; private set; } = false; + + /// + /// Entier correspondant au nombre de tour. + /// [DataMember] public int Tour { get; private set; } = 0; + /// + /// Regles utiliser dans la partie. + /// [DataMember] public IRegles Regles { get; private init; } + /// + /// Premier constructeur de partie. + /// + /// Les règles de la partie. public Partie(IRegles regles) { Regles = regles; } + /// + /// Deuxième constructeur de partie. + /// + /// La partie à reprendre en cours. public Partie(Partie partie) { joueurs = partie.joueurs; @@ -59,6 +136,9 @@ namespace CoreLibrary partie.PartiePartieTerminee = null; } + /// + /// Lance le déroulement de la partie. + /// public void Jouer() { if (joueurs.Count != Regles.NbJoueurs) @@ -67,6 +147,9 @@ namespace CoreLibrary DebutPartie(); } + /// + /// Demande un joueur. + /// private void DemanderJoueur() { Joueur joueurDemande = new Joueur(); @@ -75,6 +158,11 @@ namespace CoreLibrary QuandPartieDemanderJoueur(joueurDemande); } + /// + /// Connecte les joueurs à la partie. + /// + /// . + /// . private void JoueurConnecte(object? sender, JoueurSeConnecterEventArgs e) { joueurs.Add(e.Nom); @@ -90,6 +178,9 @@ namespace CoreLibrary } } + /// + /// Lance le début de la partie. + /// private void DebutPartie() { if (Tour == 0) @@ -105,11 +196,19 @@ namespace CoreLibrary NouveauTour(); } + /// + /// Permet de changer de tour. + /// private void NouveauTour() { QuandPartieNouveauTour(); } + /// + /// Ajoute un code au plateau. + /// + /// . + /// . private void PlateauAjouterCode(object? sender, PlateauAjouterCodeEventArgs e) { QuandPartiePasserLaMain(); @@ -132,6 +231,9 @@ namespace CoreLibrary } } + /// + /// La partie est terminée. + /// private void PartieTerminee() { Termine = true; From 659f8df6f148704d525d3e3697beedf26324e8fa Mon Sep 17 00:00:00 2001 From: "pauline.prady" Date: Tue, 4 Jun 2024 17:40:21 +0200 Subject: [PATCH 13/31] Documentation Partie fini --- Sources/CoreLibrary/Partie.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Sources/CoreLibrary/Partie.cs b/Sources/CoreLibrary/Partie.cs index 0709495..53bc9b8 100644 --- a/Sources/CoreLibrary/Partie.cs +++ b/Sources/CoreLibrary/Partie.cs @@ -161,8 +161,8 @@ namespace CoreLibrary /// /// Connecte les joueurs à la partie. /// - /// . - /// . + /// Sender envoie l'événement. + /// e est l'événement. private void JoueurConnecte(object? sender, JoueurSeConnecterEventArgs e) { joueurs.Add(e.Nom); @@ -207,8 +207,8 @@ namespace CoreLibrary /// /// Ajoute un code au plateau. /// - /// . - /// . + /// Sender permet d'envoyer l'événement. + /// e est l'événement. private void PlateauAjouterCode(object? sender, PlateauAjouterCodeEventArgs e) { QuandPartiePasserLaMain(); From 50fdad8dcd316f1fe523d07b10fc24799d4ddf6a Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Tue, 4 Jun 2024 18:08:45 +0200 Subject: [PATCH 14/31] doc partie --- Sources/CoreLibrary/Partie.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Sources/CoreLibrary/Partie.cs b/Sources/CoreLibrary/Partie.cs index 53bc9b8..3c31839 100644 --- a/Sources/CoreLibrary/Partie.cs +++ b/Sources/CoreLibrary/Partie.cs @@ -161,8 +161,8 @@ namespace CoreLibrary /// /// Connecte les joueurs à la partie. /// - /// Sender envoie l'événement. - /// e est l'événement. + /// La class qui appelle l'évenement; ici Joueur. + /// L'instance de l'événement PlateauAjouterCodeEventArgs créée par Joueur. private void JoueurConnecte(object? sender, JoueurSeConnecterEventArgs e) { joueurs.Add(e.Nom); @@ -207,8 +207,8 @@ namespace CoreLibrary /// /// Ajoute un code au plateau. /// - /// Sender permet d'envoyer l'événement. - /// e est l'événement. + /// La class qui appelle l'évenement; ici Plateau + /// L'instance de l'événement PlateauAjouterCodeEventArgs créée par Plateau . private void PlateauAjouterCode(object? sender, PlateauAjouterCodeEventArgs e) { QuandPartiePasserLaMain(); From d4e4b0030c4de85193cdbacff82d0e7b8ba8b78c Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Tue, 4 Jun 2024 18:11:42 +0200 Subject: [PATCH 15/31] doc manageur --- Sources/CoreLibrary/Manageurs/Manageur.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/Sources/CoreLibrary/Manageurs/Manageur.cs b/Sources/CoreLibrary/Manageurs/Manageur.cs index 5d2c145..7677e73 100644 --- a/Sources/CoreLibrary/Manageurs/Manageur.cs +++ b/Sources/CoreLibrary/Manageurs/Manageur.cs @@ -96,6 +96,7 @@ namespace CoreLibrary.Manageurs /// /// 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) From c0d33d292a25b77321c248a77845220bd8872804 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Tue, 4 Jun 2024 18:20:12 +0200 Subject: [PATCH 16/31] doc Code --- Sources/CoreLibrary/Core/Code.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/CoreLibrary/Core/Code.cs b/Sources/CoreLibrary/Core/Code.cs index 6971b89..747ba0d 100644 --- a/Sources/CoreLibrary/Core/Code.cs +++ b/Sources/CoreLibrary/Core/Code.cs @@ -5,7 +5,7 @@ using System.Runtime.Serialization; namespace CoreLibrary.Core { /// - /// Classe qui représente un code composé de jetons. + /// Classe représentant un code composé de jetons et ses différentes méthodes. /// [DataContract] public class Code From 812acd736a562c4663e2bae06e331c752673b347 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Tue, 4 Jun 2024 18:26:18 +0200 Subject: [PATCH 17/31] doc Accueil --- Sources/MauiSpark/Pages/AccueilPage.xaml.cs | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/Sources/MauiSpark/Pages/AccueilPage.xaml.cs b/Sources/MauiSpark/Pages/AccueilPage.xaml.cs index 4582923..df3c08f 100644 --- a/Sources/MauiSpark/Pages/AccueilPage.xaml.cs +++ b/Sources/MauiSpark/Pages/AccueilPage.xaml.cs @@ -1,5 +1,8 @@ namespace MauiSpark.Pages; +/// +/// Page d'accueil +/// public partial class AccueilPage : ContentPage { public AccueilPage() @@ -8,13 +11,25 @@ public partial class AccueilPage : ContentPage NavigationPage.SetHasNavigationBar(this, false); InitializeComponent(); - } - - private void QuandJouerClique(Object? sender, EventArgs e) + } + + /// + /// Événement déclenché quand le buton joué est cliqué. + /// Navigue vers la page Mode. + /// + /// L'object qui appelle l'évenement; ici le buton 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()); } + /// + /// Événement déclenché quand le buton reprendre est cliqué. + /// Navigue vers la page Reprendre. + /// + /// L'object qui appelle l'évenement; ici le buton 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()); From 11b7e77b25c8cd7ef91285684dcaf9e11868ad0d Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Tue, 4 Jun 2024 18:40:57 +0200 Subject: [PATCH 18/31] debut doc connexions --- Sources/MauiSpark/Pages/ConnexionPage.xaml.cs | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs index 680d5b5..caac228 100644 --- a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs +++ b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs @@ -3,10 +3,19 @@ using CoreLibrary.Joueurs; namespace MauiSpark.Pages; - +/// +/// Page de connexions où l'on rentre les joueurs de la partie +/// public partial class ConnexionPage : ContentPage { + /// + /// Indice du joueur à rentré. + /// private int? indice; + + /// + /// + /// private Joueur? joueurDemande; public ConnexionPage() From d7bc20f112932dd7b8cb74fe68a0fe7f6c1d3a49 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Tue, 4 Jun 2024 19:16:15 +0200 Subject: [PATCH 19/31] debut doc connexions --- Sources/MauiSpark/Pages/AccueilPage.xaml.cs | 12 ++++++++---- Sources/MauiSpark/Pages/ConnexionPage.xaml.cs | 17 +++++++++++++++-- Sources/MauiSpark/Pages/ModePage.xaml.cs | 11 +++++++++++ 3 files changed, 34 insertions(+), 6 deletions(-) diff --git a/Sources/MauiSpark/Pages/AccueilPage.xaml.cs b/Sources/MauiSpark/Pages/AccueilPage.xaml.cs index df3c08f..bf110bf 100644 --- a/Sources/MauiSpark/Pages/AccueilPage.xaml.cs +++ b/Sources/MauiSpark/Pages/AccueilPage.xaml.cs @@ -5,6 +5,10 @@ namespace MauiSpark.Pages; /// public partial class AccueilPage : ContentPage { + + /// + /// Constructeur de la page + /// public AccueilPage() { NavigationPage.SetHasBackButton(this, false); @@ -14,22 +18,22 @@ public partial class AccueilPage : ContentPage } /// - /// Événement déclenché quand le buton joué est cliqué. + /// Méthode déclenché quand le buton joué est cliqué. /// Navigue vers la page Mode. /// /// L'object qui appelle l'évenement; ici le buton Jouer - /// L'instance de l'événement EventArgs créée par le systéme. + /// L'instance de l'événement EventArgs créée par le systéme private void QuandJouerClique(Object? sender, EventArgs e) { Navigation.PushAsync(new ModePage()); } /// - /// Événement déclenché quand le buton reprendre est cliqué. + /// Méthode déclenché quand le buton reprendre est cliqué. /// Navigue vers la page Reprendre. /// /// L'object qui appelle l'évenement; ici le buton Reprendre - /// L'instance de l'événement EventArgs créée par le systéme. + /// L'instance de l'événement EventArgs créée par le systéme private void QuandReprendreClique(Object? sender, EventArgs e) { Navigation.PushAsync(new ReprendrePage()); diff --git a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs index caac228..fa4d044 100644 --- a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs +++ b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs @@ -9,15 +9,18 @@ namespace MauiSpark.Pages; public partial class ConnexionPage : ContentPage { /// - /// Indice du joueur à rentré. + /// Indice du joueur à rentré /// private int? indice; /// - /// + /// Le joueur qui est demandé /// private Joueur? joueurDemande; + /// + /// Constructeur pour la page de connexions + /// public ConnexionPage() { NavigationPage.SetHasNavigationBar(this, false); @@ -25,6 +28,11 @@ public partial class ConnexionPage : ContentPage InitializeComponent(); } + /// + /// Méthode déclenchée quand l'événement DemanderNom de partie est appelée + /// + /// La class qui appelle l'évenement; 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) @@ -36,6 +44,11 @@ public partial class ConnexionPage : ContentPage BindingContext = $"Joueur {e.Indice}"; } + /// + /// Méthode déclenché quand le buton joué est cliqué. + /// + /// L'object qui appelle l'évenement; ici le buton 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) diff --git a/Sources/MauiSpark/Pages/ModePage.xaml.cs b/Sources/MauiSpark/Pages/ModePage.xaml.cs index 203e293..f9d316c 100644 --- a/Sources/MauiSpark/Pages/ModePage.xaml.cs +++ b/Sources/MauiSpark/Pages/ModePage.xaml.cs @@ -3,8 +3,14 @@ using CoreLibrary.Regles; namespace MauiSpark.Pages; +/// +/// Page de sélection des modes jeux +/// public partial class ModePage : ContentPage { + /// + /// Constructeur de la page mode + /// public ModePage() { NavigationPage.SetHasNavigationBar(this, false); @@ -12,6 +18,11 @@ public partial class ModePage : ContentPage InitializeComponent(); } + /// + /// + /// + /// + /// private void QuandReglesPresse(Object sender, EventArgs e) { Partie partie; From f05bd665b2f77ed0bb25eeb42c26d7da0e173c58 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 12:14:15 +0200 Subject: [PATCH 20/31] doc de Mode --- Sources/MauiSpark/Pages/AccueilPage.xaml.cs | 43 ++++++++++--------- Sources/MauiSpark/Pages/ConnexionPage.xaml.cs | 29 +++++++------ Sources/MauiSpark/Pages/ModePage.xaml.cs | 32 +++++++------- 3 files changed, 54 insertions(+), 50 deletions(-) diff --git a/Sources/MauiSpark/Pages/AccueilPage.xaml.cs b/Sources/MauiSpark/Pages/AccueilPage.xaml.cs index bf110bf..2e6718e 100644 --- a/Sources/MauiSpark/Pages/AccueilPage.xaml.cs +++ b/Sources/MauiSpark/Pages/AccueilPage.xaml.cs @@ -1,15 +1,16 @@ -namespace MauiSpark.Pages; - -/// -/// Page d'accueil +namespace MauiSpark.Pages; + +/// +/// Page d'accueil de l'application. /// public partial class AccueilPage : ContentPage -{ - - /// - /// Constructeur de la page +{ + + /// + /// Constructeur de la page d'accueil. + /// Initialise les paramètres de navigation et les composants de la page. /// - public AccueilPage() + public AccueilPage() { NavigationPage.SetHasBackButton(this, false); NavigationPage.SetHasNavigationBar(this, false); @@ -17,23 +18,23 @@ public partial class AccueilPage : ContentPage InitializeComponent(); } - /// - /// Méthode déclenché quand le buton joué est cliqué. - /// Navigue vers la page Mode. - /// - /// L'object qui appelle l'évenement; ici le buton Jouer - /// L'instance de l'événement EventArgs créée par le systéme + /// + /// 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é quand le buton reprendre est cliqué. - /// Navigue vers la page Reprendre. - /// - /// L'object qui appelle l'évenement; ici le buton Reprendre - /// L'instance de l'événement EventArgs créée par le systéme + /// + /// 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()); diff --git a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs index fa4d044..2761a07 100644 --- a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs +++ b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs @@ -4,22 +4,23 @@ using CoreLibrary.Joueurs; namespace MauiSpark.Pages; /// -/// Page de connexions où l'on rentre les joueurs de la partie +/// Page de connexion où les joueurs de la partie sont entrés. /// public partial class ConnexionPage : ContentPage { /// - /// Indice du joueur à rentré + /// Indice du joueur à entrer. /// - private int? indice; + private int? indice; /// - /// Le joueur qui est demandé + /// Le joueur demandé. /// private Joueur? joueurDemande; - + /// - /// Constructeur pour la page de connexions + /// Constructeur de la page de connexion. + /// Initialise les paramètres de navigation et les composants de la page. /// public ConnexionPage() { @@ -29,11 +30,11 @@ public partial class ConnexionPage : ContentPage } /// - /// Méthode déclenchée quand l'événement DemanderNom de partie est appelée + /// Méthode déclenchée lorsque l'événement DemanderNom de partie est appelée. /// - /// La class qui appelle l'évenement; ici Partie - /// L'instance de l'événement PartieDemanderJoueurEventArgs créée par Partie - public async void QuandDemanderNom(Object? sender, PartieDemanderJoueurEventArgs 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); @@ -45,11 +46,11 @@ public partial class ConnexionPage : ContentPage } /// - /// Méthode déclenché quand le buton joué est cliqué. + /// Méthode déclenchée lorsque le bouton "Se Connecter" est cliqué. /// - /// L'object qui appelle l'évenement; ici le buton SeConnecterPresse - /// L'instance de l'événement EventArgs créée par le systéme - private void QuandSeConnecterPresse(Object sender, EventArgs e) + /// 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; diff --git a/Sources/MauiSpark/Pages/ModePage.xaml.cs b/Sources/MauiSpark/Pages/ModePage.xaml.cs index f9d316c..ac9408e 100644 --- a/Sources/MauiSpark/Pages/ModePage.xaml.cs +++ b/Sources/MauiSpark/Pages/ModePage.xaml.cs @@ -1,29 +1,31 @@ using CoreLibrary; using CoreLibrary.Regles; -namespace MauiSpark.Pages; - -/// -/// Page de sélection des modes jeux +namespace MauiSpark.Pages; + +/// +/// Page de sélection des modes de jeux. /// public partial class ModePage : ContentPage -{ - /// - /// Constructeur de la page mode +{ + /// + /// Constructeur de la page mode. + /// Initialise les paramètres de navigation et les composants de la page. /// public ModePage() { NavigationPage.SetHasNavigationBar(this, false); InitializeComponent(); - } - - /// - /// - /// - /// - /// - private void QuandReglesPresse(Object sender, EventArgs e) + } + + /// + /// Méthode déclenchée lorsque le bouton des règles est pressé. + /// Crée une nouvelle partie selon les règles sélectionnées et démarre le jeu. + /// + /// 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 QuandReglesPresse(Object sender, EventArgs e) { Partie partie; From a2ac548aa04714b7cdc8f63d236f66df577e01ae Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 12:22:03 +0200 Subject: [PATCH 21/31] doc de regles et plateau --- Sources/MauiSpark/Pages/PlateauPage.xaml.cs | 54 +++++++++++++++++++++ Sources/MauiSpark/Pages/ReglesPage.xaml.cs | 21 +++++++- 2 files changed, 73 insertions(+), 2 deletions(-) diff --git a/Sources/MauiSpark/Pages/PlateauPage.xaml.cs b/Sources/MauiSpark/Pages/PlateauPage.xaml.cs index 685a439..d8321f4 100644 --- a/Sources/MauiSpark/Pages/PlateauPage.xaml.cs +++ b/Sources/MauiSpark/Pages/PlateauPage.xaml.cs @@ -5,13 +5,36 @@ using CoreLibrary.Joueurs; 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; } + /// + /// 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}"; @@ -37,11 +60,18 @@ 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; + /// + /// 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); @@ -49,6 +79,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) @@ -73,6 +109,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 @@ -86,6 +128,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 @@ -99,6 +147,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 5004ddc..d384aa8 100644 --- a/Sources/MauiSpark/Pages/ReglesPage.xaml.cs +++ b/Sources/MauiSpark/Pages/ReglesPage.xaml.cs @@ -1,11 +1,24 @@ namespace MauiSpark.Pages; +/// +/// Page affichant les règles du jeu. +/// internal class Regles { - public string Titre { get; init; } = ""; + /// + /// Obtient ou définit le titre des règles. + /// + public string Titre { get; init; } = ""; + + /// + /// Obtient ou définit la description des règles. + /// public string Description { get; init; } = ""; } +/// +/// Page affichant les règles du jeu. +/// public partial class ReglesPage : ContentPage { private static readonly Regles reglesClassiques = new Regles() @@ -14,7 +27,11 @@ public partial class ReglesPage : ContentPage 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." }; - public ReglesPage() + /// + /// Constructeur de la page affichant les règles du jeu. + /// Initialise les paramètres de navigation et les composants de la page. + /// + public ReglesPage() { NavigationPage.SetHasNavigationBar(this, false); From 9e9990227e2c892573348c064be31ae1dd06dbd4 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 12:40:26 +0200 Subject: [PATCH 22/31] doc classement --- .../MauiSpark/Pages/ClassementPage.xaml.cs | 79 +++++++++++++++++++ 1 file changed, 79 insertions(+) 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(" ", ""))) From 271686f806e4942fbf67ab646fd9284a17f83e6f Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 12:46:55 +0200 Subject: [PATCH 23/31] =?UTF-8?q?doc=20Page=20termin=C3=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Sources/MauiSpark/Pages/ConnexionPage.xaml.cs | 5 ++++ Sources/MauiSpark/Pages/ModePage.xaml.cs | 1 + Sources/MauiSpark/Pages/ReglesPage.xaml.cs | 8 +++++++ Sources/MauiSpark/Pages/ReprendrePage.xaml.cs | 10 +++++++- Sources/MauiSpark/Pages/VictoirePage.xaml.cs | 23 +++++++++++++++++-- 5 files changed, 44 insertions(+), 3 deletions(-) diff --git a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs index 803e7fb..8e86105 100644 --- a/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs +++ b/Sources/MauiSpark/Pages/ConnexionPage.xaml.cs @@ -68,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 297255b..61b5d9f 100644 --- a/Sources/MauiSpark/Pages/ModePage.xaml.cs +++ b/Sources/MauiSpark/Pages/ModePage.xaml.cs @@ -10,6 +10,7 @@ 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() { diff --git a/Sources/MauiSpark/Pages/ReglesPage.xaml.cs b/Sources/MauiSpark/Pages/ReglesPage.xaml.cs index cb5ba19..f2ec1b5 100644 --- a/Sources/MauiSpark/Pages/ReglesPage.xaml.cs +++ b/Sources/MauiSpark/Pages/ReglesPage.xaml.cs @@ -2,8 +2,16 @@ 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); 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(); From d6801b9186a8cb13738f3946239417f4dc617c93 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 13:28:38 +0200 Subject: [PATCH 24/31] =?UTF-8?q?doc=20Vue=20termin=C3=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Vues/BoutonClassementVue.xaml.cs | 15 ++++++- .../MauiSpark/Vues/BoutonReglesVue.xaml.cs | 13 ++++++ .../MauiSpark/Vues/ImageResultatVue.xaml.cs | 13 ++++++ Sources/MauiSpark/Vues/IndicateurVue.xaml.cs | 24 ++++++++++- Sources/MauiSpark/Vues/JetonVue.xaml.cs | 40 +++++++++++++++++++ Sources/MauiSpark/Vues/ModeVue.xaml.cs | 17 ++++++++ .../MauiSpark/Vues/PartieCommenceeVue.xaml.cs | 30 ++++++++++++++ Sources/MauiSpark/Vues/ReglesVue.xaml.cs | 19 +++++++++ Sources/MauiSpark/Vues/TitreVue.xaml.cs | 12 ++++++ 9 files changed, 180 insertions(+), 3 deletions(-) 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(); From 88d6b6d2f4766ec3404336ccf2f7bd336fa13307 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 13:32:45 +0200 Subject: [PATCH 25/31] =?UTF-8?q?doc=20Evenements=20termin=C3=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Evenements/JoueurSeConnecterEventArgs.cs | 7 +++++ .../PartieDemanderJoueurJouerEventArgs.cs | 30 +++++++++++++++++++ .../Evenements/PartieNouveauTourEventArgs.cs | 26 +++++++++++++++- 3 files changed, 62 insertions(+), 1 deletion(-) diff --git a/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs b/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs index 3cea153..1c6282a 100644 --- a/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/JoueurSeConnecterEventArgs.cs @@ -7,8 +7,15 @@ namespace CoreLibrary.Evenements /// 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/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 16ea6ab..4fab79f 100644 --- a/Sources/CoreLibrary/Evenements/PartieNouveauTourEventArgs.cs +++ b/Sources/CoreLibrary/Evenements/PartieNouveauTourEventArgs.cs @@ -8,14 +8,38 @@ namespace CoreLibrary.Evenements public class PartieNouveauTourEventArgs : EventArgs { /// - /// Entier correspondant au nombre de tour. + /// 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; From 59a07074cf16bdd36204215a8e7c334ad2ce120a Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 13:36:33 +0200 Subject: [PATCH 26/31] doc Joueur --- Sources/CoreLibrary/Joueurs/Joueur.cs | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/Sources/CoreLibrary/Joueurs/Joueur.cs b/Sources/CoreLibrary/Joueurs/Joueur.cs index c8deda1..e036bc5 100644 --- a/Sources/CoreLibrary/Joueurs/Joueur.cs +++ b/Sources/CoreLibrary/Joueurs/Joueur.cs @@ -9,7 +9,7 @@ using CoreLibrary.Core; namespace CoreLibrary.Joueurs { /// - /// Classe représentant un joueur. + /// Représente un joueur. /// [DataContract] [KnownType(typeof(ReglesClassiques))] @@ -17,7 +17,7 @@ namespace CoreLibrary.Joueurs public class Joueur : IEstPersistant { /// - /// Événement déclenché lorsque le joueur se connecte. + /// Événement déclenché lorsqu'un joueur se connecte. /// public event EventHandler? JoueurSeConnecter; @@ -53,6 +53,10 @@ namespace CoreLibrary.Joueurs Nom = nom; } + /// + /// Connecte le joueur. + /// + /// Le joueur à connecter. public void SeConnecter(Joueur joueur) { if (EstConnecte) @@ -61,11 +65,20 @@ 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) { if (e.Nom != Nom) @@ -78,6 +91,12 @@ namespace CoreLibrary.Joueurs /// 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); /// From 0d3a30eb7e3b8cc002e7ee42a8ebfee44244f4d6 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 13:38:50 +0200 Subject: [PATCH 27/31] doc Robot --- Sources/CoreLibrary/Joueurs/Robot.cs | 72 +++++++++++++++++++++++----- 1 file changed, 60 insertions(+), 12 deletions(-) diff --git a/Sources/CoreLibrary/Joueurs/Robot.cs b/Sources/CoreLibrary/Joueurs/Robot.cs index e325998..c80628d 100644 --- a/Sources/CoreLibrary/Joueurs/Robot.cs +++ b/Sources/CoreLibrary/Joueurs/Robot.cs @@ -3,22 +3,37 @@ using CoreLibrary.Evenements; namespace CoreLibrary.Joueurs { + /// + /// Représente un joueur automatique (robot). + /// public class Robot : Joueur { private static int nbRobots = 0; private List? codesPossibles; + /// + /// Initialise une nouvelle instance de la classe . + /// public Robot() : base($"Naps {++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) @@ -32,60 +47,90 @@ namespace CoreLibrary.Joueurs SupprimerCodesImpossibles(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]); } + /// + /// 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]); } } + // 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); } + + // Ajoute le code à la liste des codes possibles codesPossibles!.Add(code); } } + /// + /// 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 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; } + /// + /// Supprime les codes impossibles du plateau. + /// + /// Le plateau de jeu. private void SupprimerCodesImpossibles(Plateau plateau) { if (codesPossibles == null) @@ -93,12 +138,15 @@ namespace CoreLibrary.Joueurs List indicesASupprimer = new List(); - for(int i = codesPossibles.Count - 1; i >= 0; --i) + // Pour chaque code possible + for (int i = codesPossibles.Count - 1; i >= 0; --i) { - if(!EstCodePossible(plateau, codesPossibles.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) codesPossibles.RemoveAt(indice); } From b78ba55c4f30d85e46368179f9fa71575b39fc11 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 13:40:59 +0200 Subject: [PATCH 28/31] doc Manageur --- Sources/CoreLibrary/Manageurs/Manageur.cs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/Sources/CoreLibrary/Manageurs/Manageur.cs b/Sources/CoreLibrary/Manageurs/Manageur.cs index bcaf465..e064afe 100644 --- a/Sources/CoreLibrary/Manageurs/Manageur.cs +++ b/Sources/CoreLibrary/Manageurs/Manageur.cs @@ -129,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) { @@ -143,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); From 94eff6ab1f29f08ddf11a27f26f236336a0a3e91 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 13:43:23 +0200 Subject: [PATCH 29/31] doc Persistance --- Sources/CoreLibrary/Persistance/IPersistance.cs | 10 ++++++---- Sources/CoreLibrary/Persistance/PersistanceJSON.cs | 6 +++--- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/Sources/CoreLibrary/Persistance/IPersistance.cs b/Sources/CoreLibrary/Persistance/IPersistance.cs index a15bf3e..6529c65 100644 --- a/Sources/CoreLibrary/Persistance/IPersistance.cs +++ b/Sources/CoreLibrary/Persistance/IPersistance.cs @@ -6,15 +6,17 @@ public interface IPersistance { /// - /// Charge les objets qui lui sont donnés. + /// Charge les objets de type T. /// - /// Renvoie un tableau. + /// Le type d'objet à charger. + /// Un tableau d'objets chargés. public T[] Charger() where T : IEstPersistant; /// - /// Enregistre les elements qui lui sont spécifiés. + /// Enregistre les éléments spécifiés. /// - /// Tableau d'élements à enregistrer. + /// 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 88cce08..78fa9fb 100644 --- a/Sources/CoreLibrary/Persistance/PersistanceJSON.cs +++ b/Sources/CoreLibrary/Persistance/PersistanceJSON.cs @@ -5,7 +5,7 @@ using System.Xml; namespace CoreLibrary.Persistance { /// - /// Classe PersistanceJSON, implémentant l'interface IPersistance. + /// Classe PersistanceJSON, implémentant l'interface IPersistance, pour la persistance des données au format JSON. /// public class PersistanceJSON : IPersistance { @@ -34,7 +34,7 @@ namespace CoreLibrary.Persistance } /// - /// Charge les données trouvés dans le fichier de sauvegarde. + /// 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 @@ -64,7 +64,7 @@ namespace CoreLibrary.Persistance } /// - /// Enragistre dans le fichier de sauvegarde, les éléments spécifiés. + /// 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 From 2f2b4dc9bedd526ebfd14884f46af85b6e4bfc98 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 13:50:47 +0200 Subject: [PATCH 30/31] doc regles --- Sources/CoreLibrary/Regles/IRegles.cs | 10 +++++ .../CoreLibrary/Regles/ReglesClassiques.cs | 19 ++++++++++ .../CoreLibrary/Regles/ReglesDifficiles.cs | 38 +++++++++++++++++++ 3 files changed, 67 insertions(+) diff --git a/Sources/CoreLibrary/Regles/IRegles.cs b/Sources/CoreLibrary/Regles/IRegles.cs index f97501b..b844d6a 100644 --- a/Sources/CoreLibrary/Regles/IRegles.cs +++ b/Sources/CoreLibrary/Regles/IRegles.cs @@ -26,7 +26,17 @@ /// 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 87d514d..c6b20b0 100644 --- a/Sources/CoreLibrary/Regles/ReglesClassiques.cs +++ b/Sources/CoreLibrary/Regles/ReglesClassiques.cs @@ -8,11 +8,19 @@ namespace CoreLibrary.Regles [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."; /// @@ -29,7 +37,18 @@ namespace CoreLibrary.Regles /// 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 == null ? false : 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 75c0dfc..3069bb8 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 == null ? false : 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(); } } From 7fa21229e6ea1034d28dff3ae8f26faedc72e871 Mon Sep 17 00:00:00 2001 From: "camille.turpin-etienne" Date: Wed, 5 Jun 2024 14:01:51 +0200 Subject: [PATCH 31/31] doc Partie --- Sources/CoreLibrary/Partie.cs | 71 +++++++++++++++++++++++++++-------- 1 file changed, 55 insertions(+), 16 deletions(-) diff --git a/Sources/CoreLibrary/Partie.cs b/Sources/CoreLibrary/Partie.cs index 889edd9..9c477c2 100644 --- a/Sources/CoreLibrary/Partie.cs +++ b/Sources/CoreLibrary/Partie.cs @@ -16,28 +16,32 @@ namespace CoreLibrary public class Partie : IEstPersistant { /// - /// Evénement déclencher quand il faut ajouter un joueur. + /// Evénement déclenché lorsqu'il faut ajouter un joueur à la partie. /// public event EventHandler? PartieDemanderJoueur; /// - /// Evénement déclencher lors du commencement d'une partie. + /// 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éclencher quand il s'agit d'un nouveau tour. + /// Evénement déclenché lorsqu'un nouveau tour commence. /// public event EventHandler? PartieNouveauTour; /// - /// Evénement déclencher quand on passe la main au joueur suivant. + /// Evénement déclenché lorsqu'on passe la main au joueur suivant. /// public event EventHandler? PartiePasserLaMain; /// - /// Evénement déclencher quand la partie est terminée. + /// Evénement déclenché lorsque la partie est terminée. /// public event EventHandler? PartiePartieTerminee; @@ -51,44 +55,79 @@ namespace CoreLibrary /// 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)); /// - /// Liste des joueurs. + /// 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(); /// - /// Entier correspondant au joueur courant. + /// Indice correspondant au joueur courant. /// [DataMember] private int courant = 0; + /// + /// Liste des noms des joueurs. + /// public IReadOnlyList Joueurs => joueurs.Keys.ToList(); + + /// + /// Liste des noms des robots. + /// public IReadOnlyList Robots => joueurs.Where(joueur => joueur.Value).Select(joueur => joueur.Key).ToList(); + + /// + /// Indique si la partie est terminée. + /// [DataMember] public bool Termine { get; private set; } = false; /// - /// Entier correspondant au nombre de tour. + /// Numéro du tour actuel. /// [DataMember] public int Tour { get; private set; } = 0; /// - /// Regles utiliser dans la partie. + /// Règles utilisées dans la partie. /// [DataMember] public IRegles Regles { get; private init; } /// - /// Premier constructeur de partie. + /// Premier constructeur de la partie. /// /// Les règles de la partie. public Partie(IRegles regles) @@ -97,7 +136,7 @@ namespace CoreLibrary } /// - /// Deuxième constructeur de partie. + /// Deuxième constructeur de la partie. /// /// La partie à reprendre en cours. public Partie(Partie partie) @@ -144,8 +183,8 @@ namespace CoreLibrary /// /// Connecte les joueurs à la partie. /// - /// La class qui appelle l'évenement; ici Joueur. - /// L'instance de l'événement PlateauAjouterCodeEventArgs créée par Joueur. + /// 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))); @@ -182,7 +221,7 @@ namespace CoreLibrary } /// - /// Permet de changer de tour. + /// Passe au tour suivant. /// private void NouveauTour() { @@ -195,8 +234,8 @@ namespace CoreLibrary /// /// Ajoute un code au plateau. /// - /// La class qui appelle l'évenement; ici Plateau - /// L'instance de l'événement PlateauAjouterCodeEventArgs créée par 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();