Jogo de Truco com Sockets

Programação Java
#1

Buenas!

E aí pessoal, tudo certo?

Estou desenvolvendo um mini-jogo de Truco(gaudério) para 2 jogadores em rede, porém estou tendo umas dores de cabeça em alguns aspectos e gostaria de ouvir umas opiniões. :smiley:

Criei as seguintes classes:

  • Baralho, que tem 40 cartas (menos oitos e noves), tem método embaralha e tal.
  • Carta, é o objeto instanciado no baralho, atributos e etc
  • Conexão, é onde inicio o socket pra enviar os pacotes e coisas do tipo
  • Jogada, que é a classe que controla as chamadas de Envido, Truco, entre outras ações do jogo (que por sinal são muitas e estão me dando trabalho!)
  • Jogador, que possui uma mão de cartas, pontos
  • Jogo, é a classe que tem as ações (de acordo com as regras do jogo)
  • Pacote, é a classe onde são criados os pacotes, com ações e coisas do tipo para serem enviadas pelo socket
  • Rodada, que é classe que controla os pontos que serão adicionados ao placar de cada jogador com conforme as chamadas realizadas.

O problema é o seguinte, preciso manter um controle muito rígido em cima das ações, pois são muitas.

  • Envido, Real Envido, Falta Envido, Truco, Retruco, Vale 4, Flor, Contra Flor, Contra Flor e o Resto, sem falar que as ações podem ser chamadas enquanto outras ações já estão em aberto.

Por exemplo: um dos jogadores inicia o jogo, ele chama truco, o socket envia o pacote pro outro jogador informação a ação solicitada, e antes do jogador 2 aceitar ou recusar a ação truco, ele pode chamar flor ou envido, aí que mora o perigo, como posso fazer este controle?

Grato desde já,

#2

coloque uma exigencia de tempo entre as respostas, assim o jogador deve esperar e apressar a resposta de acordo com o tempo estimado

#3

Opa,
existe algum método pronto que faça isso?

#4

não, isso seria uma regra do seu jogo.

#5

Acho que formulei mal minha pergunta…

Digo, um método que tenha um timeout, que fique em contagem regressiva…eu pensei em usar threads, mas nunca tentei e não faço ideia de como seja, também se é fácil ou difícil.

#6

[quote=Far.ST]Acho que formulei mal minha pergunta…

Digo, um método que tenha um timeout, que fique em contagem regressiva…eu pensei em usar threads, mas nunca tentei e não faço ideia de como seja, também se é fácil ou difícil.[/quote]

Amigo, primeiramente: Como você conseguiu fazer uma aplicação desse gênero sem usar Threads?

Se você está interessado em apreender, usa o livro Use A Cabeça Java. Ele é incrivelmente fantástico para ensinar. Procure pelo capítulo crie uma conexão. Lá irá explciar Threads e Sockets, a partir daquilo, te garanto que você irá conseguir fazer.

Mas se esse não for teu interesse, vou te passar um código que talvez te ajude.

Ele está mais para um quebra-galho… eu fiz rapidinho, testei e na teoria funciona.
Acho que a partir dele você poderá ter uma base do que se trata.


import java.text.DecimalFormat;
import javax.swing.JLabel;

/**
 *
 * @author ByIvo
 */
public class TimeOut {

    private int initValue, maxTime;
    private boolean timeout, toBreak;
    private JLabel label;
    
    
    public TimeOut(int maxTime) {
        timeout = false;
        label = new JLabel(maxTime+"");
        this.maxTime = maxTime;
        initValue = maxTime;
    }

    void chronometer() {
        Thread cont = new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = initValue; i >= 0; i--) {
                    if (!toBreak) {
                        try {
                            Thread.sleep(1000);
                            label.setText(new DecimalFormat("00").format(i));
                            System.out.println("chro: "+i);
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                    } else {
                        break;
                    }
                }
                if (initValue == 0) {
                    timeout = true;
                }
            }
        });
        cont.start();
    }

    /*
     * utilize o método start para iniciar ou continuar o Chronometer. Use ele
     * para descobrir se o tempo acabou
     */
    public boolean start() {
        if (!timeout) {
            toBreak = false;
            chronometer();
            return true;
        } else {
            return false;
        }
    }

    /*
     * utilize o método pause para dar congelar no Chronometer, usando stop para
     * iniciar novamente
     */
    public void pause() {
        toBreak = true;
    }

    /*
     * utilize o método stop para parar o Chronometer
     */
    public void stop() {
        timeout = false;
        toBreak = true;
        initValue = maxTime;
    }

    /*
     * getters and setters
     */
    public int getMaxTime() {
        return maxTime;
    }

    public void setMaxTime(int maxTime) {
        this.maxTime = maxTime;
    }

    public boolean isTimeout() {
        return timeout;
    }

    public void setTimeout(boolean timeout) {
        this.timeout = timeout;
    }

    public int getInitValue() {
        return initValue;
    }

    public void setInitValue(int initValue) {
        this.initValue = initValue;
    }

    public JLabel getLabel() {
        return label;
    }
    
    
}
#7

Boa noite,

Cara, obrigado pelas dicas, amanhã vou testar.

E sobre sua indagação referente às threads, realmente tá sendo um parto usar somente sockets, mas não está 100% pronto, eu tenho o Java Use a Cabeça, só estou meio sem tempo de ler.

Amanhã posto os resultados.

Abçs.

#8