Jogo de adivinhar a palavra secreta, escrito em Python utilizando type hints e programação orientada a objetos.

secret_game.py

import os
import random
from collections import deque


class JogoPalavraSecreta:
    def __init__(self):
        """
        Inicializa o estado do jogo: palavra secreta, progresso do jogador,
        letras utilizadas e número de oportunidades.
        """
        self._palavra_secreta = self._escolher_palavra_secreta()
        self._palavra_descoberta = ["_"] * len(self._palavra_secreta)
        self._letras_utilizadas = set()
        self._oportunidades = 5

    def _escolher_palavra_secreta(self) -> str:
        """Coordena a escolha da palavra secreta a partir de uma lista."""
        lista_palavras = self._recuperar_lista_palavras()
        return self._escolher_palavra_da_lista(lista_palavras)

    def _recuperar_lista_palavras(self) -> list[str]:
        """Retorna a lista de palavras disponíveis para o jogo."""
        return ["PASSO", "FELICIDADE", "FORÇA"]

    def _escolher_palavra_da_lista(self, lista_palavras: list[str]) -> str:
        """Seleciona uma palavra aleatória da lista fornecida."""
        return random.choice(lista_palavras)

    def validar_resposta_usuario(self, resposta_usuario: str) -> None:
        """Valida a entrada do usuário, garantindo que seja uma única letra."""
        if len(resposta_usuario) == 0:
            raise ValueError("Por favor, digite uma letra.")

        if len(resposta_usuario) > 1:
            raise ValueError("Digite apenas uma letra por vez.")

        if not resposta_usuario.isalpha():
            raise ValueError("Digite apenas letras.")

    def letra_ja_foi_utilizada(self, letra: str) -> bool:
        """Verifica se a letra já foi utilizada anteriormente."""
        return letra in self._letras_utilizadas

    def atualizar_palavra_descoberta(self, letra: str) -> None:
        """Atualiza a palavra descoberta revelando as posições da letra correta."""
        for index, letra_secreta in enumerate(self._palavra_secreta):
            if letra_secreta == letra:
                self._palavra_descoberta[index] = letra

    def atualizar_letras_utilizadas(self, letra: str) -> None:
        """Adiciona a letra ao conjunto de letras já utilizadas."""
        self._letras_utilizadas.add(letra)

    def acertou(self, letra: str) -> bool:
        """Verifica se a letra está presente na palavra secreta."""
        return letra in self._palavra_secreta

    def perdeu(self):
        """Indica se o jogador ficou sem oportunidades."""
        return self._oportunidades == 0

    def ganhou(self):
        """Indica se o jogador descobriu toda a palavra."""
        return "_" not in self._palavra_descoberta

    def diminuir_oportunidades(self):
        """Reduz em uma unidade o número de oportunidades restantes."""
        self._oportunidades -= 1

    @property
    def str_oportunidades(self) -> str:
        """Retorna uma representação textual das oportunidades restantes."""
        return f"Oportunidades restantes: {self._oportunidades}"

    @property
    def str_letras_utilizadas(self) -> str:
        """Retorna uma representação textual das letras já utilizadas."""
        return f"Letras utilzadas: " + ", ".join(self._letras_utilizadas)

    @property
    def str_palavra_descoberta(self) -> str:
        """Retorna uma representação textual do progresso da palavra."""
        return f"Palavra descoberta: " + " ".join(self._palavra_descoberta)

    def printar_status_do_jogo(self) -> None:
        """Exibe no console o estado atual do jogo."""
        print(self.str_palavra_descoberta)
        print(self.str_letras_utilizadas)
        print(self.str_oportunidades, end="\n\n")


def limpar_terminal() -> None:
    """Limpa o terminal de acordo com o sistema operacional."""
    os.system("cls" if os.name == "nt" else "clear")


def exibir_mensagens_da_fila(mensagens: deque) -> None:
    """Exibe e remove todas as mensagens armazenadas na fila."""
    while len(mensagens) > 0:
        print(mensagens.popleft())


def main():
    jogo = JogoPalavraSecreta()
    mensagens = deque()

    while True:
        limpar_terminal()
        exibir_mensagens_da_fila(mensagens)

        jogo.printar_status_do_jogo()
        letra = input("Digite uma letra: ").strip().upper()

        try:
            jogo.validar_resposta_usuario(letra)
        except ValueError as e:
            mensagens.append(e)
            mensagens.append("Tente novamente.")
            continue

        if jogo.letra_ja_foi_utilizada(letra):
            mensagens.append(f"Você já utilizou a letra '{letra}'. Tente outra.")
            continue

        jogo.atualizar_letras_utilizadas(letra)

        if jogo.acertou(letra):
            mensagens.append("Boa! Você acertou!")
            jogo.atualizar_palavra_descoberta(letra)

            if jogo.ganhou():
                mensagens.append("Você ganhou! Parabéns!")
                break
        else:
            mensagens.append("Ops! Essa letra não está na palavra.")
            jogo.diminuir_oportunidades()
            if jogo.perdeu():
                mensagens.append("Sinto muito, você perdeu. Sorte na próxima!")
                break

    exibir_mensagens_da_fila(mensagens)


if __name__ == "__main__":
    main()