Add weak gravity UI, torpedo guidance, base defense, ramming, and nukes

- Weak gravity player choice: click gravity hex indicators to toggle
  ignoring weak gravity during course preview
- Torpedo guidance direction: click hex around warship during ordnance
  phase to set terminal guidance acceleration
- Base defense fire: bases fire at 2:1 odds on enemy ships in adjacent
  gravity hexes, fires even when players skip combat
- Ramming: opposing ships on same hex after movement both roll on
  Other Damage table
- Nukes: new ordnance type (mass 20, warships only), uses Gun Combat
  table at 2:1 odds, affects all ships in hex, destroys asteroids
- Tests for base defense, ramming, and nuke launch validation (137 total)

Author: rgilks

src/client/input.ts

@@ -4,6 +4,7 @@ import {
   hexToPixel,
   hexAdd,
   hexEqual,
+  hexKey,
   HEX_DIRECTIONS,
 } from '../shared/hex';
 import type { GameState, Ship, SolarSystemMap } from '../shared/types';
@@ -151,6 +152,11 @@ export class InputHandler {
       return;
     }
 
+    if (this.gameState.phase === 'ordnance') {
+      this.handleOrdnanceClick(clickHex);
+      return;
+    }
+
     if (this.gameState.phase !== 'astrogation') return;
 
     // Check if clicking a burn or overload direction arrow
@@ -162,6 +168,21 @@ export class InputHandler {
           ? computeCourse(ship, null, this.map).path[0] // launch hex
           : predictDestination(ship);
 
+        // Check weak gravity toggle clicks
+        const overload = this.planningState.overloads.get(ship.id) ?? null;
+        const wgChoices = this.planningState.weakGravityChoices.get(ship.id) ?? {};
+        const course = computeCourse(ship, currentBurn, this.map, { overload, weakGravityChoices: wgChoices });
+        for (const grav of course.gravityEffects) {
+          if (grav.strength !== 'weak') continue;
+          if (hexEqual(clickHex, grav.hex)) {
+            const key = hexKey(grav.hex);
+            const newChoices = { ...wgChoices };
+            newChoices[key] = !newChoices[key];
+            this.planningState.weakGravityChoices.set(ship.id, newChoices);
+            return;
+          }
+        }
+
         // Check overload arrows first (they overlap with burn arrow space)
         if (currentBurn !== null) {
           const stats = SHIP_STATS[ship.type];
@@ -212,6 +233,36 @@ export class InputHandler {
     this.planningState.selectedShipId = null;
   }
 
+  private handleOrdnanceClick(clickHex: HexCoord) {
+    if (!this.gameState) return;
+
+    const selectedId = this.planningState.selectedShipId;
+    if (selectedId) {
+      const ship = this.gameState.ships.find(s => s.id === selectedId);
+      if (ship) {
+        // Check if clicking a torpedo guidance direction
+        for (let d = 0; d < 6; d++) {
+          const target = hexAdd(ship.position, HEX_DIRECTIONS[d]);
+          if (hexEqual(clickHex, target)) {
+            this.planningState.torpedoAccel =
+              this.planningState.torpedoAccel === d ? null : d;
+            return;
+          }
+        }
+      }
+    }
+
+    // Check if clicking on own ship to select it
+    for (const ship of this.gameState.ships) {
+      if (ship.owner !== this.playerId || ship.destroyed) continue;
+      if (hexEqual(clickHex, ship.position)) {
+        this.planningState.selectedShipId = ship.id;
+        this.planningState.torpedoAccel = null;
+        return;
+      }
+    }
+  }
+
   private handleCombatClick(clickHex: HexCoord) {
     if (!this.gameState) return;
 

src/client/main.ts

@@ -104,6 +104,7 @@ class GameClient {
         this.renderer.planningState.selectedShipId = null;
         this.renderer.planningState.burns.clear();
         this.renderer.planningState.overloads.clear();
+        this.renderer.planningState.weakGravityChoices.clear();
         // Auto-select the player's first ship
         if (this.gameState) {
           const myShip = this.gameState.ships.find(s => s.owner === this.playerId && !s.destroyed);
@@ -294,8 +295,10 @@ class GameClient {
       if (ship.owner !== this.playerId) continue;
       const burn = this.renderer.planningState.burns.get(ship.id) ?? null;
       const overload = this.renderer.planningState.overloads.get(ship.id) ?? null;
+      const wgChoices = this.renderer.planningState.weakGravityChoices.get(ship.id);
       const order: AstrogationOrder = { shipId: ship.id, burn };
       if (overload !== null) order.overload = overload;
+      if (wgChoices && Object.keys(wgChoices).length > 0) order.weakGravityChoices = wgChoices;
       orders.push(order);
     }
 
@@ -354,7 +357,7 @@ class GameClient {
     }, 100);
   }
 
-  private sendOrdnanceLaunch(ordType: 'mine' | 'torpedo') {
+  private sendOrdnanceLaunch(ordType: 'mine' | 'torpedo' | 'nuke') {
     if (!this.gameState || this.state !== 'playing_ordnance') return;
     const selectedId = this.renderer.planningState.selectedShipId;
     if (!selectedId) return;
@@ -367,8 +370,8 @@ class GameClient {
       ordnanceType: ordType,
     };
 
-    // For torpedoes, use the selected torpedo direction (if any)
-    if (ordType === 'torpedo') {
+    // For torpedoes and nukes, use the selected guidance direction (if any)
+    if (ordType === 'torpedo' || ordType === 'nuke') {
       launch.torpedoAccel = this.renderer.planningState.torpedoAccel ?? null;
     }
 

src/client/renderer.ts

@@ -133,6 +133,7 @@ export interface PlanningState {
   selectedShipId: string | null;
   burns: Map<string, number | null>; // shipId -> burn direction (or null for no burn)
   overloads: Map<string, number | null>; // shipId -> overload direction (warships only, 2 fuel total)
+  weakGravityChoices: Map<string, Record<string, boolean>>; // shipId -> { hexKey: true to ignore }
   torpedoAccel: number | null; // direction for torpedo terminal guidance
   combatTargetId: string | null; // enemy ship targeted for combat
 }
@@ -150,7 +151,7 @@ export class Renderer {
   private gameState: GameState | null = null;
   private playerId = -1;
   private animState: AnimationState | null = null;
-  planningState: PlanningState = { selectedShipId: null, burns: new Map(), overloads: new Map(), torpedoAccel: null, combatTargetId: null };
+  planningState: PlanningState = { selectedShipId: null, burns: new Map(), overloads: new Map(), weakGravityChoices: new Map(), torpedoAccel: null, combatTargetId: null };
   private combatResults: { results: CombatResult[]; showUntil: number } | null = null;
   private lastTime = 0;
 
@@ -285,6 +286,7 @@ export class Renderer {
     if (this.gameState && this.map) {
       this.renderCourseVectors(ctx, this.gameState, this.map, now);
       this.renderOrdnance(ctx, this.gameState, now);
+      this.renderTorpedoGuidance(ctx, this.gameState, now);
       this.renderCombatOverlay(ctx, this.gameState, now);
       this.renderShips(ctx, this.gameState, now);
     }
@@ -437,7 +439,8 @@ export class Renderer {
 
         if (burn !== null || isSelected) {
           const overload = this.planningState.overloads.get(ship.id) ?? null;
-          const course = computeCourse(ship, burn, map, { overload });
+          const wgChoices = this.planningState.weakGravityChoices.get(ship.id) ?? {};
+          const course = computeCourse(ship, burn, map, { overload, weakGravityChoices: wgChoices });
           const from = hexToPixel(ship.landed ? course.path[0] : ship.position, HEX_SIZE);
           const to = hexToPixel(course.destination, HEX_SIZE);
 
@@ -499,6 +502,39 @@ export class Renderer {
             }
           }
 
+          // Weak gravity toggle indicators on the path
+          if (isSelected) {
+            for (const grav of course.gravityEffects) {
+              if (grav.strength !== 'weak') continue;
+              const gp = hexToPixel(grav.hex, HEX_SIZE);
+              const key = hexKey(grav.hex);
+              const isIgnored = wgChoices[key] === true;
+
+              // Draw hollow/filled circle to indicate ignore/apply
+              ctx.strokeStyle = isIgnored ? 'rgba(180, 130, 255, 0.5)' : 'rgba(180, 130, 255, 0.8)';
+              ctx.fillStyle = isIgnored ? 'rgba(180, 130, 255, 0.1)' : 'rgba(180, 130, 255, 0.35)';
+              ctx.lineWidth = 1.5;
+              ctx.beginPath();
+              ctx.arc(gp.x, gp.y, 10, 0, Math.PI * 2);
+              ctx.fill();
+              ctx.stroke();
+
+              // "G" label and strikethrough when ignored
+              ctx.fillStyle = isIgnored ? 'rgba(180, 130, 255, 0.4)' : 'rgba(180, 130, 255, 0.9)';
+              ctx.font = 'bold 8px monospace';
+              ctx.textAlign = 'center';
+              ctx.fillText('G', gp.x, gp.y + 3);
+              if (isIgnored) {
+                ctx.strokeStyle = 'rgba(255, 100, 100, 0.7)';
+                ctx.lineWidth = 1;
+                ctx.beginPath();
+                ctx.moveTo(gp.x - 6, gp.y + 4);
+                ctx.lineTo(gp.x + 6, gp.y - 4);
+                ctx.stroke();
+              }
+            }
+          }
+
           // Fuel cost indicator
           if (burn !== null) {
             ctx.fillStyle = '#ffcc00';
@@ -673,7 +709,24 @@ export class Renderer {
       const color = ord.owner === this.playerId ? '#4fc3f7' : '#ff9800';
       const pulse = 0.6 + 0.3 * Math.sin(now / 400);
 
-      if (ord.type === 'mine') {
+      if (ord.type === 'nuke') {
+        // Nuke: larger pulsing red diamond with glow
+        const s = 6;
+        const nukeColor = '#ff4444';
+        ctx.fillStyle = nukeColor;
+        ctx.globalAlpha = pulse;
+        ctx.beginPath();
+        ctx.moveTo(p.x, p.y - s);
+        ctx.lineTo(p.x + s, p.y);
+        ctx.lineTo(p.x, p.y + s);
+        ctx.lineTo(p.x - s, p.y);
+        ctx.closePath();
+        ctx.fill();
+        ctx.strokeStyle = '#ff8888';
+        ctx.lineWidth = 1;
+        ctx.stroke();
+        ctx.globalAlpha = 1;
+      } else if (ord.type === 'mine') {
         // Mine: small diamond shape
         const s = 4;
         ctx.fillStyle = color;
@@ -725,6 +778,55 @@ export class Renderer {
     }
   }
 
+  private renderTorpedoGuidance(ctx: CanvasRenderingContext2D, state: GameState, now: number) {
+    if (state.phase !== 'ordnance' || state.activePlayer !== this.playerId) return;
+    if (this.animState) return;
+
+    const selectedId = this.planningState.selectedShipId;
+    if (!selectedId) return;
+
+    const ship = state.ships.find(s => s.id === selectedId);
+    if (!ship || ship.destroyed || ship.landed) return;
+
+    // Only show for warships (torpedo-capable)
+    const stats = SHIP_STATS[ship.type];
+    if (!stats?.canOverload) return;
+
+    const shipPos = hexToPixel(ship.position, HEX_SIZE);
+    const accel = this.planningState.torpedoAccel;
+
+    // Show 6 direction arrows around the ship for torpedo terminal guidance
+    for (let d = 0; d < 6; d++) {
+      const targetHex = hexAdd(ship.position, HEX_DIRECTIONS[d]);
+      const tp = hexToPixel(targetHex, HEX_SIZE);
+      const isActive = accel === d;
+
+      ctx.fillStyle = isActive ? 'rgba(255, 120, 60, 0.6)' : 'rgba(255, 120, 60, 0.12)';
+      ctx.strokeStyle = isActive ? '#ff7744' : 'rgba(255, 120, 60, 0.3)';
+      ctx.lineWidth = 1.5;
+      ctx.beginPath();
+      ctx.arc(tp.x, tp.y, 7, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.stroke();
+
+      // Arrow from ship to target direction
+      if (isActive) {
+        ctx.strokeStyle = 'rgba(255, 120, 60, 0.5)';
+        ctx.lineWidth = 1;
+        ctx.beginPath();
+        ctx.moveTo(shipPos.x, shipPos.y);
+        ctx.lineTo(tp.x, tp.y);
+        ctx.stroke();
+      }
+    }
+
+    // Label
+    ctx.fillStyle = 'rgba(255, 120, 60, 0.8)';
+    ctx.font = '8px monospace';
+    ctx.textAlign = 'center';
+    ctx.fillText('GUIDANCE', shipPos.x, shipPos.y - 20);
+  }
+
   private renderCombatOverlay(ctx: CanvasRenderingContext2D, state: GameState, now: number) {
     if (state.phase !== 'combat' || state.activePlayer !== this.playerId) return;
     if (this.animState) return;

src/client/ui.ts

@@ -13,7 +13,7 @@ export class UIManager {
   onSelectScenario: ((scenario: string) => void) | null = null;
   onJoin: ((code: string) => void) | null = null;
   onConfirm: (() => void) | null = null;
-  onLaunchOrdnance: ((type: 'mine' | 'torpedo') => void) | null = null;
+  onLaunchOrdnance: ((type: 'mine' | 'torpedo' | 'nuke') => void) | null = null;
   onSkipOrdnance: (() => void) | null = null;
   onAttack: (() => void) | null = null;
   onSkipCombat: (() => void) | null = null;
@@ -72,6 +72,7 @@ export class UIManager {
     document.getElementById('confirmBtn')!.addEventListener('click', () => this.onConfirm?.());
     document.getElementById('launchMineBtn')!.addEventListener('click', () => this.onLaunchOrdnance?.('mine'));
     document.getElementById('launchTorpedoBtn')!.addEventListener('click', () => this.onLaunchOrdnance?.('torpedo'));
+    document.getElementById('launchNukeBtn')!.addEventListener('click', () => this.onLaunchOrdnance?.('nuke'));
     document.getElementById('skipOrdnanceBtn')!.addEventListener('click', () => this.onSkipOrdnance?.());
     document.getElementById('attackBtn')!.addEventListener('click', () => this.onAttack?.());
     document.getElementById('skipCombatBtn')!.addEventListener('click', () => this.onSkipCombat?.());
@@ -128,9 +129,11 @@ export class UIManager {
 
     const launchMineBtn = document.getElementById('launchMineBtn')!;
     const launchTorpedoBtn = document.getElementById('launchTorpedoBtn')!;
+    const launchNukeBtn = document.getElementById('launchNukeBtn')!;
     const skipOrdnanceBtn = document.getElementById('skipOrdnanceBtn')!;
     launchMineBtn.style.display = isMyTurn && phase === 'ordnance' ? 'inline-block' : 'none';
     launchTorpedoBtn.style.display = isMyTurn && phase === 'ordnance' ? 'inline-block' : 'none';
+    launchNukeBtn.style.display = isMyTurn && phase === 'ordnance' ? 'inline-block' : 'none';
     skipOrdnanceBtn.style.display = isMyTurn && phase === 'ordnance' ? 'inline-block' : 'none';
 
     const skipCombatBtn = document.getElementById('skipCombatBtn')!;

src/server/game-do.ts

@@ -225,14 +225,20 @@ export class GameDO extends DurableObject {
     const gameState = await this.getGameState();
     if (!gameState) return;
 
-    const result = skipCombat(gameState, playerId);
+    const map = getSolarSystemMap();
+    const result = skipCombat(gameState, playerId, map);
 
     if ('error' in result) {
       this.send(ws, { type: 'error', message: result.error });
       return;
     }
 
-    this.broadcast({ type: 'stateUpdate', state: result.state });
+    // If base defense fire happened, send as combat results
+    if (result.baseDefenseResults && result.baseDefenseResults.length > 0) {
+      this.broadcast({ type: 'combatResult', results: result.baseDefenseResults, state: result.state });
+    }
+
+    this.broadcastEndOrUpdate(result.state);
     await this.saveGameState(result.state);
   }