Systeme de combat

Cette section détaille les composants qui gèrent le système de combat entre joueurs ou avec des bots.

Relations avec le côté Client

Côté client, plusieurs composants interagissent avec le système de combat:

• CombatMenuComponent (client) interagit avec le service client CombatService
• GameViewService (client) reçoit les notifications de début et fin de combat
• L'interface utilisateur affiche l'état du combat et permet les actions

Structure du combat

La structure d'un combat est définie par l'interface Combat qui contient:

• Les joueurs en combat (player1, player2)
• Le joueur actuel et son adversaire
• Le gagnant et le perdant (après la fin)
• Les résultats des dés et les dégâts
• L'historique des actions

CombatService (combat.service.ts)

Service principal qui implémente la logique centrale du système de combat.

Propriétés importantes

• player1: Player - Premier combattant
• player2: Player - Second combattant
• currentPlayer: Player - Joueur dont c'est le tour d'attaquer
• opponent: Player - Joueur qui défend
• timers: Timer[] - Minuteurs pour les actions de combat
• combat: Combat - État actuel du combat
• isInCombat: boolean - Indique si un combat est en cours
• combatStartedManually: boolean - Indique si le combat a été initié manuellement

Méthodes

constructor()

• Description: Initialise le service avec un combat terminé par défaut.
• Importance: Faible - Simple initialisation.

startCombat(player1: Player, player2: Player, combatStartedManually = false): void

• Description: Démarre un combat entre deux joueurs.
• Paramètres:
  • player1 - Premier joueur
  • player2 - Second joueur
  • combatStartedManually - Si le combat est initié manuellement
• Importance: Très élevée - Point d'entrée du système de combat.
• Détails: Vérifie que les joueurs ne sont pas de la même équipe, initialise les statistiques, assigne les rôles et crée l'objet de combat.

attack(isDebug: boolean): void

• Description: Exécute une attaque du joueur actuel.
• Paramètres: isDebug - Si le mode débogage est actif (valeurs de dés maximales).
• Importance: Très élevée - Mécanique centrale du combat.
• Détails: Calcule les scores d'attaque et de défense, applique les dégâts si l'attaque réussit, et passe au tour suivant ou termine le combat.

assignInitialRoles(): void

• Description: Détermine quel joueur attaque en premier (basé sur la vitesse).
• Importance: Élevée - Établit l'ordre de combat initial.

takeDamage(damage: number): void

• Description: Applique des dégâts à l'adversaire actuel.
• Paramètres: damage - Quantité de dégâts à infliger.
• Importance: Élevée - Mécanique de dégâts.

escape(isDebug: boolean): void

• Description: Tente une évasion du combat.
• Paramètres: isDebug - Si le mode débogage est actif.
• Importance: Élevée - Alternative à l'attaque.
• Détails: Vérifie les tentatives d'évasion restantes, calcule la probabilité de réussite, et termine le combat ou passe au tour suivant.

endTurn(): void

• Description: Termine le tour actuel et passe au joueur suivant.
• Importance: Élevée - Rotation des tours.

endCombat(winner: Player, loser: Player): void

• Description: Termine le combat avec un gagnant et un perdant.
• Paramètres:
  • winner - Joueur victorieux (null si évasion)
  • loser - Joueur vaincu (null si évasion)
• Importance: Très élevée - Finalisation du combat.
• Détails: Met à jour les statistiques de combat, définit le gagnant/perdant, et marque le combat comme terminé.

rollDice(dice: string, position: string): number

• Description: Lance un dé selon le type et la position.
• Paramètres:
  • dice - Type de dé ('attack' ou 'defence')
  • position - Position du joueur ('attacker' ou 'defender')
• Retour: Résultat du lancer de dé.
• Importance: Élevée - Mécanique aléatoire du combat.
• Détails: Prend en compte les objets spéciaux comme le "Fixeur" qui modifie les résultats des dés.

attemptEscape(): boolean

• Description: Détermine si une tentative d'évasion réussit.
• Retour: true si l'évasion réussit, false sinon.
• Importance: Élevée - Logique d'évasion.

resetPlayer(player: Player): void

• Description: Réinitialise les statistiques d'un joueur après le combat.
• Paramètres: player - Joueur à réinitialiser.
• Importance: Élevée - Nettoyage post-combat.

Méthodes de gestion des minuteurs

• saveTimers(timers: Timer[]): void
• startFiveSecondsTimer(): void
• startThreeSecondsTimer(): void
• stopTimers(): void

Ces méthodes gèrent les minuteurs qui limitent le temps d'action en combat.
Importance: Élevée - Maintient le rythme du combat.

getCurrentPlayerEscapeAttempts(): number

• Description: Retourne le nombre de tentatives d'évasion du joueur actuel.
• Retour: Nombre de tentatives d'évasion.
• Importance: Élevée - Accesseur simple.

getCurrentCombat(): Combat

• Description: Retourne l'état actuel du combat.
• Retour: Objet Combat actuel.
• Importance: Élevée - Accesseur pour les autres services.

Méthodes privées

• private updatePlayerStats(player: Player, combatPlayer: Player | PlayerAbs): void
• private hasFixerItem(player: Player): boolean
• private calculateAttackScore(isDebug: boolean): { attackScore: number; defenseScore: number; attackDice: number; defenseDice: number }
• private applyDamage(damage: number): void
• private syncCombatStats(): void

Ces méthodes privées implémentent des aspects spécifiques de la logique de combat. Importance: Élevée - Détails cruciaux de la mécanique.

CombatSocketService

Service (combat-socket.service.ts) qui gère les événements socket liés au combat.

Propriétés importantes

• combatServices = new Map<string, CombatService> - Stocke les services de combat pour chaque partie

Méthodes

constructor()

• Description: Initialise le service avec les services auxiliaires.
• Importance: Élevée - Simple initialisation.

initialize(service: IOnGoingGameService): void

• Description: Initialise l'accès au service de gestion des parties.
• Paramètres: service - Service OnGoingGameService.
• Importance: Élevée - Configuration nécessaire.

handleSocket(socket: Socket): void

• Description: Configure les gestionnaires d'événements liés au combat.
• Paramètres: socket - La connexion socket à configurer.
• Importance: Élevée - Point d'entrée pour les événements de combat.
• Détails: Gère les événements 'StartGame', 'StartCombat', 'Attack', 'Escape'.

async startCombatManually(onGoingGame: OnGoingGame, player1: Player, player2: Player)

• Description: Démarre un combat manuellement (typiquement par un bot).
• Paramètres:
  • onGoingGame - La partie concernée
  • player1 - Premier joueur
  • player2 - Second joueur
• Importance: Élevée - Permet aux IA de démarrer des combats.
• Détails: Vérifie les conditions, initialise les minuteurs, et démarre le combat.

getCombatService(gameCode: string): CombatService

• Description: Récupère le service de combat pour une partie.
• Paramètres: gameCode - Code de la partie.
• Retour: Service CombatService associé.
• Importance: Élevée - Accesseur pour les autres services.

attack(combatService: CombatService, gameCode: string, isDebug: boolean): void

• Description: Exécute une attaque dans un combat.
• Paramètres:
  • combatService - Service de combat concerné
  • gameCode - Code de la partie
  • isDebug - Si le mode débogage est actif
• Importance: Élevée - Action principale de combat.
• Détails: Arrête les minuteurs, exécute l'attaque, et gère la fin du combat si nécessaire.

escape(combatService: CombatService, gameCode: string, isDebug: boolean): void

• Description: Tente une évasion dans un combat.
• Paramètres: Similaires à attack.
• Importance: Élevée - Alternative à l'attaque.
• Détails: Similaire à attack mais pour l'évasion.

restartTimer(combatService: CombatService, gameCode: string, isDebug: boolean): void

• Description: Redémarre le minuteur approprié après une action.
• Paramètres: Similaires à attack.
• Importance: Élevée - Gestion du timing.
• Détails: Détermine le minuteur à utiliser, notifie les clients, et gère les actions des bots.

handlePlayerDisconnect(gameCode: string, playerName: string): boolean

• Description: Gère la déconnexion d'un joueur pendant un combat.
• Paramètres:
  • gameCode - Code de la partie
  • playerName - Nom du joueur déconnecté
• Retour: true si un combat était en cours, false sinon.
• Importance: Élevée - Gestion des déconnexions.
• Détails: Marque le joueur comme ayant quitté, préserve ses statistiques, et termine le combat.

cleanupCombatResources(gameCode: string): void

• Description: Nettoie les ressources après un combat.
• Paramètres: gameCode - Code de la partie.
• Importance: Élevée - Prévient les fuites de mémoire.
• Détails: Arrête les minuteurs, préserve les statistiques, et supprime le service de combat.

Méthodes privées

• private preserveCombatStatsBeforeCleanup(gameCode: string, combatService: CombatService): void
• private updatePlayerStats(game: OnGoingGame, combatPlayer: Player): void
• private preservePlayerStats(gameCode: string, playerName: string, combatService: CombatService): void
• private updatePlayerStatsOnDisconnect(player: Player, playerName: string, combatService: CombatService): void

Ces méthodes gèrent la persistance des statistiques de combat.
Importance: Élevée - Garantit l'intégrité des données.

CombatEndingService

Service (combat-ending.service.ts) qui gère la finalisation des combats et les conséquences (objets perdus, position, etc.).

Méthodes

constructor()

• Description: Initialise le service avec les services auxiliaires.
• Importance: Élevée - Simple initialisation.

handleCombatEnd(combatService: CombatService, gameCode: string): void

• Description: Gère la fin d'un combat et ses conséquences.
• Paramètres:
  • combatService - Service de combat concerné
  • gameCode - Code de la partie
• Importance: Très élevée - Point critique de transition post-combat.
• Détails: Préserve les statistiques, gère les joueurs déconnectés, repositionne le perdant, et vérifie les conditions de victoire.

handleLoserAfterCombat(onGoingGame: OnGoingGame, combatService: CombatService, gameCode: string): void

• Description: Gère le positionnement du perdant après le combat.
• Paramètres:
  • onGoingGame - La partie concernée
  • combatService - Service de combat concerné
  • gameCode - Code de la partie
• Importance: Élevée - Repositionnement critique.
• Détails: Place le perdant à une position accessible, fait tomber ses objets si nécessaire.

Méthodes privées

• private preserveCombatStats(combatService: CombatService, onGoingGame: OnGoingGame): void
• private saveDisconnectedPlayersStats(onGoingGame: OnGoingGame, gameCode: string): void
• private updateDisconnectedPlayerStats(gameCode: string, player: Player): void
• private broadcastAllPlayerStats(onGoingGame: OnGoingGame, gameCode: string): void
• private sendDisconnectedPlayersStats(gameCode: string): void

Ces méthodes gèrent la persistance et la diffusion des statistiques de combat.
Importance: Élevée - Maintien de la cohérence des données.

CombatHelperService

Service (combat-helper.service.ts) utilitaire qui fournit des fonctions d'aide pour le système de combat.

Méthodes

arePlayersAdjacent(player1: { row: number; col: number }, player2: { row: number; col: number }, onGoingGameService: OnGoingGameService): boolean

• Description: Vérifie si deux joueurs sont adjacents sur la grille.
• Paramètres:
  • player1 - Position du premier joueur
  • player2 - Position du second joueur
  • onGoingGameService - Service de gestion des parties
• Retour: true si les joueurs sont adjacents, false sinon.
• Importance: Élevée - Prérequis pour le combat.
• Détails: Prend en compte les objets qui augmentent la portée d'attaque.

findNearbyCells(onGoingGame: OnGoingGame, position: { row: number; col: number }): { row: number; col: number }[]

• Description: Trouve les cellules accessibles à proximité d'une position.
• Paramètres:
  • onGoingGame - La partie concernée
  • position - Position de référence
• Retour: Tableau de positions accessibles.
• Importance: Élevée - Utilisé pour le placement des joueurs et des objets.

getDirection(from: { row: number; col: number }, to: { row: number; col: number }): { row: number; col: number }

• Description: Détermine la direction entre deux positions.
• Paramètres:
  • from - Position de départ
  • to - Position d'arrivée
• Retour: Vecteur de direction.
• Importance: Moyenne - Utilitaire de positionnement.

cleanupAllDisconnectedPlayers(game: OnGoingGame, gameCode: string, socketService: SocketService): void

• Description: Nettoie les références aux joueurs déconnectés.
• Paramètres:
  • game - La partie concernée
  • gameCode - Code de la partie
  • socketService - Service de communication socket
• Importance: Élevée - Maintient la cohérence de l'état.
• Détails: Retire les joueurs déconnectés de la grille et les marque comme ayant quitté.