Java Jogo Da Velha em Java

[Nozdog]

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;
	}

}

 

[AdrianoSiqueira]

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.

[Nozdog]

@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

 

[Nozdog]

@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

 

[kgin]

@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

[Nozdog]

@kgin valeu pela ajuda, mas eu já consegui, só precisei esfriar a cabeça, n tava pensando direito. :3