Ajude nosso projeto a se manter online, faça um PIX de qualquer valor:
programacao.progressiva@gmail.com

Jogo da Velha em Python: Como Programar

Neste tutorial de Python, vamos te mostrar como criar e programar o jogo da velha em Python, para dois usuários jogarem.

Jogo da Velha em Python


Faça um script em Python que permite que dois jogadores joguem o jogo da velha.


Lógica do jogo da velha

Vamos usar uma matriz (lista dentro de lista) de tamanho 3x3 de inteiros.
Um jogador vai escolher a linha e a coluna no tabuleiro, para jogar.

Se for o jogador 1, vai assinalar um X.
Se for o jogador 2, vai assinalar um O.

Porém, só pode inserir um X ou O se aquela posição estiver vazia.
Cada vez que o jogador joga, deve verificar se alguma linha, coluna ou diagonal foi preenchida, terminando o jogo, avisando quem ganhou e em quantas rodadas.

O Tabuleiro

Inicializamos o tabuleiro com valores iguais a 0:

board= [ [0,0,0],
         [0,0,0],
         [0,0,0] ]

Também podemos inicializar fazendo:
board = [ [0 for i in range(3)] for j in range(3)]

Em seguida, o código chama a função menu().




O menu

Criamos uma variável chamada continuar, com valor inicial 1.
Enquanto esse valor não for nulo, um laço while vai continuar perguntando se o jogador deseja jogar novamente, novamente e novamente.


Exibindo o tabuleiro do jogo da velha


Na função exibe() vamos imprimir o tabuleiro.

Quando o jogador 1 joga, insere o número inteiro 1 em um local do tabuleiro.
Se o jogador 2 joga, insere o número inteiro -1 em um local do tabuleiro.

Para exibirmos, vamos usar dois laços for aninhados.
O primeiro 'cuida' da linha e o segundo cuida das colunas.

Quando nos deparamos com o valor 0 no tabuleiros, mostramos: __
Para simbolizar que está vazio.

Se encontrar o número 1, printamos o caractere X.
Se encontrar o número -1, printamos o caractere O.

O jogo

A variável jogada é que vai contabilizar o número de rodadas. Obviamente, inicia com zero.
Essa variável vai ser incrementada de um em um, a cada rodada.

Se pegarmos o resto dessa divisão dessa variável por 2, teremos valor 0 e 1 alternando.
Se somarmos 1, teremos valores 1 e 2 alternando. Vamos avisar ao usuário se é o jogador 1 ou jogador 2 através dessa lógica.

Ou seja, cada jogador é simbolizado por: (jogada%2 + 1)

Primeiro, exibimos o tabuleiro, chamando a função exibe().

A seguir, pede uma linha e uma coluna.
Detalhe: o usuário vai digitar 1, 2 ou 3, mas nosso tabuleiro tem as posições 0, 1 e 2. Ou seja, quando o usuário fornecer esses números, temos que subtrair o valor de 1.

Em seguida, testamos se o valor que ele assinalou está vazio, ou seja, se tem um 0 naquela posição do tabuleiro.

Se sim, insere um 1 caso seja vez do jogador um ou -1 se for o jogador dois.

Se não for 0 a posição do tabuleiro, cai no ELSE, avisamos que não pode e subtraímos 1 da variável jogada, pois lá embaixo essa variável é sempre incrementada.

Após cada jogada, chamamos a função ganhou() dentro de um teste condicional.
Essa função checa se alguma linha, coluna ou diagonal está completa.
Se sim, termina o jogo e mostra quem ganhou, em quantas rodadas, se foi linha, coluna ou diagonal que se completou, e exibimos o tabuleiro final.

Caso a função ganhou() retorne 0, é porque ninguém ganhou, incrementamos a variável jogada e o loop while roda novamente uma outra rodada com o outro jogador.

Quem ganha o jogo da velha

Dentro da função ganhou(), fazemos três checagens.

Primeiro, se alguma linha tem soma de valor 3 ou -3, alguém ganhou e retornamos o valor 1.
Se alguma coluna tem soma 3 ou -3, alguém ganhou e retornamos o valor 2.
Por fim, somamos as diagonais, se alguma tiver valor 3 ou -3, retornamos o valor 3.

Se passar batido por esses testes, retornamos o valor 0, pra simbolizar que ninguém ganhou.




Código Python do Jogo da Velha



def menu():
    continuar=1
    while continuar:
        continuar = int(input("0. Sair \n"+
                              "1. Jogar novamente\n"))
        if continuar:
            game()
        else:
            print("Saindo...")

def game():
    jogada=0

    while ganhou() == 0:
        print("\nJogador ", jogada%2 + 1)
        exibe()
        linha  = int(input("\nLinha :"))
        coluna = int(input("Coluna:"))

        if board[linha-1][coluna-1] == 0:
            if(jogada%2+1)==1:
                board[linha-1][coluna-1]=1
            else:
                board[linha-1][coluna-1]=-1
        else:
            print("Nao esta vazio")
            jogada -=1

        if ganhou():
            print("Jogador ",jogada%2 + 1," ganhou apos ", jogada+1," rodadas")

        jogada +=1
    
def ganhou():
    #checando linhas
    for i in range(3):
        soma = board[i][0]+board[i][1]+board[i][2]
        if soma==3 or soma ==-3:
            return 1

     #checando colunas
    for i in range(3):
        soma = board[0][i]+board[1][i]+board[2][i]
        if soma==3 or soma ==-3:
            return 1

    #checando diagonais
    diagonal1 = board[0][0]+board[1][1]+board[2][2]
    diagonal2 = board[0][2]+board[1][1]+board[2][0]
    if diagonal1==3 or diagonal1==-3 or diagonal2==3 or diagonal2==-3:
        return 1

    return 0

def exibe():
    for i in range(3):
        for j in range(3):
            if board[i][j] == 0:
                print(" _ ", end=' ')
            elif board[i][j] == 1:
                print(" X ", end=' ')
            elif board[i][j] == -1:
                print(" O ", end=' ')

        print()
                

board= [ [0,0,0],
         [0,0,0],
         [0,0,0] ]

menu()

8 comentários:

  1. Seu código está bem enxuto, o meu deu 300 linhas. Só a parte de verificar quem ganhou ficou cheio de if e else

    ResponderExcluir
  2. Respostas
    1. Faz uma função que verifique se há movimento disponível. Se não há e ninguém ganhou então é empate.

      Excluir
  3. #Mostra a matriz do argumento
    def mostra (matriz):

    print (" 1 2 3")

    for i in range (3):
    print ("%d. "%(i+1), end=' ')
    for j in range (3):
    print("%2s "%matriz[i][j], end=' ')
    print()

    #Muda a matriz do primeiro argumento de acordo com a vez do jogador
    def muda(matriz,vez):
    print ("Jogador %d"%vez)
    linha=int(input ("Digite a linha: "))
    coluna=int(input("Digite a coluna: "))
    if vez==1:
    matriz[linha-1][coluna-1]='X'
    if vez==2:
    matriz[linha-1][coluna-1]='O'

    #Retorna a matriz modificada
    return matriz

    #Verifica o ganhador
    def ganhador(matriz):
    #Checando linhas
    for i in range (3):
    if ((matriz[i][0]+matriz[i][1]+matriz[i][2])=='XXX'):
    print("Jogador 1 é o vencedor")
    return True
    if ((matriz[i][0]+matriz[i][1]+matriz[i][2])=='OOO'):
    print("Jogador 2 é o vencedor")
    return True

    #Checando colunas
    for j in range(3):
    if ((matriz[0][j]+matriz[1][j]+matriz[2][j])=='XXX'):
    print("Jogador 1 é o vancedor")
    return True
    if ((matriz[0][j]+matriz[1][j]+matriz[2][j])=='OOO'):
    print("Jogador 2 é o vancedor")
    return True

    #Checando diagonais
    principal=''
    for d in range(3):
    principal+=(matriz[i][i])

    if (principal=='XXX' or (matriz[0][2]+matriz[1][1]+matriz[2][0])=='XXX'):
    print("Jogador 1 é o vencedor")
    return True
    if (principal=='XXX' or (matriz[0][2]+matriz[1][1]+matriz[2][0])=='OOO'):
    pritn("Jogador 2 é o vencedor")
    return True

    return False

    #Inicia a matriz
    matriz=[['#' for i in range (3)] for j in range (4)]

    #Mostra a o jogo todo zerado
    mostra(matriz)

    #Inicia as vezes dos jogadores
    while 1:
    mostra(muda(matriz,1))
    if ganhador(matriz):
    break
    mostra(muda(matriz,2))
    if ganhador(matriz):
    break

    print("Saindo...")

    ResponderExcluir
  4. Meu codigo com javascript no // Tabuleiro e Construção
    let construcao_Tabu = [ " "," "," ",
    " "," "," ",
    " "," "," "];

    // Desenho do Tabuleiro
    function exibir_tabuleiro(tab) {
    console.log(" " + tab[0] + " | " + tab[1] + " | " + tab[2]);
    console.log("=====================");
    console.log(" " + tab[3] + " | " + tab[4] + " | " + tab[5]);
    console.log("=====================");
    console.log(" " + tab[6] + " | " + tab[7] + " | " + tab[8]);
    }

    let jogador1= "X";
    let jogador2 = "O";
    exibir_tabuleiro(construcao_Tabu);

    // Tratamento de erro
    function erro_Digitacao(posi, t, jogador) {
    let c = 0;
    if(t[posi] == " ") {
    t[posi] = jogador;
    } else if(t[posi] != " ") {
    console.log("Erro esta posição esta ocupada");
    while(c <= 0) {
    let posi_n = parseInt(prompt("Digite a posição novamente " + jogador));
    if(t[posi_n] == " ") {
    t[posi_n] = jogador;
    break;
    }

    }
    }
    }

    // Jogador X e O

    var jogadas = 0;
    function jogadorX(JoX, tabu) {
    let posicao = parseInt(prompt("V_e_z d_o [ " + JoX + "]"));
    jogadas = jogadas + 1;
    erro_Digitacao(posicao, tabu, JoX);
    }

    function jogadorO(JoO, tabu) {
    let posicao = parseInt(prompt("V_e_z d_o [ " + JoO + "]"));
    jogadas = jogadas + 1;
    erro_Digitacao(posicao, tabu, JoO);
    }




    function Vencedor(tabu) {
    if ( tabu[0] == "X" && tabu[1] == "X" && tabu[2] == "X" || tabu[3] == "X" && tabu[4] == "X" && tabu[5] == "X" || tabu[6] == "X" && tabu[7] == "X" && tabu[8] == "X") {
    return true;
    } else if(tabu[0] == "X" && tabu[3] == "X" && tabu[6] == "X" || tabu[1] == "X" && tabu[4] == "X" && tabu[7] == "X" || tabu[2] == "X" && tabu[5] == "X" && tabu[8] == "X") {
    return true;
    } else if(tabu[0] == "X" && tabu[4] == "X" && tabu[8] == "X" || tabu[2] == "X" && tabu[4] == "X" && tabu[6] == "X") {
    return true;
    }

    if ( tabu[0] == "O" && tabu[1] == "O" && tabu[2] == "O" || tabu[3] == "O" && tabu[4] == "O" && tabu[5] == "O" || tabu[6] == "O" && tabu[7] == "O" && tabu[8] == "O") {
    return true;
    } else if(tabu[0] == "O" && tabu[3] == "O" && tabu[6] == "O" || tabu[1] == "O" && tabu[4] == "O" && tabu[7] == "O" || tabu[2] == "O" && tabu[5] == "O" && tabu[8] == "O") {
    return true;
    } else if(tabu[0] == "O" && tabu[4] == "O" && tabu[8] == "O" || tabu[2] == "O" && tabu[4] == "O" && tabu[6] == "O") {
    return true;
    }
    }


    var cont = 0;

    while(cont <= 4) {

    jogadorX(jogador1, construcao_Tabu);
    exibir_tabuleiro(construcao_Tabu);

    if(cont == 4) {
    console.log("X_O =--------------= E_M_P_A_T_E");
    break;
    }


    if( Vencedor(construcao_Tabu) == true){
    console.log("P+A+R+A+B+E+N+S..j..o..g..a..d..o..r [ X ] GANHOU");
    break;
    }

    jogadorO(jogador2, construcao_Tabu);
    exibir_tabuleiro(construcao_Tabu);

    Vencedor(construcao_Tabu);

    if( Vencedor(construcao_Tabu) == true){
    console.log("P+A+R+A+B+E+N+S..j..o..g..a..d..o..r [ O ] GANHOU");
    break;
    }
    cont++;
    }terminal do navegador

    ResponderExcluir
  5. O programa exibido tem um bug... tente XXO, OOX E XXO fica sem solução obrigando o jogador abortar o processamento.

    ResponderExcluir