Example #1
0
        /// <summary>
        ///     Calcul de la chance
        /// </summary>
        /// <param name="dices">Tableau des 5 dé</param>
        /// <returns>Valeur que peut prendre la combinaison</returns>
        public int calculateChance(Dice[] dices)
        {
            int sum = 0;

            // Somme des 5 dés
            for (int i = 0; i < 5; i++)
            {
                sum += dices[i].Number;
            }

            return sum;
        }
Example #2
0
        /// <summary>
        ///     Initialise une nouvelle instance de la classe Player
        /// </summary>
        /// <param name="id">Id du joueur</param>
        /// <param name="name">Nom du joueur</param>
        /// <param name="score">Score du joueur</param>
        public Player(String name)
        {
            _gameRef = new EntityRef<Game>();
            _aCombinations = new EntitySet<Combination>(AttachCombination, DetachCombination);

            Name = name;

            NbRoll = 3;
            IsPlayable = false;
            IsStart = false;
            TotalScore = 0;

            Dices = new Dice[5];

            for (int i = 0; i < 5; i++)
            {
                Dice dice = new Dice();

                Dices[i] = dice;
            }
        }
Example #3
0
        /// <summary>
        ///     Compte le nombre de dés ayant comme valeur le nombre passé en paramètre
        /// </summary>
        /// <param name="number">Nombre à rechercher</param>
        /// <param name="dices">Tableau des 5 dés</param>
        /// <returns>Nombre de dés correspondants</returns>
        public int countNumberOf(int number, Dice[] dices)
        {
            int sum = 0;

            foreach (Dice dice in dices)
            {
                if (dice.Number == number)
                {
                    sum++;
                }
            }

            return sum;
        }
Example #4
0
 public int Calcul(Dice[] dices)
 {
     Value = this._calcul(dices);
     return Value;
 }
Example #5
0
 /// <summary>
 ///     Compte le nombre de dés 1 obtenus et calcule la valeur de la combinaison
 /// </summary>
 /// <param name="dices">Tableau des 5 dés</param>
 /// <returns>Valeur que peut prendre la combinaison avec ces dés</returns>
 public int calculateAces(Dice[] dices)
 {
     return 1 * countNumberOf(1, dices);
 }
Example #6
0
        /// <summary>
        ///     Contrôle si un Yahtzee est possible
        /// </summary>
        /// <param name="dices">Tableau des 5 dé</param>
        /// <returns>Valeur que peut prendre la combinaison</returns>
        public int calculateYahtzee(Dice[] dices)
        {
            int sum = 0;

            // Boucle pour chaque nombre de 1 à 6
            for (int i = 1; i <= 6; i++)
            {

                int cpt = 0;

                // Boucle pour chaque dé
                for (int j = 0; j < 5; j++)
                {
                    // Incrémentation du compteur à chaque fois qu'un dé correspond au nombre en cours
                    if (dices[j].Number == i)
                    {
                        cpt++;
                    }

                    // Si les 5 dés sont identiques, le yahtzee est possible
                    if (cpt > 4)
                    {
                        sum = 50;   // La valeur de cette combinaison sera toujours de 50
                    }
                }
            }

            return sum;
        }
Example #7
0
 /// <summary>
 ///     Compte le nombre de dés 2 obtenus et calcule la valeur de la combinaison
 /// </summary>
 /// <param name="dices">Tableau des 5 dés</param>
 /// <returns>Valeur que peut prendre la combinaison avec ces dés</returns>
 public int calculateTwos(Dice[] dices)
 {
     return 2 * countNumberOf(2, dices);
 }
Example #8
0
 /// <summary>
 ///     Compte le nombre de dés 3 obtenus et calcule la valeur de la combinaison
 /// </summary>
 /// <param name="dices">Tableau des 5 dés</param>
 /// <returns>Valeur que peut prendre la combinaison avec ces dés</returns>
 public int calculateThrees(Dice[] dices)
 {
     return 3 * countNumberOf(3, dices);
 }
Example #9
0
        /// <summary>
        ///     Contrôle si un brelan est possible et calcule la valeur de la combinaison
        /// </summary>
        /// <param name="dices">Tableau des 5 dés</param>
        /// <returns>Valeur que peut prendre la combinaison avec ces dés</returns>
        public int calculateThreeOfAKind(Dice[] dices)
        {
            int sum = 0;
            bool threeOfAKind = false;

            // Boucle pour chaque nombre de 1 à 6
            for (int i = 1; i <= 6; i++)
            {
                int cpt = 0;
                // Boucle pour chaque dé
                for (int j = 0; j < 5; j++)
                {
                    // Incrémentation du compteur à chaque fois qu'un dé correspond au nombre en cours
                    if (dices[j].Number == i)
                    {
                        cpt++;
                    }

                    // S'il y a au moins 3 dés identiques, le brelan est possible
                    if (cpt > 2)
                    {
                        threeOfAKind = true;
                    }
                }
            }

            // Si un brelan est possible, on calcule la valeur de la combinaison
            if (threeOfAKind)
            {
                for (int k = 0; k < 5; k++)
                {
                    sum += dices[k].Number;
                }
            }

            return sum;
        }
Example #10
0
        /// <summary>
        ///     Contrôle si une petite suite est possible
        /// </summary>
        /// <param name="dices">Tableau des 5 dé</param>
        /// <returns>Valeur que peut prendre la combinaison</returns>
        public int calculateSmallStraight(Dice[] dices)
        {
            int sum = 0;
            int[] i = new int[5];

            // Récupération des valeurs de chaque dé
            i[0] = dices[0].Number;
            i[1] = dices[1].Number;
            i[2] = dices[2].Number;
            i[3] = dices[3].Number;
            i[4] = dices[4].Number;

            // Tri des valeurs par ordre croissant
            Array.Sort(i);

            // Un problème se pose lorsque deux des nombres sont identiques.
            // Ceci est résolu en déplaçant le nombre qui est le même
            // à l'extrémité de la matrice et en l'ignorant
            for (int j = 0; j < 4; j++)
            {
                int temp = 0;

                if (i[j] == i[j + 1])
                {
                    temp = i[j];

                    for (int k = j; k < 4; k++)
                    {
                        i[k] = i[k + 1];
                    }

                    i[4] = temp;
                }
            }

            // Test s'il y a une petite suite
            if (((i[0] == 1) && (i[1] == 2) && (i[2] == 3) && (i[3] == 4)) ||
                ((i[0] == 2) && (i[1] == 3) && (i[2] == 4) && (i[3] == 5)) ||
                ((i[0] == 3) && (i[1] == 4) && (i[2] == 5) && (i[3] == 6)) ||
                ((i[1] == 1) && (i[2] == 2) && (i[3] == 3) && (i[4] == 4)) ||
                ((i[1] == 2) && (i[2] == 3) && (i[3] == 4) && (i[4] == 5)) ||
                ((i[1] == 3) && (i[2] == 4) && (i[3] == 5) && (i[4] == 6)))
            {
                sum = 30; // La valeur de cette combinaison sera toujours de 30
            }

            return sum;
        }
Example #11
0
 /// <summary>
 ///     Compte le nombre de dés 6 obtenus et calcule la valeur de la combinaison
 /// </summary>
 /// <param name="dices">Tableau des 5 dés</param>
 /// <returns>Valeur que peut prendre la combinaison avec ces dés</returns>
 public int calculateSixes(Dice[] dices)
 {
     return 6 * countNumberOf(6, dices);
 }
Example #12
0
        /// <summary>
        ///     Contrôle si une grande suite est possible
        /// </summary>
        /// <param name="dices">Tableau des 5 dés</param>
        /// <returns>Valeur que peut prendre la combinaison</returns>
        public int calculateLargeStraight(Dice[] dices)
        {
            int sum = 0;
            int[] i = new int[5];

            // Récupération des valeurs de chaque dé
            i[0] = dices[0].Number;
            i[1] = dices[1].Number;
            i[2] = dices[2].Number;
            i[3] = dices[3].Number;
            i[4] = dices[4].Number;

            // Tri des valeurs par ordre croissant
            Array.Sort(i);

            // Test s'il y a une grande suite
            if (((i[0] == 1) &&
                 (i[1] == 2) &&
                 (i[2] == 3) &&
                 (i[3] == 4) &&
                 (i[4] == 5)) ||

                ((i[0] == 2) &&
                 (i[1] == 3) &&
                 (i[2] == 4) &&
                 (i[3] == 5) &&
                 (i[4] == 6)))
            {
                sum = 40; // La valeur de cette combinaison sera toujours de 40
            }

            return sum;
        }
Example #13
0
        /// <summary>
        ///     Contrôle si un full est possible 
        /// </summary>
        /// <param name="dices">Tableau des 5 dés</param>
        /// <returns>Valeur que peut prendre la combinaison</returns>
        public int calculateFullHouse(Dice[] dices)
        {
            int sum = 0;
            int[] i = new int[5];

            // Récupération des valeurs de chaque dé
            i[0] = dices[0].Number;
            i[1] = dices[1].Number;
            i[2] = dices[2].Number;
            i[3] = dices[3].Number;
            i[4] = dices[4].Number;

            // Tri des valeurs par ordre croissant
            Array.Sort(i);

            // Test s'il y a un full
            if ((((i[0] == i[1]) && (i[1] == i[2])) && // Three of a Kind
                  (i[3] == i[4]) && // Two of a Kind
                  (i[2] != i[3])) ||

                 ((i[0] == i[1]) && // Two of a Kind
                 ((i[2] == i[3]) && (i[3] == i[4])) && // Three of a Kind
                  (i[1] != i[2])))
            {
                sum = 25; // La valeur de cette combinaison sera toujours de 25
            }

            return sum;
        }
Example #14
0
 /// <summary>
 ///     Compte le nombre de dés 4 obtenus et calcule la valeur de la combinaison
 /// </summary>
 /// <param name="dices">Tableau des 5 dés</param>
 /// <returns>Valeur que peut prendre la combinaison avec ces dés</returns>
 public int calculateFours(Dice[] dices)
 {
     return 4 * countNumberOf(4, dices);
 }
Example #15
0
 /// <summary>
 ///     Compte le nombre de dés 5 obtenus et calcule la valeur de la combinaison
 /// </summary>
 /// <param name="dices">Tableau des 5 dés</param>
 /// <returns>Valeur que peut prendre la combinaison avec ces dés</returns>
 public int calculateFives(Dice[] dices)
 {
     return 5 * countNumberOf(5, dices);
 }
Example #16
0
 /// <summary>
 ///     Mise à jour de l'image du dé en fonction de la propriété "keep"
 /// </summary>
 /// <param name="dice"></param>
 protected virtual void UpdateDiceProperties(Dice dice)
 {
     if (dice.Keep == true)
         {
             dice.Image = "/Resources/de" + dice.Number + "k.png";
         }
         else
         {
             dice.Image = "/Resources/de" + dice.Number + ".png";
         }
 }