Développement de personnages de jeu

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 86 sur 87.

Ce défi vous demande de construire un système de développement de personnages de jeu qui met en valeur la puissance de la POO pour modéliser des entités complexes et interactives.

Concevez une hiérarchie de personnages où une classe de base Character définit des attributs communs tels que la santé, le nom et le niveau. Des classes spécialisées telles que Warrior, Mage et Archer étendent cette base avec des capacités et des styles de combat uniques.

Les interfaces s’intègrent naturellement ici : Attackable pourrait définir les méthodes de combat, tandis que Healable gérerait les capacités de restauration. Un Mage pourrait implémenter les deux, tandis qu’un Warrior se concentrerait uniquement sur l’attaque.

Envisagez d’utiliser le pattern Strategy pour différents comportements d’attaque, afin de permettre aux personnages de changer dynamiquement de style de combat. Le pattern State pourrait gérer les états des personnages, comme les états normal, empoisonné ou étourdi, qui influencent leur comportement.

Réfléchissez à la composition pour les systèmes d’équipement où les personnages « possèdent » des armes et des armures plutôt que d’en hériter. Utilisez des énumérations pour les classes de personnages ou les types de dégâts, et appliquez l’encapsulation pour protéger les statistiques contre les modifications invalides.

Défi

Facile

Construisons un système de développement de personnages de jeu qui met en évidence la puissance de la POO pour modéliser des entités de jeu complexes et interactives ! Vous créerez une hiérarchie de personnages avec différents styles de combat, des capacités spéciales et un système d’état qui influence le comportement des personnages.

Vous organiserez votre code dans sept fichiers :

DamageType.java : créez une énumération représentant différents types de dégâts dans le jeu. Incluez les valeurs PHYSICAL, MAGICAL et RANGED. Ajoutez un champ privé description (String), un constructeur qui l’initialise et un accesseur. Les dégâts physiques doivent avoir la description "brute force", les dégâts magiques "arcane energy" et les dégâts à distance "precision strike".
Attackable.java : créez une interface définissant les capacités de combat. Déclarez les méthodes attack(Character target) qui renvoie une chaîne décrivant l’attaque, et getDamageType() qui renvoie un DamageType.
Healable.java : créez une interface pour les capacités de restauration. Déclarez une méthode heal(int amount) qui renvoie une chaîne décrivant l’action de soin.
Character.java : créez une classe de base abstraite pour tous les personnages du jeu. Incluez des champs privés pour name (String), health (int), maxHealth (int) et level (int). Le constructeur accepte name, maxHealth et level, et définit initialement health sur maxHealth. Incluez des accesseurs pour tous les champs. Ajoutez une méthode protégée setHealth(int health) qui garantit que health reste compris entre 0 et maxHealth. Créez une méthode takeDamage(int damage) qui réduit health et renvoie "[name] takes [damage] damage! Health: [health]/[maxHealth]". Ajoutez une méthode isAlive() renvoyant true si health est supérieur à 0. Déclarez une méthode abstraite getCharacterClass() renvoyant un String.
Warrior.java : créez une classe qui étend Character et implémente Attackable. Ajoutez un champ privé strength (int). Le constructeur accepte name, maxHealth, level et strength. Implémentez getCharacterClass() pour renvoyer "Warrior". Implémentez getDamageType() pour renvoyer PHYSICAL. Implémentez attack(Character target) pour infliger des dégâts égaux à strength plus level, appeler la méthode takeDamage de la cible et renvoyer "[name] strikes with [damageType description] for [damage] damage!" suivi d’un saut de ligne et du résultat de takeDamage.
Mage.java : créez une classe qui étend Character et implémente à la fois Attackable et Healable. Ajoutez les champs privés intelligence (int) et mana (int). Le constructeur accepte name, maxHealth, level, intelligence et mana. Implémentez getCharacterClass() pour renvoyer "Mage". Implémentez getDamageType() pour renvoyer MAGICAL. Implémentez attack(Character target) pour infliger des dégâts égaux à intelligence multiplié par 2, en suivant le même format que Warrior. Implémentez heal(int amount) pour restaurer health (à l’aide de setHealth) et renvoyer "[name] channels healing magic! Health: [health]/[maxHealth]".
Main.java : donnez vie à votre système de jeu ! Vous recevrez une chaîne de commandes séparées par des virgules :
- CREATE_WARRIOR:name:maxHealth:level:strength
- CREATE_MAGE:name:maxHealth:level:intelligence:mana
- ATTACK:attackerName:targetName
- HEAL:mageName:amount
- STATUS:characterName
Maintenez une collection de personnages. Traitez chaque commande et affichez :
- CREATE_WARRIOR/CREATE_MAGE : [name] the [characterClass] joins the battle!
- ATTACK : affichez le résultat de l’attaque (la String renvoyée par la méthode attack)
- HEAL : affichez le résultat du soin, ou [name] cannot heal si le personnage n’est pas un Mage
- STATUS : [name] ([characterClass]) - Level [level] - Health: [health]/[maxHealth] - [Alive/Defeated]
Après toutes les commandes, affichez --- Battle Summary --- suivi de l’état de chaque personnage.

Vous recevrez une entrée : la chaîne de commandes séparées par des virgules.

Par exemple, avec l’entrée CREATE_WARRIOR:Thorin:100:5:15,CREATE_MAGE:Gandalf:80:7:12:50,ATTACK:Thorin:Gandalf,HEAL:Gandalf:25,STATUS:Gandalf, votre sortie serait :

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

Ce défi combine l’héritage (hiérarchie Character), l’implémentation de plusieurs interfaces (Mage implémente à la fois Attackable et Healable), les énumérations avec méthodes (DamageType), le polymorphisme (traiter uniformément différents types de personnages) et l’encapsulation (gestion protégée de health) au sein d’un système de jeu captivant !

Essayez vous-même

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: Utiliser une collection pour maintenir les personnages (LinkedHashMap préserve l'ordre d'insertion)
        // LinkedHashMap<String, Character> characters = new LinkedHashMap<>();
        
        // TODO: Diviser l'entrée par des virgules pour obtenir les commandes individuelles
        // String[] commands = input.split(",");
        
        // TODO: Traiter chaque commande :
        // - 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
        //   Afficher le résultat de l'attaque de la méthode attack
        // 
        // - HEAL:mageName:amount
        //   Afficher le résultat de la guérison, ou "[name] cannot heal" si ce n'est pas un Mage
        // 
        // - STATUS:characterName
        //   Affiche : "[name] ([characterClass]) - Level [level] - Health: [health]/[maxHealth] - [Alive/Defeated]"
        
        // TODO: After all commands, print "--- Battle Summary ---"
        // Puis affiche le statut de chaque personnage
    }
}