Centralize ordnance launch rules in shared helpers

Phase 4 of the maintenance plan. Extracts duplicated ordnance
launch eligibility logic into two shared helpers in engine/util.ts:
- validateShipOrdnanceLaunch: per-ship per-type error messages
- canLaunchOrdnance: quick boolean for ship filtering

Both client ordnance.ts and engine game-engine.ts now use these
instead of encoding the same rules independently. Removes the
duplicate canShipLaunchAnyOrdnance from client code.

Fixes two client-side bugs:
- Orbital bases at D1 damage were incorrectly blocked from launching
- Torpedo error message now correctly mentions orbital bases

Author: rgilks

docs/BACKLOG.md

@@ -70,13 +70,15 @@ Split `src/shared/types.ts` into `src/shared/types/` directory:
 ScenarioPlayer). Barrel `index.ts` preserves all existing
 import paths.
 
-### Phase 4. Rules consolidation
+### ~~Phase 4. Rules consolidation~~ *(done)*
 
-- Centralize scenario capability checks and ordnance launch
-  legality so client helpers and engine validation do not
-  encode the same rules in different places.
-- Continue preferring extracted pure helpers over larger
-  architectural moves.
+Centralized ordnance launch rules into shared helpers in
+`engine/util.ts`: `validateShipOrdnanceLaunch` (per-ship
+per-type eligibility) and `canLaunchOrdnance` (quick boolean
+filter). Client `ordnance.ts` and engine `game-engine.ts`
+both use the shared helpers. Fixes: client now correctly
+allows orbital bases to launch at D1 damage and includes
+orbital base exception in torpedo rules.
 
 ### Phase 5. Stronger entity state models
 
@@ -92,7 +94,7 @@ import paths.
 2. ~~`main.ts` coordinator extraction.~~
 3. ~~`ui.ts` view extraction.~~
 4. ~~Shared type/module split.~~
-5. Rules consolidation.
+5. ~~Rules consolidation.~~
 6. Optional stronger state-model refactors.
 
 ---

src/client/game/ordnance.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, it } from 'vitest';
 
 import type { GameState, Ship } from '../../shared/types';
 import {
-  canShipLaunchAnyOrdnance,
   getFirstLaunchableShipId,
   resolveBaseEmplacementPlan,
   resolveOrdnanceLaunchPlan,
@@ -45,16 +44,6 @@ function createPlanning(
 }
 
 describe('game-client-ordnance', () => {
-  it('checks whether a ship can launch any ordnance', () => {
-    expect(
-      canShipLaunchAnyOrdnance(createShip({ type: 'packet', cargoUsed: 0 })),
-    ).toBe(true);
-
-    expect(
-      canShipLaunchAnyOrdnance(createShip({ type: 'packet', cargoUsed: 50 })),
-    ).toBe(false);
-  });
-
   it('finds the first launchable ship for the active player', () => {
     const state = createState([
       createShip({ id: 'blocked', cargoUsed: 50 }),
@@ -141,7 +130,7 @@ describe('game-client-ordnance', () => {
       ),
     ).toEqual({
       ok: false,
-      message: 'Only warships can launch torpedoes',
+      message: 'Only warships and orbital bases can launch torpedoes',
       level: 'error',
     });
 

src/client/game/ordnance.ts

@@ -1,4 +1,8 @@
-import { ORDNANCE_MASS, SHIP_STATS } from '../../shared/constants';
+import { SHIP_STATS } from '../../shared/constants';
+import {
+  canLaunchOrdnance,
+  validateShipOrdnanceLaunch,
+} from '../../shared/engine/util';
 import type {
   GameState,
   OrbitalBaseEmplacement,
@@ -50,30 +54,13 @@ const getSelectedShip = (
   return state.ships.find((ship) => ship.id === selectedShipId) ?? null;
 };
 
-export const canShipLaunchAnyOrdnance = (
-  ship: Pick<Ship, 'type' | 'cargoUsed'>,
-): boolean => {
-  const stats = SHIP_STATS[ship.type];
-
-  if (!stats) {
-    return false;
-  }
-
-  return stats.cargo - ship.cargoUsed >= ORDNANCE_MASS.mine;
-};
-
 export const getFirstLaunchableShipId = (
   state: OrdnanceState,
   playerId: number,
 ): string | null => {
   return (
     state.ships.find(
-      (ship) =>
-        ship.owner === playerId &&
-        !ship.destroyed &&
-        !ship.landed &&
-        ship.damage.disabledTurns === 0 &&
-        canShipLaunchAnyOrdnance(ship),
+      (ship) => ship.owner === playerId && canLaunchOrdnance(ship),
     )?.id ?? null
   );
 };
@@ -83,12 +70,7 @@ export const getUnambiguousLaunchableShipId = (
   playerId: number,
 ): string | null => {
   const launchable = state.ships.filter(
-    (ship) =>
-      ship.owner === playerId &&
-      !ship.destroyed &&
-      !ship.landed &&
-      ship.damage.disabledTurns === 0 &&
-      canShipLaunchAnyOrdnance(ship),
+    (ship) => ship.owner === playerId && canLaunchOrdnance(ship),
   );
 
   return launchable.length === 1 ? launchable[0].id : null;
@@ -99,8 +81,6 @@ export const resolveOrdnanceLaunchPlan = (
   planning: OrdnancePlanning,
   ordnanceType: 'mine' | 'torpedo' | 'nuke',
 ): OrdnanceLaunchPlan => {
-  const ship = getSelectedShip(state, planning.selectedShipId);
-
   if (!planning.selectedShipId) {
     return {
       ok: false,
@@ -109,70 +89,16 @@ export const resolveOrdnanceLaunchPlan = (
     };
   }
 
-  if (!ship) {
-    return { ok: false, message: null, level: 'error' };
-  }
-
-  const stats = SHIP_STATS[ship.type];
+  const ship = getSelectedShip(state, planning.selectedShipId);
 
-  if (!stats) {
+  if (!ship) {
     return { ok: false, message: null, level: 'error' };
   }
 
-  const cargoFree = stats.cargo - ship.cargoUsed;
-
-  if (ship.destroyed) {
-    return {
-      ok: false,
-      message: 'Ship is destroyed',
-      level: 'error',
-    };
-  }
-
-  if (ship.landed) {
-    return {
-      ok: false,
-      message: 'Cannot launch ordnance while landed',
-      level: 'error',
-    };
-  }
-
-  if (ship.damage.disabledTurns > 0) {
-    return {
-      ok: false,
-      message: 'Ship is disabled',
-      level: 'error',
-    };
-  }
-
-  if (ordnanceType === 'torpedo' && !stats.canOverload) {
-    return {
-      ok: false,
-      message: 'Only warships can launch torpedoes',
-      level: 'error',
-    };
-  }
-
-  if (
-    ordnanceType === 'nuke' &&
-    !stats.canOverload &&
-    (ship.nukesLaunchedSinceResupply ?? 0) >= 1
-  ) {
-    return {
-      ok: false,
-      message: 'Non-warships may carry only one nuke between resupplies',
-      level: 'error',
-    };
-  }
-
-  const neededCargo = ORDNANCE_MASS[ordnanceType] ?? 0;
+  const error = validateShipOrdnanceLaunch(ship, ordnanceType);
 
-  if (cargoFree < neededCargo) {
-    return {
-      ok: false,
-      message: `Not enough cargo (need ${neededCargo}, have ${cargoFree})`,
-      level: 'error',
-    };
+  if (error) {
+    return { ok: false, message: error, level: 'error' };
   }
 
   return {

src/shared/engine/game-engine.ts

@@ -28,6 +28,7 @@ import {
   parseBaseKey,
   usesEscapeInspectionRules,
   validatePhaseAction,
+  validateShipOrdnanceLaunch,
 } from './util';
 import {
   advanceTurn,
@@ -689,66 +690,25 @@ export const processOrdnance = (
       };
     }
     const ship = state.ships.find((s) => s.id === launch.shipId);
-    if (!ship || ship.owner !== playerId || ship.destroyed || ship.landed) {
+    if (!ship || ship.owner !== playerId) {
       return {
         error: 'Invalid ship for ordnance launch',
       };
     }
-    if (ship.damage.disabledTurns > 0) {
-      // Orbital bases may launch ordnance at D1
-      // damage (rulebook p.6)
-      if (ship.type !== 'orbitalBase' || ship.damage.disabledTurns > 1) {
-        return {
-          error: 'Disabled ships cannot launch ordnance',
-        };
-      }
-    }
-    if (ship.captured) {
-      return {
-        error: 'Captured ships cannot launch ordnance',
-      };
-    }
     if (ship.resuppliedThisTurn) {
       return {
         error:
           'Ships cannot launch ordnance during a turn in which they resupply',
       };
     }
-    const mass = ORDNANCE_MASS[launch.ordnanceType];
-    if (!mass) return { error: 'Invalid ordnance type' };
     if (!allowedOrdnanceTypes.has(launch.ordnanceType)) {
       return {
         error: `This scenario does not allow ${launch.ordnanceType} launches`,
       };
     }
-    const stats = SHIP_STATS[ship.type];
-    if (!stats) return { error: 'Unknown ship type' };
-    if (ship.cargoUsed + mass > stats.cargo) {
-      return { error: 'Insufficient cargo capacity' };
-    }
-    if (ship.type === 'orbitalBase' && launch.ordnanceType !== 'torpedo') {
-      return {
-        error: 'Orbital bases can only launch torpedoes',
-      };
-    }
-    if (
-      launch.ordnanceType === 'torpedo' &&
-      !stats.canOverload &&
-      ship.type !== 'orbitalBase'
-    ) {
-      return {
-        error: 'Only warships and orbital bases can launch torpedoes',
-      };
-    }
-    if (
-      launch.ordnanceType === 'nuke' &&
-      !stats.canOverload &&
-      (ship.nukesLaunchedSinceResupply ?? 0) >= 1
-    ) {
-      return {
-        error: 'Non-warships may carry only one nuke between resupplies',
-      };
-    }
+    const shipError = validateShipOrdnanceLaunch(ship, launch.ordnanceType);
+    if (shipError) return { error: shipError };
+    const mass = ORDNANCE_MASS[launch.ordnanceType];
     if (launch.ordnanceType === 'torpedo' && launch.torpedoAccel != null) {
       if (launch.torpedoAccel < 0 || launch.torpedoAccel > 5) {
         return {