Gestion des Items

Cette section détaille les composants qui gèrent les objets (items) dans le jeu.

Relations avec le côté Client

Côté client, plusieurs composants interagissent avec le système d'objets:

• ItemRejectPopupComponent (client) gère l'interface de rejet d'objets
• PlayerInfoComponent (client) affiche les objets d'un joueur
• GameViewService (client) traite les événements d'acquisition d'objets

Types d'objets

Le jeu propose trois types d'objets (définis dans EffectType) :

• Attribute - Modifie directement les attributs du joueur (attaque, défense, etc.)
• Condition - Applique des effets sous certaines conditions (PV bas, victoires, etc.)
• Gameplay - Modifie les règles du jeu (résultats des dés, portée, etc.)

GameItemService (game-item.service.ts)

Service qui gère les interactions de base avec les objets du jeu.

Méthodes

applyIceEffect(game: OnGoingGame, event: Vec2, player: Player)

• Description: Applique ou retire les effets de la glace sur un joueur qui se déplace.
• Paramètres:
  • game - La partie concernée
  • event - Position du joueur
  • player - Joueur concerné
• Importance: Élevée - Mécanique environnementale.
• Détails: Lorsqu'un joueur entre sur une case de glace, ses attributs d'attaque et de défense sont réduits de 2. Ces modifications sont annulées quand il quitte la glace.

replaceRandomItems(game: OnGoingGame): void

• Description: Remplace les objets aléatoires par des objets spécifiques.
• Paramètres: game - La partie à modifier.
• Importance: Élevée - Initialisation des objets.
• Détails: Identifie les objets "randomItem" sur la grille et les remplace par des objets spécifiques, en évitant les doublons lorsque possible.

GameItemHandlerService

Service (game-item-handler.service.ts) qui traite les événements liés aux objets et gère leur ramassage et utilisation.

Méthodes

initialize(service: IOnGoingGameService): void

• Description: Initialise le service avec l'instance du service de gestion des parties.
• Paramètres: service - Instance d'OnGoingGameService.
• Importance: Élevée - Configuration nécessaire.

handleItemEvents(socket: Socket): void

• Description: Configure les gestionnaires d'événements liés aux objets.
• Paramètres: socket - La connexion socket à configurer.
• Importance: Élevée - Point d'entrée pour les événements d'objets.
• Détails: Appelle les méthodes de gestion spécifiques pour chaque type d'événement.

processItemPickup(game: OnGoingGame, player: Player, event: Vec2, cell: Cell): boolean

• Description: Traite le ramassage d'un objet par un joueur.
• Paramètres:
  • game - La partie concernée
  • player - Joueur qui ramasse l'objet
  • event - Position de l'objet
  • cell - Cellule contenant l'objet
• Retour: true si l'objet a été ramassé, false sinon.
• Importance: Très élevée - Mécanique centrale de ramassage.
• Détails: Ajoute l'objet à l'inventaire du joueur, applique ses effets, et notifie les autres joueurs.

private handleRejectItem(socket: Socket): void

• Description: Gère le rejet d'un objet lorsque l'inventaire est plein.
• Paramètres: socket - La connexion socket concernée.
• Importance: Élevée - Gestion d'inventaire.
• Détails: Vérifie la validité, place l'objet sur la grille et notifie les clients.

private handleSwapRejectItem(socket: Socket): void

• Description: Gère l'échange d'un objet existant avec un nouvel objet.
• Paramètres: socket - La connexion socket concernée.
• Importance: Élevée - Alternative au rejet simple.
• Détails: Échange les objets, met à jour les effets, et notifie les clients.

ItemHandlerService (item-handler.service.ts)

Service utilitaire qui fournit des fonctions de manipulation d'objets, notamment lors des combats.

Méthodes

constructor()

• Description: Initialise le service avec un helper de combat.
• Importance: ? - Simple initialisation.

dropPlayerItems(onGoingGame: OnGoingGame, player: Player, gameCode: string, socketService: SocketService, loserPosition: Vec2): void

• Description: Fait tomber tous les objets d'un joueur sur la grille.
• Paramètres:
  • onGoingGame - La partie concernée
  • player - Joueur qui perd ses objets
  • gameCode - Code de la partie
  • socketService - Service de communication socket
  • loserPosition - Position du joueur
• Importance: Très élevée - Conséquence du combat.
• Détails: Recherche des cellules vides à proximité, y place les objets, et notifie les clients.

deactivateItemEffects(player: Player, item: Item): void

• Description: Désactive les effets d'un objet sur un joueur.
• Paramètres:
  • player - Joueur concerné
  • item - Objet à désactiver
• Importance: Élevée - Gestion des effets.
• Détails: Comportement spécifique selon le type d'effet (attribut, condition, gameplay).

OnGoingGameItemHandling

Classe utilitaire (on-going-game-item-handling.ts) qui fournit des méthodes statiques pour la manipulation des objets dans le contexte d'une partie.

Méthodes

static pickupItem(player: Player, position: Vec2, game: OnGoingGame): boolean

• Description: Traite le ramassage d'un objet par un joueur.
• Paramètres:
  • player - Joueur qui ramasse l'objet
  • position - Position de l'objet
  • game - La partie concernée
• Retour: true si l'objet a été ramassé, false sinon.
• Importance: Très élevée - Mécanique centrale de ramassage.
• Détails: Vérifie la validité, ajoute l'objet à l'inventaire, et applique ses effets.

static isInventoryFull(player: Player, game: OnGoingGame): boolean

• Description: Vérifie si l'inventaire d'un joueur est plein.
• Paramètres:
  • player - Joueur à vérifier
  • game - La partie concernée
• Retour: true si l'inventaire est plein, false sinon.
• Importance: Élevée - Vérification de capacité.

static placeItemOnGrid(item: Item, position: Vec2, game: OnGoingGame): void

• Description: Place un objet sur la grille de jeu.
• Paramètres:
  • item - Objet à placer
  • position - Position où placer l'objet
  • game - La partie concernée
• Importance: Élevée - Placement d'objets.
• Détails: Réinitialise l'état de l'objet et le place dans la cellule spécifiée.

static reevaluateConditionalItems(player: Player): void

• Description: Réévalue les objets conditionnels d'un joueur.
• Paramètres: player - Joueur concerné.
• Importance: Élevée - Gestion des effets conditionnels.
• Détails: Vérifie si les conditions sont remplies pour activer les objets conditionnels.

static hasActiveItem(player: Player, itemId: string): boolean

• Description: Vérifie si un joueur a un objet actif spécifique.
• Paramètres:
  • player - Joueur à vérifier
  • itemId - Identifiant de l'objet
• Retour: true si l'objet est actif, false sinon.
• Importance: Élevée - Vérification d'état.

static swapItem(player: Player, newItem: Item, rejectedItemId: string): Item | null

• Description: Échange un objet existant contre un nouvel objet.
• Paramètres:
  • player - Joueur concerné
  • newItem - Nouvel objet à acquérir
  • rejectedItemId - Identifiant de l'objet à rejeter
• Retour: L'objet rejeté ou null en cas d'échec.
• Importance: Élevée - Gestion d'inventaire complexe.
• Détails: Retire l'objet existant, annule ses effets, ajoute le nouvel objet, et applique ses effets.

static checkWinCondition(player: Player, game: OnGoingGame): boolean

• Description: Vérifie si un joueur remplit les conditions de victoire.
• Paramètres:
  • player - Joueur à vérifier
  • game - La partie concernée
• Retour: true si le joueur a gagné, false sinon.
• Importance: Très élevée - Condition de fin de partie.
• Détails: Vérifie le mode de jeu et les conditions spécifiques (CTF ou nombre de victoires).

static addItemToPlayer(player: Player, cell: Cell): boolean

• Description: Ajoute un objet d'une cellule à l'inventaire d'un joueur.
• Paramètres:
  • player - Joueur concerné
  • cell - Cellule contenant l'objet
• Retour: true si l'objet a été ajouté, false sinon.
• Importance: Élevée - Acquisition d'objet.
• Détails: Vérifie les doublons, ajoute l'objet, et applique ses effets.

static checkForConditionItems(player: Player): boolean

• Description: Vérifie si un joueur a des objets conditionnels non activés.
• Paramètres: player - Joueur à vérifier.
• Retour: true si des objets conditionnels sont disponibles, false sinon.
• Importance: Élevée - Vérification d'état.

static rejectItem(player: Player, rejectId: string, cell: Cell): Item | null

• Description: Rejette un objet de l'inventaire d'un joueur.
• Paramètres:
  • player - Joueur concerné
  • rejectId - Identifiant de l'objet à rejeter
  • cell - Cellule où l'objet était
• Retour: L'objet rejeté ou null en cas d'échec.
• Importance: Élevée - Gestion d'inventaire.
• Détails: Retire l'objet, annule ses effets, et nettoie la cellule.

static addItemAndReject(player: Player, cell: Cell): boolean

• Description: Ajoute un objet et en rejette un si nécessaire.
• Paramètres:
  • player - Joueur concerné
  • cell - Cellule contenant l'objet
• Retour: true si l'opération a réussi, false sinon.
• Importance: Élevée - Gestion d'inventaire complexe.

static getItemFromPosition(position: Vec2, game: OnGoingGame): Item | null

• Description: Récupère un objet à une position spécifique.
• Paramètres:
  • position - Position à vérifier
  • game - La partie concernée
• Retour: L'objet à la position ou null.
• Importance: Élevée - Accesseur.

static getPlayerWithFlag(players: Player[]): Player | null

• Description: Trouve le joueur qui possède le drapeau (mode CTF).
• Paramètres: players - Liste des joueurs.
• Retour: Le joueur avec le drapeau ou null.
• Importance: Élevée - Logique CTF.

static getFlagCell(game: OnGoingGame): Cell | null

• Description: Trouve la cellule contenant le drapeau sur la grille.
• Paramètres: game - La partie concernée.
• Retour: La cellule contenant le drapeau ou null.
• Importance: Élevée - Logique CTF.

static getAllItemsCells(game: OnGoingGame)

• Description: Récupère toutes les cellules contenant des objets.
• Paramètres: game - La partie concernée.
• Retour: Liste des cellules avec des objets.
• Importance: Élevée - Utilisé par les bots.

Méthodes privées

• private static removeAttributeModifications(player: Player, attributesModified: AttributesModified): void
• private static applyAttributeModifications(player: Player, attributesModified: AttributesModified): void
• private static evaluateConditionEffect(player: Player, item: Item): void
• private static applyGameplayEffect(player: Player, item: Item): void
• private static checkAndApplyCondition(player: Player, item: Item): boolean
• private static checkCTFWinCondition(player: Player, game: OnGoingGame): boolean

Ces méthodes privées gèrent les détails de l'application et du retrait des effets d'objets. Importance: Élevée - Mécanique fondamentale.

Item (item.ts)

Classe qui représente un objet dans le jeu.

Propriétés importantes

• id: string - Identifiant unique de l'objet
• name: string - Nom de l'objet
• description: string - Description de l'objet
• effectType: EffectType - Type d'effet (Attribute, Condition, Gameplay)
• attributesModified?: AttributesModified - Modifications d'attributs
• conditionEffect?: string - Description de l'effet conditionnel
• gameplayEffect?: string - Description de l'effet de gameplay
• isCollected: boolean - Si l'objet est collecté
• isActive: boolean - Si l'effet de l'objet est actif

Méthodes

constructor(params: ItemParams)

• Description: Initialise un nouvel objet avec les paramètres spécifiés.
• Paramètres: params - Paramètres de configuration.
• Importance: Élevée - Construction standard.

static initializeAllItems(game: Game | null, maxItems: number): Item[]

• Description: Crée tous les types d'objets disponibles dans le jeu.
• Paramètres:
  • game - Jeu concerné (pour déterminer le mode)
  • maxItems - Nombre maximum d'objets
• Retour: Liste de tous les objets disponibles.
• Importance: Très élevée - Initialisation des objets.
• Détails: Crée des objets avec différents effets: attaque, défense, dés, portée, etc.