internal string[] getCartasTrio(string[] mano)
{
//Ordenar las cartas de la mano
var manoTupla = ManosPokerUtils.manoStringToTupla(mano).OrderBy(c => c.Item1);
//Al estar ordenado, comprobamos si hay 3 cartas con el mismo valor
//Empezamos de la primera a la tercera
//Luego segunda a la cuarta
//Y terminamos con tercera a quinta
if (manoTupla.ElementAt(0).Item1 == manoTupla.ElementAt(1).Item1&& manoTupla.ElementAt(0).Item1 == manoTupla.ElementAt(2).Item1)
{
return(ManosPokerUtils.manoTuplaToString(new Tuple <int, char>[] { manoTupla.ElementAt(0), manoTupla.ElementAt(1), manoTupla.ElementAt(2) }));
}
else if (manoTupla.ElementAt(1).Item1 == manoTupla.ElementAt(2).Item1&& manoTupla.ElementAt(1).Item1 == manoTupla.ElementAt(3).Item1)
{
return(ManosPokerUtils.manoTuplaToString(new Tuple <int, char>[] { manoTupla.ElementAt(1), manoTupla.ElementAt(2), manoTupla.ElementAt(3) }));
}
else if (manoTupla.ElementAt(2).Item1 == manoTupla.ElementAt(3).Item1&& manoTupla.ElementAt(2).Item1 == manoTupla.ElementAt(4).Item1)
{
return(ManosPokerUtils.manoTuplaToString(new Tuple <int, char>[] { manoTupla.ElementAt(2), manoTupla.ElementAt(3), manoTupla.ElementAt(4) }));
}
return(null);
}
internal bool esPoker(string[] mano)
{
//Comprobar 4 cartas con el mismo valor
var manoTupla = ManosPokerUtils.manoStringToTupla(mano);
bool poker = false;
//Al tener que ser 4 cartas igual podemos comprobar si exiten 4 cartas igual a la primera o a la segunda
//Primera carta
int valorCarta = manoTupla.First().Item1;
int cartasIguales = manoTupla.Count(c => c.Item1 == valorCarta);
if (cartasIguales == 4)
{
poker = true;
}
//Segunda carta
valorCarta = manoTupla.ElementAt(1).Item1;
cartasIguales = manoTupla.Count(c => c.Item1 == valorCarta);
if (cartasIguales == 4)
{
poker = true;
}
return(poker);
}
internal string[] getCartasPoker(string[] mano)
{
var cartasPoker = new List <string>();
var manoTupla = ManosPokerUtils.manoStringToTupla(mano);
//Primera carta
int valorCarta = manoTupla.First().Item1;
var cartasIguales = manoTupla.Where(c => c.Item1 == valorCarta);
if (cartasIguales.Count() == 4)
{
return(ManosPokerUtils.manoTuplaToString(cartasIguales.ToArray()));
}
//Probamos con la segunda carta
valorCarta = manoTupla.ElementAt(1).Item1;
cartasIguales = manoTupla.Where(c => c.Item1 == valorCarta);
if (cartasIguales.Count() == 4)
{
return(ManosPokerUtils.manoTuplaToString(cartasIguales.ToArray()));
}
return(null);
}
internal bool esColor(string[] mano)
{
//Comprobar que todas las cartas son del mismo palo
var manoTupla = ManosPokerUtils.manoStringToTupla(mano);
char palo = manoTupla.First().Item2;
bool color = manoTupla.All(c => c.Item2 == palo);
return(color);
}
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");
}
}
}
}
internal string[] getCartasPareja(string[] mano)
{
//Ordenar las cartas de la mano
var manoTupla = ManosPokerUtils.manoStringToTupla(mano).OrderBy(c => c.Item1);
//Comprobar dos cartas con valores iguales seguidas
for (int i = 0; i < manoTupla.Count() - 1; i++)
{
if (manoTupla.ElementAt(i).Item1 == manoTupla.ElementAt(i + 1).Item1)
{
return(ManosPokerUtils.manoTuplaToString(new Tuple <int, char>[] { manoTupla.ElementAt(i), manoTupla.ElementAt(i + 1) }));
}
}
return(null);
}
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);
}
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");
}
}
internal bool esEscalera(string[] mano)
{
var manoTupla = ManosPokerUtils.manoStringToTupla(mano);
//Ordenar por valor
var manoOrdenada = manoTupla.OrderBy(c => c.Item1);
//Comprobamos comsecutivos
bool ordenada = true;
for (int i = 1; i < manoOrdenada.Count(); i++)
{
if (manoOrdenada.ElementAt(i).Item1 != manoOrdenada.ElementAt(i - 1).Item1 + 1)
{
ordenada = false;
}
}
return(ordenada);
}
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");
}
}
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
}
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
}
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");
}
}
private string resuelveEmpateCartaMasAlta(string[] manoJugador1, string[] manoJugador2)
{
//Ordenamos cartas por su valor (de mayor a menor)
var cartasJugador1 = ManosPokerUtils.manoStringToTupla(manoJugador1.ToArray()).OrderByDescending(c => c.Item1);
var cartasJugador2 = ManosPokerUtils.manoStringToTupla(manoJugador2.ToArray()).OrderByDescending(c => c.Item1);
int valorCartaJugador1, valorCartaJugador2;
for (int i = 0; i < cartasJugador1.Count(); i++)
{
valorCartaJugador1 = cartasJugador1.ElementAt(i).Item1;
valorCartaJugador2 = cartasJugador2.ElementAt(i).Item1;
if (valorCartaJugador1 > valorCartaJugador2)
{
return("Ganador jugador1 - CartaMasAlta : " + ManosPokerUtils.getRepresentacionCarta(valorCartaJugador1) + cartasJugador1.ElementAt(i).Item2);
}
if (valorCartaJugador2 > valorCartaJugador1)
{
return("Ganador jugador2 - CartaMasAlta : " + ManosPokerUtils.getRepresentacionCarta(valorCartaJugador2) + cartasJugador2.ElementAt(i).Item2);
}
}
return("Empate");
}
public void getRepresentacionCarta(int valor, string expected)
{
string actual = ManosPokerUtils.getRepresentacionCarta(valor);
Assert.That(actual, Is.EqualTo(expected));
}