Sviluppo del personaggio di un gioco

Fa parte della sezione Programmazione orientata agli oggetti del percorso Java di Coddy. Lezione 86 di 87.

Questa sfida ti fa costruire un sistema di sviluppo dei personaggi di gioco che mette in mostra la potenza della programmazione orientata agli oggetti nel modellare entità complesse e interattive.

Progetta una gerarchia di personaggi in cui una classe Character di base definisce attributi comuni come salute, nome e livello. Classi specializzate come Warrior, Mage e Archer estendono questa base con abilità e stili di combattimento unici.

Le interfacce funzionano in modo naturale qui: Attackable potrebbe definire metodi di combattimento, mentre Healable gestisce le abilità di ripristino. Un Mage potrebbe implementarle entrambe, mentre un Warrior si concentra solo sull’attacco.

Valuta l'uso del pattern Strategy per i diversi comportamenti di attacco, consentendo ai personaggi di cambiare dinamicamente stile di combattimento. Il pattern State potrebbe gestire condizioni del personaggio come gli stati normale, avvelenato o stordito, che ne influenzano il comportamento.

Rifletti sulla composizione nei sistemi di equipaggiamento, in cui i personaggi "hanno" armi e armature invece di ereditarle. Usa gli enum per le classi dei personaggi o i tipi di danno e applica l'incapsulamento per proteggere le statistiche da modifiche non valide.

Sfida

Facile

Costruiamo un sistema di sviluppo dei personaggi di un gioco che mostri la potenza della POO nella modellazione di entità di gioco complesse e interattive! Creerai una gerarchia di personaggi con diversi stili di combattimento, abilità speciali e un sistema di stato che influisce sul comportamento dei personaggi.

Organizzerai il codice in sette file:

DamageType.java: crea un enum che rappresenta i diversi tipi di danno nel gioco. Includi i valori PHYSICAL, MAGICAL e RANGED. Aggiungi un campo privato description (String), un costruttore che lo imposta e un getter. Il danno fisico deve avere la descrizione "brute force", quello magico "arcane energy" e quello a distanza "precision strike".
Attackable.java: crea un'interfaccia che definisce le capacità di combattimento. Dichiara i metodi attack(Character target), che restituisce una String che descrive l'attacco, e getDamageType(), che restituisce un DamageType.
Healable.java: crea un'interfaccia per le capacità di ripristino. Dichiara un metodo heal(int amount) che restituisce una String che descrive l'azione di cura.
Character.java: crea una classe base astratta per tutti i personaggi del gioco. Includi i campi privati name (String), health (int), maxHealth (int) e level (int). Il costruttore accetta name, maxHealth e level e inizialmente imposta health uguale a maxHealth. Includi i getter per tutti i campi. Aggiungi un metodo protetto setHealth(int health) che assicura che health rimanga tra 0 e maxHealth. Crea un metodo takeDamage(int damage) che riduce health e restituisce "[name] takes [damage] damage! Health: [health]/[maxHealth]". Aggiungi un metodo isAlive() che restituisce true se health è maggiore di 0. Dichiara un metodo astratto getCharacterClass() che restituisce una String.
Warrior.java: crea una classe che estende Character e implementa Attackable. Aggiungi un campo privato strength (int). Il costruttore accetta name, maxHealth, level e strength. Implementa getCharacterClass() in modo che restituisca "Warrior". Implementa getDamageType() in modo che restituisca PHYSICAL. Implementa attack(Character target) in modo che infligga un danno pari a strength più level, chiami il metodo takeDamage del bersaglio e restituisca "[name] strikes with [damageType description] for [damage] damage!", seguito da una nuova riga e dal risultato di takeDamage.
Mage.java: crea una classe che estende Character e implementa sia Attackable sia Healable. Aggiungi i campi privati intelligence (int) e mana (int). Il costruttore accetta name, maxHealth, level, intelligence e mana. Implementa getCharacterClass() in modo che restituisca "Mage". Implementa getDamageType() in modo che restituisca MAGICAL. Implementa attack(Character target) in modo che infligga un danno pari a intelligence moltiplicato per 2, seguendo lo stesso formato di Warrior. Implementa heal(int amount) in modo che ripristini health (usando setHealth) e restituisca "[name] channels healing magic! Health: [health]/[maxHealth]".
Main.java: dai vita al tuo sistema di gioco! Riceverai una stringa di comandi separati da virgole:
- CREATE_WARRIOR:name:maxHealth:level:strength
- CREATE_MAGE:name:maxHealth:level:intelligence:mana
- ATTACK:attackerName:targetName
- HEAL:mageName:amount
- STATUS:characterName
Mantieni una raccolta di personaggi. Elabora ogni comando e stampa:
- CREATE_WARRIOR/CREATE_MAGE: [name] the [characterClass] joins the battle!
- ATTACK: stampa il risultato dell'attacco (la String restituita dal metodo attack)
- HEAL: stampa il risultato della cura oppure [name] cannot heal se il personaggio non è un Mage
- STATUS: [name] ([characterClass]) - Level [level] - Health: [health]/[maxHealth] - [Alive/Defeated]
Dopo tutti i comandi, stampa --- Battle Summary --- seguito dallo stato di ogni personaggio.

Riceverai un input: la stringa di comandi separati da virgole.

Per esempio, con l'input CREATE_WARRIOR:Thorin:100:5:15,CREATE_MAGE:Gandalf:80:7:12:50,ATTACK:Thorin:Gandalf,HEAL:Gandalf:25,STATUS:Gandalf, il tuo output sarà:

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

Questa sfida combina l'ereditarietà (gerarchia Character), l'implementazione di più interfacce (Mage implementa sia Attackable sia Healable), gli enum con metodi (DamageType), il polimorfismo (trattare in modo uniforme diversi tipi di personaggi) e l'incapsulamento (gestione protetta della salute) in un coinvolgente sistema di gioco!

Provalo tu

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: Usa una collezione per memorizzare i personaggi (LinkedHashMap mantiene l'ordine di inserimento)
        // LinkedHashMap<String, Character> characters = new LinkedHashMap<>();
        
        // TODO: Dividi input usando la virgola per ottenere i singoli comandi
        // String[] commands = input.split(",");
        
        // TODO: Elabora ogni comando:
        // - CREATE_WARRIOR:name:maxHealth:level:strength
        //   Stampa: "[name] the Warrior joins the battle!"
        // 
        // - CREATE_MAGE:name:maxHealth:level:intelligence:mana
        //   Stampa: "[name] the Mage joins the battle!"
        // 
        // - ATTACK:attackerName:targetName
        //   Stampa il risultato dell'attacco restituito dal metodo attack
        // 
        // - HEAL:mageName:amount
        //   Stampa il risultato della cura oppure "[name] cannot heal" se non è un Mage
        // 
        // - STATUS:characterName
        //   Stampa: "[name] ([characterClass]) - Level [level] - Health: [health]/[maxHealth] - [Alive/Defeated]"
        
        // TODO: Dopo tutti i comandi, stampa "--- Battle Summary ---"
        // Poi stampa lo stato di ogni personaggio
    }
}