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 propose de construire un système de développement de personnages de jeu qui illustre la puissance de la POO dans la modélisation d'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 fonctionnent naturellement ici : Attackable pourrait définir des méthodes de combat, tandis que Healable gère les capacités de restauration. Un Mage pourrait implémenter les deux, alors qu'un Warrior se concentre uniquement sur l'attaque.

Envisagez d'utiliser le patron Strategy pour différents comportements d'attaque, permettant aux personnages de changer de style de combat de manière dynamique. Le patron State pourrait gérer les conditions des personnages comme les états normal, empoisonné ou étourdi qui affectent le comportement.

Pensez à 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 enums 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 avant la puissance de la POO pour modéliser des entités de jeu complexes et interactives ! Vous allez créer une hiérarchie de personnages avec différents styles de combat, des capacités spéciales et un système d'état qui affecte le comportement des personnages.

Vous organiserez votre code sur sept fichiers :

DamageType.java : Créez un enum représentant les 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 getter. Les dégâts physiques doivent avoir la description "brute force", les magiques doivent avoir "arcane energy", et à distance doivent avoir "precision strike".
Attackable.java : Créez une interface définissant les capacités de combat. Déclarez les méthodes attack(Character target) qui retourne une String décrivant l'attaque, et getDamageType() qui retourne un DamageType.
Healable.java : Créez une interface pour les capacités de restauration. Déclarez une méthode heal(int amount) qui retourne une String 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 prend name, maxHealth, et level, en initialisant health à la valeur de maxHealth. Incluez des getters pour tous les champs. Ajoutez une méthode protégée setHealth(int health) qui garantit que la santé reste entre 0 et maxHealth. Créez une méthode takeDamage(int damage) qui réduit la santé et retourne "[name] takes [damage] damage! Health: [health]/[maxHealth]". Ajoutez une méthode isAlive() retournant true si la santé est supérieure à 0. Déclarez une méthode abstraite getCharacterClass() retournant une String.
Warrior.java : Créez une classe étendant Character et implémentant Attackable. Ajoutez un champ privé strength (int). Le constructeur prend name, maxHealth, level, et strength. Implémentez getCharacterClass() pour retourner "Warrior". Implémentez getDamageType() pour retourner 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 retourner "[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 étendant Character et implémentant à la fois Attackable et Healable. Ajoutez des champs privés intelligence (int) et mana (int). Le constructeur prend name, maxHealth, level, intelligence, et mana. Implémentez getCharacterClass() pour retourner "Mage". Implémentez getDamageType() pour retourner MAGICAL. Implémentez attack(Character target) pour infliger des dégâts égaux à intelligence multipliée par 2, en suivant le même format que Warrior. Implémentez heal(int amount) pour restaurer la santé (en utilisant setHealth) et retourner "[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 retourné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 du statut de chaque personnage.

Vous recevrez une seule 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 d'interfaces multiples (Mage implémente à la fois Attackable et Healable), les enums avec méthodes (DamageType), le polymorphisme (traiter différents types de personnages de manière uniforme) et l'encapsulation (gestion protégée de la santé) dans 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 virgule pour obtenir les commandes individuelles
        // String[] commands = input.split(",");
        
        // TODO: Traiter chaque commande :
        // - CREATE_WARRIOR:name:maxHealth:level:strength
        //   Afficher : "[name] the Warrior joins the battle!"
        // 
        // - CREATE_MAGE:name:maxHealth:level:intelligence:mana
        //   Afficher : "[name] the Mage joins the battle!"
        // 
        // - ATTACK:attackerName:targetName
        //   Afficher le résultat de l'attaque à partir de la méthode attack
        // 
        // - HEAL:mageName:amount
        //   Afficher le résultat du soin, ou "[name] cannot heal" s'il ne s'agit pas d'un Mage
        // 
        // - STATUS:characterName
        //   Afficher : "[name] ([characterClass]) - Level [level] - Health: [health]/[maxHealth] - [Alive/Defeated]"
        
        // TODO: Après toutes les commandes, afficher "--- Battle Summary ---"
        // Puis afficher le statut de chaque personnage
    }
}