Slow sim to 1× on landing and resume last selected speed (ISS-057, v0.30.0)

lib/sim/engine.test.ts

@@ -301,12 +301,13 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
   });
 });
 
-describe('pause on landing when the last plane lands (ISS-041)', () => {
+describe('slow to 1× when a landing leaves any plane on the ground (ISS-057)', () => {
   const FROM = 'EDDF';
   const TO = 'LEMD';
 
   // Starter flying EDDF→LEMD with departureSimTime set so its arrival is EXACTLY T0 —
-  // any advancing tick past T0 finalizes it. timeScale is the value under test.
+  // any advancing tick past T0 finalizes it. timeScale is the value under test;
+  // lastSelectedTimeScale mirrors what a manual POST /api/sim would have stored.
   async function setupLanding(name: string, timeScale: number) {
     const inst = await freshDb(name);
     const fc = await loadAirportsGeoJson();
@@ -315,7 +316,7 @@ describe('pause on landing when the last plane lands (ISS-041)', () => {
     const km = haversineKm(from.lat, from.lon, to.lat, to.lon);
     const type = PLANE_TYPES.atr72;
 
-    await inst.db.update(schema.simState).set({ timeScale });
+    await inst.db.update(schema.simState).set({ timeScale, lastSelectedTimeScale: timeScale });
     await inst.db.update(schema.planes)
       .set({ status: 'flying', destIcao: TO, departureSimTime: T0 - travelMs(km, type.speedKmh), fuel: type.maxFuel })
       .where(eq(schema.planes.id, 'plane-starter'));
@@ -323,20 +324,21 @@ describe('pause on landing when the last plane lands (ISS-041)', () => {
     return { inst, from, km, type };
   }
 
-  it('last plane lands → sim pauses and stored timeScale is UNCHANGED', async () => {
-    const { inst } = await setupLanding('pause-last.db', 1000);
+  it('last plane lands → sim slows to 1× WITHOUT pausing; lastSelectedTimeScale is preserved', async () => {
+    const { inst } = await setupLanding('slow-last.db', 1000);
     vi.setSystemTime(T0 + 2_000); // one full clamped tick at scale 1000 → clock T0+2e6 ≥ arrival (T0)
 
     const sim = await tickOnce(inst);
 
-    expect(sim.paused).toBe(true); // persisted on the sim_state row…
-    expect((await inst.db.select().from(schema.simState))[0].paused).toBe(true); // …and visible to the next snapshot
-    expect(sim.timeScale).toBe(1000); // speed preserved — no auto-slow anymore (ISS-041)
+    expect(sim.paused).toBe(false); // no pause anymore — ISS-057 replaces it with a slow-down…
+    expect((await inst.db.select().from(schema.simState))[0].paused).toBe(false); // …persisted on the row…
+    expect(sim.timeScale).toBe(1); // …slowed to the floor…
+    expect(sim.lastSelectedTimeScale).toBe(1000); // …with the last manual speed kept for resume
     expect((await inst.db.select().from(schema.planes))[0].status).toBe('available'); // landing itself unchanged
   });
 
-  it('a landing while another plane is still flying → no pause', async () => {
-    const { inst, from, type } = await setupLanding('pause-other.db', 1000);
+  it('a landing while another plane is still flying → slows to 1× (any plane on ground)', async () => {
+    const { inst, from, type } = await setupLanding('slow-other.db', 1000);
     // A second plane on the same route departing at T0 — arrives far after this tick's clock.
     await inst.db.insert(schema.planes).values({
       id: 'p-b', model: 'atr72', status: 'flying', fuel: type.maxFuel, maxFuel: type.maxFuel,
@@ -346,26 +348,26 @@ describe('pause on landing when the last plane lands (ISS-041)', () => {
     vi.setSystemTime(T0 + 2_000);
     const sim = await tickOnce(inst);
 
-    expect(sim.paused).toBe(false); // p-b still in flight — no pause (nothing would auto-unpause it)
-    expect(sim.timeScale).toBe(1000);
+    expect(sim.paused).toBe(false);
+    expect(sim.timeScale).toBe(1); // the just-landed starter is on ground → slow (literal issue reading)
     const byId = new Map((await inst.db.select().from(schema.planes)).map((p) => [p.id, p.status]));
     expect(byId.get('plane-starter')).toBe('available'); // the starter did land…
-    expect(byId.get('p-b')).toBe('flying'); // …but the fleet is not idle
+    expect(byId.get('p-b')).toBe('flying'); // …but the fleet is not idle — still slowed
   });
 
-  it('last plane lands at scale 1 → pauses anyway, scale untouched', async () => {
-    const { inst } = await setupLanding('pause-one.db', 1);
+  it('already at 1× → stays 1 (no-op slow)', async () => {
+    const { inst } = await setupLanding('slow-one.db', 1);
     vi.setSystemTime(T0 + 2_000); // one tick at scale 1 advances 2e3 game ms — past the T0 arrival
 
     const sim = await tickOnce(inst);
 
-    expect(sim.paused).toBe(true);
+    expect(sim.paused).toBe(false);
     expect(sim.timeScale).toBe(1);
     expect((await inst.db.select().from(schema.planes))[0].status).toBe('available');
   });
 
-  it('a chained plane does NOT trigger the last-plane pause (ISS-043)', async () => {
-    const { inst } = await setupLanding('pause-chain.db', 1000); // full tank, arrival exactly T0
+  it('a chained plane does NOT slow the sim (nothing is grounded)', async () => {
+    const { inst } = await setupLanding('slow-chain.db', 1000); // full tank, arrival exactly T0
     // A queued next hop with plenty of fuel → chains on landing instead of grounding.
     await inst.db.update(schema.planes)
       .set({ queue: JSON.stringify(['EDDV']) })
@@ -374,23 +376,25 @@ describe('pause on landing when the last plane lands (ISS-041)', () => {
     vi.setSystemTime(T0 + 2_000); // one full clamped tick at scale 1000 → clock T0+2e6 ≥ arrival (T0)
     const sim = await tickOnce(inst);
 
-    expect(sim.paused).toBe(false); // still flying after the chain — no premature pause…
+    expect(sim.paused).toBe(false);
+    expect(sim.timeScale).toBe(1000); // still flying after the chain, nothing grounded — no slow…
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying'); // …the fresh select in tickOnce counts it as airborne
     expect(plane.destIcao).toBe('EDDV');
   });
 
-  it('paused sim with all planes landed → no change', async () => {
-    const inst = await freshDb('pause-paused.db');
+  it('manually-paused sim is untouched by ticks (no landing processed while paused)', async () => {
+    const inst = await freshDb('slow-paused.db');
     // The fleet is fully grounded (the seeded starter) — a paused tick must not touch the
-    // controls even though "no plane in flight" holds: the trigger requires a landing this tick.
-    await inst.db.update(schema.simState).set({ timeScale: 1000, paused: true });
+    // controls even though "any plane on ground" holds: the trigger requires a landing this tick.
+    await inst.db.update(schema.simState).set({ timeScale: 1000, lastSelectedTimeScale: 1000, paused: true });
 
     vi.setSystemTime(T0 + 5_000);
     const sim = await tickOnce(inst);
 
     expect(sim.paused).toBe(true); // no landing processed while paused → trigger never fires
     expect(sim.timeScale).toBe(1000);
+    expect(sim.lastSelectedTimeScale).toBe(1000);
     expect((await inst.db.select().from(schema.planes))[0].status).toBe('available');
   });
 });

lib/sim/engine.ts

@@ -75,8 +75,7 @@ export async function tickOnce(inst: GameDb): Promise<schema.SimStateRow> {
   let landedThisTick = 0;
   if (advanceMs > 0) {
     await expirePackages(inst, clockMs);
-    // ISS-041: remember the landings so the tick can pause when this was the last
-    // plane in flight.
+    // ISS-057: remember the landings so the tick can slow down when a plane is left on ground.
     landedThisTick = await deliverPackages(inst, clockMs);
     await spawnOpenPackages(inst, clockMs);
     // AFTER delivery on purpose: a plane that just landed gets work spawned
@@ -84,18 +83,21 @@ export async function tickOnce(inst: GameDb): Promise<schema.SimStateRow> {
     await spawnCoveragePackages(inst, clockMs);
   }
 
-  const sets: Partial<Pick<schema.SimStateRow, 'clockMs' | 'lastRealTickMs' | 'timeScale' | 'paused'>> = {
+  const sets: Partial<Pick<schema.SimStateRow, 'clockMs' | 'lastRealTickMs' | 'timeScale'>> = {
     clockMs,
     lastRealTickMs: nowMs,
   };
-  // Pause on landing (ISS-041): when ≥1 plane landed this tick and NO plane remains in flight,
-  // pause the sim WITHOUT touching timeScale — speed is preserved for the next dispatch.
-  // Arrival-triggered by design: a grounded fleet at high scale is left alone (there is no
-  // auto-resume except starting a flight; see flyPlane). A paused tick never processes landings
-  // (advanceMs === 0), so the trigger can only fire on an advancing tick.
+  // Slow on landing (ISS-057): when ≥1 plane landed this tick and ANY plane is grounded
+  // ('available') afterwards, drop the sim to MIN_TIME_SCALE — a just-landed plane counts, so
+  // any real landing slows. A chained plane stays 'flying' via deliverPackages' auto-chain
+  // branch, so a pure-chain tick with nothing grounded does NOT slow. Pause is manual-only now;
+  // flyPlane restores lastSelectedTimeScale when the last grounded plane takes off. Arrival-
+  // triggered by design: a grounded fleet at high scale is left alone (no idle-enforcement), and
+  // a paused tick never processes landings (advanceMs === 0), so the trigger only fires on an
+  // advancing tick — a manual speed change while planes sit grounded survives until the next landing.
   if (landedThisTick > 0) {
-    const flying = await inst.db.select().from(schema.planes).where(eq(schema.planes.status, 'flying'));
-    if (flying.length === 0) sets.paused = true;
+    const available = await inst.db.select().from(schema.planes).where(eq(schema.planes.status, 'available'));
+    if (available.length >= 1) sets.timeScale = MIN_TIME_SCALE;
   }
 
   // Persist lastRealTickMs even when nothing advanced — it is the tick anchor.
@@ -132,8 +134,8 @@ export async function expirePackages(inst: GameDb, clockMs: number): Promise<num
 // its remaining fuel (a short tank keeps the queue intact for refuel + re-dispatch).
 // Idempotent — a finalized plane either leaves the 'flying' state or starts a NEW
 // leg whose own arrival is in the future, so it can never be awarded twice.
-// Returns planes landed. NOTE: runs BEFORE tickOnce's pause check on purpose —
-// a chained plane counts as still flying there, so chaining never pauses early.
+// Returns planes landed. NOTE: runs BEFORE tickOnce's slow-down check on purpose —
+// a chained plane is already 'flying' again here, so a pure-chain landing never slows the sim.
 export async function deliverPackages(inst: GameDb, clockMs: number): Promise<number> {
   const [planeRows, packageRows] = await Promise.all([
     inst.db.select().from(schema.planes),
@@ -320,13 +322,20 @@ export function runAction<T>(fn: (inst: GameDb) => Promise<T>): Promise<T> {
 
 // Tick first so the returned state reflects current time, then apply the new
 // controls. timeScale is clamped to [1, 1000]; validation of raw input happens in
-// the route handler (400 on non-number / non-boolean).
+// the route handler (400 on non-number / non-boolean). ISS-057: posting a timeScale
+// ALSO records it as lastSelectedTimeScale — the resume target flyPlane restores when
+// the last grounded plane takes off. A {paused}-only post never touches it, so the
+// last manual intent wins without an extra flag.
 export function applyTimeControls(input: SimControlsInput): Promise<schema.SimStateRow> {
   return withLock(async () => {
     const inst = await getGameDb();
     await tickOnce(inst);
-    const sets: Partial<Pick<schema.SimStateRow, 'timeScale' | 'paused'>> = {};
-    if (input.timeScale !== undefined) sets.timeScale = clampTimeScale(input.timeScale);
+    const sets: Partial<Pick<schema.SimStateRow, 'timeScale' | 'lastSelectedTimeScale' | 'paused'>> = {};
+    if (input.timeScale !== undefined) {
+      const scale = clampTimeScale(input.timeScale);
+      sets.timeScale = scale;
+      sets.lastSelectedTimeScale = scale;
+    }
     if (input.paused !== undefined) sets.paused = input.paused;
     if (Object.keys(sets).length > 0) await inst.db.update(schema.simState).set(sets);
     await persist(inst);