cl

.idea/.gitignore

+# Default ignored files
+/shelf/
+/workspace.xml

.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file

.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/Poker2.0.iml" filepath="$PROJECT_DIR$/Poker2.0.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

Poker2.0.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file

src/Carta.java

+public class Carta {
+    public String valor;
+    public String palo;
+
+    public Carta()
+    {
+
+    }
+
+    public Carta(String completo)
+    {
+        this.valor = String.valueOf(completo.charAt(0));
+        this.palo = String.valueOf(completo.charAt(1));
+    }
+
+    String valorPalo()
+    {
+        return this.valor + this.palo;
+    }
+}
+
+

src/Jugada.java

+import java.util.Arrays;
+
+public class Jugada {
+    String posibleJugada = "CARTA ALTA";
+
+    public Jugada() {
+
+    }
+
+    // ----------------------------------------------------------------------------------------------------
+    // ---------------------- Metodos Auxiliares ----------------------
+
+    public String getPosibleJugada()
+    {
+        return this.posibleJugada;
+    }
+
+    public void setPosibleJugada(String posibleJugadaActualizada)
+    {
+        this.posibleJugada = posibleJugadaActualizada;
+    }
+
+    // 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 String 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);
+        String x = getPosibleJugada();
+        return x;
+    }
+
+    // Metodo para imprimir que jugada seria. (Poker, Escalera de color, full, etc.)
+    public void imprimirResultado ()
+    {
+        System.out.println("La mano es: " + 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 128 " + 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

src/Jugador.java

+import java.util.Scanner;
+
+public class Jugador {
+    String nombre = "";
+
+    public Jugador()
+    {
+
+    }
+
+    //  --------- Metodos ---------
+
+    public String getNombre() {
+        return nombre;
+    }
+
+    public void setNombre(String nombre) {
+        this.nombre = nombre;
+    }
+
+    public void pedirNombre()
+    {
+        Scanner in = new Scanner(System.in);
+        System.out.print("Introduzca su nombre: ");
+        String name = in.nextLine();
+        setNombre(name);
+    }
+
+
+}

src/Poker.java

+public class Poker {
+
+    public static int manoGanadora(String mano) {
+        int puntos = 0;
+
+        switch (mano) {
+            case "ESCALERA DE COLOR":
+                puntos += 9;
+                break;
+            case "POKER":
+                puntos += 8;
+                break;
+            case "FULL":
+                puntos += 7;
+                break;
+            case "COLOR":
+                puntos += 6;
+                break;
+            case "ESCALERA":
+                puntos += 5;
+                break;
+            case "TRIO":
+                puntos += 4;
+                break;
+            case "PAR DOBLE":
+                puntos += 3;
+                break;
+            case "PAR":
+                puntos += 2;
+                break;
+            case "CARTA MAYOR":
+                puntos += 1;
+                break;
+            default:
+                break;
+        }
+
+        return puntos;
+    }
+
+    // ------- Funcion de desempate -------
+    public static void desempate(int[] cartaGrande1, int[] cartaGrande2, String nombre1, String nombre2) {
+        if (cartaGrande1[4] == cartaGrande2[4]) {
+            boolean ganoJugador1 = false;
+            boolean ganoJugador2 = false;
+            boolean empateDefinitivo = false;
+            boolean finalizar = false;
+            int i = 3;
+            while (finalizar == false) {
+                if (cartaGrande1[i] > cartaGrande2[i]) {
+                    ganoJugador1 = true;
+                    finalizar = true;
+                } else if (cartaGrande1[i] < cartaGrande2[i]) {
+                    ganoJugador2 = true;
+                    finalizar = true;
+                } else if (cartaGrande1[i] == cartaGrande2[i]) {
+                    empateDefinitivo = true;
+                    finalizar = true;
+                }
+                i--;
+            }
+
+            if (ganoJugador1) {
+                System.out.println("Felicidades " + nombre1 + ", Has Ganado en el Desempate");
+            } else if (ganoJugador2) {
+                System.out.println("Felicidades " + nombre2 + ", Has Ganado en el Desempate");
+            } else if (empateDefinitivo) {
+                System.out.println(nombre1 + " y " + nombre2 + " han empatado.");
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        // --------------------------------------
+        // Jugadores
+        Jugador jugador1 = new Jugador();
+        jugador1.pedirNombre();
+        String nombreJugador1 = jugador1.getNombre();
+        jugador1.pedirNombre();
+        String nombreJugador2 = jugador1.getNombre();
+
+        // --------------------------------------
+        // Generacion de Cartas
+        Carta carta1 = new Carta("3C");
+        Carta carta2 = new Carta("3C");
+        Carta carta3 = new Carta("3S");
+        Carta carta4 = new Carta("5C");
+        Carta carta5 = new Carta("8C");
+
+        Carta carta6 = new Carta("2C");
+        Carta carta7 = new Carta("2C");
+        Carta carta8 = new Carta("2S");
+        Carta carta9 = new Carta("6C");
+        Carta carta10 = new Carta("8S");
+
+        // --------------------------------------
+        // Inicio de Comprobaciones
+        Jugada jugada1 = new Jugada();
+        String x = jugada1.ejecutarComprobaciones(carta1, carta2, carta3, carta4, carta5);
+        System.out.println("Jugada X " + jugada1.getPosibleJugada());
+        String z = jugada1.ejecutarComprobaciones(carta6, carta7, carta8, carta9, carta10);
+        System.out.println("Jugada Z " + jugada1.getPosibleJugada());
+
+        // ----------- Comprobacion de mano ganadora ----------
+        int puntosMano1 = manoGanadora(x);
+        int puntosMano2 = manoGanadora(z);
+
+        System.out.println("Puntos Jugador 1 = " + puntosMano1);
+        System.out.println("Puntos Jugador 2 = " + puntosMano2);
+
+        if (puntosMano1 > puntosMano2) {
+            System.out.println(nombreJugador1 + " gano con: " + x);
+        } else if (puntosMano1 > puntosMano2) {
+            System.out.println(nombreJugador2 + " gano con: " + x);
+        } else if (puntosMano1 == puntosMano2) {
+            int[] mano1Numeros = jugada1.valoresNumericosEnArray(jugada1.crearArray(carta1, carta2, carta3, carta4, carta5));
+            int[] mano2Numeros = jugada1.valoresNumericosEnArray(jugada1.crearArray(carta6, carta7, carta8, carta9, carta10));
+            desempate(mano1Numeros, mano2Numeros, nombreJugador1, nombreJugador2);
+        }
+    }
+}
\ No newline at end of file