ArrayList 2

27 de junho de 2008 5 respostas

bruxo 27 de junho de 2008

Assim oh, eu estou fazendo um jogo de Poker há algumas semanas já, e estou com problemas em verificar 3 jogadas...

O resto tudo está pronto, só falta elas, tou quebrando a cabeça mas não consigo fazer...

Vou mostrar o código, se alguém puder me ajudar =].

Full House:

public boolean verificaFullHouse(){//n funfa
        int t = mao.size();
        boolean trinca = false;
        int tr = 0;
        int par = 0;
        boolean fh = false;
        Carta c;
        for(int i=0; i<t-1; i++){
            if(mao.get(i).getValor()!=mao.get(i+1).getValor()){
                c=mao.get(i+1);
                guardaValor.add(c);
                tr++;
                    }
                    
                    if(tr==2 && verificaDoisPares() == false){
                        trinca=true;                         
                    }
                    if(mao.get(i).getValor()==mao.get(i+1).getValor()){
                        par++;
                    }
                    if(par == 1 && trinca == true){
                        fh = true;
                    }
                    else fh = false;
                }
                return fh;
            }

Straight e Straight Flush:

public int straightFlush(){
        int tamanho=mao.size();
            int n=0;
            Carta c1, c2; 
            boolean verificaSequencia=false;
            for(int i=0; i<tamanho; i++){
                   for(int y=i+1; i<tamanho; i++){
                       if((valor(mao.get(y).getValor()))-(valor(mao.get(i).getValor()))==1 || valor(mao.get(y).getValor())-(valor(mao.get(i).getValor()))==-1){
                             n++;
                            }
                            if(n==5){
                                   verificaSequencia=true;
                                  }
                                if(verificaSequencia = true && verificaFlush() == true){
                                    return 2;
                                }
                                else if(verificaSequencia = true && verificaFlush() == false){
                                    return 1;
                                }
                                else return 0;
                            }
                        }
                    
           return 0;
        }

Não quero que ninguém faça para mim, só que aponte os erros. Esses dois métodos fazem parte de um trabalho que eu tenho que desenvolver, e claro que pode pedir auxílio aos outros, mas eu quero é aprender, e não pegar as coisas prontas sem aprender nada.

Muito obrigado desde já.

5 Respostas

shoko 27 de jun. de 2008

qual erro que está dando???

vrmvinicius 27 de jun. de 2008

Detalhe o que está ocorrendo. Pelo que entendi seu algoritmo não está produzindo o resultado esperado. Então, diga o que deveria retornar e o que está retornando atualmente para conseguirmos analizar mais claramente o seu algoritmo.

abraços…

bruxo 27 de jun. de 2008

Eu testo esses dois métodos com as cartas e não retorna o esperado…

Ou retorna o esperado mas não com a combinação certa de cartas, no caso sequencia, fullhouse(1 par e 1 trinca) e straight Flush(sequencia do mesmo naipe).

Lao 27 de jun. de 2008

Cara, parece que você somenta está com um pequeno problema de lógica.
Não sabendo como suas estruturas estão montadas fica difícil de dar uma opinião precisa de como resolver isso.
Por exemplo: para verificar um FullHouse(1 par e 1 Trinca qualquer) eu faria algo como criar um mapa de Cartas, onde a chave é o nome da carta e o valor é a quantidade…
A = 2
J = 3
E ao final varrer o mapa e verificar: map.contains(3) && map.contains(2).

Já no Straight você só faria duas verificações, se suas cartas estão em sequência e se são do mesmo naipe.
Não sei como você determinou naipe e os valores das cartas, o melhor seria com números definidos como constantes.
Uma maneira que vejo seria: criar uma coleção de cartas com os valores e ordena-los. E você verifica enquanto varre se o valor anterior é menor em apenas uma unidade e se os naipes batem…

Isso é apenas uma maneira, existem muitas outras.

Espero ter ajudado.

sergiotaborda 27 de jun. de 2008

bruxo:
Assim oh, eu estou fazendo um jogo de Poker há algumas semanas já, e estou com problemas em verificar 3 jogadas…

Eu sei q vc não quer que façamos por vc mas seu codigo é complicado demais para tentar mudar

Supondo que a classe Carta tenha um getValor e um getNaipe e que Naipe é um enum:
Verificar a sequencia é verificar se as cartas são em ordem sequencial.
Ordem implica que vc pode comparar duas cartas. Isso implica em implementar Comparable
Vc precisa ordenar as cartas pelo seu valor e depois verificar se não ha iatos (cartas faltando)

Supondo que 'mao" é uma lista

Collections.sort (mao);

Comparar a carta é simples:

public int compareTo(Card other){
    if (this.value == other.value){
           return this.naipe.compareTo(other.naipe);
    } 

    return this.value - other.value;
    
}

Veja que o naipe tb é comparável A ordem do Poker é : Espadas, Copas, Diamantes, Paus.

Saber se ha iatos basta iterar, a mao ordenada, se o numero da carta a seguir não for imediatamente a seguir, então
não é uma sequencia. Para saber se é sequencia real basta manter controle do naipe. Se o naipe muda, é porque não seq real.

Naipe naipe = mao.get(0).getNaipe();
int valorAnterior = mao.get(0).getValor();
boolean royal = true; //asume que é real

for (int i= 1; i < mao.size(); i++){
    
    if (!mao.get(i).getNaipe().equals(naipe)){
         royal=false;
    }
     
    if (mao.get(i-1).getValue() != mao.get(i).getValue() + 1){
        return false; // não é sequencia, muito menos real
   }
}

// se chegar aqui é sequencia. Se royal é true, então é sequencia real

Para o FullHouse :
Full House = Par + Trinca ou seja

temFullHouse (){ return temPar() && temTrinca (); }

A pegadinha é que o temPar não pode retornar true quando existir um terno.

Criado 27 de junho de 2008

Ultima resposta 27 de jun. de 2008

Respostas 5

Participantes 5

5 Respostas

Topicos relacionados