Ir ao conteúdo

Java Jogo Da Velha em Java


Ir à solução Resolvido por Nozdog,

Posts recomendados

Postado

Fiz um jogo da velha para 2jogadores, mas estou querendo colocar para um jogador apenas. porém estou com dificuldade para fazer as jogadas do computador e implementar no código. O computador contendo 3Dificuldades Exemplo: fácil, médio e difícil.

package com.JVelha;

import java.util.Scanner;

public class JogoVelha {

	public static void main(String[] args) {
		Scanner ler = new Scanner(System.in);
		Ms jogo = new Ms();
		String posicao;
		int valida = 0, Jogadas = 0;
		
		while(true) {
			System.out.println("+++++Jogo Da Velha+++++");
			jogo.Mostrar();
			
			do {//inicia o primeiro jogador
				System.out.print("Jogador 1, informe a posição: ");
				posicao = ler.next();
				while(!jogo.Valido(posicao)) {
					System.out.println("Jogada Invalida, Escolha Outra Posição!!!");
					System.out.print("Jogador 1, informe a posição: ");
					posicao = ler.next();
					valida = 0;
				}
				jogo.jogada(posicao, "X");
				valida = 1;
				
				
			}while(valida == 0);//fim primeiro jogador
			
			Jogadas++;
			valida = 0;
			jogo.Mostrar();
			if(!jogo.Ganhou(Jogadas).equals("null")) {
				break;
			}
			
			do {//inicia o segundo jogador
				System.out.print("Jogador 2, informe a posição: ");
				posicao = ler.next();
				while(!jogo.Valido(posicao)) {
					System.out.println("Jogada Invalida, Escolha Outra Posição!!!");
					System.out.print("Jogador 2, informe a posição: ");
					posicao = ler.next();
					valida = 0;
				}
				jogo.jogada(posicao, "O");
				valida = 1;
				
			}while(valida == 0);//fim segundo jogador

			Jogadas++;
			valida = 0;
			jogo.Mostrar();
			if(!jogo.Ganhou(Jogadas).equals("null")) {
				break;		
		}

	}
	System.out.println("O "+jogo.Ganhou(Jogadas)+" Venceu!");

	}

}




________________________________________________________________________________________________________________________



package com.JVelha;

public class Ms {
	
	private String[][] m = {{"1","2","3"},
			                {"4","5","6"},//Tabuleiro   
			                {"7","8","9"}};
	
	public String Mostrar() {
		for(int linha=0; linha<3; linha++) {
			for(int coluna=0; coluna<3; coluna++) {
				System.out.printf("   "+ m[linha][coluna]);				
			}
			System.out.println("\n");
		}
		return null;
	}
	public boolean Valido(String p) {
		for(int linha=0; linha<3; linha++) {
			for(int coluna=0; coluna<3; coluna++) {
				if(m[linha][coluna].equals(p))
					return true;
			}			
		}
		return false;		
	}
	
	public void jogada(String p, String j) {
		if(p.equals("1"))
			m[0][0] = j;
		else if(p.equals("2"))
			m[0][1] = j;
		else if(p.equals("3"))
			m[0][2] = j;
		else if(p.equals("4"))
			m[1][0] = j;
		else if(p.equals("5"))
			m[1][1] = j;
		else if(p.equals("6"))
			m[1][2] = j;
		else if(p.equals("7"))
			m[2][0] = j;
		else if(p.equals("8"))
			m[2][1] = j;
		else if(p.equals("9"))
			m[2][2] = j;		
	}
	
	public String Ganhou(int jogadas) {
		String[] T = new String[8];
		String vencedor = "null";
		if(jogadas == 9) {
			vencedor = "EMPATE";
			
		}		
		T[0] = m[0][0] + m[0][1] + m[0][2];
		T[1] = m[1][0] + m[1][1] + m[1][2];
		T[2] = m[2][0] + m[2][1] + m[2][2];
		
		T[3] = m[0][0] + m[1][0] + m[2][0];
		T[4] = m[0][1] + m[1][1] + m[2][1];
		T[5] = m[0][2] + m[1][2] + m[2][2];
		
		T[6] = m[0][0] + m[1][1] + m[2][2];
		T[7] = m[0][2] + m[1][1] + m[2][0];
		
		for(int i=0; i<T.length; i++) {
			if(T[i].equals("XXX")) {
				vencedor = "Jogador 1";
			}else if(T[i].equals("000")) {
					vencedor = "Jogador 2";
			}
		}
		return vencedor;
	}

}

 

  • Amei 1
Postado

Para jogar contra o PC, você vai ter que implementar algum algoritmo de inteligência artificial, não precisa ser algo complexo de ficção científica, apenas o suficiente para entender a jogada do usuário e dar um jeito de contra atacar.

 

Por exemplo, você poderia detectar quando o usuário marcou duas casas e está indo para completar a terceira, e você programa o PC para fazer a jogada nessa terceira casa, bloqueando o usuário.

  • Curtir 1
  • 3 semanas depois...
Postado

@AdrianoSiqueira eu fiz um negocio aqui, n sei se ta certo, e ele apresenta como se estivesse errado, como eu poderia resolver ?

já importei o pacote do random

 

do {//inicia jogador 2
				Random aleatorio = new Random();
				int co = aleatorio.nextInt(10);
				
				posicao = co.next();
				while(!jogo.Valido(posicao)){//valida a posição jogada
					posicao = ler.next();
					valida = 0;
				}
				jogo.Jogada(posicao, "O");
				valida = 1;				
				
			}while(valida == 0);//fim jogador 2

 

  • Obrigado 1
Postado

@AdrianoSiqueira consegui arrumar o de cima, agora ele faz a jogada normalmente, o problema é que ele só faz a jogada uma vez. e eu não estou conseguindo com que ele faça repetidas vezes na vez dele

do {//inicia jogador 2
					
					int x = aleatorio.nextInt(10);
					String str_x = String.valueOf(x);
					
					posicao = str_x;
					while(!jogo.Valido(posicao)){//valida a posição jogada
						posicao = ler.next();
						valida = 0;
					}
					jogo.Jogada(posicao, "O");
					valida = 1;				
					
				}while(valida == 0);//fim jogador 2

 

  • Obrigado 1
Postado

@Nozdog Faça o seguinte

  1. Crie um vetor e guarde todas as posições possíveis.
  2. Embaralhe o vetor com o algoritmo fisher yates.  
  3. Percorra o vetor para buscando uma jogada possível.

Para achar uma jogada possível divida o valor do vetor pela quantidade de linhas, com o quociente em mão você vai ter a linha da jogada.

Faça o mesmo processo para achar a coluna da jogada, mas só que dessa vez você utiliza o resto da operação.

 

Exemplo

	int linha = locais[contador]/3;
	int coluna = locais[contador]%3;

 

Exemplo de simulação em C

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>

/* Constantes */
#define Q_LINHAS 3
#define Q_COLUNAS 3

/* Valores dos objetos no jogo */
enum t_objetos {
    VAZIO,
    CRUZ,
    BOLA,
    VELHA
};

void
limpaTabuleiro(enum t_objetos t[][Q_COLUNAS]);

int

validaJogada(enum t_objetos t[][Q_COLUNAS], int linha, int coluna);

enum t_objetos
verificaVitoria(enum t_objetos t[][Q_COLUNAS]);

int main(void)
{
    enum
        t_objetos tabuleiro[Q_LINHAS][Q_COLUNAS],
        vez = CRUZ;
    int
        locais[Q_LINHAS*Q_COLUNAS],
        contador,
        linhas,
        colunas;
    
    char opcao;
    
    /* Inicia o gerador de numeros aleatorios */
    srand(time(NULL));
    do {
        /* Limpa o tabuleiro */
        limpaTabuleiro(tabuleiro);
        
        /* 
         * Inicia o local das jogadas 
         * Coloca todos os locais das jogadas em sequencia
         */
        for (contador = 0; contador < Q_LINHAS*Q_COLUNAS; contador++) {
            locais[contador] = contador;
        }
        
        /* 
         * Embaralha o local das jogadas
         * Com o algoritmo Fisher Yates
         */
        for (contador = 0; contador < Q_LINHAS*Q_COLUNAS; contador++) {
            int indice = rand()%(Q_LINHAS*Q_COLUNAS);
            int temporario = locais[contador];
            locais[contador] = locais[indice];
            locais[indice] = temporario;
        }
        
        /* Faz as jogadas */
        do {
            contador = 0;
            while (contador < (Q_LINHAS*Q_COLUNAS)) {
                if (validaJogada(tabuleiro, locais[contador]/Q_LINHAS, locais[contador]%Q_COLUNAS)) {
                    /* Coloca a jogada no tabuleiro */
                    tabuleiro[locais[contador]/Q_LINHAS][locais[contador]%Q_COLUNAS] = vez;
                    if (vez == CRUZ) {
                        vez = BOLA;
                    } else {
                        vez = CRUZ;
                    }
                    break;
                }
                contador++;
            }
        } while (verificaVitoria(tabuleiro) == VAZIO);
        
        /* Mostra o tabuleiro */
        for (linhas = 0; linhas < Q_LINHAS; linhas++) {
            for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
                switch (tabuleiro[linhas][colunas]) {
                    case VAZIO:
                        if (linhas < Q_LINHAS-1) {
                            printf("_");
                        } else {
                            printf(" ");
                        }
                        break;
                    case CRUZ:
                        printf("X");
                        break;
                    case BOLA:
                        printf("O");
                        break;
                }
                
                if (colunas < Q_COLUNAS-1) {
                    printf("|");
                }
            }
            printf("\n");
        }
        switch (verificaVitoria(tabuleiro)) {
            case CRUZ:
                printf("Vitoria da cruz!\n");
                break;
            case BOLA:
                printf("Vitoria da bola!\n");
                break;
            case VELHA:
                printf("Ninguem ganhou!\n");
        }
        printf("\n");
        printf("Rodar a simulacao novamente\nS|N:");
        scanf("%c%*c", &opcao);
    } while (toupper(opcao) == 'S');
    return(0);
}

void
limpaTabuleiro(enum t_objetos t[][Q_COLUNAS])
{
    int linhas, colunas;
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
            t[linhas][colunas] = VAZIO;
        }
    }
}

int
validaJogada(enum t_objetos t[][Q_COLUNAS], int linha, int coluna)
{
    if (t[linha][coluna] == VAZIO) {
        return(1);
    }
    return(0);
}

enum t_objetos
verificaVitoria(enum t_objetos t[][Q_COLUNAS])
{
    int
        linhas,
        colunas,
        contador;
    
    enum t_objetos objeto;
    /* Verifica as linhas */
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        objeto = t[linhas][0];
        contador = 1;
        for (colunas = 1; colunas < Q_COLUNAS; colunas++) {
            if (objeto == t[linhas][colunas]) {
                contador++;
            }
        }
        if (contador >= Q_LINHAS) {
            if (objeto != VAZIO) {
                return(objeto);
            }
        }
    } 
    
    /* Verifica as colunas */
    for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
        objeto = t[0][colunas];
        contador = 1;
        for (linhas = 1; linhas < Q_LINHAS; linhas++) {
            if (objeto == t[linhas][colunas]) {
                contador++;
            }
        }
        if (contador >= Q_LINHAS) {
            if (objeto != VAZIO) {
                return(objeto);
            }
        }
    }
    
    /* Verifica diagona esquerda */
    objeto = t[0][0];
    contador = 1;
    for (linhas = 1, colunas = 1; linhas < Q_LINHAS||colunas < Q_COLUNAS; linhas++, colunas++) {
        if (objeto == t[linhas][colunas]) {
            contador++;
        }
    }
    if (contador >= Q_LINHAS) {
        if (objeto != VAZIO) {
            return(objeto);
        }
    }
    
    /* Verifica diagona direita */
    objeto = t[Q_LINHAS-1][0];
    contador = 1;
    for (linhas = Q_LINHAS-2, colunas = 1; linhas > 0||colunas < Q_COLUNAS; linhas--, colunas++) {
        if (objeto == t[linhas][colunas]) {
            contador++;
        }
    }
    if (contador >= Q_LINHAS) {
        if (objeto != VAZIO) {
            return(objeto);
        }
    }
    
    /* Verifica velha */
    contador = 0;
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
            if (t[linhas][colunas] != VAZIO) {
                contador++;
            }
        }
    }
    if (contador == (Q_LINHAS*Q_COLUNAS)) {
        return(VELHA);
    }
    return(VAZIO);
}

você pode testar o programa no link abaixo

https://onlinegdb.com/U-lTNT4xF

Infelizmente eu não sei java 😕

  • Curtir 1

Crie uma conta ou entre para comentar

Você precisa ser um usuário 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 comunidades 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

×
×
  • Criar novo...

LANÇAMENTO!

eletronica2025-popup.jpg


CLIQUE AQUI E BAIXE AGORA MESMO!