Extract client message planning helpers

Author: rgilks

src/client/game-client-messages.test.ts

@@ -0,0 +1,192 @@
+import { describe, expect, it } from 'vitest';
+
+import type { CombatResult, GameState, MovementEvent, OrdnanceMovement, S2C, Ship, ShipMovement } from '../shared/types';
+import type { ClientState } from './game-client-phase';
+import { deriveClientMessagePlan } from './game-client-messages';
+
+function createShip(overrides: Partial<Ship> = {}): Ship {
+  return {
+    id: 'ship-0',
+    type: 'packet',
+    owner: 0,
+    position: { q: 0, r: 0 },
+    velocity: { dq: 0, dr: 0 },
+    fuel: 10,
+    cargoUsed: 0,
+    nukesLaunchedSinceResupply: 0,
+    resuppliedThisTurn: false,
+    landed: false,
+    destroyed: false,
+    detected: true,
+    damage: { disabledTurns: 0 },
+    ...overrides,
+  };
+}
+
+function createState(overrides: Partial<GameState> = {}): GameState {
+  return {
+    gameId: 'MSG',
+    scenario: 'test',
+    scenarioRules: {},
+    escapeMoralVictoryAchieved: false,
+    turnNumber: 4,
+    phase: 'astrogation',
+    activePlayer: 0,
+    ships: [createShip(), createShip({ id: 'enemy', owner: 1 })],
+    ordnance: [],
+    pendingAstrogationOrders: null,
+    pendingAsteroidHazards: [],
+    destroyedAsteroids: [],
+    destroyedBases: [],
+    players: [
+      { connected: true, ready: true, targetBody: 'Mars', homeBody: 'Terra', bases: [], escapeWins: false },
+      { connected: true, ready: true, targetBody: 'Terra', homeBody: 'Mars', bases: [], escapeWins: false },
+    ],
+    winner: null,
+    winReason: null,
+    ...overrides,
+  };
+}
+
+function derive(msg: S2C, currentState: ClientState = 'connecting') {
+  return deriveClientMessagePlan(currentState, 2, 0, 5_000, msg);
+}
+
+describe('game-client-messages', () => {
+  it('derives welcome handling from reconnect and current state', () => {
+    expect(derive({
+      type: 'welcome',
+      playerId: 1,
+      code: 'ABCDE',
+      playerToken: 'player-token',
+    })).toEqual({
+      kind: 'welcome',
+      playerId: 1,
+      code: 'ABCDE',
+      playerToken: 'player-token',
+      clearInviteLink: true,
+      showReconnectToast: true,
+      nextState: 'waitingForOpponent',
+    });
+  });
+
+  it('derives game start, movement, combat, and state update plans', () => {
+    const movementState = createState();
+    const movements: ShipMovement[] = [{
+      shipId: 'ship-0',
+      from: { q: 0, r: 0 },
+      to: { q: 1, r: 0 },
+      path: [],
+      newVelocity: { dq: 1, dr: 0 },
+      fuelSpent: 1,
+      gravityEffects: [],
+      crashed: false,
+      landedAt: null,
+    }];
+    const ordnanceMovements: OrdnanceMovement[] = [];
+    const events: MovementEvent[] = [];
+    const results: CombatResult[] = [{
+      attackerIds: ['ship-0'],
+      targetId: 'enemy',
+      targetType: 'ship',
+      attackType: 'gun',
+      odds: '1-1',
+      attackStrength: 1,
+      defendStrength: 1,
+      rangeMod: 0,
+      velocityMod: 0,
+      dieRoll: 3,
+      modifiedRoll: 3,
+      damageType: 'disabled',
+      disabledTurns: 1,
+      counterattack: null,
+    }];
+
+    expect(derive({
+      type: 'gameStart',
+      state: createState({ phase: 'fleetBuilding' }),
+    }, 'waitingForOpponent')).toEqual({
+      kind: 'gameStart',
+      state: createState({ phase: 'fleetBuilding' }),
+      nextState: 'playing_fleetBuilding',
+    });
+
+    expect(derive({
+      type: 'movementResult',
+      state: movementState,
+      movements,
+      ordnanceMovements,
+      events,
+    }, 'playing_astrogation')).toEqual({
+      kind: 'movementResult',
+      state: movementState,
+      movements,
+      ordnanceMovements,
+      events,
+    });
+
+    expect(derive({
+      type: 'combatResult',
+      state: movementState,
+      results,
+    }, 'playing_combat')).toEqual({
+      kind: 'combatResult',
+      state: movementState,
+      results,
+      shouldTransition: true,
+    });
+
+    expect(derive({
+      type: 'stateUpdate',
+      state: movementState,
+    }, 'playing_movementAnim')).toEqual({
+      kind: 'stateUpdate',
+      state: movementState,
+      shouldTransition: false,
+    });
+  });
+
+  it('derives endgame, rematch, disconnect, error, and pong plans', () => {
+    expect(derive({
+      type: 'gameOver',
+      winner: 1,
+      reason: 'Lost all ships',
+    }, 'playing_combat')).toEqual({
+      kind: 'gameOver',
+      won: false,
+      reason: 'Lost all ships',
+    });
+
+    expect(derive({ type: 'rematchPending' }, 'gameOver')).toEqual({
+      kind: 'rematchPending',
+    });
+
+    expect(derive({ type: 'opponentDisconnected' }, 'playing_ordnance')).toEqual({
+      kind: 'opponentDisconnected',
+      nextState: 'gameOver',
+      won: true,
+      reason: 'Opponent disconnected',
+    });
+
+    expect(derive({ type: 'error', message: 'Bad request' }, 'playing_astrogation')).toEqual({
+      kind: 'error',
+      message: 'Bad request',
+    });
+
+    expect(derive({ type: 'pong', t: 4_000 }, 'playing_astrogation')).toEqual({
+      kind: 'pong',
+      latencyMs: 1_000,
+    });
+
+    expect(derive({ type: 'pong', t: 0 }, 'playing_astrogation')).toEqual({
+      kind: 'pong',
+      latencyMs: null,
+    });
+  });
+
+  it('marks match found as a phase-change notification', () => {
+    expect(derive({ type: 'matchFound' }, 'waitingForOpponent')).toEqual({
+      kind: 'matchFound',
+    });
+  });
+});

src/client/game-client-messages.ts

@@ -0,0 +1,139 @@
+import type { CombatResult, GameState, MovementEvent, OrdnanceMovement, S2C, ShipMovement } from '../shared/types';
+import type { ClientState } from './game-client-phase';
+import {
+  deriveGameStartClientState,
+  deriveWelcomeHandling,
+  shouldTransitionAfterStateUpdate,
+} from './game-client-network';
+
+export type ClientMessagePlan =
+  | {
+      kind: 'welcome';
+      playerId: number;
+      code: string;
+      playerToken: string;
+      clearInviteLink: boolean;
+      showReconnectToast: boolean;
+      nextState: ClientState | null;
+    }
+  | { kind: 'matchFound' }
+  | {
+      kind: 'gameStart';
+      state: GameState;
+      nextState: ClientState;
+    }
+  | {
+      kind: 'movementResult';
+      state: GameState;
+      movements: ShipMovement[];
+      ordnanceMovements: OrdnanceMovement[];
+      events: MovementEvent[];
+    }
+  | {
+      kind: 'combatResult';
+      state: GameState;
+      results: CombatResult[];
+      shouldTransition: true;
+    }
+  | {
+      kind: 'stateUpdate';
+      state: GameState;
+      shouldTransition: boolean;
+    }
+  | {
+      kind: 'gameOver';
+      won: boolean;
+      reason: string;
+    }
+  | { kind: 'rematchPending' }
+  | {
+      kind: 'opponentDisconnected';
+      nextState: 'gameOver';
+      won: true;
+      reason: 'Opponent disconnected';
+    }
+  | {
+      kind: 'error';
+      message: string;
+    }
+  | {
+      kind: 'pong';
+      latencyMs: number | null;
+    };
+
+export function deriveClientMessagePlan(
+  currentState: ClientState,
+  reconnectAttempts: number,
+  playerId: number,
+  nowMs: number,
+  msg: S2C,
+): ClientMessagePlan {
+  switch (msg.type) {
+    case 'welcome': {
+      const welcome = deriveWelcomeHandling(currentState, reconnectAttempts, msg.playerId);
+      return {
+        kind: 'welcome',
+        playerId: msg.playerId,
+        code: msg.code,
+        playerToken: msg.playerToken,
+        clearInviteLink: welcome.clearInviteLink,
+        showReconnectToast: welcome.showReconnectToast,
+        nextState: welcome.nextState,
+      };
+    }
+    case 'matchFound':
+      return { kind: 'matchFound' };
+    case 'gameStart':
+      return {
+        kind: 'gameStart',
+        state: msg.state,
+        nextState: deriveGameStartClientState(msg.state, playerId),
+      };
+    case 'movementResult':
+      return {
+        kind: 'movementResult',
+        state: msg.state,
+        movements: msg.movements,
+        ordnanceMovements: msg.ordnanceMovements,
+        events: msg.events,
+      };
+    case 'combatResult':
+      return {
+        kind: 'combatResult',
+        state: msg.state,
+        results: msg.results,
+        shouldTransition: true,
+      };
+    case 'stateUpdate':
+      return {
+        kind: 'stateUpdate',
+        state: msg.state,
+        shouldTransition: shouldTransitionAfterStateUpdate(currentState),
+      };
+    case 'gameOver':
+      return {
+        kind: 'gameOver',
+        won: msg.winner === playerId,
+        reason: msg.reason,
+      };
+    case 'rematchPending':
+      return { kind: 'rematchPending' };
+    case 'opponentDisconnected':
+      return {
+        kind: 'opponentDisconnected',
+        nextState: 'gameOver',
+        won: true,
+        reason: 'Opponent disconnected',
+      };
+    case 'error':
+      return {
+        kind: 'error',
+        message: msg.message,
+      };
+    case 'pong':
+      return {
+        kind: 'pong',
+        latencyMs: msg.t > 0 ? nowMs - msg.t : null,
+      };
+  }
+}