Class Joueur et Partie + methode ajouterCombinaisons dans la class Plateau

BibliothequeClasses/Jeton.cs

@@ -1,14 +1,24 @@
-namespace BibliothequeClasses
+using System;
+
+namespace BibliothequeClasses
 {
     /// <summary>
-    /// Class Jeton qui nous permet de recuperer la couleur du jeton et de pouvoir la changer 
+    /// Représente un jeton de jeu qui permet de récupérer et de modifier sa couleur.
     /// </summary>
     public abstract class Jeton
     {
-        protected Jeton(Couleur couleur) 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe Jeton avec la couleur spécifiée.
+        /// </summary>
+        /// <param name="couleur">La couleur du jeton.</param>
+        protected Jeton(Couleur couleur)
         {
             this.Couleur = couleur;
         }
+
+        /// <summary>
+        /// Obtient la couleur du jeton.
+        /// </summary>
         public Couleur Couleur
         {
             get;

BibliothequeClasses/JetonIndicateur.cs

@@ -7,20 +7,23 @@ using System.Threading.Tasks;
 namespace BibliothequeClasses
 {
     /// <summary>
-    /// Class fille de la class Jeton
-    /// Class JetonIndicateur qui créé un jeton du joueur avec une des couleurs de l'enum couleur
+    /// Représente un jeton indicateur, une classe dérivée de la classe Jeton.
     /// </summary>
     public class JetonIndicateur : Jeton
     {
-        public JetonIndicateur(Couleur couleur) 
-            :base(couleur)
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe JetonIndicateur avec la couleur spécifiée.
+        /// </summary>
+        /// <param name="couleur">La couleur du jeton.</param>
+        /// <exception cref="ArgumentException">Levée si la couleur spécifiée n'est pas Noir ou Blanc.</exception>
+        public JetonIndicateur(Couleur couleur)
+            : base(couleur)
         {
-            if(couleur < Couleur.Noir) 
+            if (couleur < Couleur.Noir)
             {
-                throw new ArgumentException("La couleur doit etre Noir ou Blanche");
+                throw new ArgumentException("La couleur doit être Noir ou Blanc");
             }
-
-
         }
     }
 }
+

BibliothequeClasses/JetonJoueur.cs

@@ -7,15 +7,19 @@ using System.Threading.Tasks;
 namespace BibliothequeClasses
 {
     /// <summary>
-    /// Class fille de la class Jeton
-    /// Class JetonJoueur qui créé un jeton du joueur avec une des couleurs de l'enum couleur
+    /// Représente un jeton joueur, une classe dérivée de la classe Jeton.
     /// </summary>
     public class JetonJoueur : Jeton
     {
-        public JetonJoueur(Couleur couleur) 
-            :base(couleur)
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe JetonJoueur avec la couleur spécifiée.
+        /// </summary>
+        /// <param name="couleur">La couleur du jeton.</param>
+        public JetonJoueur(Couleur couleur)
+            : base(couleur)
         {
-            
+
         }
     }
 }
+

BibliothequeClasses/Joueur.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System;
+
+namespace BibliothequeClasses
+{
+    /// <summary>
+    /// Représente un joueur dans une partie.
+    /// </summary>
+    public class Joueur
+    {
+        private Plateau plateau;
+        private bool gagne;
+
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="Joueur"/> avec le nom spécifié.
+        /// </summary>
+        /// <param name="nom">Le nom du joueur.</param>
+        public Joueur(string nom)
+        {
+            this.Nom = nom;
+            this.plateau = new Plateau();
+        }
+
+        /// <summary>
+        /// Obtient ou définit le nom du joueur.
+        /// </summary>
+        public string Nom
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Joue une combinaison pour ce joueur sur le plateau.
+        /// </summary>
+        /// <param name="combinaisonJoueur">La combinaison à jouer.</param>
+        public void JouerCombinaison(CombinaisonJoueur combinaisonJoueur)
+        {
+            gagne = plateau.AjouterCombinaison(combinaisonJoueur);
+        }
+
+        /// <summary>
+        /// Détermine si le joueur a gagné la partie.
+        /// </summary>
+        /// <returns>True si le joueur a gagné, sinon False.</returns>
+        public bool AGagne()
+        {
+            return gagne;
+        }
+    }
+}

BibliothequeClasses/Partie.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BibliothequeClasses
+{
+    /// <summary>
+    /// Représente une partie du jeu.
+    /// </summary>
+    public class Partie
+    {
+        private int tour;
+        private Joueur joueur1;
+        private Joueur joueur2;
+        private Joueur joueurCourant;
+
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe Partie avec les noms des joueurs.
+        /// </summary>
+        /// <param name="nomJoueur1">Le nom du premier joueur.</param>
+        /// <param name="nomJoueur2">Le nom du deuxième joueur.</param>
+        public Partie(string nomJoueur1, string nomJoueur2)
+        {
+            this.tour = 1;
+            this.joueur1 = new Joueur(nomJoueur1);
+            this.joueur2 = new Joueur(nomJoueur2);
+            this.joueurCourant = this.joueur1;
+        }
+
+        /// <summary>
+        /// Récupère le joueur qui joue actuellement.
+        /// </summary>
+        /// <returns>Le joueur actuel.</returns>
+        public Joueur GetJoueur()
+        {
+            return this.joueurCourant;
+        }
+
+        /// <summary>
+        /// Passe la main au prochain joueur.
+        /// </summary>
+        public void PasserlaMain()
+        {
+            if (this.joueurCourant == this.joueur1)
+            {
+                this.joueurCourant = this.joueur2;
+            }
+            else
+            {
+                this.joueurCourant = this.joueur1;
+            }
+            tour++;
+        }
+
+        /// <summary>
+        /// Détermine si la partie est terminée.
+        /// </summary>
+        /// <returns>True si la partie est terminée, sinon False.</returns>
+        public bool EstTerminer()
+        {
+            const int nbMaxTour = 24;
+            if (joueurCourant.AGagne())
+            {
+                return true;
+            }
+
+            if (tour == nbMaxTour)
+            {
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
+

BibliothequeClasses/Plateau.cs

@@ -3,14 +3,12 @@ using System.ComponentModel.DataAnnotations;
 using System.Reflection;
 using System.Collections.Generic;
 
-
-
 namespace BibliothequeClasses
 {
 
     /// <summary>
-    /// Class plateau qui initialise deux tableaux à 12.
-    /// Il a deux methodes une pour ajouter une combinaison dans le tableaux et une autres pour verifier si le tableau est plein.
+    /// Représente le plateau de jeu qui initialise deux tableaux de taille 12.
+    /// Il possède deux méthodes : une pour ajouter une combinaison dans le tableau et une autre pour vérifier si le tableau est plein.
     /// </summary>
     public class Plateau
     {
@@ -19,23 +17,32 @@ namespace BibliothequeClasses
         private CombinaisonJoueur[] lesCombinaisonsJoueur = new CombinaisonJoueur[tailleMax];
         private Combinaison[] lesCombinaisonsIndicateur = new CombinaisonIndicateur[tailleMax];
         private int index = 0;
+
+        /// <summary>
+        /// Ajoute une combinaison de joueur au plateau.
+        /// </summary>
+        /// <param name="combinaisonJoueur">La combinaison du joueur à ajouter.</param>
+        /// <returns>True si la combinaison correspond à la combinaison secrète, sinon False.</returns>
         public bool AjouterCombinaison(CombinaisonJoueur combinaisonJoueur)
         {
-            if (estComplet() == false)
+            if (EstComplet())
             {
-                lesCombinaisonsJoueur[index] = combinaisonJoueur;
-                index++;
-                return true;
-            }
-            else
-            {
-                throw  new Exception("Le plateau est plein, impossible d'ajouter une combinaison supplémentaire.");
+                throw new Exception("Le plateau est plein, impossible d'ajouter une combinaison supplémentaire.");
             }
+
+            lesCombinaisonsJoueur[index] = combinaisonJoueur;
+            index++;
+            return combinaisonSecrete.EstEgal(combinaisonJoueur);
         }
 
-        public bool estComplet()
+        /// <summary>
+        /// Vérifie si le plateau est complet.
+        /// </summary>
+        /// <returns>True si le plateau est plein, sinon False.</returns>
+        public bool EstComplet()
         {
             return index >= tailleMax;
         }
     }
 }
+

BibliothequeClasses/abc.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BibliothequeClasses
+{
+    public abstract class Combinaison;
+    public class CombinaisonSecrete : Combinaison
+    {
+        public bool EstEgal(CombinaisonJoueur combinaisonJoueur)
+        {
+            return true;
+        }
+    };
+    public class CombinaisonJoueur : Combinaison;
+    public class CombinaisonIndicateur : Combinaison;
+
+}

BibliothequeClasses/couleurs.cs

@@ -1,15 +1,17 @@
-namespace BibliothequeClasses
-{
-	/// <summary>
-	///	Enumeration des 6 couleurs que peuvent prendre les jetons
-	/// </summary>
-	public enum Couleur
-	{
-		Rouge,
-		Bleu,
-		Vert,
-		Jaune,
-		Noir = 100,
-		Blanc,
-	}
-}
+using System;
+
+namespace BibliothequeClasses
+{
+    /// <summary>
+    /// Énumération représentant les 6 couleurs que peuvent prendre les jetons.
+    /// </summary>
+    public enum Couleur
+    {
+        Rouge,
+        Bleu,
+        Vert,
+        Jaune,
+        Noir = 100,
+        Blanc,
+    }
+}