v0.62.0: fixed 24x world clock — frozen when fully grounded (#135)

lib/sim/engine.test.ts

@@ -16,7 +16,6 @@ import {
   deliverPackages,
   expirePackages,
   finishRepairs,
-  IDLE_WORLD_TIME_SCALE,
   MAX_TICK_ELAPSED_MS,
   reputationGainFor,
   shouldAdvanceTime,
@@ -31,9 +30,9 @@ import {
 // public tickNow()/setTestTimeScale() wrappers (singleton + lock) are covered by the e2e suite
 // (every spec's setScale helper hits /api/test/set-timescale; sim.spec.ts pins its validation).
 
-// ISS-117 / ISS-128: fresh DBs seed a GROUNDED starter, so any test that needs FULL-scale advance
-// must put a plane in flight first (a grounded fleet only advances at the idle real-time rate) —
-// departureSimTime at the game-clock origin keeps its arrival hours away.
+// #135: fresh DBs seed a GROUNDED starter, so any test that needs clock advance must put a plane in
+// flight first (a fully grounded fleet freezes the world) — departureSimTime at the game-clock
+// origin keeps its arrival hours away.
 async function makeWorldActive(inst: Awaited<ReturnType<typeof openGameDb>>) {
   await inst.db.update(schema.planes)
     .set({ status: 'flying', destIcao: 'LEMD', departureSimTime: STARTING_CLOCK_MS })
@@ -62,7 +61,7 @@ async function freshDb(name: string) {
 describe('tickOnce — clock advance', () => {
   it('advances the clock by elapsed real ms × timeScale', async () => {
     const inst = await freshDb('scale.db');
-    await makeWorldActive(inst); // a grounded fleet would slow the world to the idle real-time rate (ISS-128)
+    await makeWorldActive(inst); // a fully grounded fleet freezes the clock (#135)
     vi.setSystemTime(T0 + 1_000); // one real second later
     await inst.db.update(schema.simState).set({ timeScale: 5 });
 
@@ -72,30 +71,30 @@ describe('tickOnce — clock advance', () => {
     expect(sim.lastRealTickMs).toBe(T0 + 1_000);
   });
 
-  it('a fully grounded fleet advances at the idle real-time rate, not frozen (ISS-128)', async () => {
-    const inst = await freshDb('idle.db'); // seeded starter is on the ground → idle
+  it('a fully grounded fleet freezes the clock, then resumes with no catch-up (#135)', async () => {
+    const inst = await freshDb('idle.db'); // seeded starter is on the ground → frozen
 
     vi.setSystemTime(T0 + 3_600_000); // an hour of real idleness
     let sim = await tickOnce(inst);
-    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + MAX_TICK_ELAPSED_MS * IDLE_WORLD_TIME_SCALE); // clamped to one idle-rate tick — no fast-forward, no freeze
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS); // frozen — no fast-forward, no idle creep
     expect(sim.lastRealTickMs).toBe(T0 + 3_600_000);
 
-    // A plane takes off: resumes from where it stopped, with NO catch-up for the idle time.
+    // A plane takes off: resumes from where it stopped, with NO catch-up for the frozen time.
     await inst.db.update(schema.simState).set({ timeScale: 60 });
     await makeWorldActive(inst);
     vi.setSystemTime(T0 + 3_600_500);
     sim = await tickOnce(inst);
-    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + MAX_TICK_ELAPSED_MS * IDLE_WORLD_TIME_SCALE + 500 * 60); // only the 500 ms since activity × 60
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + 500 * 60); // only the 500 ms since activity × 60
   });
 
-  it('a grounded fleet ignores any raised timeScale — the idle rate wins (ISS-128)', async () => {
+  it('a grounded fleet ignores any raised timeScale — frozen regardless (#135)', async () => {
     const inst = await freshDb('idle-scale.db');
     await inst.db.update(schema.simState).set({ timeScale: 1_000 }); // FLIGHT_TEST_HOOKS-style override
 
     vi.setSystemTime(T0 + 1_000);
     const sim = await tickOnce(inst);
 
-    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + 1_000 * IDLE_WORLD_TIME_SCALE); // real time, NOT ×1000
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS); // frozen, NOT ×1000
   });
 
   it('clamps long absences: a 1-hour gap advances at most MAX_TICK_ELAPSED_MS × scale', async () => {
@@ -586,13 +585,12 @@ describe('finishRepairs (v0.39.0, ISS-069)', () => {
   });
 });
 
-describe('idle slowdown — a grounded fleet slows the world to real time (ISS-128)', () => {
-  it('pins IDLE_WORLD_TIME_SCALE = WORLD_TIME_SCALE / 24, i.e. exactly real time', () => {
-    expect(IDLE_WORLD_TIME_SCALE).toBe(WORLD_TIME_SCALE / 24);
-    expect(IDLE_WORLD_TIME_SCALE).toBe(1); // one game-second per real second
+describe('grounded fleet freezes the world clock (#135)', () => {
+  it('pins WORLD_TIME_SCALE = 24 — the single fixed world rate (ISS-117)', () => {
+    expect(WORLD_TIME_SCALE).toBe(24);
   });
 
-  it('shouldAdvanceTime: grounded/empty fleets are idle; any flying or repairing plane advances', () => {
+  it('shouldAdvanceTime: grounded/empty fleets are frozen; any flying or repairing plane advances', () => {
     expect(shouldAdvanceTime([])).toEqual({ advance: false, flying: 0, repairing: 0 });
     expect(shouldAdvanceTime([{ status: 'available' }, { status: 'available' }])).toEqual({ advance: false, flying: 0, repairing: 0 });
     expect(shouldAdvanceTime([{ status: 'flying' }, { status: 'available' }])).toEqual({ advance: true, flying: 1, repairing: 0 });
@@ -600,13 +598,13 @@ describe('idle slowdown — a grounded fleet slows the world to real time (ISS-1
     expect(shouldAdvanceTime([{ status: 'flying' }, { status: 'repairing' }])).toEqual({ advance: true, flying: 1, repairing: 1 });
   });
 
-  it('a fully grounded fleet advances at the idle rate but keeps tracking real time', async () => {
-    const inst = await freshDb('idle-pause.db'); // seeded starter is on the ground → idle
+  it('a fully grounded fleet stays frozen but keeps tracking real time', async () => {
+    const inst = await freshDb('idle-pause.db'); // seeded starter is on the ground → frozen
     vi.setSystemTime(T0 + 3_600_000);
 
     const sim = await tickOnce(inst);
 
-    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + MAX_TICK_ELAPSED_MS * IDLE_WORLD_TIME_SCALE); // real-time rate, clamped — not frozen
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS); // frozen — no idle creep
     expect(sim.lastRealTickMs).toBe(T0 + 3_600_000); // …and the real-time anchor moved on
   });
 

lib/sim/engine.ts

@@ -9,7 +9,7 @@ import { FUEL_DISCOUNT_PER_REP, FUEL_PRICE_PER_L, MAX_FUEL_DISCOUNT, PLANE_TYPES
 import { SPECIALS } from '@/lib/game/specials';
 import { getStateSnapshot, parseIcaoQueue, sseFrame } from '@/lib/game/state';
 import { broadcast } from '@/lib/sse';
-import { IDLE_WORLD_TIME_SCALE } from '@/lib/worldClock';
+
 import {
   generatePackage,
   MARKET_TARGET_OPEN_PACKAGES,
@@ -24,8 +24,8 @@ import { arrivalTimeFor, fuelAtWeighted, requiredFuelFor, windBurnFactor } from
 // tick (~1 s, started at boot from instrumentation.ts) AND on every read/action — both through the
 // same locked tickOnce path. Each tick advances by (real ms since last tick) × timeScale, clamped
 // per tick so long absences never fast-forward the game; while no plane is flying or in repair the
-// world slows to real time instead of freezing (IDLE_WORLD_TIME_SCALE, ISS-128 v0.56.0), and
-// lastRealTickMs always keeps tracking real time.
+// world clock stays FROZEN (#135 v0.62.0 — final ISS-117 semantics), and lastRealTickMs always
+// keeps tracking real time, so resuming activity never fast-forwards the frozen span.
 
 // Clamp constant: max real-time gap counted by a single tick. Chosen at 2000 ms — comfortably above
 // both the client poll interval (~1 s) and the background-tick interval, so active play advances
@@ -33,9 +33,8 @@ import { arrivalTimeFor, fuelAtWeighted, requiredFuelFor, windBurnFactor } from
 // 2 s × scale.
 export const MAX_TICK_ELAPSED_MS = 2_000;
 
-// ISS-117 / ISS-128: the fixed world rates — re-exported here so server code and tests have one
-// familiar home (full rate while something is active, real-time rate while fully grounded).
-export { IDLE_WORLD_TIME_SCALE, WORLD_TIME_SCALE } from '@/lib/worldClock';
+// ISS-117: the fixed world rate — re-exported here so server code and tests have one familiar home.
+export { WORLD_TIME_SCALE } from '@/lib/worldClock';
 
 // Reputation gain per delivered package: BASE + PER_KM × great-circle km, rounded
 // to 2 decimals (reputation is REAL). A short hop (~300 km) earns ~1.15 rep, a
@@ -64,10 +63,10 @@ function withLock<T>(fn: () => Promise<T>): Promise<T> {
 
 // --- Tick core (takes a GameDb so unit tests can inject their own instance) ---
 
-// ISS-117 / ISS-128: idle decision — pure, so unit tests feed it synthetic fleets. The world clock
-// runs at full scale only while something is happening (at least one plane flying OR in repair); a
-// fully grounded fleet slows it to IDLE_WORLD_TIME_SCALE (real time) instead of freezing it, so
-// expiries/spawns keep running until a dispatch or repair starts.
+// #135: advance decision — pure, so unit tests feed it synthetic fleets. The world clock runs at
+// full scale only while something is happening (at least one plane flying OR in repair); a fully
+// grounded fleet freezes it entirely — no expiry/spawn/repair progress until a dispatch or repair
+// starts again.
 export function shouldAdvanceTime(planes: Array<{ status: string }>): { advance: boolean; flying: number; repairing: number } {
   let flying = 0;
   let repairing = 0;
@@ -84,15 +83,13 @@ export async function tickOnce(inst: GameDb): Promise<schema.SimStateRow> {
   if (!sim) throw new Error('sim_state row missing');
 
   const nowMs = Date.now();
-  // ISS-128: a fully grounded fleet slows the world to real time (IDLE_WORLD_TIME_SCALE) instead of
-  // freezing it — packages keep spawning/expiring while idle. An active fleet keeps its full scale,
-  // including any FLIGHT_TEST_HOOKS override in sim.timeScale. lastRealTickMs always tracks real
-  // time, so resuming activity never fast-forwards the idle duration.
+  // #135: a fully grounded fleet freezes the world — no advance, no expiry/spawn/repair progress.
+  // An active fleet keeps its full scale, including any FLIGHT_TEST_HOOKS override in sim.timeScale.
+  // lastRealTickMs always tracks real time, so resuming activity never fast-forwards the frozen span.
   const planeRows = await inst.db.select().from(schema.planes);
   const { advance } = shouldAdvanceTime(planeRows.map((p) => ({ status: p.status })));
   const elapsed = Math.max(0, nowMs - sim.lastRealTickMs);
-  const scale = advance ? sim.timeScale : IDLE_WORLD_TIME_SCALE;
-  const advanceMs = Math.min(elapsed, MAX_TICK_ELAPSED_MS) * scale;
+  const advanceMs = advance ? Math.min(elapsed, MAX_TICK_ELAPSED_MS) * sim.timeScale : 0;
   const clockMs = Math.round(sim.clockMs + advanceMs);
 
   if (advanceMs > 0) {