Desenvolvimento de Personagens de Jogos

Vamos construir um sistema de Desenvolvimento de Personagens de Jogo onde diferentes classes de personagens batalham usando habilidades únicas. Você criará uma hierarquia de personagens com um sistema de experiência e níveis, demonstrando como herança, interfaces, traits e encapsulamento trabalham juntos em um contexto de jogo.

Você organizará seu código em seis arquivos:

• Ability.php — Defina uma interface Ability com dois métodos: getName(): string e use(Character $target): string. Este contrato garante que todas as habilidades possam ser usadas de forma consistente, independentemente de seus efeitos específicos.
• CombatLogger.php — Crie uma trait CombatLogger que fornece um método logAction(string $action): string. Este método deve retornar a string da ação prefixada com "[COMBAT] ". Os personagens usarão esta trait para formatar suas mensagens de combate de forma consistente.
• Character.php — Inclua os arquivos Ability e CombatLogger. Crie uma classe abstrata Character que utiliza a trait CombatLogger. Use a promoção de construtor para name (string, public readonly). Inclua propriedades privadas para health (int, começando em 100), level (int, começando em 1) e experience (int, começando em 0). Implemente:
  • getHealth(): int e getLevel(): int — getters para as propriedades privadas
  • takeDamage(int $amount): void — reduz a saúde, mas nunca abaixo de 0
  • heal(int $amount): void — aumenta a saúde, mas nunca acima de 100
  • gainExperience(int $xp): string — adiciona XP; se a experiência atingir 100 ou mais, sobe de nível (reseta XP para 0, aumenta o nível, cura 20 HP), retorna "{$this->name} leveled up to {$this->level}!"; caso contrário, retorna "{$this->name} gained {$xp} XP"
  • isAlive(): bool — retorna true se a saúde for maior que 0
  • abstract getSpecialAbility(): Ability — cada tipo de personagem fornece sua habilidade única
  • attack(Character $target): string — causa 10 de dano ao alvo, usa logAction() para retornar "[COMBAT] {$this->name} attacks {$target->name} for 10 damage"
• Warrior.php — Inclua o arquivo Character. Crie uma classe Warrior que estende Character. Implemente getSpecialAbility() para retornar uma classe anônima que implementa Ability:
  • getName() retorna "Shield Bash"
  • use() causa 25 de dano e retorna "[COMBAT] Shield Bash hits {$target->name} for 25 damage!" (use o logAction() da trait)
• Mage.php — Inclua o arquivo Character. Crie uma classe Mage que estende Character. Implemente getSpecialAbility() para retornar uma classe anônima que implementa Ability:
  • getName() retorna "Fireball"
  • use() causa 35 de dano e retorna "[COMBAT] Fireball engulfs {$target->name} for 35 damage!"
• main.php — Inclua os arquivos Warrior e Mage. Você receberá duas entradas: dados dos personagens (JSON) e uma sequência de ações de combate (JSON).

  Formato JSON dos personagens:

  [{"type": "warrior", "name": "Thorin"}, {"type": "mage", "name": "Gandalf"}]

  Formato JSON das ações:

  [{"action": "attack", "attacker": 0, "target": 1}, {"action": "special", "attacker": 1, "target": 0}, {"action": "xp", "character": 0, "amount": 100}, {"action": "status", "character": 0}]

  Crie todos os personagens e armazene-os em um array (índice 0, 1, etc.). Processe cada ação:

  • "attack" — O personagem no índice do atacante ataca o alvo; imprima o resultado
  • "special" — O personagem usa sua habilidade especial no alvo; imprima o resultado
  • "xp" — O personagem ganha experiência; imprima o resultado
  • "heal" — O personagem se cura pela quantidade fornecida; imprima "{$character->name} healed to {$character->getHealth()} HP"
  • "status" — Imprima "{$character->name} - Level {$character->getLevel()}, HP: {$character->getHealth()}, Alive: {$alive}" (onde $alive é 'Yes' ou 'No')

  Imprima cada resultado em uma nova linha.

Este sistema demonstra como classes abstratas definem comportamentos compartilhados de personagens, interfaces garantem que as habilidades sigam um contrato consistente, traits fornecem funcionalidade de log reutilizável e classes anônimas criam implementações de habilidades únicas sem poluir seu código com classes de uso único.