AYUDA CON CODIGO DE JUEGO DE CARTAS

[kasidy]

Bueno pues tengo las clases Carta y PruebaPaqueteDeCartas ademas del PaqueteDeCartas y el me arroja las cinco cartas de poker al azar.. el problema es q me pide que identifique si la 5 cartas son:
a) un par
b) dos pares
c) tercia
d) cuatro aces
e) cinco cartas del mismo palo
f) full= un par y una tercia

tengo estas clases
public class PruebaPaqueteDeCartas
{     // Abre clase PruebaDeCartas
    public static void main(String args[])
    {     // Abre main
        PaqueteDeCartas miPaqueteDeCartas = new PaqueteDeCartas();
        miPaqueteDeCartas.barajar();
 
       System.out.println("\n");
       for ( int i = 0; i < 1; i++)
       { // Abre for
           System.out.printf("%-20s%-20s%-20s%-20s%-20s\n",
           miPaqueteDeCartas.repartirCarta(), miPaqueteDeCartas.repartirCarta(),
           miPaqueteDeCartas.repartirCarta(), miPaqueteDeCartas.repartirCarta(), miPaqueteDeCartas.repartirCarta());
       }  // Cierra for
    }
}




°
public class Carta
{
// Abre clase Carta
    private String cara;
    private String palo;
    public Carta( String caraCarta, String paloCarta)
    {   // Abre constructor
        cara = caraCarta;
        palo = paloCarta;
    }   // Cierra constructor
   
    public String toString()
    {   // Abre metodo toString
        return  cara + " de " + palo;
    }   // Cierra metodo toString
}



° Y AHORA SE SUPONE QUE DEBO MODIFICAR LA CLASE PaqueteDeCartas PARA DETERMINE LO QUE CONTIENE LA MANOS PERO NO TENGO IDEA DE COMO QUEDARIA....... 

import java.util.Random;

public class PaqueteDeCartas
{  // Abre clase PaqueteDeCartas
    private Carta paquete[];
    private int cartaActual;
    private final int NUMERO_DE_CARTAS = 52;
    private Random numerosAleatorios;
   
    public PaqueteDeCartas()
    {   // Abre constructor PaqueteDeCartas
        String caras[] = { "AS", "DOS", "TRES", "CUATRO", "CINCO", "SEIS", "SIETE",
            "OCHO", "NUEVE", "DIEZ", "JOTA", "QUINA", "REY"};
        String palos[] = { "CORAZONES", "DIAMANTES", "TREBOLES", "ESPADAS"};
       
        paquete = new Carta[ NUMERO_DE_CARTAS ];
        cartaActual = 0;
        numerosAleatorios = new Random();
       
        for ( int cuenta = 0; cuenta < paquete.length; cuenta++ )
        paquete[ cuenta ] = new Carta( caras[cuenta % 13], palos[cuenta/13]);
    }   // Cierra constructor PaqueteDeCartas
   
    public void barajar()
    {   // Abre metodo barajar
        cartaActual = 0;

        for ( int primera = 0; primera < paquete.length; primera++ )
        { // Abre for
            int segunda = numerosAleatorios.nextInt(NUMERO_DE_CARTAS);

            Carta temp = paquete[primera];

            paquete[primera] = paquete[segunda];
            paquete[segunda] = temp;
        }  // Cierra for
    }   // Cierra metodo barajar
   
    public Carta repartirCarta()
   {  // Abre metodo repartirCarta
       if (cartaActual < paquete.length )   
       return paquete[cartaActual++];
       else return null;       
   }
}// Cierra clase PaqueteDeCartas


ESPERO Y ME PUEDAN AYUDAR 

[Mitsu]

Primero, es conveniente colocar en la clase Carta unos getters para obtener la carta y el palo. La razón es sencilla, como en el arreglo se guardan las cartas con el formato carta + palo si comparamos las cartas así nomás, nunca habrá coincidencias, porque solo va a existir una carta del palo.

Código (=java) [Seleccionar] Expandir


/* Getters en clase Carta para obtener el palo y la carta */
public String getCarta(){
return this.carta;
}

public String getPalo() {
return this.palo;
}


Código (=java) [Seleccionar] Expandir


public class CardsPack {
   
    // Abre clase PaqueteDeCartas
    private Card mazo[];
    private int cartaActual;
    private final int NUMERODECARTAS = 52;
    private Random numerosAleatorios;
   
public CardsPack()
{   // Abre constructor PaqueteDeCartas
    String caras[] = { "AS", "DOS", "TRES", "CUATRO", "CINCO", "SEIS", "SIETE",
            "OCHO", "NUEVE", "DIEZ", "JOTO", "QUINA", "REY"};
    String palos[] = { "CORAZONES", "DIAMANTES", "TREBOLES", "ESPADAS"};
       
    mazo = new Card[ NUMERODECARTAS ];
    cartaActual = 0;
    numerosAleatorios = new Random();
       
    for ( int cuenta = 0; cuenta < mazo.length; cuenta++ )
    mazo[ cuenta ] = new Card( caras[cuenta % 13], palos[cuenta/13]);
}   // Cierra constructor PaqueteDeCartas
   
/* BARAJA LAS CARTAS */
public void barajar()
{   
    cartaActual = 0;

    for ( int primera = 0; primera < mazo.length; primera++ )
    {
      int segunda = numerosAleatorios.nextInt(NUMERODECARTAS);

      Card temp = mazo[primera];
      mazo[primera] = mazo[segunda];
      mazo[segunda] = temp;
    }
}
   
/* METODO DE AYUDA - REPARTE UNA CARTAC */
private Card repartirCarta()
{ 
    if (cartaActual < mazo.length )   
           return mazo[cartaActual++];
    else
           return null;       
}
   
/* REPARTE UNA MANO DE 5 CARTAS */
public Card[] repartirMano() {
        Card[] mano = new Card[5];
         System.out.println("*** Tu mano es: ***\n\n");
            for (byte carta = 0; carta < 5; carta++) {
                mano[carta] = this.repartirCarta();
                System.out.println(mano[carta].toString());
            }
         return mano;
    }
   
   
/* RESULTADOS DE LA MANO */
public void analizarMano(Card[] mano) {
    String[][] manoHecha = new String[5][2];
    manoHecha[0][0] = "¿Hay par?";
    manoHecha[1][0] = "¿Hay doble par?";
    manoHecha[2][0] = "¿Hay tercia?";
    manoHecha[3][0] = "¿Hay poker de ases?";
    manoHecha[4][0] = "¿Hay color?";
   
   
    System.out.println("\n\n*** Resultados de la mano: ***\n\n");
    for (byte indice = 0; indice < manoHecha.length; indice++) {
        byte col = 1;
        switch(indice) {
                case 0:  manoHecha[indice][col] = String.valueOf(this.hayPar(mano)); break;
                case 1:  manoHecha[indice][col] = String.valueOf(this.hay2pares(mano)); break;
                case 2: manoHecha[indice][col] = String.valueOf(this.hayTercia(mano)); break;
                case 3:  manoHecha[indice][col] = String.valueOf(this.hayPokerAses(mano)); break;
                case 4: manoHecha[indice][col] = String.valueOf(this.hayColor(mano)); break;
            }
    }
   
     for (byte fila = 0; fila < manoHecha.length; fila++) {
        for (byte col = 0; col < manoHecha[fila].length; col++) {
            if (col == 0) {
            System.out.print(manoHecha[fila][col] + " - ");
            }
            else {
                System.out.print(manoHecha[fila][col]);
                System.out.println();
            }
        }
    }
    }
   
/* DETERMINA SI HAY UN PAR EN LA MANO */
private boolean hayPar(Card[] mano) {

    boolean isPar = false;
    for (byte fila=0; fila<mano.length; fila++) {
        for(byte elemento=0; elemento<mano.length; elemento++) {
            if (fila != elemento) {
                if (mano[fila].getCara().equals(mano[elemento].getCara())) {
                    isPar = true;
                    break;
}
            }
}
    }
        return isPar;
}

/* DETERMINA SI HAY 2 PARES */
private boolean hay2pares(Card[] mano) {

boolean is2par = false;
byte pares = 0;
for(byte fila = 0; fila < mano.length; fila++) {
for( byte elemento = 0; elemento < mano.length; elemento++) {
if (fila != elemento) {
if(mano[fila].getCara().equals(mano[elemento].getCara())) {
pares++;
}
}
}
}
if(pares == 2) {
is2par = true;
}
        return is2par;
}

/* COMPRUEBA SI HAY TERCIA */
private boolean hayTercia(Card[] mano) {
boolean hayTrio = false;
byte tercia = 0;

for(byte fila = 0; fila < mano.length; fila++) {
for( byte elemento = 0; elemento < mano.length; elemento++) {
if (fila != elemento) {
if(mano[fila].getCara().equals(mano[elemento].getCara())) {
tercia++;
}
}
}
}

if(tercia == 3) {
hayTrio = true;
}

return hayTrio;
}

/* DETERMINA SI HAY 4 ASES */
private boolean hayPokerAses(Card[] mano) {
boolean haypoker = false;
byte asescount = 0;
final String as = "AS";

for(byte fila = 0; fila < mano.length; fila++) {
for( byte elemento = 0; elemento < mano.length; elemento++) {
if (fila != elemento) {
if(mano[elemento].getCara().equals(as)) {
asescount++;
}
}
}
}

if (asescount == 4) {
haypoker = true;
}

return haypoker;
}

/* DETERMINA SI HAY CINCO CARTAS DEL MISMO PALO */
private boolean hayColor(Card[] mano) {
boolean haycolor = false;
byte colorcount = 0;

for(byte fila = 0; fila < mano.length; fila++) {
for( byte elemento = 0; elemento < mano.length; elemento++) {
if (fila != elemento) {
if(mano[fila].getPalo().equals(mano[elemento].getPalo())) {
colorcount++;
}
}
}
}

if(colorcount == 5) {
haycolor = true;
}

return haycolor;
}

public static void main(String... args) {
    CardsPack pack = new CardsPack();
    pack.barajar();
    Card[] mano = pack.repartirMano();
    pack.analizarMano(mano);
   
  }
}


Lo del full ya hazlo tú

[kasidy]

Una duda porque pones cartas.length? no deberia ser paquete.length?
y dos al poner el paquete.length me marca error en el get.Carta