Composant de personnage de jeu

Construisons un système de personnages de jeu à l’aide du modèle d’architecture basé sur les composants ! Au lieu de créer des hiérarchies d’héritage rigides, vous composerez les personnages en leur associant des composants indépendants qui gèrent des comportements spécifiques — une approche flexible largement utilisée dans le développement de jeux.

Vous organiserez votre code dans cinq fichiers :

• IComponent.cs : définissez une interface IComponent dans l’espace de noms Game.Components. Chaque composant doit disposer d’une méthode Update() qui affiche ce que fait le composant.
• HealthComponent.cs : créez une classe HealthComponent qui implémente IComponent. Elle doit suivre les points de vie actuels et maximum, avec des méthodes TakeDamage(int amount) et Heal(int amount). Les points de vie ne doivent jamais être inférieurs à 0 ni supérieurs au maximum. Incluez un event Action<int> HealthChanged qui se déclenche chaque fois que les points de vie changent, en transmettant la nouvelle valeur des points de vie. La méthode Update() doit afficher l’état actuel des points de vie.
• InventoryComponent.cs : créez une classe InventoryComponent qui implémente IComponent. Elle gère une liste de noms d’objets avec les méthodes AddItem(string item) et RemoveItem(string item) (qui renvoie bool pour indiquer si l’opération a réussi). La méthode Update() doit afficher le contenu de l’inventaire.
• Character.cs : créez une classe Character dans l’espace de noms Game qui contient une collection de composants. Votre personnage doit posséder une propriété Name ainsi que les méthodes suivantes :
  • AddComponent(IComponent component) — associe un composant au personnage
  • GetComponent<T>() où T : IComponent — renvoie le premier composant de type T, ou null s’il n’est pas trouvé
  • UpdateAll() — appelle Update() sur chaque composant associé
• Program.cs : rassemblez tous les éléments en créant un personnage, en lui associant des composants et en traitant les commandes.

Vous recevrez les entrées suivantes :

• Le nom du personnage
• Le nombre maximal initial de points de vie pour le HealthComponent
• Le nombre de commandes à traiter
• Pour chaque commande : l’action suivie des données pertinentes

Formats des commandes :

damage
{amount}

heal
{amount}

add_item
{itemName}

remove_item
{itemName}

update

Formats de sortie :

• Lorsque les points de vie changent (via l’événement) : Health changed: {newHealth}
• Lors de l’ajout d’un objet : Added: {itemName}
• Lors du retrait d’un objet : Removed: {itemName} ou Item not found: {itemName}
• Update() de HealthComponent : Health: {current}/{max}
• Update() de InventoryComponent : Inventory: {item1}, {item2}, ... ou Inventory: empty

Par exemple, si les entrées sont :

Hero
100
7
add_item
Sword
add_item
Shield
damage
30
heal
10
remove_item
Potion
remove_item
Sword
update

La sortie devrait être :

Added: Sword
Added: Shield
Health changed: 70
Health changed: 80
Item not found: Potion
Removed: Sword
Health: 80/100
Inventory: Shield

Remarquez que le personnage n’hérite de rien de particulier : il contient simplement des composants qui fournissent des comportements. La méthode GetComponent<T>() utilise les génériques pour une récupération sécurisée du type, et les événements signalent les changements de points de vie. Cette approche par composition vous permet de combiner librement les composants !