fix: le HUD mettait à jour les compteurs des joueurs trop tôt pendant la résolution du tour

Cause : le serveur émet 'round-result' (déclenche l'animation de révélation
des cartes/gains sur le plateau Phaser, ~3.5s avant le tour suivant) et
'game-state' en phase 'resolve' (déjà avec les jauges/scores post-résolution
via getPlayersInfo) au même instant. Le HUD Vue (alimenté directement par
gameStore.players) sautait donc à ses nouvelles valeurs INSTANTANÉMENT, en
même temps que l'animation de résolution démarrait tout juste sur le
plateau — les compteurs changeaient avant/pendant que le joueur voie
l'animation qui justifie ce changement, au lieu d'être synchronisés avec
elle.

Fix : le store Pinia (client/src/stores/game.js) gèle désormais
players/currentTurn pendant toute la phase 'resolve' — les valeurs reçues
sont stockées dans un buffer interne (_pendingPlayers/_pendingCurrentTurn)
au lieu d'être appliquées immédiatement, et ne sont propagées à l'affichage
qu'au game-state suivant dont la phase n'est PLUS 'resolve' (typiquement
'selecting' du tour suivant, ou 'end'). Le reste de l'état (phase, main,
objets/bâtiments/événements) continue de se mettre à jour normalement et
immédiatement — seul l'affichage des jauges/scores est différé.

6 nouveaux tests unitaires (game.store.test.js) couvrant le gel/dégel du
buffer, la rediffusion de plusieurs game-state en phase 'resolve'
successifs, la transition directe vers 'end', et le nettoyage du buffer
par reset().

Nouveau test E2E (hud-resolution-timing.spec.js) confirmé discriminant :
échoue de façon reproductible (2/2 tentatives) sans le fix ("0 pts" attendu
pendant resolve, "5 pts" déjà affiché), passe systématiquement avec le fix
(stable sur 3 répétitions). Attente active de la phase 'resolve' via
expect.poll plutôt qu'un délai fixe, pour éviter la fenêtre d'observation
manquée sous charge variable.

60 tests unitaires client + 166 tests unitaires serveur + suite
game-flow.spec.js (4 tests, non liée à ce fix) toujours au vert.

client/src/stores/game.js

@@ -31,6 +31,12 @@ export const useGameStore = defineStore('game', () => {
   // ── Fin de partie ────────────────────────────────────────────────────────────
   const gameOverResults = ref(null) // liste des joueurs (avec score) une fois la partie terminée, sinon null
 
+  // ── Buffer interne : gel du HUD pendant la phase 'resolve' ──────────────────
+  // Non exposé dans le return (détail d'implémentation de updateState),
+  // voir le commentaire dans updateState() pour le pourquoi.
+  const _pendingPlayers     = ref(null)
+  const _pendingCurrentTurn = ref(null)
+
   function setGameOver(results) {
     gameOverResults.value = results
   }
@@ -40,8 +46,33 @@ export const useGameStore = defineStore('game', () => {
   }
 
   function updateState(state) {
-    players.value     = state.players ?? []
-    currentTurn.value = state.currentTurn ?? 0
+    // Les jauges/scores affichés dans le HUD (players) ne doivent PAS sauter
+    // à leur nouvelle valeur dès que le serveur résout le tour : à cet
+    // instant précis, l'animation de révélation des cartes + des gains
+    // (+X sur chaque carte) démarre tout juste sur le plateau Phaser (voir
+    // GameScene._showPlayedCards, déclenchée par l'event 'round-result' émis
+    // au même moment que ce game-state en phase 'resolve'). Sans ce gel, le
+    // HUD affichait déjà les valeurs finales AVANT que le joueur ait vu
+    // l'animation qui les justifie, donnant l'impression que les compteurs
+    // se mettaient à jour "au mauvais moment" (trop tôt, désynchronisés de
+    // ce qui se passe visuellement sur le plateau).
+    //
+    // Le gel dure toute la phase 'resolve' (~3.5s côté serveur avant
+    // nextTurn) : players/currentTurn reçus pendant cette phase sont stockés
+    // dans un buffer, appliqué au prochain game-state dont la phase N'EST
+    // PLUS 'resolve' (typiquement 'selecting' du tour suivant, ou 'end').
+    if (state.phase === 'resolve') {
+      _pendingPlayers.value    = state.players ?? []
+      _pendingCurrentTurn.value = state.currentTurn ?? currentTurn.value
+    } else {
+      // Sortie de la phase 'resolve' (ou jamais entré dedans) : appliquer
+      // en priorité le buffer s'il existe (valeurs déjà connues depuis le
+      // round-result), sinon les valeurs de cet état directement.
+      players.value     = _pendingPlayers.value ?? state.players ?? []
+      currentTurn.value = _pendingCurrentTurn.value ?? state.currentTurn ?? 0
+      _pendingPlayers.value    = null
+      _pendingCurrentTurn.value = null
+    }
     maxTurns.value    = state.maxTurns ?? 12
     phase.value       = state.phase ?? 'idle'
     myTeamIndex.value = state.myTeamIndex ?? 0
@@ -83,6 +114,8 @@ export const useGameStore = defineStore('game', () => {
     hasPendingEventDraw.value = false
     pendingEventPlayId.value  = null
     gameOverResults.value  = null
+    _pendingPlayers.value     = null
+    _pendingCurrentTurn.value = null
   }
 
   return {

client/test/unit/game.store.test.js

@@ -155,6 +155,73 @@ describe('stores/game (Pinia)', () => {
       expect(store.pendingEventPlayId).toBeNull()
       expect(store.hasPendingEventDraw).toBe(false)
     })
+
+    describe('gel du HUD pendant la phase "resolve"', () => {
+      it('ne met PAS à jour players/currentTurn immédiatement quand phase="resolve"', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 0 }], currentTurn: 1, phase: 'selecting' })
+
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 1, phase: 'resolve' })
+
+        // Les valeurs affichées restent celles d'AVANT la résolution
+        expect(store.players).toEqual([{ name: 'Alice', score: 0 }])
+        expect(store.phase).toBe('resolve') // la phase, elle, est bien mise à jour immédiatement
+      })
+
+      it('applique les valeurs gelées au prochain game-state qui sort de la phase "resolve"', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 0 }], currentTurn: 1, phase: 'selecting' })
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 1, phase: 'resolve' })
+
+        // Le tour suivant arrive (phase='selecting', currentTurn=2) : les
+        // valeurs gelées (score=5 du round-result) doivent s'appliquer ici,
+        // PAS les valeurs de ce nouveau game-state si elles diffèrent.
+        store.updateState({ players: [{ name: 'Alice', score: 999 }], currentTurn: 2, phase: 'selecting' })
+
+        expect(store.players).toEqual([{ name: 'Alice', score: 5 }])
+        expect(store.currentTurn).toBe(1)
+      })
+
+      it('applique directement les valeurs si phase="end" suit "resolve" (fin de partie)', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 0 }], currentTurn: 12, phase: 'selecting' })
+        store.updateState({ players: [{ name: 'Alice', score: 42 }], currentTurn: 12, phase: 'resolve' })
+        store.updateState({ players: [{ name: 'Alice', score: 42 }], currentTurn: 13, phase: 'end' })
+
+        expect(store.players).toEqual([{ name: 'Alice', score: 42 }])
+        expect(store.phase).toBe('end')
+      })
+
+      it('n\'affecte pas les valeurs si la phase ne passe jamais par "resolve" (mise à jour directe classique)', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 3 }], currentTurn: 2, phase: 'waiting' })
+        expect(store.players).toEqual([{ name: 'Alice', score: 3 }])
+        expect(store.currentTurn).toBe(2)
+      })
+
+      it('un second game-state en phase "resolve" (rediffusion) écrase le buffer avec les valeurs les plus récentes', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 0 }], currentTurn: 1, phase: 'selecting' })
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 1, phase: 'resolve' })
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 1, phase: 'resolve' }) // rediffusion identique
+
+        store.updateState({ players: [{ name: 'Alice', score: 999 }], currentTurn: 2, phase: 'selecting' })
+
+        expect(store.players).toEqual([{ name: 'Alice', score: 5 }])
+      })
+
+      it('reset() vide aussi le buffer interne (pas de fuite de valeurs gelées vers une nouvelle partie)', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 3, phase: 'resolve' })
+        store.reset()
+
+        // Après reset, un nouveau game-state 'selecting' doit s'appliquer
+        // directement, sans que le buffer de l'ancienne partie ne persiste.
+        store.updateState({ players: [{ name: 'Bob', score: 0 }], currentTurn: 1, phase: 'selecting' })
+        expect(store.players).toEqual([{ name: 'Bob', score: 0 }])
+        expect(store.currentTurn).toBe(1)
+      })
+    })
   })
 
   describe('selectCard / clearSelection', () => {