Estou criando um joguinho da velha em java. Os jogadores podem ser:
- humano
- computador burro(escolhe aleatoriamente uma posição vazia e joga ali)
- agente inteligente
criei uma interface comum a todos os jogadores, assim eu posso manipular o jogo sem me preocupar se os jogadores são agentes, humanos ou burros.
a interface é:
import java.awt.event.ActionEvent;
public interface Jogador extends Runnable {
public boolean efetuaJogada();
public void eventoJogador(Jogador jogador, ActionEvent evento);
}
o método efetuaJogada() é chamado pela engine do jogo, é ele que vai, não interessa como, selecionar uma das posições disponíveis e jogar nela. no caso do jogador burro, esse método escolhe uma casa livre aleatoriamente. no caso do jogador humano, esse método vai fazer a jogada aonde o jogador escolheu.
Daí em tenho, então, 3 classes que implementam essa interface: JogadorBurro, JogadorHumano e, ainda não implementada, JogadorAgente.
O método eventoJogador é chamado em ambos os jogadores(o ‘X’ e o ‘O’) sempre que vc clica em uma das posições do jogo(o tabuleiro do jogo da velha é representado por 9 JButton’s, dispostos como em uma matriz 3x3). O parametro ‘jogador’ é uma referencia ao objeto que representa o jogador atual no momento em que houve a ação, e o parametro ‘evento’ é o ActionEvent gerado quando há ação de clique em um desses 9 JButtons.
Quando vc inicia uma nova partida, é rodado um algoritimo assim:
for (int i = 0; i < 9; ++i) {
jogador[jogadorAtual].efetuaJogada(); /* os dois jogadores estão armazenados em um array de duas posições, e há uma variavel inteira chamada jogadorAtual que indica o indice do jogador que possui a vez de jogar */
if (jogadorAtual == 0)
jogadorAtual = 1;
else
jogadorAtual = 0;
}
sempre que é chamado o método efetuaJogada() do Jogador, é verificado se ocorreu essa vitória. se ocorreu, esse laço for aí de cima é interrompido.
Bom, toda essa enrolação até agora foi necessária para descrever a minha atual situação, para que assim haja a possibilidade de me indicarem uma solução. Agora vamos ao meu problema:
No jogador humano… no método efetuaJogada(), esse método só pode retornar depois que duas váriaveis que existem nessa classe, chamadas x e y(ambas são int) forem preenchidas. Esse preenchimento ocorre no método eventoJogador(), que vai analizar qual posição o usuario clicou e ver se há possibilidade de jogar ali(verifica se a posição está vazia). se houver possibilidade, ele preenche as tais variáveis x e y com as coordenadas adequadas. Aí então o método efetuaJogada(), que estava esperando, vai estar apto a finalmente efetuar a jogada.
no método efetuaJogada(), eu fiz assim para implementar essa espera:
while (x == -1); // usem -1 para indicar q a variável nao está preenchida
mas aí toda a execução ficou parada nesse ponto, nao era possivel clicar nos botões, consequentemente, nao seria gerado o ActionEvent, consequentemente nao seria chamado o método eventoJogador(), e assim o programa continuaria parado.
Foi então que pensei em usar threads(é por isso que a interface Jogador está estendendo a interface Runnable), para que apenas a thread do jogador ficasse parada esperando, mas o resto do programa poderia continuar. mas ainda assim nao funcionou.
será que alguém pode me dar uma ideia de como resolver isso?