Composant de personnage de jeu

Construisons un système de personnages de jeu en utilisant le modèle d'architecture basé sur les composants ! Au lieu de créer des hiérarchies d'héritage rigides, vous composerez des personnages en attachant 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 sur cinq fichiers :

• IComponent.cs : Définissez une interface IComponent dans l'espace de noms Game.Components. Chaque composant doit avoir une méthode Update() qui affiche ce que le composant est en train de faire.
• 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). La santé ne doit jamais descendre en dessous de 0 ou dépasser le maximum. Incluez un event Action<int> HealthChanged qui se déclenche chaque fois que la santé change, en passant la nouvelle valeur de santé. La méthode Update() doit afficher l'état de santé actuel.
• 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) (renvoie un bool indiquant le succès). 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 a besoin d'une propriété Name et de ces méthodes :
  • AddComponent(IComponent component) - attache 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 attaché
• Program.cs : Rassemblez le tout en créant un personnage, en attachant des composants et en traitant des commandes.

Vous recevrez les entrées suivantes :

• Nom du personnage
• Santé maximale initiale pour le HealthComponent
• 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 la santé change (via l'événement) : Health changed: {newHealth}
• Lors de l'ajout d'un objet : Added: {itemName}
• Lors de la suppression d'un objet : Removed: {itemName} ou Item not found: {itemName}
• Update() du HealthComponent : Health: {current}/{max}
• Update() de l'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 comment le personnage n'hérite de rien de spécial - il contient simplement des composants qui fournissent un comportement. La méthode GetComponent<T>() utilise les génériques pour une récupération de type sécurisé, et les événements notifient lorsque la santé change. Cette approche par composition vous permet de mélanger et d'associer librement les composants !