Skip to content

P
poker
Commit 3cf64b53 by Nahuel Mereles Rodriguez
Options

Comprobaciones hechas

parent ef86bf02
Showing with 284 additions and 3 deletions
Carta.java
public class Carta { public class Carta {
public String valor; public String valor;
public String palo; public String palo;
public Carta() public Carta()
{ {
...@@ -16,7 +17,4 @@ public class Carta { ...@@ -16,7 +17,4 @@ public class Carta {
{ {
return this.valor + this.palo; return this.valor + this.palo;
} }
//aa
} }
Jugada.java 0 → 100644
import java.util.Arrays;
public class Jugada {
String posibleJugada = "CARTA ALTA";
public Jugada() {
}
// ----------------------------------------------------------------------------------------------------
// ---------------------- Metodos Auxiliares ----------------------
// Metodo para Crear el Array con los objetos Carta
public String[] crearArray(Carta carta1, Carta carta2, Carta carta3, Carta carta4, Carta carta5) {
String[] mano = new String[5];
mano[0] = carta1.valorPalo();
mano[1] = carta2.valorPalo();
mano[2] = carta3.valorPalo();
mano[3] = carta4.valorPalo();
mano[4] = carta5.valorPalo();
return mano;
}
// Metodo para separar los los valores numericos de los palos
public int[] valoresNumericosEnArray(String[] mano) {
int[] valorNumerico = new int[5];
for (int i = 0; i < mano.length; i++) {
// Guardo en var tipo String el primer caracter del String,
// que seria el valor numerico de la mano
String valorNumericoString = String.valueOf(mano[i].charAt(0));
// Reasignamos el valor a entero en caso que encontremos alguna de las letras posibles
switch (valorNumericoString) {
case "A":
valorNumerico[i] = 1;
break;
case "T":
valorNumerico[i] = 10;
break;
case "J":
valorNumerico[i] = 11;
break;
case "Q":
valorNumerico[i] = 12;
break;
case "K":
valorNumerico[i] = 13;
break;
default:
// En caso de no encontrar ninguna letra, convertimos el string a entero
valorNumerico[i] = Integer.parseInt(valorNumericoString);
break;
}
}
// Ordeno el Array Numerico de menor a mayor
Arrays.sort(valorNumerico);
return valorNumerico;
}
// Metodo para separar los los palos de los valores numericos
public String[] palosEnUnArray(String[] mano) {
String[] valorPalo = new String[5];
for (int i = 0; i < mano.length; i++) {
String valorPaloString = String.valueOf(mano[i].charAt(1));
valorPalo[i] = valorPaloString;
}
return valorPalo;
}
// Metodo para retornar el contador de coincidencias
// Esta forma de comparar los elementos del array, se realiza de la misma forma en todos los casos excepto en el metodo
// EscaleraDeColor. Por esta razon, creamos esta funcion para ejecutarse varias veces sin la necesidad de repetir codigo.
// En realidad, esta es la intencion de todos los metodos auxiliares.
public int contadorDeCartasCoincidentes(int[] mano) {
int contador = 0;
for (int i = 0; i < mano.length - 1; i++) {
// Si el numero en la posicion [i] es igual al que esta en la sig. posicion, el contador se aumenta.
if (mano[i] == mano[i + 1]) {
contador++;
}
}
return contador;
}
// Metodo para ejecutar todos los metodos de comprobacion
public void ejecutarComprobaciones(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5)
{
escaleraColor(c1, c2, c3, c4, c5);
poker(c1, c2, c3, c4, c5);
full(c1, c2, c3, c4, c5);
trio(c1, c2, c3, c4, c5);
parDoble(c1, c2, c3, c4, c5);
par(c1, c2, c3, c4, c5);
}
// Metodo para imprimir que jugada seria. (Poker, Escalera de color, full, etc.)
public void imprimirResultado ()
{
System.out.println(this.posibleJugada);
}
// ----------------------------------------------------------------------------------------------------
// ---------------------- Metodos De Comprobacion ----------------------
// Metodo Escalera De Color
public void escaleraColor(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5) {
String[] mano = crearArray(c1, c2, c3, c4, c5);
int[] manoNumerica = valoresNumericosEnArray(mano);
String[] manoPalos = palosEnUnArray(mano);
// Impresion de la mano para que se vea en onsola y se compruebe si esta bien la Jugada
for ( int i = 0; i < manoNumerica.length; i++)
{
System.out.println("Linea 110 " + manoNumerica[i]);
}
int contador1 = 0;
for (int i = 0; i < manoNumerica.length - 1; i++) {
// Si el dado en la posicion [0] es 1 y le sumas 1, el resultado debe ser igual
// al dado de la posicion siguiente
if (manoNumerica[i] + 1 == manoNumerica[i + 1]) {
contador1++;
}
}
int contador2 = 0;
for (int i = 0; i < manoPalos.length - 1; i++) {
if (manoPalos[i].equals(manoPalos[i + 1])) {
contador2++;
}
}
// ----------- Comprobaciones -----------
if ((contador1 == 4 && contador2 == 4) || (contador1 == 3 && contador2 == 4 && manoNumerica[0] == 1 && manoNumerica[4] == 13))
{
this.posibleJugada = "ESCALERA DE COLOR";
} else if (contador1 == 4 && contador2 < 4)
{
this.posibleJugada = "ESCALERA";
} else if (contador2 == 4 && contador1 < 4) {
this.posibleJugada = "COLOR";
}
}
// ------------------------------------------------------------------------------------
// Metodo POKER
public void poker(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5)
{
String[] mano = crearArray(c1, c2, c3, c4, c5);
int[] manoNumerica = valoresNumericosEnArray(mano);
int contador = contadorDeCartasCoincidentes(manoNumerica);
// ----------- Comprobaciones -----------
if (contador == 3 && manoNumerica[1] == manoNumerica[2] && manoNumerica[2] == manoNumerica[3]) {
this.posibleJugada = "POKER";
}
}
// ------------------------------------------------------------------------------------
// Metodo FULL
public void full(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5)
{
String[] mano = crearArray(c1, c2, c3, c4, c5);
int[] manoNumerica = valoresNumericosEnArray(mano);
int contador = contadorDeCartasCoincidentes(manoNumerica);
// ----------- Comprobaciones -----------
if ((contador == 3 && manoNumerica[2] != manoNumerica[3] && manoNumerica[3] == manoNumerica[4]) || (contador == 3 && manoNumerica[2] != manoNumerica[1] && manoNumerica[0] == manoNumerica[1])) {
this.posibleJugada = "FULL";
}
}
// ------------------------------------------------------------------------------------
// Metodo TRIO
public void trio(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5)
{
String[] mano = crearArray(c1, c2, c3, c4, c5);
int[] manoNumerica = valoresNumericosEnArray(mano);
int contador = contadorDeCartasCoincidentes(manoNumerica);
// TRIO: tres cartas del mismo valor y dos de un valor diferente
// Las 3 opciones posibles son:
// 1,1,1,2,4
// 1,2,4,4,4
// 1,2,2,2,4
// ----------- Comprobaciones -----------
if ( (contador == 2 && manoNumerica[0] == manoNumerica[1] && manoNumerica[1] == manoNumerica[2]
&& manoNumerica[2] != manoNumerica[3] && manoNumerica[3] != manoNumerica[4] ) ||
(contador == 2 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] != manoNumerica[2]
&& manoNumerica[2] == manoNumerica[3] && manoNumerica[3] == manoNumerica[4]) ||
(contador == 2 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] == manoNumerica[2]
&& manoNumerica[2] == manoNumerica[3] && manoNumerica[3] != manoNumerica[4]) )
{
this.posibleJugada = "TRIO";
}
}
public void parDoble(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5)
{
String[] mano = crearArray(c1, c2, c3, c4, c5);
int[] manoNumerica = valoresNumericosEnArray(mano);
int contador = contadorDeCartasCoincidentes(manoNumerica);
// PAR DOBLE: dos cartas del mismo valor, otras dos cartas del mismo valor diferente al anterior y una carta desemparda
// Las 3 opciones posibles son:
// 1,1,2,2,4
// 1,2,2,4,4
// 1,1,2,4,4
// ----------- Comprobaciones -----------
if ( (contador == 2 && manoNumerica[0] == manoNumerica[1] && manoNumerica[1] != manoNumerica[2] &&
manoNumerica[2] == manoNumerica[3] && manoNumerica[3] != manoNumerica[4]) ||
(contador == 2 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] == manoNumerica[2] &&
manoNumerica[2] != manoNumerica[3] && manoNumerica[3] == manoNumerica[4]) ||
(contador == 2 && manoNumerica[0] == manoNumerica[1] && manoNumerica[1] != manoNumerica[2] &&
manoNumerica[2] != manoNumerica[3] && manoNumerica[3] == manoNumerica[4])
)
{
this.posibleJugada = "PAR DOBLE";
}
}
public void par(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5)
{
String[] mano = crearArray(c1, c2, c3, c4, c5);
int[] manoNumerica = valoresNumericosEnArray(mano);
int contador = contadorDeCartasCoincidentes(manoNumerica);
// Par (one pair) es una mano formada por dos cartas del mismo valor más tres cartas adicionales de valor distinto de la pareja
// y distintas entre sí.
// Las 4 opciones disponibles son:
// 1,1,2,3,4
// 1,2,3,4,4
// 1,2,2,3,4
// 1,2,3,3,4
// ----------- Comprobaciones -----------
if ( (contador == 1 && manoNumerica[0] == manoNumerica[1] && manoNumerica[1] != manoNumerica[2] &&
manoNumerica[2] != manoNumerica[3] && manoNumerica[3] != manoNumerica[4]) ||
(contador == 1 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] != manoNumerica[2] &&
manoNumerica[2] != manoNumerica[3] && manoNumerica[3] == manoNumerica[4]) ||
(contador == 1 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] == manoNumerica[2] &&
manoNumerica[2] != manoNumerica[3] && manoNumerica[3] != manoNumerica[4]) ||
(contador == 1 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] != manoNumerica[2] &&
manoNumerica[2] == manoNumerica[3] && manoNumerica[3] != manoNumerica[4])
)
{
this.posibleJugada = "PAR";
}
}
}
\ No newline at end of file
Poker.java 0 → 100644
public class Poker {
public static void main(String[] args) {
// --------------------------------------
Carta carta1 = new Carta("AC");
Carta carta2 = new Carta("2C");
Carta carta3 = new Carta("3S");
Carta carta4 = new Carta("5C");
Carta carta5 = new Carta("4C");
Jugada jugada1 = new Jugada();
jugada1.ejecutarComprobaciones(carta1, carta2, carta3, carta4, carta5);
jugada1.imprimirResultado();
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment