Gestion des Parties

Cette section détaille les composants responsables de la création, la gestion et le déroulement des parties de jeu. Ces services forment le cœur du système, maintenant l'état global des parties et orchestrant les transitions entre les différentes phases du jeu.

États du jeu

Les états principaux d'une partie sont définis dans l'énumération State:

• Waiting - Salle d'attente initiale
• InBetweenRound - Phase entre deux tours
• Round - Tour de jeu actif
• GameOver - Fin de partie

OnGoingGameService

Ce service (on-going-game.service.ts) central gère toutes les parties en cours dans le système. Il implémente l'interface IOnGoingGameService et coordonne les autres services spécialisés.

Propriétés importantes

• games: Map<string, OnGoingGame> - Stocke toutes les parties en cours, indexées par leur code
• socketToNip = new Map<string, string> - Associe un ID de socket à un code de partie
• socketToPlayer = new Map<string, string> - Associe un ID de socket à un identifiant joueur
• timers: Map<string, GameTimer[]> - Stocke les minuteurs pour chaque partie

Méthodes

constructor(private gameSocketHandlerService: GameSocketHandlerService, private gameStateService: GameStateService, private gamePlayerService: GamePlayerService, private gameTimerService: GameTimerService, private gameItemService: GameItemService)

Description: Initialise le service avec tous les services spécialisés nécessaires.
Importance: Élevée - Point d'entrée pour la gestion des parties.
Détails: Initialise tous les services dépendants avec une référence à lui-même.

getCombatSocketService(): CombatSocketService

Description: Récupère le service de gestion des combats.
Retour: Instance de CombatSocketService.
Importance: Élévée - Accès à un service externe.

Méthodes d'activation des services

• activateWaitingRoom(socket: Socket, waitingRoomSocket: WaitingSocketService)
• activateJoinRoom(socket: Socket, joinRoomSocket: JoinGameService)
• activateTimer(socket: Socket, timerSocket: TimerSocketService)
• handleSocket(socket: Socket)
• handleGame(socket: Socket)

Ces méthodes délèguent la gestion des événements socket aux services spécialisés. Importance: Élevée - Établit la chaîne de responsabilité.

Méthodes de gestion des états

• switchState = async (game: OnGoingGame) => { ... }
• async handleBotTurn(game: OnGoingGame)
• applyIceEffect(name: string, gameCode: string): void
• changeState(game: OnGoingGame, state: State)

Ces méthodes gèrent la progression du jeu et les changements d'état.
Importance: Très élevée - Cœur de la mécanique de jeu.

Méthodes d'accès aux parties

• getGame(nip: string): OnGoingGame
• setGame(nip: string, game: OnGoingGame)
• removeGame(nip: string)
• cleanupGame(game: OnGoingGame)
• getGameBySocketID(socketId: string): OnGoingGame | undefined

Ces méthodes manipulent la collection de parties.
Importance: Élevée - Gestion du cycle de vie des parties.

Méthodes de gestion des joueurs

• getNeareastReacheableCell(nip: string, player: Player): Vec2
• setPlayerSocket(socketId: string, playerName: string, nip: string): void
• getPlayerNameBySocket(socketId: string): string
• getSocketIdByPlayerNameAndGame(playerName: string, gameCode: string): string | undefined
• getSocketIdByPlayerName(playerName: string): string | undefined
• removePlayerSocket(socketId: string)
• handlePlayerDisconnect(socketId: string, playerName: string, game: OnGoingGame, nip: string): void

Ces méthodes gèrent l'association entre joueurs, sockets et parties.
Importance: Élevée - Critique pour la persistance des connexions.

Méthodes de gestion des codes et sockets

• generateUniqueCode(): string
• getNipBySocket(id: string)
• setSocketToNip(socket: Socket, nip: string)

Gèrent les codes de partie et les associations avec les sockets.
Importance: Élevée - Infrastructure de communication.

Méthodes de jeu

• isWall(row: number, col: number, code: string): boolean
• sendGameStats(gameCode: string): void
• setGameBeforeGame(playerName: string, gameCode: string)

Utilitaires pour la logique de jeu.
Importance: Élévée - Support aux fonctionnalités principales.

Méthodes de reconstruction d'objets

• reconstructGame(game: OnGoingGame | undefined, nip: string, player?: Player): OnGoingGame
• reconstructPlayer(player: Player): Player

Créent des instances propres d'objets de jeu.
Importance: Élevée - Évite les problèmes de référence circulaire.

async delay(ms: number): Promise<void>

Description: Utilitaire pour créer des délais.
Paramètres: ms - Délai en millisecondes.
Importance: Élévée - Utilitaire.

GameStateService

Ce service (game-state.service.ts) gère les transitions d'état du jeu et le déroulement des tours.

Méthodes

initialize(service: IOnGoingGameService): void

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

switchState = async (game: OnGoingGame) => { ... }

Description: Gère la transition entre différents états du jeu.
Paramètres: game - La partie concernée.
Importance: Très élevée - Orchestration du jeu.
Détails: Selon l'état actuel (attente entre tours, tour en cours, fin de partie), exécute les actions appropriées.

async handleBotTurn(game: OnGoingGame)

Description: Exécute le tour d'un bot si c'est son tour.
Paramètres: game - La partie concernée.
Importance: Élevée - Intelligence artificielle du jeu.

changeState(game: OnGoingGame, state: State)

Description: Modifie l'état d'une partie et notifie les clients.
Paramètres:
- game - La partie concernée
- state - Le nouvel état
Importance: Élevée - Transition explicite d'état.

sendGameStats(gameCode: string): void

Description: Envoie les statistiques actuelles de la partie aux clients.
Paramètres: gameCode - Code de la partie.
Importance: Élévée - Mise à jour des statistiques.

private async handleInBetweenRoundState(game: OnGoingGame)

Description: Gère l'état d'attente entre les tours.
Paramètres: game - La partie concernée.
Importance: Élevée - Phase cruciale de préparation du tour.

private async handleRoundState(game: OnGoingGame)

Description: Gère la fin d'un tour et la préparation du suivant.
Paramètres: game - La partie concernée.
Importance: Élevée - Transition de tour.

GameTimerService

Ce service (game-timer.service.ts) gère les minuteurs (timers) associés aux parties.

Méthodes

initialize(service: IOnGoingGameService)

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

stopTimers(nip: string)

Description: Arrête tous les minuteurs d'une partie.
Paramètres: nip - Code de la partie.
Importance: Élevée - Évite les problèmes de timing lors des changements d'état.

startTurnTimer(gameCode: string)

Description: Démarre le minuteur du tour de jeu.
Paramètres: gameCode - Code de la partie.
Importance: Élevée - Limite le temps de jeu par tour.

startInterludeTimer(gameCode: string)

Description: Démarre le minuteur d'interlude entre les tours.
Paramètres: gameCode - Code de la partie.
Importance: Élevée - Définit la pause entre les tours.

TimerSocketService

Ce service (timer-socket.service.ts) gère les événements socket liés aux minuteurs.

Méthodes

constructor(private onGoingGameService: OnGoingGameService)

Description: Initialise le service.
Paramètres: onGoingGameService - Service de gestion des parties.
Importance: Élevée - Injection standard.

handleSocket(socket: Socket): void

Description: Configure les gestionnaires d'événements liés aux minuteurs.
Paramètres: socket - La connexion socket à configurer.
Importance: Élevée - Point d'entrée pour la gestion des minuteurs.
Détails: Configure les événements 'StartGame', 'PauseTurnTimer', 'ResumeTurnTimer', 'EndTurn'.