Desenvolvimento de Personagens de Jogos

Parte da seção Programação Orientada a Objetos do Journey de Java da Coddy. Lição 86 de 87.

Este desafio propõe que você construa um sistema de Desenvolvimento de Personagens de Jogo que demonstre o poder da POO na modelagem de entidades complexas e interativas.

Projete uma hierarquia de personagens na qual uma classe Character base define atributos comuns, como saúde, nome e nível. Classes especializadas, como Warrior, Mage e Archer, estendem essa base com habilidades únicas e estilos de combate.

Interfaces funcionam naturalmente aqui: Attackable poderia definir métodos de combate, enquanto Healable cuidaria das habilidades de restauração. Um Mage poderia implementar ambas, enquanto um Warrior se concentra apenas em atacar.

Considere usar o padrão Strategy para diferentes comportamentos de ataque, permitindo que os personagens alternem estilos de combate dinamicamente. O padrão State poderia gerenciar condições dos personagens, como estados normal, envenenado ou atordoado, que afetam o comportamento.

Pense em composição para sistemas de equipamentos nos quais os personagens “possuem” armas e armaduras, em vez de herdarem delas. Use enums para classes de personagens ou tipos de dano e aplique encapsulamento para proteger os atributos contra modificações inválidas.

Desafio

Fácil

Vamos construir um sistema de Desenvolvimento de Personagens de Jogo que demonstre o poder da OOP na modelagem de entidades de jogo complexas e interativas! Você criará uma hierarquia de personagens com diferentes estilos de combate, habilidades especiais e um sistema de estados que afeta o comportamento dos personagens.

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

DamageType.java: Crie um enum que represente diferentes tipos de dano no jogo. Inclua os valores PHYSICAL, MAGICAL e RANGED. Adicione um campo privado description (String), um construtor que o defina e um getter. O dano físico deve ter a descrição "brute force", o mágico deve ter "arcane energy" e o de longa distância deve ter "precision strike".
Attackable.java: Crie uma interface que defina capacidades de combate. Declare os métodos attack(Character target), que retorna uma String descrevendo o ataque, e getDamageType(), que retorna um DamageType.
Healable.java: Crie uma interface para habilidades de restauração. Declare um método heal(int amount) que retorne uma String descrevendo a ação de cura.
Character.java: Crie uma classe base abstrata para todos os personagens do jogo. Inclua campos privados para name (String), health (int), maxHealth (int) e level (int). O construtor recebe name, maxHealth e level, definindo inicialmente health como igual a maxHealth. Inclua getters para todos os campos. Adicione um método protegido setHealth(int health) que garanta que health permaneça entre 0 e maxHealth. Crie um método takeDamage(int damage) que reduza health e retorne "[name] takes [damage] damage! Health: [health]/[maxHealth]". Adicione um método isAlive() que retorne true se health for maior que 0. Declare um método abstrato getCharacterClass() que retorne uma String.
Warrior.java: Crie uma classe que estenda Character e implemente Attackable. Adicione um campo privado strength (int). O construtor recebe name, maxHealth, level e strength. Implemente getCharacterClass() para retornar "Warrior". Implemente getDamageType() para retornar PHYSICAL. Implemente attack(Character target) para causar dano igual a strength mais level, chamar o método takeDamage do alvo e retornar "[name] strikes with [damageType description] for [damage] damage!" seguido por uma nova linha e pelo resultado de takeDamage.
Mage.java: Crie uma classe que estenda Character e implemente tanto Attackable quanto Healable. Adicione os campos privados intelligence (int) e mana (int). O construtor recebe name, maxHealth, level, intelligence e mana. Implemente getCharacterClass() para retornar "Mage". Implemente getDamageType() para retornar MAGICAL. Implemente attack(Character target) para causar dano igual a intelligence vezes 2, seguindo o mesmo formato de Warrior. Implemente heal(int amount) para restaurar health (usando setHealth) e retornar "[name] channels healing magic! Health: [health]/[maxHealth]".
Main.java: Dê vida ao seu sistema de jogo! Você receberá uma String de comandos separados por vírgulas:
- CREATE_WARRIOR:name:maxHealth:level:strength
- CREATE_MAGE:name:maxHealth:level:intelligence:mana
- ATTACK:attackerName:targetName
- HEAL:mageName:amount
- STATUS:characterName
Mantenha uma coleção de personagens. Processe cada comando e imprima:
- CREATE_WARRIOR/CREATE_MAGE: [name] the [characterClass] joins the battle!
- ATTACK: Imprima o resultado do ataque (a String retornada pelo método attack)
- HEAL: Imprima o resultado da cura ou [name] cannot heal se o personagem não for um Mage
- STATUS: [name] ([characterClass]) - Level [level] - Health: [health]/[maxHealth] - [Alive/Defeated]
Após todos os comandos, imprima --- Battle Summary --- seguido pelo status de cada personagem.

Você receberá uma entrada: a string de comandos separados por vírgulas.

Por exemplo, com a entrada CREATE_WARRIOR:Thorin:100:5:15,CREATE_MAGE:Gandalf:80:7:12:50,ATTACK:Thorin:Gandalf,HEAL:Gandalf:25,STATUS:Gandalf, sua saída seria:

Thorin the Warrior joins the battle!
Gandalf the Mage joins the battle!
Thorin strikes with brute force for 20 damage!
Gandalf takes 20 damage! Health: 60/80
Gandalf channels healing magic! Health: 80/80
Gandalf (Mage) - Level 7 - Health: 80/80 - Alive
--- Battle Summary ---
Thorin (Warrior) - Level 5 - Health: 100/100 - Alive
Gandalf (Mage) - Level 7 - Health: 80/80 - Alive

Este desafio combina herança (hierarquia de Character), implementação de múltiplas interfaces (Mage implementa tanto Attackable quanto Healable), enums com métodos (DamageType), polimorfismo (tratamento uniforme de diferentes tipos de personagens) e encapsulamento (gerenciamento protegido de health) em um sistema de jogo envolvente!

is not a valid tag and must not be included.

Experimente você mesmo

import java.util.Scanner;
import java.util.HashMap;
import java.util.Map;
import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        
        // TODO: Use uma coleção para manter os personagens (LinkedHashMap preserva a ordem de inserção)
        // LinkedHashMap<String, Character> characters = new LinkedHashMap<>();
        
        // TODO: Divida a entrada por vírgula para obter os comandos individuais
        // String[] commands = input.split(",");
        
        // TODO: Processe cada comando:
        // - CREATE_WARRIOR:name:maxHealth:level:strength
        //   Print: "[name] the Warrior joins the battle!"
        // 
        // - CREATE_MAGE:name:maxHealth:level:intelligence:mana
        //   Print: "[name] the Mage joins the battle!"
        // 
        // - ATTACK:attackerName:targetName
        //   Imprima o resultado do ataque do método attack
        // 
        // - HEAL:mageName:amount
        //   Imprima o resultado da cura, ou "[name] cannot heal" se não for um Mage
        // 
        // - STATUS:characterName
        //   Imprima: "[name] ([characterClass]) - Level [level] - Health: [health]/[maxHealth] - [Alive/Defeated]"
        
        // TODO: After all commands, print "--- Battle Summary ---"
        // Em seguida, imprima o status de cada personagem
    }
}