Add QoL shortcuts, timer warning, and AI scenario tests

- H key centers camera on own fleet
- L key toggles game log panel
- Turn timer warning sound + toast at 30s remaining
- Urgent timer pulse animation when under 30s
- playWarning() synthesized beep in audio system
- 6 new AI tests covering fleet action, blockade, difficulty levels
- 182 total tests passing

Author: rgilks

src/client/audio.ts

@@ -171,6 +171,26 @@ export function playPhaseChange() {
   osc2.stop(ac.currentTime + 0.25);
 }
 
+/** Warning beep for low timer. */
+export function playWarning() {
+  const ac = getCtx();
+  if (!ac) return;
+  // Two short beeps
+  for (let i = 0; i < 2; i++) {
+    const osc = ac.createOscillator();
+    const gain = ac.createGain();
+    osc.connect(gain);
+    gain.connect(ac.destination);
+    osc.type = 'square';
+    const t = ac.currentTime + i * 0.2;
+    osc.frequency.setValueAtTime(1000, t);
+    gain.gain.setValueAtTime(0.05, t);
+    gain.gain.exponentialRampToValueAtTime(0.001, t + 0.1);
+    osc.start(t);
+    osc.stop(t + 0.1);
+  }
+}
+
 /** Victory fanfare. */
 export function playVictory() {
   const ac = getCtx();

src/client/main.ts

@@ -9,7 +9,7 @@ import { Renderer, HEX_SIZE } from './renderer';
 import { InputHandler } from './input';
 import { UIManager } from './ui';
 import { Tutorial } from './tutorial';
-import { initAudio, playSelect, playConfirm, playThrust, playCombat, playExplosion, playPhaseChange, playVictory, playDefeat, isMuted, setMuted } from './audio';
+import { initAudio, playSelect, playConfirm, playThrust, playCombat, playExplosion, playPhaseChange, playVictory, playDefeat, playWarning, isMuted, setMuted } from './audio';
 
 type ClientState =
   | 'menu'
@@ -48,6 +48,7 @@ class GameClient {
   // Turn timer
   private turnStartTime = 0;
   private turnTimerInterval: number | null = null;
+  private timerWarningPlayed = false;
 
   constructor() {
     this.canvas = document.getElementById('gameCanvas') as HTMLCanvasElement;
@@ -134,6 +135,13 @@ class GameClient {
           (this.state === 'playing_astrogation' || this.state === 'playing_ordnance' || this.state === 'playing_combat' || this.state === 'playing_opponentTurn')) {
         // Focus camera on nearest enemy
         this.focusNearestEnemy();
+      } else if (e.key.toLowerCase() === 'h' && this.gameState &&
+          (this.state === 'playing_astrogation' || this.state === 'playing_ordnance' || this.state === 'playing_combat' || this.state === 'playing_opponentTurn')) {
+        // Center camera on own fleet
+        this.focusOwnFleet();
+      } else if (e.key.toLowerCase() === 'l' && this.gameState) {
+        // Toggle game log
+        this.ui.toggleLog();
       } else if (e.key.toLowerCase() === 'w' || e.key === 'ArrowUp') {
         this.renderer.camera.pan(0, 40);
       } else if (e.key.toLowerCase() === 's' || e.key === 'ArrowDown') {
@@ -998,6 +1006,15 @@ class GameClient {
     this.renderer.centerOnHex(nearest.position);
   }
 
+  private focusOwnFleet() {
+    if (!this.gameState) return;
+    const myShips = this.gameState.ships.filter(s => s.owner === this.playerId && !s.destroyed);
+    if (myShips.length === 0) return;
+    // Center on first alive ship (or selected ship if one is selected)
+    const selected = myShips.find(s => s.id === this.renderer.planningState.selectedShipId);
+    this.renderer.centerOnHex((selected ?? myShips[0]).position);
+  }
+
   // --- Burn shortcuts ---
 
   private setBurnDirection(dir: number) {
@@ -1141,13 +1158,21 @@ class GameClient {
   private startTurnTimer() {
     this.stopTurnTimer();
     this.turnStartTime = Date.now();
+    this.timerWarningPlayed = false;
     const timerEl = document.getElementById('turnTimer')!;
     this.turnTimerInterval = window.setInterval(() => {
       const elapsed = Math.floor((Date.now() - this.turnStartTime) / 1000);
+      const remaining = 120 - elapsed;
       const mins = Math.floor(elapsed / 60);
       const secs = elapsed % 60;
       timerEl.textContent = mins > 0 ? `${mins}:${secs.toString().padStart(2, '0')}` : `${secs}s`;
-      timerEl.className = 'turn-timer' + (elapsed >= 30 ? ' turn-timer-slow' : ' turn-timer-active');
+      timerEl.className = 'turn-timer' + (elapsed >= 90 ? ' turn-timer-urgent' : elapsed >= 30 ? ' turn-timer-slow' : ' turn-timer-active');
+      // Warning at 30s remaining
+      if (remaining <= 30 && !this.timerWarningPlayed) {
+        this.timerWarningPlayed = true;
+        playWarning();
+        this.ui.showToast('30 seconds remaining!', 'error');
+      }
     }, 1000);
   }
 

src/client/ui.ts

@@ -136,6 +136,18 @@ export class UIManager {
     });
   }
 
+  toggleLog() {
+    if (this.logVisible) {
+      this.logVisible = false;
+      this.gameLogEl.style.display = 'none';
+      this.logShowBtn.style.display = 'block';
+    } else {
+      this.logVisible = true;
+      this.gameLogEl.style.display = 'flex';
+      this.logShowBtn.style.display = 'none';
+    }
+  }
+
   hideAll() {
     this.menuEl.style.display = 'none';
     this.scenarioEl.style.display = 'none';

src/shared/__tests__/ai.test.ts

@@ -260,6 +260,24 @@ describe('aiCombat', () => {
     expect(attacks[0].targetId).toBe(pilgrim.id);
   });
 
+  it('easy AI is more conservative about attacking', () => {
+    const state = createGame(SCENARIOS.biplanetary, map, 'TEST', findBaseHex);
+    const aiShip = state.ships.find(s => s.owner === 1)!;
+    const enemyShip = state.ships.find(s => s.owner === 0)!;
+
+    // Place them far apart — poor odds
+    aiShip.position = { q: 0, r: 0 };
+    aiShip.velocity = { dq: 0, dr: 0 };
+    aiShip.landed = false;
+    enemyShip.position = { q: 8, r: 0 };
+    enemyShip.velocity = { dq: 3, dr: 0 };
+    enemyShip.landed = false;
+
+    // Easy AI should skip combat with bad range + velocity mods
+    const attacks = aiCombat(state, 1, 'easy');
+    expect(attacks).toHaveLength(0);
+  });
+
   it('attack contains valid ship references', () => {
     const state = createGame(SCENARIOS.biplanetary, map, 'TEST', findBaseHex);
     const aiShip = state.ships.find(s => s.owner === 1)!;
@@ -282,3 +300,79 @@ describe('aiCombat', () => {
     }
   });
 });
+
+describe('AI scenario handling', () => {
+  it('fleet action: AI generates orders for all 3 ships', () => {
+    const state = createGame(SCENARIOS.fleetAction, map, 'FA01', findBaseHex);
+    const orders = aiAstrogation(state, 1, map);
+    const aiShips = state.ships.filter(s => s.owner === 1);
+    expect(orders).toHaveLength(aiShips.length);
+    expect(aiShips.length).toBe(3);
+  });
+
+  it('fleet action: AI seeks combat when no target body', () => {
+    const state = createGame(SCENARIOS.fleetAction, map, 'FA02', findBaseHex);
+    // Unland all ships and place opposing fleets nearby
+    for (const ship of state.ships) {
+      ship.landed = false;
+      ship.position = ship.owner === 0
+        ? { q: 0, r: 0 }
+        : { q: 5, r: 0 };
+      ship.velocity = { dq: 0, dr: 0 };
+    }
+    const orders = aiAstrogation(state, 1, map, 'hard');
+    // At least one ship should burn toward enemy (not null)
+    const hasBurn = orders.some(o => o.burn !== null);
+    expect(hasBurn).toBe(true);
+  });
+
+  it('blockade: AI interceptor seeks enemy runner', () => {
+    const state = createGame(SCENARIOS.blockade, map, 'BK01', findBaseHex);
+    // The dreadnaught (player 1) starts in space
+    const dreadnaught = state.ships.find(s => s.owner === 1)!;
+    expect(dreadnaught.landed).toBe(false);
+    const orders = aiAstrogation(state, 1, map);
+    expect(orders).toHaveLength(1);
+  });
+
+  it('blockade: runner AI navigates toward Mars', () => {
+    const state = createGame(SCENARIOS.blockade, map, 'BK02', findBaseHex);
+    const runner = state.ships.find(s => s.owner === 0)!;
+    // Unland runner and place it in open space
+    runner.landed = false;
+    runner.position = { q: -3, r: -5 };
+    runner.velocity = { dq: 0, dr: 0 };
+
+    const orders = aiAstrogation(state, 0, map, 'hard');
+    expect(orders).toHaveLength(1);
+    // Hard AI should burn toward Mars (not drift)
+    expect(orders[0].burn).not.toBeNull();
+  });
+
+  it('AI handles all difficulty levels without errors', () => {
+    const difficulties: Array<'easy' | 'normal' | 'hard'> = ['easy', 'normal', 'hard'];
+    const scenarios = [SCENARIOS.biplanetary, SCENARIOS.escape, SCENARIOS.blockade, SCENARIOS.fleetAction];
+
+    for (const scenario of scenarios) {
+      for (const diff of difficulties) {
+        const state = createGame(scenario, map, 'DF01', findBaseHex);
+        // Unland ships for meaningful AI decisions
+        state.ships.forEach(s => {
+          if (!s.destroyed) {
+            s.landed = false;
+            s.velocity = { dq: 0, dr: 0 };
+          }
+        });
+
+        const orders = aiAstrogation(state, 1, map, diff);
+        expect(orders.length).toBeGreaterThan(0);
+
+        const launches = aiOrdnance(state, 1, map, diff);
+        expect(Array.isArray(launches)).toBe(true);
+
+        const attacks = aiCombat(state, 1, diff);
+        expect(Array.isArray(attacks)).toBe(true);
+      }
+    }
+  });
+});

static/index.html

@@ -155,6 +155,8 @@ <h3>Combat</h3>
       <div class="help-section">
         <h3>Other</h3>
         <div class="help-row"><span class="help-key">E</span> Focus nearest enemy</div>
+        <div class="help-row"><span class="help-key">H</span> Center on own fleet</div>
+        <div class="help-row"><span class="help-key">L</span> Toggle game log</div>
         <div class="help-row"><span class="help-key">M</span> Toggle sound</div>
         <div class="help-row"><span class="help-key">?</span> Toggle this help</div>
       </div>

static/style.css

@@ -544,6 +544,16 @@ body {
   color: #ffb74d;
 }
 
+.turn-timer-urgent {
+  color: #ef5350;
+  animation: timer-pulse 0.5s ease-in-out infinite alternate;
+}
+
+@keyframes timer-pulse {
+  from { opacity: 1; }
+  to { opacity: 0.5; }
+}
+
 /* Latency indicator in HUD */
 .latency-text {
   color: #888;