Gestion des Joueurs

Cette section détaille les composants qui gèrent les joueurs, leurs actions, et leurs interactions avec l'environnement de jeu. Ces services sont essentiels pour la gestion des déplacements, la persistance des connexions, et le traitement des déconnexions.

GamePlayerService (game-player.service.ts)

Service qui centralise la logique de gestion des joueurs dans le jeu.

Méthodes

initialize(service: IOnGoingGameService)

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.

reconstructPlayer(player: Player): Player

Description: Crée une nouvelle instance propre de joueur à partir d'un objet joueur existant.
Paramètres: player - Joueur à reconstruire.
Retour: Nouvelle instance de joueur.
Importance: Élevée - Évite les références circulaires.
Détails: Copie toutes les propriétés importantes dans une nouvelle instance pour garantir la cohérence.

getNeareastReacheableCell(nip: string, player: Player): Vec2

Description: Trouve la cellule accessible la plus proche pour placer un joueur.
Paramètres:
- nip - Code de la partie
- player - Joueur à positionner
Retour: Position accessible.
Importance: Très élevée - Repositionnement après combat.
Détails: Utilisé pour repositionner les joueurs après un combat, en privilégiant le point d'apparition ou une position proche.

handlePlayerDisconnect(socketId: string, playerName: string, game: OnGoingGame, nip: string): void

Description: Gère la déconnexion d'un joueur.
Paramètres:
- socketId - ID de la socket déconnectée
- playerName - Nom du joueur
- game - Partie concernée
- nip - Code de la partie
Importance: Très élevée - Gestion des déconnexions.
Détails: Marque le joueur comme ayant quitté, retire sa représentation de la grille, fait tomber ses objets, gère le combat en cours si nécessaire, et vérifie les conditions de fin de partie.

private dropPlayerItemsOnDisconnect(game: OnGoingGame, player: Player, position: { row: number; col: number }, gameCode: string): void

Description: Fait tomber les objets d'un joueur déconnecté.
Paramètres:
- game - Partie concernée
- player - Joueur déconnecté
- position - Dernière position du joueur
- gameCode - Code de la partie
Importance: Élevée - Récupération des objets.
Détails: Cherche des cellules libres à proximité, y place les objets, et notifie les autres joueurs.

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

Description: Trouve les cellules accessibles autour d'une position.
Paramètres:
- onGoingGame - Partie concernée
- position - Position centrale
Retour: Liste des positions accessibles.
Importance: Élevée - Placement d'objets.
Détails: Analyse la grille en spirale pour trouver les cellules libres les plus proches.

private 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: Élevée - Utilitaire de positionnement.

private cleanPlayerFromGrid(game: OnGoingGame, playerName: string): void

Description: Retire la représentation d'un joueur de la grille.
Paramètres:
- game - Partie concernée
- playerName - Nom du joueur à retirer
Importance: Élevée - Nettoyage de la grille.
Détails: Parcourt toute la grille pour trouver et retirer les références au joueur.

private handleRemainingPlayers(game: OnGoingGame, nip: string): void

Description: Vérifie l'état de la partie après une déconnexion.
Paramètres:
- game - Partie concernée
- nip - Code de la partie
Importance: Très élevée - Gestion de fin de partie.
Détails: Si un seul joueur reste, déclare ce joueur gagnant. Si tous les joueurs sont des bots, ou si aucun joueur ne reste, annule la partie.

OnGoingGamePathFinding

Classe utilitaire (on-going-game-path-finding.ts) qui fournit des méthodes statiques pour calculer les déplacements des joueurs.

Méthodes

static cellValue(row: number, col: number, game: OnGoingGame): number

Description: Calcule la valeur (coût de déplacement) d'une cellule.
Paramètres:
- row - Ligne de la cellule
- col - Colonne de la cellule
- game - Partie concernée
Retour: Coût de déplacement (0, 1, 2 ou Infinity).
Importance: Très élevée - Fondamental pour le pathfinding.
Détails: Prend en compte le type de terrain (glace=0, sol=1, eau=2, mur=Infinity).

static getOccupiedCells(game: OnGoingGame): Vec2[]

Description: Récupère toutes les cellules occupées par des joueurs.
Paramètres: game - Partie concernée.
Retour: Liste des positions occupées.
Importance: Élevée - Évite les collisions.

static allPossibleCell(player: PlayerAbs, game: OnGoingGame): Vec2[]

Description: Calcule toutes les cellules accessibles pour un joueur.
Paramètres:
- player - Joueur concerné
- game - Partie concernée
Retour: Liste des positions accessibles.
Importance: Très élevée - Déplacements possibles.
Détails: Utilise un algorithme de recherche en largeur (BFS) avec coûts pour déterminer les cellules atteignables avec les points de mouvement disponibles.

static isAccesibleNeighbor(row: number, col: number, game: OnGoingGame): boolean

Description: Vérifie si une cellule voisine est accessible.
Paramètres:
- row - Ligne de la cellule
- col - Colonne de la cellule
- game - Partie concernée
Retour: true si la cellule est accessible, false sinon.
Importance: Élevée - Validation de déplacement.
Détails: Vérifie les limites de la grille, l'occupation et le type de terrain.

static ucs(initialPos: Vec2, finalPos: Vec2, game: OnGoingGame): { path: Vec2[]; cost: number }

Description: Calcule le chemin optimal entre deux positions (Uniform Cost Search).
Paramètres:
- initialPos - Position initiale
- finalPos - Position finale
- game - Partie concernée
Retour: Chemin et coût total.
Importance: Très élevée - Pathfinding central.
Détails: Algorithme de recherche du chemin le moins coûteux, prenant en compte les différents types de terrain.

static reconstructPath(cameFrom: Map<string, Vec2 | null>, current: Vec2): Vec2[]

Description: Reconstruit le chemin à partir des prédécesseurs.
Paramètres:
- cameFrom - Map des prédécesseurs
- current - Position finale
Retour: Chemin complet.
Importance: Élevée - Partie de l'algorithme UCS.

static getValidPositionsFrom(start: Vec2, movementPoints: number, game: OnGoingGame): Vec2[]

Description: Calcule toutes les positions atteignables avec un nombre de points de mouvement.
Paramètres:
- start - Position de départ
- movementPoints - Points de mouvement disponibles
- game - Partie concernée
Retour: Liste des positions atteignables.
Importance: Élevée - Alternative à allPossibleCell.

static calculatePathCost(path: Vec2[], game: OnGoingGame): number

Description: Calcule le coût total d'un chemin.
Paramètres:
- path - Chemin à évaluer
- game - Partie concernée
Retour: Coût total du chemin.
Importance: Élevée - Validation de déplacement.

static isWall(tile: string | null | undefined): boolean

Description: Vérifie si une tuile est un mur.
Paramètres: tile - Type de tuile à vérifier.
Retour: true si c'est un mur, false sinon.
Importance: Élevée - Utilitaire.

static getNeareastReacheableCell(player: PlayerAbs, game: OnGoingGame): Vec2

Description: Trouve la cellule accessible la plus proche pour placer un joueur.
Paramètres:
- player - Joueur à positionner
- game - Partie concernée
Retour: Position accessible.
Importance: Élevée - Repositionnement.
Détails: Version plus détaillée utilisée par GamePlayerService.

static allPossibleAttackCells(player: PlayerAbs, game: OnGoingGame): Cell[]

Description: Trouve toutes les cellules où le joueur peut attaquer.
Paramètres:
- player - Joueur concerné
- game - Partie concernée
Retour: Liste des cellules d'attaque.
Importance: Élevée - Utilisé par les bots.
Détails: Identifie les cellules contenant des joueurs adverses.

Player (player.ts)

Classe qui représente un joueur humain dans le jeu.

Propriétés importantes

• hasQuit: boolean - Indique si le joueur a quitté la partie
• isAdmin: boolean - Indique si le joueur est l'administrateur de la partie
• isBot: boolean - Indique si c'est un joueur virtuel (toujours false ici)
• wins: number - Nombre de victoires
• name: string - Nom du joueur
• avatar: string - Chemin de l'avatar du joueur
• hp: number - Points de vie actuels
• maxHp: number - Points de vie maximum
• speed: number - Vitesse (points de mouvement par tour)
• attack: number - Valeur d'attaque
• defense: number - Valeur de défense
• dice: string - Type de dé préféré ('attack' ou 'defence')
• movementPoints: number - Points de mouvement restants
• isActionPossible: boolean - Indique si le joueur peut encore effectuer une action
• itemInventory: Item[] - Objets possédés
• isPlayerTurn: boolean - Indique si c'est le tour du joueur
• position: Vec2 - Position sur la grille
• escapeAttempts: number - Nombre de tentatives d'évasion en combat
• spawnPoint: Vec2 - Point d'apparition initial
• isOnIce: boolean - Indique si le joueur est sur de la glace
• team: Team - Équipe du joueur (pour le mode CTF)

Méthodes

constructor(playerInfo: { name: string; avatar: string; stat: Stat; dice: string; team?: number } = { ... })

Description: Initialise un nouveau joueur avec les paramètres spécifiés.
Paramètres: playerInfo - Informations du joueur.
Importance: Élevée - Construction standard.

move(deplacement: number)

Description: Réduit les points de mouvement après un déplacement.
Paramètres: deplacement - Coût du déplacement.
Importance: Élevée - Mécanique de déplacement.

resetTurn()

Description: Réinitialise l'état du joueur pour un nouveau tour.
Importance: Élevée - Début de tour.
Détails: Restaure les points de mouvement et la possibilité d'action.

Bot , AggressiveBot, DefensiveBot

Classes (bot.ts, aggressive-bot.ts, defensive-bot.ts) qui représentent les joueurs virtuels (IA) avec différents comportements.

Propriétés importantes (en plus de celles de Player)

• botType: string - Type de bot ('Aggressive' ou 'Defensive')
• endTurn: boolean - Indique si le bot a terminé son tour
• ctfEndGame: boolean - Indique si le bot a gagné en mode CTF
• isNextToFlagCarrierSpawn: boolean - Position spéciale en mode CTF
• isCombatLost: boolean - Résultat du dernier combat
• isCombatActive: boolean - État de combat
• botUtils: BotUtils - Utilitaires pour les bots
• allPossibleMoves: Vec2[] - Cache des mouvements possibles
• allPossibleAttacks: Vec2[] - Cache des attaques possibles
• allItems: Cell[] - Cache de tous les objets
• allItemsInRange: Cell[] - Cache des objets accessibles
• visitedItems: Cell[] - Objets déjà visités

Relations avec le côté Client

Côté client, plusieurs composants interagissent avec ces joueurs:

• PlayerInfoComponent (client) affiche les informations d'un joueur
• PlayersListComponent (client) affiche la liste des joueurs
• GameViewService (client) traite les événements de joueur

Types de joueurs

Le système distingue trois types de joueurs:

• Joueurs humains (Player)
• Bots agressifs (AggressiveBot) - Privilégient l'attaque et la capture d'objets offensifs
• Bots défensifs (DefensiveBot) - Privilégient la défense et la capture d'objets défensifs

Méthodes principales

async executeCommonTurn(onGoingGame: OnGoingGame): Promise<void>

Description: Exécute le tour complet d'un bot.
Paramètres: onGoingGame - Partie concernée.
Importance: Très élevée - IA centrale.
Détails: Boucle tant que des points de mouvement sont disponibles, en exécutant des actions selon la stratégie du bot.

abstract handleDeplacement(onGoingGame: OnGoingGame): void

Description: Gère la stratégie de déplacement spécifique à chaque type de bot.
Paramètres: onGoingGame - Partie concernée.
Importance: Très élevée - Différenciation des stratégies.
Détails: Implémentée différemment dans AggressiveBot et DefensiveBot.

abstract handleItemSwap(onGoingGame: OnGoingGame, itemPos: Vec2): void

Description: Gère la stratégie d'échange d'objets spécifique à chaque type de bot.
Paramètres:
- onGoingGame - Partie concernée
- itemPos - Position de l'objet
Importance: Élevée - Différenciation des stratégies.

handleCombat(onGoingGame: OnGoingGame, posFinal: Vec2)

Description: Initie un combat si un adversaire est adjacent.
Paramètres:
- onGoingGame - Partie concernée
- posFinal - Position finale après déplacement
Importance: Très élevée - Comportement offensif.
Détails: Vérifie les quatre directions, identifie les adversaires, et démarre le combat.

async moveToFlag(game: OnGoingGame)

Description: Déplace le bot vers le drapeau (mode CTF).
Paramètres: game - Partie concernée.
Importance: Élevée - Stratégie CTF.
Détails: Trouve le drapeau, calcule un chemin, et s'y déplace.

async moveToSpawnPoint(game: OnGoingGame)

Description: Déplace le bot vers son point d'apparition.
Paramètres: game - Partie concernée.
Importance: Élevée - Stratégie CTF après capture.
Détails: Particulièrement utile quand le bot a capturé le drapeau.

handleItems(onGoingGame: OnGoingGame, itemPos: Vec2)

Description: Gère le ramassage d'un objet.
Paramètres:
- onGoingGame - Partie concernée
- itemPos - Position de l'objet
Importance: Élevée - Acquisition d'objets.

moveToRandomPosition(onGoingGame: OnGoingGame)

Description: Déplace le bot vers une position aléatoire accessible.
Paramètres: onGoingGame - Partie concernée.
Importance: Élevée - Comportement par défaut.
Détails: Utilisé quand aucune meilleure action n'est disponible.

moveTroughtDoor(game: OnGoingGame, targetVec2: Vec2)

Description: Tente de se déplacer à travers une porte fermée.
Paramètres:
- game - Partie concernée
- targetVec2 - Position cible
Retour: true si un déplacement a été effectué, false sinon.
Importance: Élevée - Navigation intelligente.
Détails: Identifie les portes bloquantes, s'en approche, et les ouvre.

async openDoor(onGoingGame: OnGoingGame, door: Cell)

Description: Ouvre une porte.
Paramètres:
- onGoingGame - Partie concernée
- door - Cellule de la porte
Importance: Élevée - Action sur l'environnement.

BotUtils (bot-utils.ts)

Classe utilitaire qui fournit des fonctions d'aide pour les bots.

Méthodes

generateRandomStats(): { maxHp: number; speed: number }

Description: Génère des statistiques aléatoires pour un bot.
Retour: Statistiques générées.
Importance: Moyenne - Initialisation des bots. A REVOIR
Détails: Produit soit {6, 4} soit {4, 6} pour maxHp et speed.

getAllPossibleMoves(bot: Bot, game: OnGoingGame)

Description: Calcule et cache tous les mouvements possibles pour un bot.
Paramètres:
- bot - Bot concerné
- game - Partie concernée
Importance: Élevée - Information de mouvement.

getAllItems(bot: Bot, game: OnGoingGame)

Description: Identifie et cache tous les objets sur la grille.
Paramètres:
- bot - Bot concerné
- game - Partie concernée
Importance: Élevée - Information sur les objets.
Détails: Filtre également les objets accessibles.

getAllPossibleAttacks(bot: Bot, game: OnGoingGame)

Description: Identifie toutes les positions d'attaque possibles.
Paramètres:
- bot - Bot concerné
- game - Partie concernée
Importance: Très élevée - Comportement offensif.
Détails: Trouve les positions depuis lesquelles le bot peut attaquer d'autres joueurs.

endTurnAttribute(bot: Bot): void

Description: Force la fin du tour d'un bot.
Paramètres: bot - Bot concerné.
Importance: Élevée - Contrôle du tour.
Détails: Réinitialise les points de mouvement et les possibilités d'action.

async waitForAllPlayers(onGoingGame: OnGoingGame)

Description: Attend que tous les joueurs aient terminé leurs actions.
Paramètres: onGoingGame - Partie concernée.
Importance: Élevée - Synchronisation.
Détails: Bloque jusqu'à ce que playerInAction soit à zéro.

async waitForCombatToEnd(bot: Bot)

Description: Attend la fin d'un combat.
Paramètres: bot - Bot concerné.
Importance: Élevée - Synchronisation.
Détails: Bloque tant que le bot est en combat.

getAdjacentValidPositions(position: Vec2, onGoingGame: OnGoingGame): Vec2[]

Description: Trouve toutes les positions adjacentes valides.
Paramètres:
- position - Position centrale
- onGoingGame - Partie concernée
Retour: Liste des positions adjacentes valides.
Importance: Élevée - Navigation.
Détails: Exclut les diagonales et les positions bloquées.

isTurnOver(bot: Bot, onGoingGame: OnGoingGame)

Description: Vérifie si le tour d'un bot doit se terminer.
Paramètres:
- bot - Bot concerné
- onGoingGame - Partie concernée
Retour: true si le tour doit se terminer, false sinon.
Importance: Très élevée - Contrôle du flux.
Détails: Vérifie diverses conditions comme la perte de combat, l'état CTF, les points de mouvement, etc.