Ejemplo n.º 1
0
    void comprarCard()
    {
        //Compra carta aleatória do baralho
        int        rn = Random.Range(0, baralho.Count);
        GameObject go = new GameObject("numero: " + baralho[rn].numero + ", cor: " + baralho[rn].cor);

        go.tag = "piece";
        PieceMovement pm = go.AddComponent <PieceMovement>();

        pm.numero = baralho[rn].numero;
        pm.cor    = baralho[rn].cor;
        BoxCollider2D bc = go.AddComponent <BoxCollider2D>();

        bc.size      = new Vector2(1, 2);
        bc.isTrigger = true;
        SpriteRenderer renderer = go.AddComponent <SpriteRenderer>();

        renderer.sortingLayerName = "02";
        renderer.sprite           = Resources.Load <Sprite>("teste");

        Mao bd = GameObject.Find("Mao").GetComponent <Mao>();

        baralho.RemoveAt(rn);
        bd.AdicionarPeca(go);
        //cm.Adicionar(go);
        //cm.Posicionar(go);
    }
Ejemplo n.º 2
0
 public Jogador(int numero, Mao mao, string nome, bool auto)
 {
     Numero = numero;
     Mao    = mao;
     Nome   = nome;
     Auto   = auto;
 }
Ejemplo n.º 3
0
        public void IniciaJogo()
        {
            var deck        = new Deck();
            var mao         = new Mao(deck);
            var jogador     = new Jogador();
            var logicaPoker = new LogicaPoker();
            var flop        = new Mao(deck);
            var turn        = new Mao(deck);
            var river       = new Mao(deck);

            string[] maoCompleta = new string[7];

            var numeroJogadores = ObterNumeroJogadores();


            var listaJogadores = jogador.ObterListaDeJogadores(numeroJogadores);

            deck.Embaralhar();
            mao.PuxarCartas(2);
            mao.Sort();
            //var novamao =


            for (int i = 0; 1 <= maoCompleta.Length; i++)
            {
                maoCompleta[i] = mao[i];
            }


            foreach (var itens in listaJogadores)
            {
                //itens.Mao = mao;
                //itens.Score = (int)_logicaPoker.Score(mao);
                //itens.MaoDePoker = _logicaPoker.Score(mao);

                //Console.WriteLine(String.Format("Jogador: {0}, Mão: {1}, Mão De Poker: {2}",itens.Nome,itens.Mao, Enum.GetName(typeof(MaosDePoker), itens.MaoDePoker)));
            }

            flop.PuxarCartas(3);
            flop.Sort();
            var cartasFlop = flop;

            turn.PuxarCartas(1);
            turn.Sort();
            var cartaTurn = turn;

            river.PuxarCartas(1);
            river.Sort();
            var cartaRiver = river;



            var vencedor = listaJogadores.OrderByDescending(a => a.Score).FirstOrDefault();

            if (!vencedor.Score.Equals((int)MaosDePoker.None))
            {
                Console.WriteLine(String.Format("Vencedor: {0} ", vencedor.Nome));
            }
            Console.WriteLine();
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Verifica quais são as pedras possíveis de serem jogadas para as pontas informadas
        /// </summary>
        /// <param name="pEsquerda"></param>
        /// <param name="pDireita"></param>
        /// <returns></returns>
        public List <Pedra> ObterJogadasPossiveis(int pEsquerda, int pDireita)
        {
            var pontas = new[] { pEsquerda, pDireita };

            return(Mao
                   .Where(p => pontas.Contains(p.Lado1) || pontas.Contains(p.Lado2))
                   .ToList());
        }
Ejemplo n.º 5
0
 /*
  * é straight e flush
  */
 private static bool EhStraightFlush(Mao h)
 {
     if (EhStraight(h) && EhFlush(h))
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 6
0
        public void NaoDeveGerarClassificacaoCasoHajaCartasDuplicadas()
        {
            var cartaBuilderGerada = new CartaBuilder("A;O|K;C", "Q;C|10;C|K;C|8;P|A;O");
            var maoGerada          = new Mao(cartaBuilderGerada.CartasJogador[0], cartaBuilderGerada.CartasJogador[1]);

            string mensagemDeErro = Assert.Throws <Exception>(() => maoGerada.Classificar(cartaBuilderGerada.CartasMesa)).Message;

            Assert.Equal($"{Ressource.MaoMsgCartasClassificacaoDuplicadas} A;O|K;C", mensagemDeErro);
        }
Ejemplo n.º 7
0
 void Start()
 {
     mao              = GameObject.Find("Mao").GetComponent <Mao>();
     turno            = false;
     pecaSelecionada  = null;
     primeiraJogada   = false;
     fazendoMovimento = false;
     roundTime        = 5;
     //FazMovimento();
 }
Ejemplo n.º 8
0
        public void DeveClassificarEGerarPontuacaoDaJogada(string cartasJogador, string cartasMesa, long pontuacaoEsperada, string classificacaoEsperada)
        {
            var cartaBuilderGerada = new CartaBuilder(cartasJogador, cartasMesa);
            var maoGerada          = new Mao(cartaBuilderGerada.CartasJogador[0], cartaBuilderGerada.CartasJogador[1]);

            maoGerada.Classificar(cartaBuilderGerada.CartasMesa);

            Assert.Equal(classificacaoEsperada, maoGerada.Classificacao);
            Assert.Equal(pontuacaoEsperada, maoGerada.Pontuacao);
        }
Ejemplo n.º 9
0
        private static void Main(string[] args)
        {
            int  currentPlayer = 0;
            bool reverse       = false;

            game = new Mao();

            game.AddRule(new CustomRule("", RuleResponse.ResponseType.Reverse, RuleResponse.ResponseType.Legal, CustomRule.MatchType.Card, new Card(Suit.Clubs, CardValue.Eight)));

            Console.WriteLine("Welcome to Mao");
            GetPlayers();

            game.Deal();

            while (true)
            {
                Console.WriteLine($"{game.Players[currentPlayer].Name}'s turn:");
                Console.WriteLine($"The active card is {game.ActiveCard}");

                var card = GetCard(currentPlayer);

                var outcome = PlayCard(currentPlayer, card);

                foreach (var response in outcome)
                {
                    Console.WriteLine(response.Reason);
                    if (response.Response == RuleResponse.ResponseType.Reverse)
                    {
                        reverse = !reverse;
                    }
                    if (response.Penalty != null)
                    {
                        game.Players[currentPlayer].Hand.Add(response.Penalty);
                    }
                }

                if (reverse)
                {
                    currentPlayer--;
                    if (currentPlayer < 0)
                    {
                        currentPlayer = game.Players.Count - 1;
                    }
                }
                else
                {
                    currentPlayer++;
                    if (currentPlayer == game.Players.Count)
                    {
                        currentPlayer = 0;
                    }
                }
            }
        }
        public Carta Eh_Carta_Alta(Mao mao1)
        {
            Carta maiorCarta = mao1.Cartas.First();

            for (int i = 0; i < mao1.Cartas.Count; i++)
            {
                maiorCarta = DescobreMaiorCarta(maiorCarta, mao1.Cartas[i]);
            }

            return maiorCarta;
        }
Ejemplo n.º 11
0
 /*
  * todas as cartas são do mesmo naipe
  */
 private static bool EhFlush(Mao h)
 {
     if (h[0].Naipe == h[1].Naipe &&
         h[1].Naipe == h[2].Naipe &&
         h[2].Naipe == h[3].Naipe &&
         h[3].Naipe == h[4].Naipe)
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 12
0
 public static void ImprimeMao(Mao mao, bool verso, bool posicoes)
 {
     Linha(mao.QntCartas());
     if (mao.Visibilidade == true && verso == true)
     {
         ImprimeCartas(mao.Cartas, true);
     }
     else
     {
         ImprimeCartas(mao.Cartas, false);
     }
 }
Ejemplo n.º 13
0
        /// <summary>
        /// Inicia uma instância da MaoBuilder. Apenas preenche as cartas do jogador
        /// </summary>
        /// <param name="cartasJogador">Sequência de cartas do jogador separadas por pipe (|)</param>
        public MaoBuilder(string cartasJogador)
        {
            var arrCartasJogador = cartasJogador.Split("|");
            var cartas           = new List <Carta>();

            foreach (var carta in arrCartasJogador)
            {
                cartas.Add(new Carta(carta));
            }

            Mao = new Mao(cartas[0], cartas[1]);
        }
Ejemplo n.º 14
0
        public static void Player(int indice, JogoPifpaf jogo, bool mostrarInf, bool verso)
        {
            Mao mao = jogo.Jogadores[indice].Mao;

            if (jogo.JogadorAtual.Equals(jogo.Jogadores[indice]))
            {
                Console.Write(jogo.Jogadores[indice].Numero + "- ");
                Console.Write(jogo.Jogadores[indice].Nome);
                Print(" << Vez...     ", ConsoleColor.DarkCyan);
            }
            else
            {
                Console.Write(jogo.Jogadores[indice].Numero + "- " + jogo.Jogadores[indice].Nome + "           ");
            }

            //trincas e sequencias
            if (mostrarInf)
            {
                Console.Write("T " + jogo.Jogadores[indice].Mao.Trincas + " - S " + jogo.Jogadores[indice].Mao.Sequencias);
            }
            Console.WriteLine();
            Linha(jogo.Jogadores[indice].Mao.QntCartas());

            //grupos
            if (mostrarInf)
            {
                Console.Write("    ");
                foreach (var carta in mao.Cartas)
                {
                    ImprimeGrupo(carta.Grupo);
                    Console.Write("   ");
                }
                Console.WriteLine("   ");
            }

            if (verso)
            {
                ImprimeCartas(mao.Cartas, true);
            }
            else
            {
                ImprimeCartas(mao.Cartas, false);
            }


            //posicoes
            if (mostrarInf)
            {
                int indiceSelecionado = jogo.Jogadores[indice].Mao.selec;
                Posicoes(jogo.Jogadores[indice].Mao.QntCartas(), indiceSelecionado);
            }
        }
Ejemplo n.º 15
0
 /*
  * deve ser flush e straight e ter certas cartas
  */
 private static bool EhRoyalFlush(Mao h)
 {
     if (EhStraight(h) && EhFlush(h) &&
         h[0].Rank == Rank.As &&
         h[1].Rank == Rank.Dez &&
         h[2].Rank == Rank.Valete &&
         h[3].Rank == Rank.Dama &&
         h[4].Rank == Rank.Rei)
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 16
0
    IEnumerator DarDano(GameObject obj, GameObject atacante)
    {
        //animações dos efeitos
        Mao player = transform.GetComponent <Mao>();

        yield return(new WaitForSeconds(0.4f));

        if (obj && obj.transform.GetChild(0))
        {
            obj.transform.GetChild(0).GetComponent <CartaNaMesa>().Defesa      -= atacante.transform.GetChild(0).GetComponent <CartaNaMesa>().Ataque;
            atacante.transform.GetChild(0).GetComponent <CartaNaMesa>().Defesa -= obj.transform.GetChild(0).GetComponent <CartaNaMesa>().Ataque;
        }
        player.Audio(2);
    }
        public bool Tem_Dois_Pares(Mao mao1)
        {
            var cartas = mao1.Cartas;

            var listaDePares = new Dictionary<Carta, Carta>();
            for (int index = 0; index < cartas.Count; index++)
            {
                for (int i = index + 1; i < cartas.Count; i++)
                {
                    if (cartas[index].Numero == cartas[i].Numero)
                    {
                        listaDePares.Add(cartas[index], cartas[i]);
                    }
                }
            }
            return listaDePares.Count == 2;
        }
Ejemplo n.º 18
0
 /*
  * ou uma trinca e um par
  * ou um par e uma trinca
  */
 private static bool EhFullHouse(Mao h)
 {
     // par e trinca
     if (h[0].Rank == h[1].Rank &&
         h[2].Rank == h[3].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return(true);
     }
     // trinca e par
     if (h[0].Rank == h[1].Rank &&
         h[1].Rank == h[2].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 19
0
 /*
  * ou as quatro primeiras tem o mesmo rank
  * ou as quatro últimas tem o mesmo rank
  */
 private static bool EhQuadra(Mao h)
 {
     // quatro primeiras
     if (h[0].Rank == h[1].Rank &&
         h[1].Rank == h[2].Rank &&
         h[2].Rank == h[3].Rank)
     {
         return(true);
     }
     // quatro últimas
     if (h[1].Rank == h[2].Rank &&
         h[2].Rank == h[3].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 20
0
        public void DeveGerarMao()
        {
            var cartas = new List <Carta>
            {
                _primeiraCarta,
                _segundaCarta
            };

            var maoEsperada = new
            {
                Cartas        = cartas,
                Classificacao = "",
                Pontuacao     = Int64.Parse("0")
            };

            var maoGerada = new Mao(_primeiraCarta, _segundaCarta);

            maoEsperada.ToExpectedObject().ShouldMatch(maoGerada);
        }
        public void evaluateMaos()
        {
            AvaliadorDaMao mao1Avaliador = new AvaliadorDaMao(cartasNaMao1);
            AvaliadorDaMao mao2Avaliador = new AvaliadorDaMao(cartasNaMao2);

            Mao mao1 = mao1Avaliador.AvalieMao();
            Mao mao2 = mao2Avaliador.AvalieMao();

            Console.WriteLine("\n\n\n\n\nJogador 1: " + mao1);
            Console.WriteLine("\nJogador 2: " + mao2);

            if (mao1 > mao2)
            {
                Console.WriteLine("Jogador 1 venceu! ┏(;))┛");
            }
            else if (mao1 < mao2)
            {
                Console.WriteLine("Jogador 2 venceu! ┏( ͡;))┛");
            }
            else
            {
                if (mao1Avaliador.ValoresDaMao.Total > mao2Avaliador.ValoresDaMao.Total)
                {
                    Console.WriteLine("Jogador 1 venceu! ┏( ͡;))┛");
                }
                else if (mao1Avaliador.ValoresDaMao.Total < mao2Avaliador.ValoresDaMao.Total)
                {
                    Console.WriteLine("Jogador 2 venceu! ┏( ͡;) )┛");
                }
                else if (mao1Avaliador.ValoresDaMao.MaiorCarta > mao2Avaliador.ValoresDaMao.MaiorCarta)
                {
                    Console.WriteLine("Jogador 1 venceu! ┏( ͡;))┛");
                }
                else if (mao1Avaliador.ValoresDaMao.MaiorCarta < mao2Avaliador.ValoresDaMao.MaiorCarta)
                {
                    Console.WriteLine("Jogador 2 venceu! ┏( ͡;))┛");
                }
                else
                {
                    Console.WriteLine("Ninguém ganhou");
                }
            }
        }
        public bool Eh_Um_Par(Mao mao1)
        {
            var cartas = mao1.Cartas;

            Carta primeira = cartas.First();
            bool tempar = false;
            for (int index = 0; index < cartas.Count; index++)
            {
                for (int i = index + 1; i < cartas.Count; i++)
                {
                    if (cartas[index].Numero == cartas[i].Numero)
                    {
                        tempar = true;
                        break;
                    }
                }

            }
            return tempar;
        }
Ejemplo n.º 23
0
 /*
  * confere que o rank difere em 1
  * isso é possível porque assumimos
  * que está ordernado
  */
 private static bool EhStraight(Mao h)
 {
     if (h[0].Rank == h[1].Rank - 1 &&
         h[1].Rank == h[2].Rank - 1 &&
         h[2].Rank == h[3].Rank - 1 &&
         h[3].Rank == h[4].Rank - 1)
     {
         return(true);
     }
     // caso special porque Az é menor que dez
     if (h[1].Rank == Rank.Dez &&
         h[2].Rank == Rank.Valete &&
         h[3].Rank == Rank.Dama &&
         h[4].Rank == Rank.Rei &&
         h[0].Rank == Rank.As)
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 24
0
 /*
  * ou a 1a carta igual a 2a carta
  * ou a 2a carta igual a 3a carta
  * ou a 3a carta igual a 4a carta
  * ou a 4a carta igual a 5a carta
  */
 private static bool EhPar(Mao h)
 {
     if (h[0].Rank == h[1].Rank)
     {
         return(true);
     }
     if (h[1].Rank == h[2].Rank)
     {
         return(true);
     }
     if (h[2].Rank == h[3].Rank)
     {
         return(true);
     }
     if (h[3].Rank == h[4].Rank)
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 25
0
 /*
 * assume:
 * -> a mão deve estar ordenada
 * -> as cartas não podem repetir
 */
 public static Combinacao CalculaScore(Mao h)
 {
     if (EhRoyalFlush(h))
     {
         return Combinacao.RoyalFlush;
     }
     if (EhStraightFlush(h))
     {
         return Combinacao.StraightFlush;
     }
     if (EhQuadra(h))
     {
         return Combinacao.Quadra;
     }
     if (EhFullHouse(h))
     {
         return Combinacao.FullHouse;
     }
     if (EhFlush(h))
     {
         return Combinacao.Flush;
     }
     if (EhStraight(h))
     {
         return Combinacao.Straight;
     }
     if (EhTrinca(h))
     {
         return Combinacao.Trinca;
     }
     if (EhDoisPares(h))
     {
         return Combinacao.DoisPares;
     }
     if (EhPar(h))
     {
         return Combinacao.Par;
     }
     return Combinacao.Nenhuma;
 }
Ejemplo n.º 26
0
 /*
  * assume:
  * -> a mão deve estar ordenada
  * -> as cartas não podem repetir
  */
 public static Combinacao CalculaScore(Mao h)
 {
     if (EhRoyalFlush(h))
     {
         return(Combinacao.RoyalFlush);
     }
     if (EhStraightFlush(h))
     {
         return(Combinacao.StraightFlush);
     }
     if (EhQuadra(h))
     {
         return(Combinacao.Quadra);
     }
     if (EhFullHouse(h))
     {
         return(Combinacao.FullHouse);
     }
     if (EhFlush(h))
     {
         return(Combinacao.Flush);
     }
     if (EhStraight(h))
     {
         return(Combinacao.Straight);
     }
     if (EhTrinca(h))
     {
         return(Combinacao.Trinca);
     }
     if (EhDoisPares(h))
     {
         return(Combinacao.DoisPares);
     }
     if (EhPar(h))
     {
         return(Combinacao.Par);
     }
     return(Combinacao.Nenhuma);
 }
Ejemplo n.º 27
0
 /*
  * ou as três primeiras tem mesmo rank
  * ou as três do meio tem mesmo rank
  * ou as três últimas tem mesmo rank
  */
 private static bool EhTrinca(Mao h)
 {
     // três primeiras
     if (h[0].Rank == h[1].Rank &&
         h[1].Rank == h[2].Rank)
     {
         return(true);
     }
     // três do meio
     if (h[1].Rank == h[2].Rank &&
         h[2].Rank == h[3].Rank)
     {
         return(true);
     }
     // três últimas
     if (h[2].Rank == h[3].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 28
0
 /*
  * ou dois pares no início
  * ou dois pares separados pela carta do meio
  * ou dois pares no final
  */
 private static bool EhDoisPares(Mao h)
 {
     // dois pares no início
     if (h[0].Rank == h[1].Rank &&
         h[2].Rank == h[3].Rank)
     {
         return(true);
     }
     // dois pares separados pela carta do meio
     if (h[0].Rank == h[1].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return(true);
     }
     // dois pares no final
     if (h[1].Rank == h[2].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 29
0
 /*
 * ou dois pares no início
 * ou dois pares separados pela carta do meio
 * ou dois pares no final
 */
 private static bool EhDoisPares(Mao h)
 {
     // dois pares no início
     if (h[0].Rank == h[1].Rank &&
         h[2].Rank == h[3].Rank)
     {
         return true;
     }
     // dois pares separados pela carta do meio
     if (h[0].Rank == h[1].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return true;
     }
     // dois pares no final
     if (h[1].Rank == h[2].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return true;
     }
     return false;
 }
Ejemplo n.º 30
0
    void ReciboMulliganClientRpc(int rn, int rn2)
    {
        var mullig = GameObject.Find("MulliganBackground");

        mullig.GetComponent <Animator>().SetTrigger("Event");
        Mao player = GameObject.Find("Canvas").GetComponent <Mao>();
        PlayerAdversario player2 = GameObject.Find("Canvas").GetComponent <PlayerAdversario>();

        if (!IsOwner)
        {
            mullig.GetComponent <MulliganBehaviour>().CriarCarta(rn);
            player.CriarCartaInicio(rn);
            player2.CriarCarta(rn2);
        }
        else
        {
            mullig.GetComponent <MulliganBehaviour>().CriarCarta(rn2);
            player.CriarCartaInicio(rn2);
            player2.CriarCarta(rn);
        }
        GameObject.Find("Canvas").GetComponent <EventControllerBehaviour>().BotaoInteragivel(IsOwner);
    }
Ejemplo n.º 31
0
    public void OnMulliganClick()
    {
        transform.GetChild(0).GetComponent <Selectable>().interactable = false;

        //ntwrkid = NetworkClient.connection.identity;
        //playerid = ntwrkid.GetComponent<PlayerId>();

        Mao player     = canvas.GetComponent <Mao>();
        int rejeitados = 0;

        for (int i = 0; i != cartas.Count; i++)
        {
            SetAnimacao(40);
            print(i);
            if (cartas[i].transform.childCount != 1)
            {
                cartas[i].GetComponent <Animator>().SetBool("Destruir", true);
                player.DestruirCartaBaralho(player.mao[i]);
                player.distanciamentoCartasMaximo -= 20;
                player.mao.RemoveAt(i);
                canvas.GetComponent <EventControllerBehaviour>().PlayerAtual.TirarCartaBaralhoInimigoServerRpc(i);
                cartas.RemoveAt(i);
                SetAnimacao(40);
                player.SetAnimacaoInicial(player.distanciamentoCartasMaximo);
                rejeitados++;
                i--;
                //  playerid
            }
            while (rejeitados != 0)
            {
                int rnd = Random.Range(0, canvas.GetComponent <EventControllerBehaviour>().numeroCartas);
                canvas.GetComponent <EventControllerBehaviour>().PlayerAtual.AdicionarAoBaralhoServerRpc(rnd);
                CriarCarta(rnd);
                SetAnimacao(40);
                rejeitados--;
            }
            final = true;
        }
    }
    private void Start()
    {
        testandoNoEditor = false;

        DefinirPlayerIdJogadores();

        PlayerHost.PedidoMulliganHost();
        //botao.transform.GetChild(0).GetComponent<Text>().text = "INICIAR";
        turno = Turnos.DecidirIniciante;

        Inimigo = GetComponent <PlayerAdversario>();
        Player  = GetComponent <Mao>();

        ouroLimite = 10;
        ouroMaximo = 1;

        Player.SetarGold(ouroMaximo);
        Inimigo.SetarGold(ouroMaximo);

        CartasInimigo = transform.GetChild(2).GetComponent <MesaBehaviour>();
        CartasPlayer  = transform.GetChild(1).GetComponent <MesaBehaviour>();

        preparado = true;
    }
Ejemplo n.º 33
0
 private void OnMaoReleaseUp(Mao mao)
 {
     UILogic.Instance.Confertable.SetHeadIcon(HeadState.Normal);
 }
Ejemplo n.º 34
0
 /*
 * deve ser flush e straight e ter certas cartas
 */
 private static bool EhRoyalFlush(Mao h)
 {
     if (EhStraight(h) && EhFlush(h) &&
         h[0].Rank == Rank.As &&
         h[1].Rank == Rank.Dez &&
         h[2].Rank == Rank.Valete &&
         h[3].Rank == Rank.Dama &&
         h[4].Rank == Rank.Rei)
     {
         return true;
     }
     return false;
 }
Ejemplo n.º 35
0
 /*
 * todas as cartas são do mesmo naipe
 */
 private static bool EhFlush(Mao h)
 {
     if (h[0].Naipe == h[1].Naipe &&
         h[1].Naipe == h[2].Naipe &&
         h[2].Naipe == h[3].Naipe &&
         h[3].Naipe == h[4].Naipe)
     {
         return true;
     }
     return false;
 }
Ejemplo n.º 36
0
 private void OnMaoTouchDown(Mao mao)
 {
     UILogic.Instance.Confertable.SetHeadIcon(HeadState.Nervious);
 }
Ejemplo n.º 37
0
 /*
 * ou a 1a carta igual a 2a carta
 * ou a 2a carta igual a 3a carta
 * ou a 3a carta igual a 4a carta
 * ou a 4a carta igual a 5a carta
 */
 private static bool EhPar(Mao h)
 {
     if (h[0].Rank == h[1].Rank)
     {
         return true;
     }
     if (h[1].Rank == h[2].Rank)
     {
         return true;
     }
     if (h[2].Rank == h[3].Rank)
     {
         return true;
     }
     if (h[3].Rank == h[4].Rank)
     {
         return true;
     }
     return false;
 }
Ejemplo n.º 38
0
 /*
 * ou uma trinca e um par
 * ou um par e uma trinca
 */
 private static bool EhFullHouse(Mao h)
 {
     // par e trinca
     if (h[0].Rank == h[1].Rank &&
         h[2].Rank == h[3].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return true;
     }
     // trinca e par
     if (h[0].Rank == h[1].Rank &&
         h[1].Rank == h[2].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return true;
     }
     return false;
 }
Ejemplo n.º 39
0
 /*
 * ou as quatro primeiras tem o mesmo rank
 * ou as quatro últimas tem o mesmo rank
 */
 private static bool EhQuadra(Mao h)
 {
     // quatro primeiras
     if (h[0].Rank == h[1].Rank &&
         h[1].Rank == h[2].Rank &&
         h[2].Rank == h[3].Rank)
     {
         return true;
     }
     // quatro últimas
     if (h[1].Rank == h[2].Rank &&
         h[2].Rank == h[3].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return true;
     }
     return false;
 }
Ejemplo n.º 40
0
 /*
 * é straight e flush
 */
 private static bool EhStraightFlush(Mao h)
 {
     if (EhStraight(h) && EhFlush(h))
     {
         return true;
     }
     return false;
 }
Ejemplo n.º 41
0
 /*
 * ou as três primeiras tem mesmo rank
 * ou as três do meio tem mesmo rank
 * ou as três últimas tem mesmo rank
 */
 private static bool EhTrinca(Mao h)
 {
     // três primeiras
     if (h[0].Rank == h[1].Rank &&
         h[1].Rank == h[2].Rank)
     {
         return true;
     }
     // três do meio
     if (h[1].Rank == h[2].Rank &&
         h[2].Rank == h[3].Rank)
     {
         return true;
     }
     // três últimas
     if (h[2].Rank == h[3].Rank &&
         h[3].Rank == h[4].Rank)
     {
         return true;
     }
     return false;
 }
 public AvaliadorDeJogo(Mao mao2, Mao mao1)
 {
     Mao1 = mao1;
     Mao2 = mao2;
 }
        public bool Tem_Uma_Trinca(Mao mao1)
        {
            var cartas = mao1.Cartas;

            var listaTrinca = new List<Carta>();
            var listaResto = new List<Carta>();
            for (int index = 0; index < cartas.Count; index++)
            {
                for (int i = index + 1; i < cartas.Count; i++)
                {
                    for (int j = i + 1; j < cartas.Count; j++)
                    {
                        if (cartas[index].Numero == cartas[i].Numero && cartas[i].Numero == cartas[j].Numero)
                        {
                            listaTrinca.Add(cartas[index]);
                            break;
                        }
                    }
                }
            }

            listaResto = cartas.Where(x => x.Numero != listaTrinca.First().Numero).ToList();

            return listaTrinca.Count == 1 && listaResto.Count == 2;
        }
Ejemplo n.º 44
0
 private void OnEnable()
 {
     mao = target as Mao;
 }
Ejemplo n.º 45
0
 /*
 * confere que o rank difere em 1
 * isso é possível porque assumimos
 * que está ordernado
 */
 private static bool EhStraight(Mao h)
 {
     if (h[0].Rank == h[1].Rank - 1 &&
         h[1].Rank == h[2].Rank - 1 &&
         h[2].Rank == h[3].Rank - 1 &&
         h[3].Rank == h[4].Rank - 1)
     {
         return true;
     }
     // caso special porque Az é menor que dez
     if (h[1].Rank == Rank.Dez &&
         h[2].Rank == Rank.Valete &&
         h[3].Rank == Rank.Dama &&
         h[4].Rank == Rank.Rei &&
         h[0].Rank == Rank.As)
     {
         return true;
     }
     return false;
 }