forca.py

"""
Jogo da Forca em Python
Autor(a): Anna Zrzebiela
Descrição: Implementação completa do jogo da forca com modularização,
validação de entrada, loop de repetição e opção de jogar novamente.
Estruturas de dados escolhidas:
- Lista para palavra_oculta: preserva a ordem e permite atualização por índice.
- Set para letras_tentadas: garante unicidade e buscas O(1), essencial para performance.
"""
import random

# Constante contendo as palavras possíveis do jogo
PALAVRAS = [
    "PYTHON",
    "PROGRAMACAO",
    "ESTRUTURA",
    "ALGORITMO",
    "VARIAVEL",
    "FUNCAO",
    "LOOP",
    "CONDICIONAL",
    "LISTA",
    "DICIONARIO",
    "TUPLA",
    "CONJUNTO",
    "CLASSE",
    "OBJETO",
    "HERANCA",
    "POLIMORFISMO",
    "ENCAPSULAMENTO",
    "ABSTRACAO",
    "INTERFACE",
    "EXCECAO",
    "DECORADOR",
    "GENERATOR",
    "ITERADOR",
    "COMPREHENSION",
    "LAMBDA",
    "ASYNC",
    "AWAIT",
    "MODULE",
    "PACKAGE",
    "VIRTUALENV",
    "FIFO",
]


def sortear_palavra(lista_palavras):
    """Sorteia uma palavra aleatória da lista."""
    if not lista_palavras:
        raise ValueError("A lista de palavras está vazia.")
    # random.choice retorna um elemento aleatório da lista fornecida
    return random.choice(lista_palavras)


def iniciar_jogo(lista_palavras, tentativas_iniciais=6):
    """Inicializa o estado da partida."""
    palavra_secreta = sortear_palavra(lista_palavras)
    # Cria uma lista com underscore para cada letra da palavra secreta, para exibir ao jogador
    palavra_oculta = ["_" for _ in palavra_secreta]
    # Conjunto vazio para guardar as letras que o jogador já tentou, evitando repetições
    # A verificação é insantânea, enquanto em uma lista seria mais lenta
    letras_tentadas = set()

    return (
        palavra_secreta,
        palavra_oculta,
        letras_tentadas,
        tentativas_iniciais
    )


def processar_tentativa(
    letra,
    palavra_secreta,
    palavra_oculta,
    letras_tentadas
):
    """Processa uma tentativa do jogador."""
    letra = letra.upper()
    # Impede que a mesma letra seja tentada mais de uma vez
    # O uso de um conjunto (set) para letras_tentadas torna a verificação de repetição eficiente e muito mais rápida do que uma lista 
    if letra in letras_tentadas:
        return "repetida", "Você já tentou essa letra. Tente outra, por favor."

    letras_tentadas.add(letra)

    acertou = False
    # Atualiza todas as posições onde a letra aparece
    for indice, caractere in enumerate(palavra_secreta):
        if caractere == letra:
            palavra_oculta[indice] = letra
            acertou = True

    if acertou:
        return "acertou", "Você acertou uma letra!"
    else:
        return "errou", "Letra incorreta."


def verificar_fim_jogo(palavra_oculta, tentativas_restantes):
    """Verifica se o jogo terminou."""
    # Vitória: não há mais underscores na palavra oculta, ou seja, todas as letras foram descobertas
    if "_" not in palavra_oculta:
        return "vitoria"
    # Derrota: acabaram as tentativas e ainda há underscores.
    
    elif tentativas_restantes <= 0:
        return "derrota"
    # Caso contrário, o jogo continua
    else:
        return "continua"


# Fluxo principal

def jogar():
    # Inicializa todas as estruturas para uma nova partida
    palavra_secreta, palavra_oculta, letras_tentadas, tentativas_restantes = iniciar_jogo(PALAVRAS)

    # Enquanto houver tentativas e a palavra não estiver completamente descoberta, o jogo continua
    while tentativas_restantes > 0 and "_" in palavra_oculta:
        # Exibir status
        print("\nPalavra:", " ".join(palavra_oculta))
        print(f"Tentativas restantes: {tentativas_restantes}")
        print("Letras tentadas:", ", ".join(sorted(letras_tentadas)))
        
        # Captura e valida a entrada do jogador
        letra = input("Digite uma letra: ").strip()
        if len(letra) != 1 or not letra.isalpha():
            print("Entrada inválida. Digite apenas uma letra (A-Z).")
            continue
        
        # Processar tentativa e obtendo o resultado
        status, mensagem = processar_tentativa(
            letra, palavra_secreta, palavra_oculta, letras_tentadas
        )
        print(mensagem)
        
        # Atualizar tentativas restantes em caso de erro
        if status == "errou":
            tentativas_restantes -= 1

    # Fim do jogo
    estado=verificar_fim_jogo(
        palavra_oculta,
         tentativas_restantes
    )
    #Após o loop, verificamos o estado final do jogo para exibir a mensagem correta ao jogador
    if estado == "vitoria":
        print(f"\n🎉 Parabéns! Você escapou da forca! A palavra era {palavra_secreta}.")
    elif estado == "derrota":
        print(f"\n💀 Você foi enforcado(a)! A palavra era: {palavra_secreta}.")


def main():
    """Função principal para iniciar o jogo e permitir múltiplas partidas."""
    while True:
        jogar() # Inicia uma nova partida
        print("Fim de jogo!")
        opcao = input("Deseja jogar novamente? (s/n): ").strip().lower()
        if opcao != 's':
            print("Obrigado por jogar!")
            break # Sai do loop e encerra o jogo

# Garantindo que o jogo só seja iniciado quando este script for executado diretamente, e não importado como módulo
if __name__ == "__main__":
    main()