Esempio n. 1
0
        private string resuelveEmpateDoblePareja(string[] manoJugador1, string[] manoJugador2)
        {
            //Mirar el valor del trio
            var cartasDobleParejaJugador1 = getCartasDoblePareja(manoJugador1);
            var cartasDobleParejaJugador2 = getCartasDoblePareja(manoJugador2);

            int valorParejaAltaJugador1 = ManosPokerUtils.getValorNumericoCarta(cartasDobleParejaJugador1[2]);
            int valorParejaAltaJugador2 = ManosPokerUtils.getValorNumericoCarta(cartasDobleParejaJugador2[2]);

            if (valorParejaAltaJugador1 > valorParejaAltaJugador2)
            {
                return("Ganador jugador1 - DoblePareja");
            }
            else if (valorParejaAltaJugador2 > valorParejaAltaJugador1)
            {
                return("Ganador jugador2 - DoblePareja");
            }
            //En caso de que la pareja más alta sea igual, comprobar el valor de la segunda pareja
            else
            {
                int valorParejaBajaJugador1 = ManosPokerUtils.getValorNumericoCarta(cartasDobleParejaJugador1[0]);
                int valorParejaBajaJugador2 = ManosPokerUtils.getValorNumericoCarta(cartasDobleParejaJugador2[0]);

                if (valorParejaBajaJugador1 > valorParejaBajaJugador2)
                {
                    return("Ganador jugador1 - DoblePareja");
                }
                else if (valorParejaBajaJugador2 > valorParejaBajaJugador1)
                {
                    return("Ganador jugador2 - DoblePareja");
                }
                //En caso de empatar en la segunda pareja comprobamos el valor de la carta que sobra
                else
                {
                    int valorCartaSobranteJugador1 = ManosPokerUtils.getValorNumericoCarta(manoJugador1.Except(cartasDobleParejaJugador1).ToArray()[0]);
                    int valorCartaSobranteJugador2 = ManosPokerUtils.getValorNumericoCarta(manoJugador2.Except(cartasDobleParejaJugador2).ToArray()[0]);
                    if (valorCartaSobranteJugador1 > valorCartaSobranteJugador2)
                    {
                        return("Ganador jugador1 - CartaMasAlta : " + manoJugador1.Except(cartasDobleParejaJugador1).ToArray()[0]);
                    }
                    else if (valorCartaSobranteJugador2 > valorCartaSobranteJugador1)
                    {
                        return("Ganador jugador2 - CartaMasAlta : " + manoJugador2.Except(cartasDobleParejaJugador2).ToArray()[0]);
                    }
                    //En caso de empatar en la segunda pareja comprobamos el valor de la carta que sobra
                    else
                    {
                        return("Empate");
                    }
                }
            }
        }
Esempio n. 2
0
        internal string getCartaMasAlta(string[] mano)
        {
            string cartaMasAlta = mano[0];
            int    valorNumericoCartaMasAlta = ManosPokerUtils.getValorNumericoCarta(cartaMasAlta);
            int    valorNumericoCarta;


            foreach (string carta in mano)
            {
                valorNumericoCarta = ManosPokerUtils.getValorNumericoCarta(carta);
                if (valorNumericoCarta > valorNumericoCartaMasAlta)
                {
                    cartaMasAlta = carta;
                    valorNumericoCartaMasAlta = valorNumericoCarta;
                }
            }
            return(cartaMasAlta);
        }
Esempio n. 3
0
        private string resuelveEmpateColor(string[] manoJugador1, string[] manoJugador2)
        {
            //Mirar la carta mas alta del color
            int valorColorJugador1 = ManosPokerUtils.getValorNumericoCarta(getCartaMasAlta(manoJugador1));
            int valorColorJugador2 = ManosPokerUtils.getValorNumericoCarta(getCartaMasAlta(manoJugador2));

            if (valorColorJugador1 > valorColorJugador2)
            {
                return("Ganador jugador1 - Color");
            }
            else if (valorColorJugador2 > valorColorJugador1)
            {
                return("Ganador jugador2 - Color");
            }
            else
            {
                return("Empate");
            }
        }
Esempio n. 4
0
        private string resuelveEmpatePareja(string[] manoJugador1, string[] manoJugador2)
        {
            //Mirar el valor de la pareja
            var cartasParejaJugador1 = getCartasPareja(manoJugador1);
            var cartasParejaJugador2 = getCartasPareja(manoJugador2);

            int valorParejaJugador1 = ManosPokerUtils.getValorNumericoCarta(cartasParejaJugador1[0]);
            int valorParejaJugador2 = ManosPokerUtils.getValorNumericoCarta(cartasParejaJugador2[0]);

            if (valorParejaJugador1 > valorParejaJugador2)
            {
                return("Ganador jugador1 - Pareja");
            }
            else if (valorParejaJugador2 > valorParejaJugador1)
            {
                return("Ganador jugador2 - Pareja");
            }
            //En caso de que la pareja sea igual, comprobar el valor del resto de cartas
            else
            {
                //Ordenamos el resto de cartas por su valor (De mayor a menor)
                var restoCartasJugador1 = ManosPokerUtils.manoStringToTupla(manoJugador1.Except(cartasParejaJugador1).ToArray()).OrderByDescending(c => c.Item1);
                var restoCartasJugador2 = ManosPokerUtils.manoStringToTupla(manoJugador2.Except(cartasParejaJugador2).ToArray()).OrderByDescending(c => c.Item1);

                int valorCartaJugador1, valorCartaJugador2;
                for (int i = 0; i < restoCartasJugador1.Count(); i++)
                {
                    valorCartaJugador1 = restoCartasJugador1.ElementAt(i).Item1;
                    valorCartaJugador2 = restoCartasJugador2.ElementAt(i).Item1;
                    if (valorCartaJugador1 > valorCartaJugador2)
                    {
                        return("Ganador jugador1 - CartaMasAlta : " + ManosPokerUtils.getRepresentacionCarta(valorCartaJugador1) + restoCartasJugador1.ElementAt(i).Item2);
                    }
                    if (valorCartaJugador2 > valorCartaJugador1)
                    {
                        return("Ganador jugador2 - CartaMasAlta : " + ManosPokerUtils.getRepresentacionCarta(valorCartaJugador2) + restoCartasJugador2.ElementAt(i).Item2);
                    }
                }

                return("Empate");
            }
        }
Esempio n. 5
0
        private string resuelveEmpateTrio(string[] manoJugador1, string[] manoJugador2)
        {
            //Mirar el valor del trio
            var cartasTrioJugador1 = getCartasTrio(manoJugador1);
            var cartasTrioJugador2 = getCartasTrio(manoJugador2);

            int valorTrioJugador1 = ManosPokerUtils.getValorNumericoCarta(cartasTrioJugador1[0]);
            int valorTrioJugador2 = ManosPokerUtils.getValorNumericoCarta(cartasTrioJugador2[0]);

            if (valorTrioJugador1 > valorTrioJugador2)
            {
                return("Ganador jugador1 - Trio");
            }
            else
            {
                return("Ganador jugador2 - Trio");
            }

            //No puede haber empate de trios
        }
Esempio n. 6
0
        private string resuleveEmpatePoker(string[] manoJugador1, string[] manoJugador2)
        {
            //Mirar el valor del poker
            var cartasPokerJugador1 = getCartasPoker(manoJugador1);
            var cartasPokerJugador2 = getCartasPoker(manoJugador2);

            int valorPokerJugador1 = ManosPokerUtils.getValorNumericoCarta(cartasPokerJugador1[0]);
            int valorPokerJugador2 = ManosPokerUtils.getValorNumericoCarta(cartasPokerJugador2[0]);

            if (valorPokerJugador1 > valorPokerJugador2)
            {
                return("Ganador jugador1 - Poker");
            }
            else
            {
                return("Ganador jugador2 - Poker");
            }

            //No puede haber dos pokers con las mismas cartas
        }
Esempio n. 7
0
        private string resuleveEmpateEscalera(string[] manoJugador1, string[] manoJugador2)
        {
            //Valor de la carta más alta de la escalera
            string cartaMasAltaJugador1       = getCartaMasAlta(manoJugador1);
            string cartaMasAltaJugador2       = getCartaMasAlta(manoJugador2);
            int    valorCartaEscaleraJugador1 = ManosPokerUtils.getValorNumericoCarta(cartaMasAltaJugador1);
            int    valorCartaEscaleraJugador2 = ManosPokerUtils.getValorNumericoCarta(cartaMasAltaJugador2);

            if (valorCartaEscaleraJugador1 > valorCartaEscaleraJugador2)
            {
                return("Ganador jugador1 - CartaMasAlta :" + cartaMasAltaJugador1);
            }
            else if (valorCartaEscaleraJugador2 > valorCartaEscaleraJugador1)
            {
                return("Ganador jugador2 - CartaMasAlta :" + cartaMasAltaJugador2);
            }
            else
            {
                return("Empate");
            }
        }