Skip to content
The Chat Archive
gemini-2.5-pro-preview-03-25· Google LMArena Human Preference 140K

Crie um codigo para gerar um jogo de jogo da velha no terminal

  1. User

    Crie um codigo para gerar um jogo de jogo da velha no terminal

  2. Assistant

    Okay, vamos criar o código para um jogo da velha funcional no terminal usando Python.

    import os
    import time # Usaremos para pequenas pausas (opcional)
    
    # Função para limpar o terminal (funciona na maioria dos sistemas)
    def limpar_tela():
        os.system('cls' if os.name == 'nt' else 'clear')
    
    # Função para exibir o tabuleiro
    def exibir_tabuleiro(tabuleiro):
        """Exibe o tabuleiro formatado."""
        limpar_tela() # Limpa a tela antes de mostrar o novo estado
        print("\n --- JOGO DA VELHA ---")
        print(f"     |     |     ")
        print(f"  {tabuleiro[0]}  |  {tabuleiro[1]}  |  {tabuleiro[2]}  ")
        print(f"_____|_____|_____")
        print(f"     |     |     ")
        print(f"  {tabuleiro[3]}  |  {tabuleiro[4]}  |  {tabuleiro[5]}  ")
        print(f"_____|_____|_____")
        print(f"     |     |     ")
        print(f"  {tabuleiro[6]}  |  {tabuleiro[7]}  |  {tabuleiro[8]}  ")
        print(f"     |     |     \n")
    
    # Função para verificar se um jogador venceu
    def verificar_vencedor(tabuleiro, jogador):
        """Verifica todas as condições de vitória para o jogador."""
        # Linhas
        if (tabuleiro[0] == jogador and tabuleiro[1] == jogador and tabuleiro[2] == jogador) or \
           (tabuleiro[3] == jogador and tabuleiro[4] == jogador and tabuleiro[5] == jogador) or \
           (tabuleiro[6] == jogador and tabuleiro[7] == jogador and tabuleiro[8] == jogador):
            return True
        # Colunas
        elif (tabuleiro[0] == jogador and tabuleiro[3] == jogador and tabuleiro[6] == jogador) or \
             (tabuleiro[1] == jogador and tabuleiro[4] == jogador and tabuleiro[7] == jogador) or \
             (tabuleiro[2] == jogador and tabuleiro[5] == jogador and tabuleiro[8] == jogador):
            return True
        # Diagonais
        elif (tabuleiro[0] == jogador and tabuleiro[4] == jogador and tabuleiro[8] == jogador) or \
             (tabuleiro[2] == jogador and tabuleiro[4] == jogador and tabuleiro[6] == jogador):
            return True
        else:
            return False
    
    # Função para verificar se o tabuleiro está cheio (empate)
    def verificar_empate(tabuleiro):
        """Verifica se todas as posições estão preenchidas."""
        for espaco in tabuleiro:
            # Se encontrar algum número (posição não jogada), não é empate
            if espaco.isdigit():
                return False
        return True # Se não encontrou números, está cheio
    
    # Função principal do jogo
    def jogar():
        """Inicia e controla o fluxo do jogo da velha."""
        tabuleiro = ['1', '2', '3', '4', '5', '6', '7', '8', '9'] # Tabuleiro inicial com números
        jogador_atual = 'X' # X sempre começa
        jogo_ativo = True
    
        while jogo_ativo:
            exibir_tabuleiro(tabuleiro)
            print(f"É a vez do Jogador '{jogador_atual}'.")
    
            # --- Obter jogada do jogador ---
            while True:
                try:
                    posicao = input(f"Escolha uma posição (1-9): ")
                    posicao_int = int(posicao) - 1 # Converte para índice da lista (0-8)
    
                    # Validar se a posição está no intervalo 0-8
                    if 0 <= posicao_int <= 8:
                        # Validar se a posição está livre (contém um número)
                        if tabuleiro[posicao_int].isdigit():
                            tabuleiro[posicao_int] = jogador_atual # Realiza a jogada
                            break # Sai do loop de pedir jogada
                        else:
                            print("Essa posição já está ocupada. Tente novamente.")
                    else:
                        print("Posição inválida. Escolha um número entre 1 e 9.")
    
                except ValueError:
                    print("Entrada inválida. Por favor, digite um número.")
                except IndexError: # Segurança extra, embora a validação anterior cubra
                     print("Posição fora do intervalo. Escolha um número entre 1 e 9.")
                time.sleep(1) # Pequena pausa para o usuário ler a mensagem
    
            # --- Verificar estado do jogo após a jogada ---
            # Verificar vitória
            if verificar_vencedor(tabuleiro, jogador_atual):
                exibir_tabuleiro(tabuleiro)
                print(f"*** Parabéns! Jogador '{jogador_atual}' venceu! ***")
                jogo_ativo = False
            # Verificar empate
            elif verificar_empate(tabuleiro):
                exibir_tabuleiro(tabuleiro)
                print("*** Deu velha! O jogo empatou! ***")
                jogo_ativo = False
            # Se ninguém venceu e não empatou, troca o jogador
            else:
                jogador_atual = 'O' if jogador_atual == 'X' else 'X'
    
        # --- Fim do jogo ---
        jogar_novamente = input("Jogar novamente? (s/n): ").lower()
        if jogar_novamente == 's':
            jogar() # Reinicia o jogo chamando a função novamente
        else:
            print("Obrigado por jogar!")
    
    # --- Iniciar o jogo ---
    if __name__ == "__main__":
        jogar()
    

    Como funciona o código:

    1. limpar_tela(): Função auxiliar para limpar o console antes de redesenhar o tabuleiro, proporcionando uma experiência mais limpa.

    2. exibir_tabuleiro(tabuleiro): Recebe a lista tabuleiro e a imprime no formato 3x3.

    3. verificar_vencedor(tabuleiro, jogador): Checa todas as 8 combinações possíveis de vitória (3 linhas, 3 colunas, 2 diagonais) para o jogador atual. Retorna True se ele venceu, False caso contrário.

    4. verificar_empate(tabuleiro): Percorre o tabuleiro. Se encontrar alguma posição que ainda seja um número (indicando que não foi jogada), retorna False. Se todas as posições foram preenchidas ('X' ou 'O'), retorna True.

    5. jogar():

      • Inicializa o tabuleiro como uma lista de strings de '1' a '9'. Isso ajuda o usuário a saber qual número digitar para cada posição.
      • Define jogador_atual como 'X' e jogo_ativo como True.
      • Loop Principal (while jogo_ativo):
        • Mostra o tabuleiro atual.
        • Pede a jogada ao jogador_atual.
        • Usa um loop while True interno com try-except para garantir que a entrada seja um número válido (1-9) e que a posição escolhida esteja livre.
        • Atualiza o tabuleiro com a jogada.
        • Chama verificar_vencedor(). Se retornar True, exibe a mensagem de vitória e define jogo_ativo como False.
        • Se não houve vencedor, chama verificar_empate(). Se retornar True, exibe a mensagem de empate e define jogo_ativo como False.
        • Se o jogo continua, alterna o jogador_atual ('X' vira 'O', 'O' vira 'X').
      • Após o fim do loop (jogo terminado), pergunta se o usuário quer jogar novamente.
    6. if __name__ == "__main__":: Garante que a função jogar() seja chamada apenas quando o script é executado diretamente.

    Para rodar o jogo:

    1. Salve o código em um arquivo, por exemplo, jogo_da_velha.py.
    2. Abra o seu terminal ou prompt de comando.
    3. Navegue até o diretório onde você salvou o arquivo.
    4. Execute o script com o comando: python jogo_da_velha.py
    5. Siga as instruções no terminal para jogar!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.