Ir ao conteúdo
  • Cadastre-se
Renan Galina

Java Jogo da velha em java

Recommended Posts

Estou parado, não consigo evoluir nesse código... 
 

Spoiler

Diagrama UML:

UML

Spoiler

Main: JogoDaVelha.java
 


public class JogoDaVelha {
	public static void main(String[] args) {
		Menu menu = new Menu();
		Tabuleiro tabuleiro = new Tabuleiro();
		int linha, coluna, contador=0;
		Jogador jogador1;
		Jogador jogador2;
		boolean vitoriaX=false, vitoriaO=false;

    	//Identifica o jogador 1 como humano ( usando id 1 )
		jogador1 = new Jogador(1);
		jogador2 = new Jogador(2);

		//Impressão inicial para começar o jogo
		menu.imprimeTabuleiro(tabuleiro);

		do{
			//Faz a jogada do primeiro jogador, considerando o método para usuário humano
			jogador1.jogada(tabuleiro,menu.lerLinha(), menu.lerColuna());
			//contabiliza a jogada com sucesso, visto que os métodos já garantem que a jogada sempre acontecerá com sucesso
			contador++;
			//Imprime o tabuleiro para o usuário ver a situação atual
			menu.imprimeTabuleiro(tabuleiro);
			//Verifica se alguém venceu
			vitoriaX = tabuleiro.verificaVitoria("X");
			vitoriaO = tabuleiro.verificaVitoria("O");
			//Caso ngm tenha vencido ainda e não tenha acabado as jogadas, o segundo jogador joga.
			if(vitoriaX == false && vitoriaO == false && contador < 9){
				//Faz a jogada do primeiro jogador, considerando o método para usuário computador
				jogador2.jogada(tabuleiro);
				//contabiliza a jogada com sucesso, visto que os métodos já garantem que a jogada sempre acontecerá com sucesso
				contador++;
				//Imprime o tabuleiro para o usuário ver a situação atual
				menu.imprimeTabuleiro(tabuleiro);	
				//Verifica se alguém venceu		
				vitoriaX = tabuleiro.verificaVitoria("X");
				vitoriaO = tabuleiro.verificaVitoria("O");
			}
			//Repete a estrutura enquanto ngm vencer e houver jogadas disponíveis.
		}while(vitoriaX == false && vitoriaO == false && contador < 9);

		//Verifica se o jogador 1 ganhou
		if (vitoriaX) {
			System.out.println("Vitória do jogador X");
		}else{
			//Verifica se o jogador 2 ganhou
			if (vitoriaO) {
				System.out.println("Vitória do jogador O");
			}else{
				//Verifica se deu velha
				System.out.println("Deu velha!");
			}
		}
	}
}

 

Spoiler

Jogador
 


public class Jogador{
	private int qtd, id, id_jogador;
	public int linha=0, coluna=0;
	
	//Construtor
	public Jogador(int id_jogador){
		this.id_jogador = id_jogador; 
	}
	public int getid(){
		return this.id;
	}
	public void jogada(Tabuleiro tabuleiro, int linha, int coluna){
		this.linha = linha;
		this.coluna = coluna;		
		 if (posições[linha][coluna] == sinal || posições[linha][coluna] == 'O') {
            return false;

       	 } 	else { //jogada válida
           	 posições[linha][coluna] = sinal;
            	jogada++;
           	 return true;
        	}
	  	}
	}

 

Spoiler

Menu
 


import java.util.Scanner;
public class Menu{
	private int linha=0, coluna=0;
	private String[][] posições;
	public Menu(){
		Scanner sc = new Scanner (System.in);
	}
	public void imprimeTabuleiro(Tabuleiro tabuleiro){
		 posições = new String[3][3];
		 for (int i = 0; i < posições.length; i++) {
            for (int j = 0; j < posições[i].length; j++) {
                System.out.print(posições[i][j] + " | ");
            }
            System.out.println();
        }
    }
	public void lerLinha(){
		Scanner sc = new Scanner (System.in);
		for (int i = 0; i < posições.length; i++) {
		System.out.println("Digite a linha: ");
		this.linha = sc.nextInt();
	}
	}
	public void lerColuna(){
		for (int i = 0; i < posições.length; i++) {
		for (int j = 0; j < posições[i].length; j++) {
		Scanner sc = new Scanner (System.in);
		System.out.println("Digite a coluna: ");
		this.coluna = sc.nextInt();
			}	
		}
	}
}

 

Spoiler

Tabuleiro



public class Tabuleiro {

    public String[][] posições;

    public Tabuleiro() {
        posições = new String[3][3];
        for (int i = 0; i < posições.length; i++) {
            for (int j = 0; j < posições[i].length; j++) {
                posições[i][j] = "";
            }
        }
    }

    public String getPosicao(int linha, int coluna) {
        return posições[linha][coluna];
    }

    public void setPosicao(int linha, int coluna, String valor) {
        posições[linha][coluna] = valor;
    }
    public boolean verificaVitoria(String sinal) {
        if ((posições[0][0] == sinal && posições[0][1] == sinal && posições[0][2] == sinal) || //linha 1
                (posições[1][0] == sinal && posições[1][1] == sinal && posições[1][2] == sinal) || //linha 2
                (posições[2][0] == sinal && posições[2][1] == sinal && posições[2][2] == sinal) || //linha 3
                (posições[0][0] == sinal && posições[1][0] == sinal && posições[2][0] == sinal) || //coluna 1
                (posições[0][1] == sinal && posições[1][1] == sinal && posições[2][1] == sinal) || //coluna 2
                (posições[0][2] == sinal && posições[1][2] == sinal && posições[2][2] == sinal) || //coluna 3
                (posições[0][0] == sinal && posições[1][1] == sinal && posições[2][2] == sinal) || //diagonal
                (posições[0][2] == sinal && posições[1][1] == sinal && posições[2][0] == sinal)) {  //diagonal inversa
            return true;
        }
        return false;
	}
}	

 


 

 

 

 

 

Ao compilar, recebo os seguintes erros:
 

Ao compilar a classe main, dá os seguintes erros:

 

JogoDaVelha.java:19: error: 'void' type not allowed here
                        jogador1.jogada(tabuleiro,menu.lerLinha(), menu.lerColun
a());
                                                               ^
JogoDaVelha.java:19: error: 'void' type not allowed here
                        jogador1.jogada(tabuleiro,menu.lerLinha(), menu.lerColun
a());

 ^
JogoDaVelha.java:30: error: method jogada in class Jogador cannot be applied to
given types;
                                jogador2.jogada(tabuleiro);
                                        ^
  required: Tabuleiro,int,int
  found: Tabuleiro
  reason: actual and formal argument lists differ in length
.\Jogador.java:15: error: cannot find symbol
                 if (posições[linha][coluna] == sinal || posições[linha][coluna]
 == 'O') {
                     ^
  symbol:   variable posições
  location: class Jogador
.\Jogador.java:15: error: cannot find symbol
                 if (posições[linha][coluna] == sinal || posições[linha][coluna]
 == 'O') {
                                                ^
  symbol:   variable sinal
  location: class Jogador
.\Jogador.java:15: error: cannot find symbol
                 if (posições[linha][coluna] == sinal || posições[linha][coluna]
 == 'O') {
                                                         ^
  symbol:   variable posições
  location: class Jogador
.\Jogador.java:16: error: incompatible types: unexpected return value
            return false;
                   ^
.\Jogador.java:19: error: cannot find symbol
                 posições[linha][coluna] = sinal;
                 ^
  symbol:   variable posições
  location: class Jogador
.\Jogador.java:19: error: cannot find symbol
                 posições[linha][coluna] = sinal;
                                           ^
  symbol:   variable sinal
  location: class Jogador
.\Jogador.java:20: error: cannot find symbol
                jogada++;
                ^
  symbol:   variable jogada
  location: class Jogador
.\Jogador.java:21: error: incompatible types: unexpected return value
                 return true;
                        ^
11 errors
  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Renan Galina Olá. A questão é ir por partes

- Os métodos lerLinha e lerColuna estão definidos no diagrama com o tipo de retorno int e não void

- Na classe Menu (entrada) Scanner deve ser um atributo da classe, segundo o diagrama:

private Scanner sc = new Scanner(System.in);

- O matriz de String referente as posições deve ser definida apenas na classe Tabuleiro, logo, não deveria estar na classe Menu também

- O atributo qtd não está em uso na classe Jogador

Seriam esses alguns pontos que não estão d acordo com o diagrama UML

 

Na classe JogoDaVelha em uma ou duas vezes você chama o método jogada  da classe Jogador passando apenas a variável do tipo tabuleiro como parâmetro, e não os outros dois parâmetros

Também a foma de como você está imprimindo o tabuleiro precisa ser ajustada:

public void imprimeTabuleiro(Tabuleiro tabuleiro) {
    for (int i = 0; i < tabuleiro.posições.length; i++) {
        for (int j = 0; j < tabuleiro.posições[0].length; j++) {
            System.out.print(tabuleiro.posições[i][j] + "|");
        }
        System.out.println();
    }
}

Sobre os métodos lerLinha e lerColuna, um exemplo de como poderia ficar:

public int lerLinha() {
    System.out.println("Digite a linha: ");
    linha = sc.nextInt();
    return linha;
}

O jogo rodou aqui, mas o que não ficou ajustado é a questão dos símbolos no método jogada da classe Jogador

 

Seria isso por enquanto. Dê uma pequena revisada em seu código seguindo as dicas acima 🙂

Boa sorte!

adicionado 2 minutos depois

Só mais um ponto: no método jogada da classe Jogador você está retornando true e false, mas o tipo de retorno do método é void 

Outro ponto importante: Não use acentuação para nome de variáveis, tal como posições

 

Obs: Gostei muito do projeto e do seu código. Bem interessante o negócio 😉

 

Atualizando:

Agora deu para fazer o jogo funcionar, mas inda não tá legal

Na classe Jogador é preciso criar dois métodos com o nome de jogada, e é nessa parte q não resolvi aqui

É bem provável que um método, tal como eu fiz, seria para efetuar a jogada e no outro para verificar se a jogada é válida

Dica: Use o id de cada jogador para efetuar a jogada, algo assim:

public void jogada(Tabuleiro tabuleiro, int linha, int coluna) {
    if (id == 1)
        tabuleiro.setPosicao(linha, coluna, "X");
    else
        tabuleiro.setPosicao(linha, coluna, "O");
}

Só que é o seguinte: É só uma dica, pois ainda não estou fazendo uso do outro método jogada que recebe apenas um parâmetro, que deve ser para validar uma jogada 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Renan Galina Olá de novo. Apenas um ponto importante que eu estava deixando passar: O sinal de menos nos atributos das classes do diagrama representa qual visibilidade os mesmos devem ter, nesse caso private (privados)

Logo, o método para imprimir o tabuleiro na classe Menu teria que ser mudado

Já mudei aqui, mas creio q vai saber como resolver isso

No seu código também está faltando um método a mais na classe Jogador, que é o método jogada, que recebe apenas um parâmetro. O outro método jogada dessa classe você criou

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@giu_d Mas ta com sinal de + no UML. O que tem sinal de - é apenas o teclado, que eu declarei: private Scanner sc = new Scanner (System.in);


Pensei em um método para criar o jogada:
 

boolean validarJogada(Tabuleiro tabuleiro) {

if (posições[linha][coluna] == sinal || posições[linha][coluna] == 'O') {

return false;

} else { //jogada válida

posições[linha][coluna] = sinal;

jogada++;

return true;

}

}

Compartilhar este post


Link para o post
Compartilhar em outros sites

Fiz alterações!

> Tabuleiro

public class Tabuleiro {
        public String[][] matriz;
        public String[][] posições;

        public Tabuleiro() {
            posições = new String[3][3];
            for (int i = 0; i < posições.length; i++) {
                for (int j = 0; j < posições[i].length; j++) {
                    posições[i][j] = "";
                }
            }
        }

        public String getPosicao(int linha, int coluna) {
            return posições[linha][coluna];
        }

        public String getPosicoes(int a, int b){
            return matriz[a][b];
        }

        public void setPosicao(int linha, int coluna, String valor) {
            posições[linha][coluna] = valor;
        }
        public boolean verificaVitoria(String sinal) {
            if ((posições[0][0] == sinal && posições[0][1] == sinal && posições[0][2] == sinal) || //linha 1
                    (posições[1][0] == sinal && posições[1][1] == sinal && posições[1][2] == sinal) || //linha 2
                    (posições[2][0] == sinal && posições[2][1] == sinal && posições[2][2] == sinal) || //linha 3
                    (posições[0][0] == sinal && posições[1][0] == sinal && posições[2][0] == sinal) || //coluna 1
                    (posições[0][1] == sinal && posições[1][1] == sinal && posições[2][1] == sinal) || //coluna 2
                    (posições[0][2] == sinal && posições[1][2] == sinal && posições[2][2] == sinal) || //coluna 3
                    (posições[0][0] == sinal && posições[1][1] == sinal && posições[2][2] == sinal) || //diagonal
                    (posições[0][2] == sinal && posições[1][1] == sinal && posições[2][0] == sinal)) {  //diagonal inversa
                return true;
            }
            return false;
        }
    }

Jogador
   

 public class Jogador{
        private int qtd, id, id_jogador;
        public int linha=0, coluna=0;
        
        //Construtor
        public Jogador(int id_jogador){
            this.id_jogador = id_jogador; 
        }
        public int getid(){
            return this.id;
        }
        public void jogada(Tabuleiro tabuleiro, int linha, int coluna){
            this.linha = linha;
            this.coluna = coluna;        
             if (posições[linha][coluna] == sinal || posições[linha][coluna] == 'O') {
                return false;

                }     else { //jogada válida
                    posições[linha][coluna] = sinal;
                    jogada++;
                    return true;
                }
              }
              public void jogada(Tabuleiro tabuleiro){
                  System.out.println(tabuleiro);
                  menu.lerLinha();
                  menu.lerColuna();
              }
                  public void jogada(Tabuleiro tabuleiro){    
             if (id ==1)
                 tabuleiro.setPosicao(linha, coluna, "X");
             else
                tabuleiro.setPosicao(linha, coluna, "O");

                        }
        }

Menu   

 import java.util.Scanner;
    public class Menu{
        private Scanner sc = new Scanner (System.in);
        private int linha=0, coluna=0;
        public Menu(){
        }
        public void imprimeTabuleiro(int oi, int ola, Tabuleiro tabuleiro){
             String[][] matriz = tabuleiro.getPosicoes();

             for (int a = 0; a < matriz.length; a++) {
                for (int b = 0; b < matriz[0].length; b++) {
                    System.out.print(matriz[a][b] + " | ");
                }
                System.out.println();
            }
        }
        public int lerLinha(){
            System.out.println("Digite a linha: ");
            this.linha = sc.nextInt();
            return linha;
        
        }
        public int lerColuna(){
            
            System.out.println("Digite a coluna: ");
            this.coluna = sc.nextInt();
                return coluna;
            }
        }

Main   

 public class JogoDaVelha {
        public static void main(String[] args) {
            Menu menu = new Menu();
            Tabuleiro tabuleiro = new Tabuleiro();
            int linha, coluna, contador=0;
            Jogador jogador1;
            Jogador jogador2;
            boolean vitoriaX=false, vitoriaO=false;

            //Identifica o jogador 1 como humano ( usando id 1 )
            jogador1 = new Jogador(1);
            jogador2 = new Jogador(2);

            //Impressão inicial para começar o jogo
            menu.imprimeTabuleiro(tabuleiro);

            do{
                //Faz a jogada do primeiro jogador, considerando o método para usuário humano
                jogador1.jogada(tabuleiro,menu.lerLinha(), menu.lerColuna());
                //contabiliza a jogada com sucesso, visto que os métodos já garantem que a jogada sempre acontecerá com sucesso
                contador++;
                //Imprime o tabuleiro para o usuário ver a situação atual
                menu.imprimeTabuleiro(tabuleiro);
                //Verifica se alguém venceu
                vitoriaX = tabuleiro.verificaVitoria("X");
                vitoriaO = tabuleiro.verificaVitoria("O");
                //Caso ngm tenha vencido ainda e não tenha acabado as jogadas, o segundo jogador joga.
                if(vitoriaX == false && vitoriaO == false && contador < 9){
                    //Faz a jogada do primeiro jogador, considerando o método para usuário computador
                    jogador2.jogada(tabuleiro);
                    //contabiliza a jogada com sucesso, visto que os métodos já garantem que a jogada sempre acontecerá com sucesso
                    contador++;
                    //Imprime o tabuleiro para o usuário ver a situação atual
                    menu.imprimeTabuleiro(tabuleiro);    
                    //Verifica se alguém venceu        
                    vitoriaX = tabuleiro.verificaVitoria("X");
                    vitoriaO = tabuleiro.verificaVitoria("O");
                }
                //Repete a estrutura enquanto ngm vencer e houver jogadas disponíveis.
            }while(vitoriaX == false && vitoriaO == false && contador < 9);

            //Verifica se o jogador 1 ganhou
            if (vitoriaX) {
                System.out.println("Vitória do jogador X");
            }else{
                //Verifica se o jogador 2 ganhou
                if (vitoriaO) {
                    System.out.println("Vitória do jogador O");
                }else{
                    //Verifica se deu velha
                    System.out.println("Deu velha!");
                }
            }
        }
    }


Agora, dá os seguintes erros:

    
    .\Jogador.java:29: error: method jogada(Tabuleiro) is already defined in class J
    ogador
                            public void jogada(Tabuleiro tabuleiro){
                                        ^
    JogoDaVelha.java:15: error: method imprimeTabuleiro in class Menu cannot be appl
    ied to given types;
                    menu.imprimeTabuleiro(tabuleiro);
                        ^
      required: int,int,Tabuleiro
      found: Tabuleiro
      reason: actual and formal argument lists differ in length
    JogoDaVelha.java:23: error: method imprimeTabuleiro in class Menu cannot be appl
    ied to given types;
                            menu.imprimeTabuleiro(tabuleiro);
                                ^
      required: int,int,Tabuleiro
      found: Tabuleiro
      reason: actual and formal argument lists differ in length
    JogoDaVelha.java:34: error: method imprimeTabuleiro in class Menu cannot be appl
    ied to given types;
                                    menu.imprimeTabuleiro(tabuleiro);
                                        ^
      required: int,int,Tabuleiro
      found: Tabuleiro
      reason: actual and formal argument lists differ in length
    .\Menu.java:8: error: method getPosicoes in class Tabuleiro cannot be applied to
     given types;
                     String[][] matriz = tabuleiro.getPosicoes();
                                                  ^
      required: int,int
      found: no arguments
      reason: actual and formal argument lists differ in length
    .\Jogador.java:15: error: cannot find symbol
                     if (posições[linha][coluna] == sinal || posições[linha][coluna]
     == 'O') {
                         ^
      symbol:   variable posições
      location: class Jogador
    .\Jogador.java:15: error: cannot find symbol
                     if (posições[linha][coluna] == sinal || posições[linha][coluna]
     == 'O') {
                                                    ^
      symbol:   variable sinal
      location: class Jogador
    .\Jogador.java:15: error: cannot find symbol
                     if (posições[linha][coluna] == sinal || posições[linha][coluna]
     == 'O') {
                                                             ^
      symbol:   variable posições
      location: class Jogador
    .\Jogador.java:16: error: incompatible types: unexpected return value
                return false;
                       ^
    .\Jogador.java:19: error: cannot find symbol
                     posições[linha][coluna] = sinal;
                     ^
      symbol:   variable posições
      location: class Jogador
    .\Jogador.java:19: error: cannot find symbol
                     posições[linha][coluna] = sinal;
                                               ^
      symbol:   variable sinal
      location: class Jogador
    .\Jogador.java:20: error: cannot find symbol
                    jogada++;
                    ^
      symbol:   variable jogada
      location: class Jogador
    .\Jogador.java:21: error: incompatible types: unexpected return value
                     return true;
                            ^
    .\Jogador.java:26: error: cannot find symbol
                            menu.lerLinha();
                            ^
      symbol:   variable menu
      location: class Jogador
    .\Jogador.java:27: error: cannot find symbol
                            menu.lerColuna();
                            ^
      symbol:   variable menu
      location: class Jogador
    15 errors

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Renan Galina Olá. Conforme o diagrama UML os atributos todos devem ser privados e não públicos

Segue alguns exemplos:

Classe Tabuleiro:

private String[][] posicao; // essa matriz deve ser privada, e não pública

Classe Jogador:

private int qtd, id;

E por aí vai. Veja que no diagrama UML tem o sinal de menos (-) antes do nome do atributo. Esse sinal significa que os atributos devem ser privados (private).

No diagrama, ao se referir dos métodos, tem o sinal de mais (+). Isso indica que os métodos devem ser públicos ( public )

Na classe Jogador os dois métodos com o nome jogada devem ser do tipo void, ou seja, não retornam nada e você está em um método jogada retornando false e true?

Ainda na classe Jogador, de onde está saindo essa variável com o nome de "sinal"?

dica: Construtor da classe Jogador:

public Jogador(int id_jogador) {
    this.id = id_jogador;
}

Uma forma de imprimir o tabuleiro na classe Menu:

public void imprimeTabuleiro(Tabuleiro tabuleiro) {
    for (int i = 0; i < 3; i++) {
        System.out.println(" " + tabuleiro.getPosicao(i, 0)
                           + " | " + tabuleiro.getPosicao(i, 1) + " | " + tabuleiro.getPosicao(i, 2));
        if (i < 2) {
            System.out.println("---|---|---");
        }
    }
}

Erros que estão dando em seu código:

A variável "sinal" não foi definida, bem como a variável "jogada". Está fazendo isso: jogada++ sendo que essa variável não foi criada

Na classe Jogador não devem ser criados os atributos linha e coluna ( De acordo com o diagrama )

Fazer uso da classe Menu na classe Jogador não está de acordo com o diagrama

Na classe Tabuleiro o único atributo que deve ser criado eu passei acima

OBS: Não use acentuação em nomes de variáveis, atributos ou métodos. Isso não está de acordo com o padrão Java de nomenclaturas

 

Experimenta fazer essas mudanças e aí vê se vai, ok?

Qualquer dúvida é só perguntar, ok?

Não posso passar o código do modo como criei té porque iria atrapalhar no seu processo de aprendizagem 😉

  • Curtir 2

Compartilhar este post


Link para o post
Compartilhar em outros sites

@giu_d O único erro para compilar agora, está na classe Jogador.

 

Jogador.java:17: error: cannot find symbol
                        tabuleiro.setPosicao(linha, coluna, "X");
                                             ^
  symbol:   variable linha
  location: class Jogador
Jogador.java:17: error: cannot find symbol
                        tabuleiro.setPosicao(linha, coluna, "X");
                                                    ^
  symbol:   variable coluna
  location: class Jogador
Jogador.java:19: error: cannot find symbol
            tabuleiro.setPosicao(linha, coluna, "O");
                                 ^
  symbol:   variable linha
  location: class Jogador
Jogador.java:19: error: cannot find symbol
            tabuleiro.setPosicao(linha, coluna, "O");
                                        ^
  symbol:   variable coluna
  location: class Jogador
Jogador.java:24: error: cannot find symbol
                 if (posições[linha][coluna] == sinal || posições[linha][coluna]
 == 'O') {
                     ^
  symbol:   variable posições
  location: class Jogador
Jogador.java:24: error: cannot find symbol
                 if (posições[linha][coluna] == sinal || posições[linha][coluna]
 == 'O') {
                                                ^
  symbol:   variable sinal
  location: class Jogador
Jogador.java:24: error: cannot find symbol
                 if (posições[linha][coluna] == sinal || posições[linha][coluna]
 == 'O') {
                                                         ^
  symbol:   variable posições
  location: class Jogador
Jogador.java:27: error: cannot find symbol
                 posições[linha][coluna] = sinal;
                 ^
  symbol:   variable posições
  location: class Jogador
Jogador.java:27: error: cannot find symbol
                 posições[linha][coluna] = sinal;
                                           ^
  symbol:   variable sinal
  location: class Jogador
Jogador.java:28: error: cannot find symbol
                jogada++;
                ^
  symbol:   variable jogada
  location: class Jogador
10 errors

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Renan Galina Olá. Segue o código da classe Jogador (ainda não está pronto ) 

public class Jogador {

    private int qtd, id; // o atributo qtd ainda não está em uso

    public Jogador(int id_jogador) {
        this.id = id_jogador;
    }

    public int getid() {
        return this.id;
    }
    // Em um desses métodos aqui teria que validar se a posição da jogada está vazia
    public void jogada(Tabuleiro tabuleiro, int linha, int coluna) {

        if (id == 1) {
            tabuleiro.setPosicao(linha, coluna, "X");
        } else {
            tabuleiro.setPosicao(linha, coluna, "O");
        }
    }

    public void jogada(Tabuleiro tabuleiro) {
        // esse método ainda não está ajustado
    }
}

Agora vê se ajuda a concluir o exercício. Ainda falta validar se a posição da jogada não está preenchida 

Segue o código de uma parte que verifica se a jogada é válida:

public int lerLinha() {
    do {
        System.out.print("Digite a linha: ");
        linha = teclado.nextInt();
    } while (linha < 0 || linha > 2);
    return linha;
}

Outro ponto. Método setPosicao da classe Tabuleiro:

public void setPosicao(int linha, int coluna, String valor) {
    posicao[linha][coluna] = valor;
}

Perceba que mudei o nome da matriz para String[][] posicao; (conforme o diagrama )

Compartilhar este post


Link para o post
Compartilhar em outros sites

Ok, consegui rodar finalmente o programa.
Agora, há um dilema: Tenho que alterar para td vez não repetir o 'x' porque qualquer valor que eu digite em linha ou coluna me retorna apenas X. 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Alguma luz?

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Renan Galina Só um pouco. Deu um probleminha aqui e já retorno

Atualizando...

Tudo resolvido. Deu uns probleminhas aqui no pc mas agora tá tudo ok!

É o seguinte: agora deu para ajustar o restante do jogo que faltava. Só que fiz várias mudanças na classe JogoDaVelha e também ajustei a classe Jogador (foi preciso fazer uso da classe Menu na classe Jogador para resolver e centralizar o processamento nessa classe )

Segue como ficou a classe JogoDaVelha:

import java.util.ArrayList;
import java.util.List;

public class JogoDaVelha {

    public static void main(String[] args) {

        List<Jogador> jogadores = new ArrayList<>();
        int indexAtual;
        boolean finalizado;


        jogadores.add(new Jogador(1));
        jogadores.add(new Jogador(2));

        Menu menu = new Menu();

        Tabuleiro tabuleiro = new Tabuleiro();

        menu.imprimeTabuleiro(tabuleiro);

        finalizado = false;

        Jogador vencedor = null;

        indexAtual = 0;

        while (!finalizado) {

            Jogador jogador = jogadores.get(indexAtual);

            jogador.jogada(tabuleiro);

            if (tabuleiro.verificaVitoria("X") || tabuleiro.verificaVitoria("O")) {
                finalizado = true;
                vencedor = jogador;
            }

            menu.imprimeTabuleiro(tabuleiro);

            indexAtual = (indexAtual + 1) % jogadores.size();
        }

        System.out.println("A vitória foi do jogador com id " + vencedor.getid());

    }

}
}

Segue como ficou a classe Jogador:

public class Jogador {

    private int qtd, id;
    private int linha, coluna;
    private Menu menu = new Menu();

    public Jogador(int id_jogador) {
        this.id = id_jogador;
        this.qtd = 0;
    }

    public int getid() {
        return this.id;
    }

    public void jogada(Tabuleiro tabuleiro, int linha, int coluna) {

        if (id == 1) {
            tabuleiro.setPosicao(linha, coluna, "X");
        } else {
            tabuleiro.setPosicao(linha, coluna, "O");
        }

        qtd++;
    }

    public void jogada(Tabuleiro tabuleiro) {

        do {

            System.out.println("É a vez do jogador com id " + getid());

            do {
                linha = menu.lerLinha();
            } while (linha < 0 || linha > 2);

            do {
                coluna = menu.lerColuna();
            } while (coluna < 0 || coluna > 2);

            if (tabuleiro.getPosicao(linha, coluna) != " ") {
                System.out.println("Erro: Essa jogada já foi efetuada!");
                menu.imprimeTabuleiro(tabuleiro);
                continue;
            }

        } while (tabuleiro.getPosicao(linha, coluna) != " ");

        jogada(tabuleiro, linha, coluna);

        qtd++;

        if (qtd > 9) {
            System.out.println("Deu empate!");
            System.exit(0);
        }
    }

}

Ficou um pouco diferente de como você havia feito

A única maneira que encontrei para ajustar a classe Jogador foi essa

 

Qualquer dúvida é só perguntar, ok?

Compartilhar este post


Link para o post
Compartilhar em outros sites

@giu_d O meu ficou assim: 

public class JogoDaVelha {
	  public static void main(String[] args) {
        Menu menu = new Menu();
        Tabuleiro tabuleiro = new Tabuleiro();

        // Identifica o jogador 1 como humano ( usando id 1 )
        Jogador jogador1 = new Jogador(1);
        Jogador jogador2 = new Jogador(2);

        // Impressão inicial para começar o jogo
        menu.imprimeTabuleiro(tabuleiro);

        // começa com o jogador humano
        Jogador jogador = jogador1;

        boolean acabou = false;
        do {
            if (jogador.getid() == 1) {
                // Faz a jogada do considerando o método para usuário humano
                jogador.jogada(tabuleiro, menu.lerLinha(), menu.lerColuna());
            } else {
                // Faz a jogada do considerando o método para computador
                jogador.jogada(tabuleiro);
            }

            // troca de jogador
            if (jogador == jogador1) {
                jogador = jogador2;
            } else {
                jogador = jogador1;
            }

            // Imprime o tabuleiro para o usuário ver a situação atual
            menu.imprimeTabuleiro(tabuleiro);

            // Verifica se alguém venceu
            if (tabuleiro.verificaVitoria("X")) {
                System.out.println("Vitória do jogador X");
                acabou = true;
            } else if (tabuleiro.verificaVitoria("O")) {
                System.out.println("Vitória do jogador O");
                acabou = true;
            } else if ((jogador1.getQtd() + jogador2.getQtd()) == 9) {
                System.out.println("Deu velha!");
                acabou = true;
            }
        } while (!acabou);
    }
}
public class Jogador {

    private int qtd, id; // o atributo qtd ainda não está em uso

    public Jogador(int id_jogador) {
        this.id = id_jogador;
        this.qtd = 0;
    }
    public int getQtd() {
        return qtd;
    }

    public int getid() {
        return this.id;
    }
    // Em um desses métodos aqui teria que validar se a posição da jogada está vazia
    public void jogada(Tabuleiro tabuleiro, int linha, int coluna) {

        if (id == 1) {
            tabuleiro.setPosicao(linha, coluna, "X");
        } else {
            tabuleiro.setPosicao(linha, coluna, "O");
        }
        qtd++;
    }

    public void jogada(Tabuleiro tabuleiro) {
        // aqui o computador deve escolher uma posição vazia do tabuleiro para jogar
        int linha = 0; // trocar o zero pela linha escolhida pelo computador;
        int coluna = 0; // trocar o zero pela coluna escolhida pelo computador;
        tabuleiro.setPosicao(linha, coluna, "O");
        qtd++;
    }

}

Só que quando executo, mesmo problema:
 

Citação

 |  |  |
 |  |  |
 |  |  |
Digite a linha: 1
Digite a coluna: 1
 |  |  |
 | X |  |
 |  |  |
O |  |  |
 | X |  |
 |  |  |
Digite a linha: 2
Digite a coluna: 2
O |  |  |
 | X |  |
 |  | X |
O |  |  |
 | X |  |
 |  | X |
Digite a linha: 2
Digite a coluna: 1
O |  |  |
 | X |  |
 | X | X |
O |  |  |
 | X |  |
 | X | X |
Digite a linha: 2
Digite a coluna: 0
O |  |  |
 | X |  |
X | X | X |
Vitória do jogador X

Precisa de uma lógica para quando jogar X, trocar para o O. 

adicionado 6 minutos depois

Rodei seu código aqui, mas não da pra digitar a linha nem coluna: sempre aparece: "Erro essa jogada ja foi efetuada" sendo que nao ta preenchido.

 

Consegui arrumar: em vez do continue; era break. 

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Renan Galina Olá. Veja o resultado de um jogo aqui do modo como estou fazendo:


   |   |  
---|---|---
   |   |  
---|---|---
   |   |  

É a vez do jogador com id 1
Digite a linha: 0
Digite a coluna: 0

 X |   |  
---|---|---
   |   |  
---|---|---
   |   |  

É a vez do jogador com id 2
Digite a linha: 1
Digite a coluna: 1

 X |   |  
---|---|---
   | O |  
---|---|---
   |   |  

É a vez do jogador com id 1
Digite a linha: 2
Digite a coluna: 2

 X |   |  
---|---|---
   | O |  
---|---|---
   |   | X

É a vez do jogador com id 2
Digite a linha: 0
Digite a coluna: 1

 X | O |  
---|---|---
   | O |  
---|---|---
   |   | X

É a vez do jogador com id 1
Digite a linha: 2
Digite a coluna: 1

 X | O |  
---|---|---
   | O |  
---|---|---
   | X | X

É a vez do jogador com id 2
Digite a linha: 2
Digite a coluna: 0

 X | O |  
---|---|---
   | O |  
---|---|---
 O | X | X

É a vez do jogador com id 1
Digite a linha: 1
Digite a coluna: 0

 X | O |  
---|---|---
 X | O |  
---|---|---
 O | X | X

É a vez do jogador com id 2
Digite a linha: 0
Digite a coluna: 2

 X | O | O
---|---|---
 X | O |  
---|---|---
 O | X | X

Vitória do jogador com id 2

Tudo funcionando de acordo com o esperado 😀

 

Veja a simulação de uma jogada inválida:


   |   |  
---|---|---
   |   |  
---|---|---
   |   |  

É a vez do jogador com id 1
Digite a linha: 1
Digite a coluna: 1

   |   |  
---|---|---
   | X |  
---|---|---
   |   |  

É a vez do jogador com id 2
Digite a linha: 1
Digite a coluna: 1
Erro: Essa jogada já foi efetuada!

   |   |  
---|---|---
   | X |  
---|---|---
   |   |  

É a vez do jogador com id 2
Digite a linha: 

 

adicionado 57 minutos depois

@Renan Galina Olá. Se sua ideia é fazer usuário contra computador experimenta isso:

Classe Jogador:

private int qtd, id;	
private Random random = new Random();

//////

public void jogada(Tabuleiro tabuleiro, int linha, int coluna) {

    tabuleiro.setPosicao(linha, coluna, "X");

    qtd++;
}

public void jogada(Tabuleiro tabuleiro) {

    int linha;
    int coluna;

    do {

        linha = random.nextInt(3);
        coluna = random.nextInt(3);
    } while (tabuleiro.getPosicao(linha, coluna) != " ");

    tabuleiro.setPosicao(linha, coluna, "O");
}

E aí na classe JogoDaVelha:


jogador.jogada(tabuleiro, menu.lerLinha(), menu.lerColuna());

if (jogador == jogador1) {
    jogador = jogador2;
} else {
    jogador = jogador1;
}

jogador.jogada(tabuleiro);

// Imprime o tabuleiro para o usuário ver a situação atual
menu.imprimeTabuleiro(tabuleiro);

Funciona, mas dessa forma usa bastante processamento, pois a medida que as posições vão sendo ocupadas, a qtde de posições no tabuleiro diminui

  • Amei 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@giu_d Obrigado pela ajuda giu_d! 

  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×