Exibir código-fonte para Programação em Java - Exemplo Jogo da Velha

Voltar para [[Programação em Java]]

O Jogo da Velha é um jogo para dois jogadores e que deve ser jogado sobre um tabuleiro de 3x3 casas. Um dos jogadores escolhe uma casa e a marca com um círculo. Em seguida o outro escolhe outra casa e a marca com um xis. Os jogadores continuam se alternando desta forma, até que uma linha com os mesmos símbolos seja formada, na vertical, horizontal ou diagonal. No caso, o jogador que completou a linha, vence o jogo. O jogo também acaba se não houver mais jogadas possíveis, o que caracteriza um empate.

Para este exercício deve ser implementado um programa Java que permita a duas pessoas jogarem Jogo da Velha. Este exercício visa colocar em prática conhecimentos básicas de programação, como arrays, métodos, estruturas de controle de fluxo/repetição, classes, objetos e interação com o usuário.

O tabuleiro deve ser implementado como um array 3x3, onde cada posição do array representa uma casa no jogo. Cada casa do tabuleiro deve acomodar três estados possíveis: vazio, círculo e xis. Portanto o conteúdo do array pode ser int (0=vazio, 1=círculo, 2=xis), char (_=vazio, o=círculo, x=xis), enum, ou qualquer outra coisa que permita representar estes três estados distintos.

Deve ser criada uma classe para encapsular a lógica do jogo. Dentro desta classe deve ficar o tabuleiro, cujo acesso deve ser feito apenas através de métodos desta classe. Devem ser criados métodos para fazer uma jogada (indicando as coordenadas), checar se o jogo não acabou ainda, saber qual jogador ganhou (ou se deu empate), imprimir o tabuleiro na tela, e outros, conforme necessidade.

Durante a execução do programa, cada jogador deve escrever sua jogada (coordenadas) na linha de comando, e o jogo deve imprimir o tabuleiro e esperar pela jogada do próximo jogador. O programa não deve permitir que o jogador tente marcar uma casa que já esteja marcada, nem que tente jogar em casas que não existam (coordenadas negativas, ou maior que o tamanho do tabuleiro). A classe que encapsula a lógica do jogo deve conter métodos para testar se uma dada jogada é válida, que devem ser chamados antes de efetuar a jogada de fato. Ou pode-se fazer este tratamento de erro com exceções.

= Resolução =

<syntaxhighlight lang=java line>
import java.util.Scanner;

public class JogoDaVelha {
	private int jogo[][] = new int[3][3];

	public JogoDaVelha() {
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				jogo[i][j] = 0;
			}
		}
	}

	public void mostrar() {
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				System.out.print(jogo[i][j] + " ");
			}
			System.out.println();
		}
	}

	public int verificarVencedor() {
		for (int i = 0; i < 3; i++) {
			if ((jogo[i][0] == jogo[i][1]) &&
				(jogo[i][0] == jogo[i][2])) {
				if (jogo[i][0] != 0) {
					return jogo[i][0];
				}
			}
		}
		for (int j = 0; j < 3; j++) {
			if ((jogo[0][j] == jogo[1][j]) &&
				(jogo[0][j] == jogo[2][j]) &&
				(jogo[0][j] != 0)) {
				return jogo[0][j];
			}
		}
		if ((jogo[0][0] == jogo[1][1]) &&
			(jogo[0][0] == jogo[2][2]) &&
			(jogo[0][0] != 0)) {
			return jogo[0][0];
		}
		if ((jogo[0][2] == jogo[1][1]) &&
			(jogo[0][2] == jogo[2][0]) &&
			(jogo[0][2] != 0)) {
			return jogo[0][2];
		}
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				if (jogo[i][j] == 0) {
					return 0;
				}
			}
		}
		return 3;
	}
	
	public boolean efetuarJogada(int jogador, int linha, int coluna) {
		if ((linha < 0) || (linha > 2)) {
			return false;
		}
		if ((coluna < 0) || (coluna > 2)) {
			return false;
		}
		if (jogo[linha][coluna] != 0) {
			return false;
		}
		jogo[linha][coluna] = jogador;
		return true;
	}

	public static void main(String[] argumentos) {
		Scanner teclado = new Scanner(System.in);
		JogoDaVelha jogo = new JogoDaVelha();
		int jogador = 1;
		int vencedor = jogo.verificarVencedor();
		jogo.mostrar();
		while (vencedor == 0) {
			System.out.println("Jogador " + jogador);
			System.out.print("Linha: ");
			int linha = teclado.nextInt();
			System.out.print("Coluna: ");
			int coluna = teclado.nextInt();
			if (!jogo.efetuarJogada(jogador, linha-1, coluna-1)) {
				System.out.println("Jogada inválida...");
			} else {
				jogador = (jogador == 1) ? 2 : 1;
			}
			jogo.mostrar();
			vencedor = jogo.verificarVencedor();
		}
		switch (vencedor) {
		case 1 :
			System.out.println("Vencedor jogador 1");
			break;
		case 2:
			System.out.println("Vencedor jogador 2");
			break;
		case 3:
			System.out.println("Empate");
			break;
		}
	}
}

</syntaxhighlight>

= Resolução 2 =

<syntaxhighlight lang=java line>
import java.util.Scanner;

public class JogoDaVelha {
	private int [][] tabuleiro = new int[3][3];
	private int jogador = 1;
	
	public boolean jogar(int x, int y) {
		if ((x < 0) || (x > 2) || (y < 0) || (y > 2)) {
			return false;
		}
		if (tabuleiro[x][y] != 0) {
			return false;
		}
		tabuleiro[x][y] = jogador;
		jogador = (jogador == 1) ? 2 : 1;
		return true;
	}
	
	public int vencedor() {
		for (int j = 1; j < 3; j++) {
			// Testa as linhas
			for (int linha = 0; linha < 3; linha++) {
				boolean fechou = true;
				for (int coluna = 0; coluna < 3; coluna++) {
					if (tabuleiro[coluna][linha] != j) {
						fechou = false;
					}
				}
				if (fechou) {
					return j;
				}
			}
			// Testa as colunas
			for (int coluna = 0; coluna < 3; coluna++) {
				boolean fechou = true;
				for (int linha = 0; linha < 3; linha++) {
					if (tabuleiro[coluna][linha] != j) {
						fechou = false;
					}
				}
				if (fechou) {
					return j;
				}
			}
			// Testar as diagonais
			boolean fechou = true;
			for (int posicao = 0; posicao < 3; posicao++) {
				if (tabuleiro[posicao][posicao] != j) {
					fechou = false;
				}
			}
			if (fechou) {
				return j;
			}
			fechou = true;
			for (int posicao = 2; posicao >= 0; posicao--) {
				if (tabuleiro[posicao][2-posicao] != j) {
					fechou = false;
				}
			}
			if (fechou) {
				return j;
			}
		}
		boolean empate = true;
		for (int linha = 0; linha < 3; linha++) {
			for (int coluna = 0; coluna < 3; coluna++) {
				if (tabuleiro[coluna][linha] == 0) {
					empate = false;
				}
			}
		}
		if (empate) {
			return 3;
		}
		return 0;
	}
	
	public String toString() {
		String out = "";
		for (int linha = 0; linha < 3; linha++) {
			for (int coluna = 0; coluna < 3; coluna++) {
				switch (tabuleiro[coluna][linha]) {
				case 0 :
					out += "_ ";
					break;
				case 1 :
					out += "O ";
					break;
				case 2 :
					out += "X ";
					break;
				}
			}
			out += "\n";
		}
		return out;
	}
	
	public void executar() {
		Scanner entrada = new Scanner(System.in);
		while (vencedor() == 0) {
			System.out.println(this);
			System.out.println("Jogador: " + jogador);
			System.out.print("Coluna: ");
			int coluna = entrada.nextInt();
			System.out.print("Linha: ");
			int linha = entrada.nextInt();
			if (!jogar(coluna, linha)) {
				System.out.println("Jogada invalida, tente novamente...");
			}
		}
		System.out.println(this);
		System.out.println(vencedor());
	}
	
	public static void main(String [] args) {
		JogoDaVelha jogo = new JogoDaVelha();
		jogo.executar();
	}
}
</syntaxhighlight>