Exemplo n.º 1
0
        public Bot Call(Bot user, ref int previous)
        {
            if (user.Chips > MainPoker.Call)
            {
                MainPoker.Raising      = false;
                user.Turn              = false;
                user.Chips            -= MainPoker.Call;
                user.ChipsTextBox.Text = @"Chips : " + user.Chips;
                user.StatusLabel.Text  = @"Call " + (MainPoker.Call + previous);
                PotText  = PotText + MainPoker.Call;
                previous = int.Parse(user.StatusLabel.Text.Substring(5));
                user     = (Bot)MainPoker.GetStatus(user);
                return(user);
            }

            MainPoker.Raising     = false;
            user.Turn             = false;
            user.StatusLabel.Text = @"Call " + user.Chips;
            if (user.Chips != null)
            {
                PotText = PotText + (int)user.Chips;
            }
            else
            {
                MessageBox.Show(@"Unexpected error has occured !");
                Application.Exit();
            }
            user.Chips = 0;
            previous   = int.Parse(user.StatusLabel.Text.Substring(5));
            user       = (Bot)MainPoker.GetStatus(user);
            return(user);
        }
Exemplo n.º 2
0
 public void ConstructorTest3()
 {
     var j    = new Joueur("joueur");
     var main = new MainPoker(j, new CartePoker[] {
         JeuPoker.Cartes.AsCarreau, JeuPoker.Cartes.AsCoeur, JeuPoker.Cartes.AsTrefle, JeuPoker.Cartes.AsPique,
         JeuPoker.Cartes.RoiCarreau
     });
 }
Exemplo n.º 3
0
        public void EqualsTest1()
        {
            MainPoker target = ConstructeurMainPoker("Joueur1", JeuPoker.Cartes.AsCoeur, JeuPoker.Cartes.AsCarreau,
                                                     new CartePoker[] { JeuPoker.Cartes.AsTrefle, JeuPoker.Cartes.AsPique, JeuPoker.Cartes.DeuxCarreau, JeuPoker.Cartes.DeuxCoeur, JeuPoker.Cartes.DeuxTrefle });
            object obj = ConstructeurMainPoker("Joueur2", JeuPoker.Cartes.AsCoeur, JeuPoker.Cartes.AsCarreau,
                                               new CartePoker[] { JeuPoker.Cartes.AsTrefle, JeuPoker.Cartes.AsPique, JeuPoker.Cartes.DeuxCarreau, JeuPoker.Cartes.DeuxCoeur, JeuPoker.Cartes.DeuxTrefle });

            Assert.IsTrue(target.Equals(obj));
        }
Exemplo n.º 4
0
 public Bot Check(Bot user, out int previous)
 {
     user.StatusLabel.Text  = @"Check";
     user.ChipsTextBox.Text = @"Chips : " + user.Chips;
     user.Turn         = false;
     MainPoker.Raising = false;
     previous          = 0;
     user = (Bot)MainPoker.GetStatus(user);
     return(user);
 }
Exemplo n.º 5
0
 public Bot Fold(Bot user)
 {
     MainPoker.Raising      = false;
     user.StatusLabel.Text  = @"Fold";
     user.ChipsTextBox.Text = @"Chips : " + user.Chips;
     user.Turn     = false;
     user.FoldTurn = true;
     user          = (Bot)MainPoker.GetStatus(user);
     return(user);
 }
Exemplo n.º 6
0
        public void EqualsTest2()
        {
            Joueur j = new Joueur("Joueur");

            j.Carte1 = JeuPoker.Cartes.AsCoeur;
            j.Carte2 = JeuPoker.Cartes.AsCarreau;
            var       board  = new CartePoker[] { JeuPoker.Cartes.AsTrefle, JeuPoker.Cartes.AsPique, JeuPoker.Cartes.DeuxCarreau, JeuPoker.Cartes.DeuxCoeur, JeuPoker.Cartes.DeuxTrefle };
            MainPoker target = new MainPoker(j, board);
            object    obj    = new MainPoker(j, board);

            Assert.IsTrue(target.Equals(obj));
        }
Exemplo n.º 7
0
        public void EqualsTest4()
        {
            Joueur j = new Joueur("Joueur");

            j.Carte1 = JeuPoker.Cartes.AsCoeur;
            j.Carte2 = JeuPoker.Cartes.AsCarreau;
            var       board1 = new CartePoker[] { JeuPoker.Cartes.AsTrefle, JeuPoker.Cartes.AsPique, JeuPoker.Cartes.DeuxCarreau, JeuPoker.Cartes.DeuxCoeur, JeuPoker.Cartes.DeuxTrefle };
            var       board2 = new CartePoker[] { JeuPoker.Cartes.RoiTrefle, JeuPoker.Cartes.RoiPique, JeuPoker.Cartes.RoiCarreau, JeuPoker.Cartes.RoiCoeur, JeuPoker.Cartes.DameTrefle };
            MainPoker target = new MainPoker(j, board1);
            object    obj    = new MainPoker(j, board2);

            Assert.IsFalse(target.Equals(obj));
        }
Exemplo n.º 8
0
 public Bot Raised(Bot user, ref int previous)
 {
     user.Chips            -= Convert.ToInt32(MainPoker.Raise - previous);
     user.StatusLabel.Text  = @"Raise " + MainPoker.Raise;
     user.ChipsTextBox.Text = @"Chips : " + user.Chips;
     PotText            = PotText + Convert.ToInt32(MainPoker.Raise);
     MainPoker.Call     = Convert.ToInt32(MainPoker.Raise);
     MainPoker.TempCall = MainPoker.Call;
     MainPoker.Raising  = true;
     user.Turn          = false;
     previous           = int.Parse(user.StatusLabel.Text.Substring(6));
     user = (Bot)MainPoker.GetStatus(user);
     return(user);
 }
Exemplo n.º 9
0
        public void ConstructorTest1()
        {
            var j = new Joueur("joueur");
            var exceptionLevee = false;
            var message        = "Une exception ArgumentException aurait du être levée";

            try
            {
                var main = new MainPoker(j, null);
            }
            catch (ArgumentException)
            {
                exceptionLevee = true;
            }
            catch (Exception ex)
            {
                exceptionLevee = false;
                message        = "Une exception ArgumentException aurait du être levée au lieu d'une " + ex.ToString();
            }
            Assert.IsTrue(exceptionLevee, message);
        }
Exemplo n.º 10
0
        /// <summary>
        /// Déclenche une vérification de couleur carte
        /// </summary>
        /// <param name="carte"></param>
        /// <param name="carteAttendue"></param>
        private void VerifierCarte(CouleurCarte couleurAttendue, MainPoker main, int indexCarte)
        {
            var carte = main.ResultatMain.MainGagnante[indexCarte];

            Assert.AreEqual(carte.Couleur, couleurAttendue, string.Format("{0} : carte n°{1}", main.ResultatMain.TypeCombinaison, indexCarte + 1));
        }
Exemplo n.º 11
0
        public void CompareToTest()
        {
            var j1 = new Joueur("Joueur1");

            j1.Elimine = false;
            var j2 = new Joueur("Joueur2");

            j2.Elimine = false;
            var jElim = new Joueur("Joueur Eliminé");

            jElim.Elimine = true;

            // Quinte flush 1 & 2
            j1.Carte1 = JeuPoker.Cartes.AsCoeur;
            j1.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var quinteFlush1 = new MainPoker(j1, new CartePoker[] { JeuPoker.Cartes.RoiCoeur, JeuPoker.Cartes.ValetCoeur, JeuPoker.Cartes.HuitTrefle, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.DixCoeur });

            quinteFlush1.DeterminerCombinaison();
            j2.Carte1 = JeuPoker.Cartes.AsCoeur;
            j2.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var quinteFlush2 = new MainPoker(j2, new CartePoker[] { JeuPoker.Cartes.TroisCoeur, JeuPoker.Cartes.DeuxCoeur, JeuPoker.Cartes.HuitTrefle, JeuPoker.Cartes.CinqCoeur, JeuPoker.Cartes.QuatreCoeur });

            quinteFlush2.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.QuinteFlush, quinteFlush1.ResultatMain.TypeCombinaison);
            Assert.AreEqual(TypeCombinaison.QuinteFlush, quinteFlush2.ResultatMain.TypeCombinaison);
            Assert.IsTrue(quinteFlush1.CompareTo(quinteFlush2) > 0, "Quinte flush à l'AS > Quinte flush au 5");

            //  Quinte flush 2 & Carre 1
            j1.Carte1 = JeuPoker.Cartes.AsCoeur;
            j1.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var carre1 = new MainPoker(j1, new CartePoker[] { JeuPoker.Cartes.NeufCoeur, JeuPoker.Cartes.NeufTrefle, JeuPoker.Cartes.NeufPique, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.DixCoeur });

            carre1.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Carre, carre1.ResultatMain.TypeCombinaison);
            Assert.IsTrue(quinteFlush2.CompareTo(carre1) > 0, "Quinte flush au 5 > Carre au 9");

            // Carre 1 & Carre 2
            j2.Carte1 = JeuPoker.Cartes.DeuxCoeur;
            j2.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var carre2 = new MainPoker(j2, new CartePoker[] { JeuPoker.Cartes.DeuxCarreau, JeuPoker.Cartes.DeuxPique, JeuPoker.Cartes.DeuxTrefle, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.DixCoeur });

            carre2.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Carre, carre2.ResultatMain.TypeCombinaison);
            Assert.IsTrue(carre1.CompareTo(carre2) > 0, "Carre au 9 > Carre au 2");

            //  Carré 2 & Full 1
            j1.Carte1 = JeuPoker.Cartes.AsCoeur;
            j1.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var full1 = new MainPoker(j1, new CartePoker[] { JeuPoker.Cartes.NeufCoeur, JeuPoker.Cartes.NeufTrefle, JeuPoker.Cartes.AsCarreau, JeuPoker.Cartes.AsTrefle, JeuPoker.Cartes.DixCoeur });

            full1.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Full, full1.ResultatMain.TypeCombinaison);
            Assert.IsTrue(carre2.CompareTo(full1) > 0, "Carre au 9 > Full des As par les 9 ");

            // Full 1 & Full 2
            j2.Carte1 = JeuPoker.Cartes.AsCoeur;
            j2.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var full2 = new MainPoker(j2, new CartePoker[] { JeuPoker.Cartes.NeufCoeur, JeuPoker.Cartes.NeufTrefle, JeuPoker.Cartes.AsCarreau, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.DixCoeur });

            full2.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Full, full2.ResultatMain.TypeCombinaison);
            Assert.IsTrue(full1.CompareTo(full2) > 0, "Full des As par les 9  > Full des 9 par les As");

            //  Full 2 & Couleur 1
            j1.Carte1 = JeuPoker.Cartes.AsCoeur;
            j1.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var couleur1 = new MainPoker(j1, new CartePoker[] { JeuPoker.Cartes.NeufCoeur, JeuPoker.Cartes.NeufTrefle, JeuPoker.Cartes.CinqCoeur, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.DixCoeur });

            couleur1.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Couleur, couleur1.ResultatMain.TypeCombinaison);
            Assert.IsTrue(full2.CompareTo(couleur1) > 0, "Full des 9 par les As > Couleur à l'As");

            // Couleur 1 & Couleur 2
            j2.Carte1 = JeuPoker.Cartes.DeuxCarreau;
            j2.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var couleur2 = new MainPoker(j2, new CartePoker[] { JeuPoker.Cartes.TroisCarreau, JeuPoker.Cartes.DeuxPique, JeuPoker.Cartes.CinqCarreau, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.SeptCarreau });

            couleur2.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Couleur, couleur2.ResultatMain.TypeCombinaison);
            Assert.IsTrue(couleur1.CompareTo(couleur2) > 0, "Couleur à l'as > Couleur à la dame");

            //  Couleur 2 & quinte 1
            j1.Carte1 = JeuPoker.Cartes.DeuxCarreau;
            j1.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var quinte1 = new MainPoker(j1, new CartePoker[] { JeuPoker.Cartes.HuitPique, JeuPoker.Cartes.DeuxPique, JeuPoker.Cartes.ValetTrefle, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.DixCoeur });

            quinte1.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Quinte, quinte1.ResultatMain.TypeCombinaison);
            Assert.IsTrue(couleur2.CompareTo(quinte1) > 0, "Couleur à la dame > Quinte à la Dame");

            // quinte 1 & quinte 2
            j2.Carte1 = JeuPoker.Cartes.DeuxCarreau;
            j2.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var quinte2 = new MainPoker(j2, new CartePoker[] { JeuPoker.Cartes.TroisTrefle, JeuPoker.Cartes.AsCoeur, JeuPoker.Cartes.QuatrePique, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.CinqPique });

            quinte2.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Quinte, quinte2.ResultatMain.TypeCombinaison);
            Assert.IsTrue(quinte1.CompareTo(quinte2) > 0, "Quinte à la Dame > Quinte au 5");

            //  Quinte 2 & brelan 1
            j1.Carte1 = JeuPoker.Cartes.DeuxCarreau;
            j1.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var brelan1 = new MainPoker(j1, new CartePoker[] { JeuPoker.Cartes.HuitPique, JeuPoker.Cartes.DamePique, JeuPoker.Cartes.ValetTrefle, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.DameCarreau });

            brelan1.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Brelan, brelan1.ResultatMain.TypeCombinaison);
            Assert.IsTrue(quinte2.CompareTo(brelan1) > 0, "Quinte au 5 > Brelan de dames");

            // brelan 1 & brelan 2
            j2.Carte1 = JeuPoker.Cartes.DeuxCarreau;
            j2.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var brelan2 = new MainPoker(j2, new CartePoker[] { JeuPoker.Cartes.TroisTrefle, JeuPoker.Cartes.SeptCoeur, JeuPoker.Cartes.SeptPique, JeuPoker.Cartes.SeptCarreau, JeuPoker.Cartes.CinqPique });

            brelan2.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Brelan, brelan1.ResultatMain.TypeCombinaison);
            Assert.IsTrue(brelan1.CompareTo(brelan2) > 0, "Brelan de dames > Brelan de sept");

            //  brelan 2 & Double paire 1
            j1.Carte1 = JeuPoker.Cartes.DeuxCarreau;
            j1.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var doublepaire1 = new MainPoker(j1, new CartePoker[] { JeuPoker.Cartes.RoiTrefle, JeuPoker.Cartes.RoiPique, JeuPoker.Cartes.HuitCarreau, JeuPoker.Cartes.HuitCoeur, JeuPoker.Cartes.DameCarreau });

            doublepaire1.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.DoublePaire, doublepaire1.ResultatMain.TypeCombinaison);
            Assert.IsTrue(brelan2.CompareTo(doublepaire1) > 0, "Brelan de sept > Double paire Roi-Huit");

            // Double paire 1 & Double paire 2
            j2.Carte1 = JeuPoker.Cartes.RoiTrefle;
            j2.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var doublepaire2 = new MainPoker(j2, new CartePoker[] { JeuPoker.Cartes.TroisTrefle, JeuPoker.Cartes.SeptCoeur, JeuPoker.Cartes.SeptPique, JeuPoker.Cartes.RoiCoeur, JeuPoker.Cartes.CinqPique });

            doublepaire2.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.DoublePaire, doublepaire2.ResultatMain.TypeCombinaison);
            Assert.IsTrue(doublepaire1.CompareTo(doublepaire2) > 0, "Double paire Roi-Huit > Double paire Roi-Sept");

            //  Double paire 2 & paire 1
            j1.Carte1 = JeuPoker.Cartes.AsCarreau;
            j1.Carte2 = JeuPoker.Cartes.AsCoeur;
            var paire1 = new MainPoker(j1, new CartePoker[] { JeuPoker.Cartes.RoiTrefle, JeuPoker.Cartes.CinqPique, JeuPoker.Cartes.TroisCarreau, JeuPoker.Cartes.HuitCoeur, JeuPoker.Cartes.DameCarreau });

            paire1.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Paire, paire1.ResultatMain.TypeCombinaison);
            Assert.IsTrue(doublepaire2.CompareTo(paire1) > 0, "Double paire Roi-Huit > Paire d'As");

            // paire 1 & paire 2
            j2.Carte1 = JeuPoker.Cartes.RoiTrefle;
            j2.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var paire2 = new MainPoker(j2, new CartePoker[] { JeuPoker.Cartes.TroisTrefle, JeuPoker.Cartes.SeptCoeur, JeuPoker.Cartes.SeptPique, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.CinqPique });

            paire2.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Paire, paire2.ResultatMain.TypeCombinaison);
            Assert.IsTrue(paire1.CompareTo(paire2) > 0, "Paire d'As > Paire Sept");

            //  paire 2 & carte 1
            j1.Carte1 = JeuPoker.Cartes.AsCarreau;
            j1.Carte2 = JeuPoker.Cartes.HuitPique;
            var carte1 = new MainPoker(j1, new CartePoker[] { JeuPoker.Cartes.RoiTrefle, JeuPoker.Cartes.CinqPique, JeuPoker.Cartes.TroisCarreau, JeuPoker.Cartes.QuatreCoeur, JeuPoker.Cartes.DameCarreau });

            carte1.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Carte, carte1.ResultatMain.TypeCombinaison);
            Assert.IsTrue(paire2.CompareTo(carte1) > 0, "Paire Sept > As");

            // carte 1 & carte 2
            j2.Carte1 = JeuPoker.Cartes.DameCoeur;
            j2.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var carte2 = new MainPoker(j2, new CartePoker[] { JeuPoker.Cartes.TroisTrefle, JeuPoker.Cartes.SeptCoeur, JeuPoker.Cartes.SixTrefle, JeuPoker.Cartes.DeuxCoeur, JeuPoker.Cartes.HuitTrefle });

            carte2.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.Carte, carte2.ResultatMain.TypeCombinaison);
            Assert.IsTrue(carte1.CompareTo(carte2) > 0, "As > Dame");

            // Carte2 à Quinte flush éliminé
            jElim.Carte1 = JeuPoker.Cartes.AsCoeur;
            jElim.Carte2 = JeuPoker.Cartes.NeufCarreau;
            var quinteFlushElimine = new MainPoker(jElim, new CartePoker[] { JeuPoker.Cartes.RoiCoeur, JeuPoker.Cartes.ValetCoeur, JeuPoker.Cartes.HuitTrefle, JeuPoker.Cartes.DameCoeur, JeuPoker.Cartes.DixCoeur });

            quinteFlushElimine.DeterminerCombinaison();
            Assert.AreEqual(TypeCombinaison.QuinteFlush, quinteFlushElimine.ResultatMain.TypeCombinaison);
            Assert.IsTrue(carte2.CompareTo(quinteFlushElimine) > 0, "Dame > Quinte flush éliminée");
        }