Beispiel #1
0
        private int RetornaMelhorMaoPartidaFinalizada_antiga(IPartida p)
        {
            if (p.Rodadas.Last().TipoRodada != TipoRodada.River)
            {
                throw new DealerException("Rodada inválida para avaliação de mãos.");
            }

            // Recupera as cartas
            Carta[] CartasBanca = new Carta[] {
                p.Banca.Cartas[0],
                p.Banca.Cartas[1]
            };
            Carta[] CartasJogador = new Carta[] {
                p.Jogador.Cartas[0],
                p.Jogador.Cartas[1]
            };
            Carta[] CartasMesa = p.CartasMesa;

            ConstrutorMelhorMao construtorMao    = new ConstrutorMelhorMao();
            MaoTexasHoldem      melhorMaoJogador = construtorMao.GetMelhorMao(CartasMesa.Union(CartasJogador).ToList());

            construtorMao = new ConstrutorMelhorMao();
            MaoTexasHoldem melhorMaoBanca = construtorMao.GetMelhorMao(CartasMesa.Union(CartasBanca).ToList());

            return(melhorMaoJogador.Compara(melhorMaoBanca));
        }
Beispiel #2
0
        public void DuasDuplas_1()
        {
            MelhorMao     m       = new MelhorMao();
            IList <Carta> entrada = new List <Carta>()
            {
                new Carta(14, Enuns.Naipe.Ouros),
                new Carta(2, Enuns.Naipe.Copas),
                new Carta(6, Enuns.Naipe.Espadas),
                new Carta(4, Enuns.Naipe.Copas),
                new Carta(6, Enuns.Naipe.Paus),
                new Carta(14, Enuns.Naipe.Copas),
                new Carta(3, Enuns.Naipe.Copas),
            };

            MaoTexasHoldem atual    = m.AvaliaMao(entrada);
            MaoTexasHoldem esperado = new MaoTexasHoldem()
            {
                MeuJogo    = Enuns.Jogo.DuasDuplas,
                MelhorJogo = new List <Carta>()
                {
                    new Carta(14, Enuns.Naipe.Ouros),
                    new Carta(14, Enuns.Naipe.Copas),
                    new Carta(6, Enuns.Naipe.Espadas),
                    new Carta(6, Enuns.Naipe.Paus),
                    new Carta(4, Enuns.Naipe.Copas),
                }
            };

            Assert.AreEqual(esperado, atual);
        }
Beispiel #3
0
        public void Straight_3()
        {
            MelhorMao     m       = new MelhorMao();
            IList <Carta> entrada = new List <Carta>()
            {
                new Carta(12, Enuns.Naipe.Espadas),
                new Carta(2, Enuns.Naipe.Espadas),
                new Carta(14, Enuns.Naipe.Espadas),
                new Carta(13, Enuns.Naipe.Espadas),
                new Carta(10, Enuns.Naipe.Paus),
                new Carta(9, Enuns.Naipe.Copas),
                new Carta(11, Enuns.Naipe.Paus),
            };

            MaoTexasHoldem atual    = m.AvaliaMao(entrada);
            MaoTexasHoldem esperado = new MaoTexasHoldem()
            {
                MeuJogo    = Enuns.Jogo.Straight,
                MelhorJogo = new List <Carta>()
                {
                    new Carta(14, Enuns.Naipe.Espadas),
                    new Carta(13, Enuns.Naipe.Espadas),
                    new Carta(12, Enuns.Naipe.Espadas),
                    new Carta(11, Enuns.Naipe.Paus),
                    new Carta(10, Enuns.Naipe.Paus),
                }
            };

            Assert.AreEqual(esperado, atual);
        }
Beispiel #4
0
        public void Four_2()
        {
            MelhorMao     m       = new MelhorMao();
            IList <Carta> entrada = new List <Carta>()
            {
                new Carta(2, Enuns.Naipe.Copas),
                new Carta(10, Enuns.Naipe.Copas),
                new Carta(7, Enuns.Naipe.Copas),
                new Carta(2, Enuns.Naipe.Paus),
                new Carta(2, Enuns.Naipe.Espadas),
                new Carta(2, Enuns.Naipe.Ouros),
                new Carta(13, Enuns.Naipe.Espadas),
            };

            MaoTexasHoldem atual    = m.AvaliaMao(entrada);
            MaoTexasHoldem esperado = new MaoTexasHoldem()
            {
                MeuJogo    = Enuns.Jogo.Four,
                MelhorJogo = new List <Carta>()
                {
                    new Carta(2, Enuns.Naipe.Copas),
                    new Carta(2, Enuns.Naipe.Paus),
                    new Carta(2, Enuns.Naipe.Espadas),
                    new Carta(2, Enuns.Naipe.Ouros),
                    new Carta(13, Enuns.Naipe.Espadas),
                }
            };

            Assert.AreEqual(esperado, atual);
        }
Beispiel #5
0
        public void StraightFlush_1()
        {
            MelhorMao     m       = new DealerTH.MelhorMao();
            IList <Carta> entrada = new List <Carta>()
            {
                new Carta(5, Enuns.Naipe.Copas),
                new Carta(2, Enuns.Naipe.Copas),
                new Carta(14, Enuns.Naipe.Ouros),
                new Carta(7, Enuns.Naipe.Paus),
                new Carta(14, Enuns.Naipe.Copas),
                new Carta(3, Enuns.Naipe.Copas),
                new Carta(4, Enuns.Naipe.Copas),
            };

            MaoTexasHoldem atual    = m.AvaliaMao(entrada);
            MaoTexasHoldem esperado = new MaoTexasHoldem()
            {
                MeuJogo    = Enuns.Jogo.StraightFlush,
                MelhorJogo = new List <Carta>()
                {
                    new Carta(5, Enuns.Naipe.Copas),
                    new Carta(4, Enuns.Naipe.Copas),
                    new Carta(3, Enuns.Naipe.Copas),
                    new Carta(2, Enuns.Naipe.Copas),
                    new Carta(1, Enuns.Naipe.Copas),
                }
            };

            Assert.AreEqual(esperado, atual);
        }
        public void PartidaJogadorGanha_1()
        {
            uint
                stackJogadorInicial            = 500,
                valorStackJogadorAposPagarAnt  = 495,
                valorStackJogadorAposPagarFlop = 485,
                valorPortMesaAposPreFlop       = (5 + 10 + 10);

            IJogador  jog    = new DummyJogadorTHB(PartidaIntegracaoTest.configPadrao, stackJogadorInicial);
            IJogador  banca  = new Banca(PartidaIntegracaoTest.configPadrao);
            ICroupier dealer = new Croupier(
                new Comum.Mesa(PartidaIntegracaoTest.configPadrao),
                banca,
                jog
                );

            dealer.IniciarNovaPartida(); //pre Jogo

            // Pre-jogo (Paga ant, distribui carta ao jogador, adiciona rodada)
            IPartida p = dealer.Mesa.PartidasAtuais[jog];

            p.AddToPote(jog.PagarValor(PartidaIntegracaoTest.configPadrao.Ant), TipoJogadorTHB.Jogador);
            jog.ReceberCarta(new Carta(10, Enuns.Naipe.Copas), new Carta(9, Enuns.Naipe.Copas));
            p.AddRodada(new RodadaTHB(Enuns.TipoRodada.PreFlop, p.PoteAgora, null));
            Assert.IsTrue(valorStackJogadorAposPagarAnt == jog.Stack);

            // Pre-flop (Pagar para ver flop)
            p.AddToPote(jog.PagarValor(PartidaIntegracaoTest.configPadrao.Flop), TipoJogadorTHB.Jogador);
            p.AddToPote(banca.PagarValor(PartidaIntegracaoTest.configPadrao.Flop), TipoJogadorTHB.Banca);
            p.AddRodada(new RodadaTHB(Enuns.TipoRodada.Flop, p.PoteAgora, p.CartasMesa));

            Assert.IsTrue(jog.Stack == valorStackJogadorAposPagarFlop); // stack jogador
            Assert.IsTrue(p.PoteAgora == valorPortMesaAposPreFlop);     // pote banca

            // Flop (Revelar Flop - Perguntar pagar turn)
            Carta[] flop = new Carta[] { new Carta(12, Enuns.Naipe.Copas), new Carta(13, Enuns.Naipe.Copas), new Carta(11, Enuns.Naipe.Copas) };
            typeof(Partida).GetProperty("Flop").SetValue(p, flop);
            p.AddRodada(new RodadaTHB(Enuns.TipoRodada.Turn, p.PoteAgora, p.CartasMesa));

            // Turn
            Carta turn = new Carta(4, Enuns.Naipe.Paus);

            typeof(Partida).GetProperty("Turn").SetValue(p, turn);
            p.AddRodada(new RodadaTHB(Enuns.TipoRodada.River, p.PoteAgora, p.CartasMesa));

            // River
            Carta river = new Carta(8, Enuns.Naipe.Ouros);

            typeof(Partida).GetProperty("River").SetValue(p, river);


            banca.ReceberCarta(new Carta(2, Enuns.Naipe.Espadas), new Carta(3, Enuns.Naipe.Espadas));

            Carta[] CartasBanca = new Carta[] {
                p.Banca.Cartas[0],
                p.Banca.Cartas[1]
            };
            Carta[] CartasJogador = new Carta[] {
                p.Jogador.Cartas[0],
                p.Jogador.Cartas[1]
            };
            Carta[] CartasMesa = p.CartasMesa;

            ConstrutorMelhorMao construtorMao    = new ConstrutorMelhorMao();
            MaoTexasHoldem      melhorMaoJogador = construtorMao.GetMelhorMao(CartasMesa.Union(CartasJogador).ToList());

            construtorMao = new ConstrutorMelhorMao();
            MaoTexasHoldem melhorMaoBanca = construtorMao.GetMelhorMao(CartasMesa.Union(CartasBanca).ToList());

            Assert.IsTrue(melhorMaoJogador.Compara(melhorMaoBanca) == 1);

            p.JogadorGanhador = VencedorPartida.Jogador;
            p.Jogador.ReceberValor(p.PoteAgora);

            Assert.IsTrue(p.Jogador.Stack == 510);
        }