Hangman é um clássico jogo de adivinhação de palavras divertido e um ótimo projeto para programadores iniciantes.

Neste artigo, aprenderemos como construir uma versão simples do jogo Hangman em Python.

Ao final, você entenderá como usar as estruturas de controle, funções e listas básicas do Python para criar este jogo.

O que é o Carrasco?

O objetivo do Hangman é adivinhar uma palavra secreta sugerindo letras, uma de cada vez.

O jogador pode fazer apenas um número limitado de suposições incorretas antes do jogo terminar.

Para cada palpite incorreto, uma parte da figura do "carrasco" é sorteada, e se a figura inteira for sorteada antes da palavra ser adivinhada, o jogador perde.

Vamos analisar isso e construir o jogo passo a passo.

Etapa 1: planeje o jogo

Vamos planejar o jogo e seus principais recursos:

• O jogo seleciona uma palavra aleatoriamente.
• O jogador adivinha uma letra de cada vez.
• O jogador tem um número limitado de palpites incorretos.
• O jogo exibe a palavra com as letras adivinhadas corretamente e espaços em branco para as letras restantes.

O jogo terá os seguintes componentes:

• Seleção de palavras
• Entrada do jogador (adivinhação)
• Atualizar a exibição da palavra
• Acompanhe o número de suposições incorretas

Etapa 2: importar bibliotecas necessárias

Usaremos o módulo aleatório para selecionar aleatoriamente uma palavra de uma lista.

import random

Etapa 3: definir a lista de palavras

Em seguida, defina uma lista de palavras que o jogo escolherá aleatoriamente.

Você pode adicionar mais palavras para tornar o jogo mais interessante.

word_list = ['python', 'java', 'hangman', 'programming', 'computer']

Passo 4: Definir funções para o jogo

Função 1: Selecione aleatoriamente uma palavra

Precisamos de uma função para escolher aleatoriamente uma palavra de nossa lista de palavras.

def get_random_word(word_list):
    return random.choice(word_list)

Função 2: Exibir o estado atual da palavra

À medida que o jogador adivinha as letras, precisamos mostrar as letras adivinhadas corretamente e os espaços reservados (_) para as letras não adivinhadas.

def display_word(word, guessed_letters):
    display = ''
    for letter in word:
        if letter in guessed_letters:
            display  = letter   ' '
        else:
            display  = '_ '
    return display.strip()

Função 3: Verifique se o jogador ganhou

Esta função verifica se todas as letras da palavra foram adivinhadas.

def is_word_guessed(word, guessed_letters):
    for letter in word:
        if letter not in guessed_letters:
            return False
    return True

Função 4: Exibir Hangman

Para exibir uma figura do carrasco em um jogo baseado em texto, você pode usar arte ASCII para representar os diferentes estágios do carrasco.

def display_hangman(wrong_guesses):
    stages = [
        """
           -----
           |   |
           O   |
          /|\\  |
          / \\  |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
          /    |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
           |   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
               |
               |
               |
        --------
        """,
        """
           -----
           |   |
               |
               |
               |
               |
        --------
        """
    ]
    # Reverse the list to display the stages in the correct order
    stages.reverse()
    return stages[wrong_guesses]

Etapa 5: o ciclo principal do jogo

Agora podemos montar o loop principal do jogo. Este loop irá:

• Acompanhe as letras adivinhadas e as suposições incorretas.
• Permitir que o jogador insira suposições.
• Atualize o estado do jogo com base na estimativa.
• Termine o jogo quando o jogador ganhar ou perder.

Exemplo de código completo:

import random


# Function to get a random word from the list
def get_random_word(word_list):
    return random.choice(word_list)


# Function to display the current state of the word
def display_word(word, guessed_letters):
    display = ''
    for letter in word:
        if letter in guessed_letters:
            display  = letter   ' '
        else:
            display  = '_ '
    return display.strip()


# Function to check if the word has been guessed
def is_word_guessed(word, guessed_letters):
    for letter in word:
        if letter not in guessed_letters:
            return False
    return True


# Function to display the hangman figure
def display_hangman(wrong_guesses):
    stages = [
        """
           -----
           |   |
           O   |
          /|\\  |
          / \\  |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
          /    |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
           |   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
               |
               |
               |
        --------
        """,
        """
           -----
           |   |
               |
               |
               |
               |
        --------
        """
    ]
    # Reverse the list to display the stages in the correct order
    stages.reverse()
    return stages[wrong_guesses]


# Main function to play the game
def play_hangman():
    word_list = ['python', 'java', 'hangman', 'programming', 'computer']
    word = get_random_word(word_list)
    guessed_letters = []
    attempts = 6
    wrong_guesses = 0

    print("Welcome to Hangman!")
    print("Guess the word!")

    # Main game loop
    while wrong_guesses 

  
  
  Explicação

• get_random_word(): seleciona aleatoriamente uma palavra da lista de palavras.
• display_word(): Cria uma string que representa o estado atual da palavra, mostrando as letras adivinhadas corretamente e os espaços reservados para as não adivinhadas.
• is_word_guessed(): Verifica se o jogador adivinhou todas as letras da palavra.
• display_hangman(wrong_guesses): Esta função pega o número de suposições incorretas como argumento e retorna a arte ASCII correspondente para esse estágio.
• play_hangman(): A função principal que controla o jogo. Ele lida com a entrada do usuário, acompanha as suposições do jogador e determina se o jogador ganhou ou perdeu.

Variáveis-chave:

• guessed_letters: Uma lista para armazenar as letras que o jogador adivinhou.
• wrong_guesses: rastreia quantas suposições incorretas o jogador fez. tentativas: o número máximo de suposições incorretas permitidas.
• estágios: Esta lista contém representações artísticas ASCII da figura do carrasco em diferentes estágios de conclusão. Cada estágio corresponde a um número diferente de suposições incorretas.

Etapa 6: executando o jogo

Para rodar o jogo, basta executar o script Python, supondo que você criou um arquivo main.py:

python main.py

O jogo solicitará que você insira letras e exibirá a palavra com as letras adivinhadas corretamente conforme você avança.

Se você ficar sem tentativas, o jogo termina e você perde, assim:

           -----
           |   |
           O   |
          /|\  |
          / \  |
               |
        --------

Game over! The word was: programming

Se você acertar a palavra, você ganha, assim:

           -----
           |   |
               |
               |
               |
               |
        --------

j a _ a
Enter a letter: v
Good guess! v is in the word.
Congratulations! You've guessed the word: java

Conclusão

Este jogo Hangman simples demonstra o uso de estruturas de controle, funções, listas e entrada/saída básica em Python.

À medida que você cria este projeto, você pode adicionar mais recursos, como:

• Adicionando categorias de palavras.
• Dando dicas.
• Adicionando um sistema de pontuação.

Este é um ótimo projeto para expandir à medida que você aprende conceitos mais avançados de Python.