467 lines
22 KiB
TypeScript
467 lines
22 KiB
TypeScript
import { randomInt, randomUUID } from 'node:crypto';
|
||
import { eq, inArray } from 'drizzle-orm';
|
||
import { getGameDb, persist, type GameDb } from '@/lib/db/client';
|
||
import * as schema from '@/lib/db/schema';
|
||
import { loadAirportsGeoJson } from '@/lib/airports';
|
||
import { haversineKm, initialBearingDeg } from '@/lib/geo';
|
||
import { weatherFor } from '@/lib/weather';
|
||
import { FUEL_DISCOUNT_PER_REP, FUEL_PRICE_PER_L, MAX_FUEL_DISCOUNT, PLANE_TYPES, REPAIR_DURATION_MS, repRate, WEAR_PER_KM } from '@/lib/game/catalog';
|
||
import { SPECIALS } from '@/lib/game/specials';
|
||
import { parseIcaoQueue } from '@/lib/game/state';
|
||
import {
|
||
generatePackage,
|
||
MARKET_TARGET_OPEN_PACKAGES,
|
||
mulberry32,
|
||
pickDestWithinCap,
|
||
type Rng,
|
||
type SeedAirport,
|
||
} from '@/lib/game/seed';
|
||
import { arrivalTimeFor, fuelAtWeighted, requiredFuelFor, windBurnFactor } from './movement';
|
||
|
||
// Server-authoritative sim engine (v0.7.0) — tick-on-read: there is NO background
|
||
// timer. Every read/action endpoint calls tickNow() first; the clock advances by
|
||
// (real ms since last tick) × timeScale, clamped per tick so long absences never
|
||
// fast-forward the game.
|
||
|
||
// Clamp constant: max real-time gap counted by a single tick. Chosen at 2000 ms —
|
||
// comfortably above a normal client poll interval (~1 s), so active play advances
|
||
// ~real time × scale; small enough that one stale read after an absence moves game
|
||
// time by at most 2 s × scale (≈ 33 min even at max scale 1000). The sim therefore
|
||
// only meaningfully progresses while actively polled.
|
||
export const MAX_TICK_ELAPSED_MS = 2_000;
|
||
|
||
export const MIN_TIME_SCALE = 1;
|
||
export const MAX_TIME_SCALE = 1000; // top of the slider ladder (v0.14.0)
|
||
|
||
// 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
|
||
// cross-Europe leg (~3000 km) ~2.5 — slow growth from the starting 10.
|
||
export const REP_BASE = 1;
|
||
export const REP_PER_KM = 0.0005;
|
||
|
||
export function reputationGainFor(km: number): number {
|
||
return Math.round((REP_BASE + REP_PER_KM * km) * 100) / 100;
|
||
}
|
||
|
||
export interface SimControlsInput {
|
||
timeScale?: number;
|
||
paused?: boolean;
|
||
}
|
||
|
||
// Serialize ticks across concurrent requests (Next.js route handlers run in the
|
||
// same process): each tick re-reads sim_state after the previous one wrote it, so
|
||
// no advance is ever applied twice.
|
||
let chain: Promise<unknown> = Promise.resolve();
|
||
function withLock<T>(fn: () => Promise<T>): Promise<T> {
|
||
const run = chain.then(fn);
|
||
chain = run.then(
|
||
() => undefined,
|
||
() => undefined,
|
||
);
|
||
return run;
|
||
}
|
||
|
||
// --- Tick core (takes a GameDb so unit tests can inject their own instance) ---
|
||
|
||
export async function tickOnce(inst: GameDb): Promise<schema.SimStateRow> {
|
||
const rows = await inst.db.select().from(schema.simState);
|
||
const sim = rows[0];
|
||
if (!sim) throw new Error('sim_state row missing');
|
||
|
||
const nowMs = Date.now();
|
||
const elapsed = Math.max(0, nowMs - sim.lastRealTickMs);
|
||
// While paused the clock is frozen; lastRealTickMs still tracks real time so
|
||
// unpausing resumes cleanly with no catch-up jump for the pause duration.
|
||
const advanceMs = sim.paused ? 0 : Math.min(elapsed, MAX_TICK_ELAPSED_MS) * sim.timeScale;
|
||
const clockMs = Math.round(sim.clockMs + advanceMs);
|
||
|
||
let landedThisTick = 0;
|
||
if (advanceMs > 0) {
|
||
await expirePackages(inst, clockMs);
|
||
// ISS-057: remember the landings so the tick can slow down when a plane is left on ground.
|
||
landedThisTick = await deliverPackages(inst, clockMs);
|
||
// v0.39.0 (ISS-069): repairs whose gate has passed flip back to 'available' — runs even when
|
||
// nothing landed this tick; BEFORE the spawns so a just-repaired plane gets coverage work too.
|
||
await finishRepairs(inst, clockMs);
|
||
await spawnOpenPackages(inst, clockMs);
|
||
// AFTER delivery on purpose: a plane that just landed gets work spawned
|
||
// at its new location within the same tick.
|
||
await spawnCoveragePackages(inst, clockMs);
|
||
}
|
||
|
||
const sets: Partial<Pick<schema.SimStateRow, 'clockMs' | 'lastRealTickMs' | 'timeScale'>> = {
|
||
clockMs,
|
||
lastRealTickMs: nowMs,
|
||
};
|
||
// 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 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.
|
||
await inst.db.update(schema.simState).set(sets);
|
||
await persist(inst);
|
||
const updated = (await inst.db.select().from(schema.simState))[0];
|
||
if (!updated) throw new Error('sim_state row missing after tick');
|
||
return updated;
|
||
}
|
||
|
||
// Packages whose deadline has passed become 'expired' — both OPEN ones (they leave
|
||
// the market so spawn can top it back up) and LOADED ones (v0.12.0: they keep
|
||
// occupying their slot, deliver no reward on arrival, and abandon for free).
|
||
// Delivered/abandoned packages are terminal and never flip. Returns the count.
|
||
export async function expirePackages(inst: GameDb, clockMs: number): Promise<number> {
|
||
const rows = await inst.db.select().from(schema.packages).where(inArray(schema.packages.status, ['open', 'loaded']));
|
||
let n = 0;
|
||
for (const p of rows) {
|
||
if (p.deadlineSimTime <= clockMs) {
|
||
await inst.db.update(schema.packages).set({ status: 'expired' }).where(eq(schema.packages.id, p.id));
|
||
n++;
|
||
}
|
||
}
|
||
return n;
|
||
}
|
||
|
||
// Repairs heal gradually (v0.45.0, ISS-089): while a plane is 'repairing', its health climbs along
|
||
// round(f × 100), where f is the fraction of REPAIR_DURATION_MS elapsed since the repair started —
|
||
// derived from the stored gate alone (start = gate − duration), so no schema change. The plane flips
|
||
// back to 'available' exactly when it reaches full health, i.e. at the gate. Same shape as
|
||
// expirePackages: one guarded pass over the rows. Returns the count flipped.
|
||
export async function finishRepairs(inst: GameDb, clockMs: number): Promise<number> {
|
||
const rows = await inst.db.select().from(schema.planes).where(eq(schema.planes.status, 'repairing'));
|
||
let n = 0;
|
||
for (const p of rows) {
|
||
if (p.repairUntilSimTime === null) continue; // defensive — repairing always carries a gate
|
||
// ponytail: constant duration regardless of starting health — the curve is absolute (f × 100), so a
|
||
// plane at 90 heals in the same sim time as one at 5. Proportional duration would need storing the
|
||
// start health; add a column if balance wants it. The flip stays strictly at the gate (`<=` inclusive,
|
||
// as before) — round(f × 100) can hit 100 a hair early (f ≥ 0.995), which is cosmetic only: the plane
|
||
// is still 'repairing' and grounded until the gate passes.
|
||
const f = Math.min(1, Math.max(0, (clockMs - (p.repairUntilSimTime - REPAIR_DURATION_MS)) / REPAIR_DURATION_MS));
|
||
if (p.repairUntilSimTime <= clockMs) {
|
||
await inst.db.update(schema.planes)
|
||
.set({ status: 'available', health: 100, repairUntilSimTime: null })
|
||
.where(eq(schema.planes.id, p.id));
|
||
n++;
|
||
} else {
|
||
const newHealth = Math.min(100, Math.max(p.health, Math.round(f * 100)));
|
||
if (newHealth !== p.health) {
|
||
await inst.db.update(schema.planes).set({ health: newHealth }).where(eq(schema.planes.id, p.id));
|
||
}
|
||
}
|
||
}
|
||
return n;
|
||
}
|
||
|
||
// Finalize in-flight planes whose arrival time has passed (v0.12.0 delivery):
|
||
// for every package bound to the plane and destined for its dest_icao — 'loaded'
|
||
// ones still inside their deadline are delivered (cash += reward + reputation
|
||
// gain per package), 'expired' ones just unbind (no reward). Packages destined
|
||
// elsewhere stay loaded on the plane for a later leg. Then (v0.25.0, ISS-043)
|
||
// auto-chain: if the queue holds legs, fuel covers the first one and the plane is not
|
||
// broken by this landing's wear (v0.45.0, ISS-089), start it immediately from the arrival
|
||
// airport; with a short tank, ISS-082 (v0.42.0) tops
|
||
// up to 150% of the requirement (capped at tank capacity) when cash allows and
|
||
// chains anyway — only an unaffordable top-up grounds the plane there with its
|
||
// remaining fuel and the queue kept intact for a later 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 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),
|
||
inst.db.select().from(schema.packages),
|
||
]);
|
||
|
||
const fc = await loadAirportsGeoJson();
|
||
const byIcao = new Map(fc.features.map((f) => [f.properties.icao, f.properties]));
|
||
|
||
let n = 0;
|
||
for (const p of planeRows) {
|
||
if (p.status !== 'flying' || p.departureSimTime == null || !p.destIcao) continue;
|
||
const type = PLANE_TYPES[p.model];
|
||
const from = byIcao.get(p.locationIcao);
|
||
const to = byIcao.get(p.destIcao);
|
||
if (!type || !from || !to) continue; // no route info — leave alone
|
||
|
||
const distanceKm = haversineKm(from.lat, from.lon, to.lat, to.lon);
|
||
if (clockMs < arrivalTimeFor(p.departureSimTime, distanceKm, type.speedKmh)) continue;
|
||
|
||
// Arrived: progress is exactly 1 here, so remaining fuel is the full-leg weighted burn —
|
||
// wind-adjusted (v0.36.0) by departure weather vs route heading, same factor flyPlane used.
|
||
const w = weatherFor(p.locationIcao);
|
||
const landedFuel = fuelAtWeighted(
|
||
p.fuel,
|
||
type.burnPerKm * windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon)),
|
||
type.emptyWeightKg,
|
||
type.maxFuel,
|
||
distanceKm,
|
||
1,
|
||
);
|
||
|
||
// Wear (v0.39.0, ISS-069): health drops by WEAR_PER_KM per km of this landed leg, clamped at 0.
|
||
const newHealth = Math.max(0, p.health - WEAR_PER_KM * distanceKm);
|
||
|
||
// Deliver every bound package whose destination is the airport just reached —
|
||
// runs whether or not a queued leg chains next (ISS-043).
|
||
const onBoard = packageRows.filter((pk) => pk.planeId === p.id && pk.destIcao === to.icao);
|
||
for (const pk of onBoard) {
|
||
if (pk.status === 'loaded' && clockMs <= pk.deadlineSimTime) {
|
||
await inst.db.update(schema.packages).set({ status: 'delivered' }).where(eq(schema.packages.id, pk.id));
|
||
// Fresh account read per award so multiple deliveries in one tick all count.
|
||
const fresh = (await inst.db.select().from(schema.account))[0];
|
||
if (!fresh) throw new Error('account row missing');
|
||
// v0.37.0 (ISS-073): special packages add the registry's flat rep bonus on top of the
|
||
// distance-based gain — same double-rounding convention as before (gain rounded to cents, total re-rounded).
|
||
const repBonus = pk.special ? SPECIALS[pk.special]?.repBonus ?? 0 : 0;
|
||
await inst.db.update(schema.account).set({
|
||
cash: fresh.cash + pk.reward,
|
||
reputation: Math.round((fresh.reputation + reputationGainFor(distanceKm) + repBonus) * 100) / 100,
|
||
});
|
||
} else if (pk.status === 'expired') {
|
||
// Expired cargo keeps no value — just free the slot.
|
||
await inst.db.update(schema.packages).set({ planeId: null }).where(eq(schema.packages.id, pk.id));
|
||
}
|
||
}
|
||
|
||
// Auto-chain (ISS-043): with a non-empty queue and enough fuel for the first
|
||
// queued leg, start it immediately from `to` — same feasibility rule as flyPlane
|
||
// (requiredFuelFor is independent of current load). ISS-082 (v0.42.0): manual refuel is gone,
|
||
// so a short tank no longer strands the chain — when cash allows, top up to 150% of the
|
||
// requirement (capped at tank capacity) and chain anyway; unaffordable → ground here with the
|
||
// queue kept intact. An unknown ICAO in the queue simply cannot chain either way. v0.45.0
|
||
// (ISS-089): a plane that lands BROKEN (newHealth ≤ 0) never chains — it stays grounded with
|
||
// the queue intact until repaired, exactly like flyPlane's broken guard.
|
||
const queue = parseIcaoQueue(p.queue);
|
||
let chainedTo: string | null = null;
|
||
let topUpFuel: number | null = null; // post-top-up fuel for the chained departure, when a top-up happened
|
||
if (queue.length > 0 && newHealth > 0) {
|
||
const nextDest = queue[0];
|
||
// ponytail: defensive guard for legacy rows — a queued leg to the airport we just landed at is a
|
||
// zero-distance no-op hop; drop it and ground instead of flying. Normal play can't produce this
|
||
// since v0.46.0 (flyPlane consumes queue[0] on dispatch, every chain shifts its own leg).
|
||
if (nextDest === to.icao) {
|
||
queue.shift();
|
||
} else {
|
||
const next = byIcao.get(nextDest); // unknown ICAO in the queue → cannot chain
|
||
if (next) {
|
||
// Wind-adjusted requirement for the NEXT leg — it departs from `to` (v0.36.0).
|
||
const wNext = weatherFor(to.icao);
|
||
const nextRequiredL = requiredFuelFor(
|
||
type.burnPerKm * windBurnFactor(wNext.windKt, wNext.windDirDeg, initialBearingDeg(to.lat, to.lon, next.lat, next.lon)),
|
||
type.emptyWeightKg,
|
||
type.maxFuel,
|
||
haversineKm(to.lat, to.lon, next.lat, next.lon),
|
||
);
|
||
// v0.46.0 backstop: a leg that doesn't fit even a full tank is unflyable — ground with the queue
|
||
// intact, mirroring flyPlane's 409 without throwing in the engine.
|
||
if (nextRequiredL > type.maxFuel) {
|
||
// no chain — the grounded update below keeps the queue for a later dispatch
|
||
} else if (nextRequiredL <= landedFuel) {
|
||
queue.shift();
|
||
chainedTo = nextDest;
|
||
} else {
|
||
// ISS-082: auto top-up — same target/price terms as flyPlane's dispatch refuel.
|
||
const target = Math.min(type.maxFuel, Math.max(landedFuel, nextRequiredL * 1.5));
|
||
const liters = Math.max(0, target - landedFuel);
|
||
// Fresh account read (same pattern as the delivery awards above) so a top-up in this tick sees current cash.
|
||
const fresh = (await inst.db.select().from(schema.account))[0];
|
||
if (!fresh) throw new Error('account row missing');
|
||
const cost = Math.round(liters * FUEL_PRICE_PER_L * (1 - repRate(fresh.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT)) * 100) / 100;
|
||
if (cost === 0 || fresh.cash >= cost) {
|
||
queue.shift();
|
||
chainedTo = nextDest;
|
||
topUpFuel = target;
|
||
if (cost > 0) await inst.db.update(schema.account).set({ cash: Math.round((fresh.cash - cost) * 100) / 100 });
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
await inst.db.update(schema.planes)
|
||
.set(
|
||
chainedTo
|
||
? {
|
||
status: 'flying',
|
||
locationIcao: to.icao,
|
||
lat: to.lat,
|
||
lon: to.lon,
|
||
fuel: topUpFuel ?? landedFuel, // ISS-082: the post-top-up level when a top-up funded the chain
|
||
health: newHealth, // v0.39.0 (ISS-069) — this leg's wear persists into the chained flight
|
||
destIcao: chainedTo,
|
||
departureSimTime: clockMs, // the arrival instant — position is exactly `to`
|
||
queue: JSON.stringify(queue),
|
||
}
|
||
: {
|
||
status: 'available',
|
||
locationIcao: to.icao,
|
||
lat: to.lat,
|
||
lon: to.lon,
|
||
fuel: landedFuel,
|
||
health: newHealth, // v0.39.0 (ISS-069) — this leg's wear persists on the grounded plane
|
||
departureSimTime: null,
|
||
destIcao: null,
|
||
queue: JSON.stringify(queue),
|
||
},
|
||
)
|
||
.where(eq(schema.planes.id, p.id));
|
||
n++;
|
||
}
|
||
return n;
|
||
}
|
||
|
||
// Top the market back up to MARKET_TARGET_OPEN_PACKAGES open packages using the
|
||
// SAME builder as the first-run seed (generatePackage), so spawned packages are
|
||
// indistinguishable from seeded ones. RNG is injectable for deterministic tests.
|
||
export async function spawnOpenPackages(
|
||
inst: GameDb,
|
||
clockMs: number,
|
||
rng?: Rng,
|
||
): Promise<number> {
|
||
const openCount = (
|
||
await inst.db.select().from(schema.packages).where(eq(schema.packages.status, 'open'))
|
||
).length;
|
||
const needed = MARKET_TARGET_OPEN_PACKAGES - openCount;
|
||
if (needed <= 0) return 0;
|
||
|
||
const fc = await loadAirportsGeoJson();
|
||
const airports: SeedAirport[] = fc.features.map((f) => ({
|
||
icao: f.properties.icao,
|
||
name: f.properties.name,
|
||
lat: f.properties.lat,
|
||
lon: f.properties.lon,
|
||
}));
|
||
const rand = rng ?? mulberry32(randomInt(0, 2 ** 31));
|
||
// v0.38.0 (ISS-072): spawned jobs carry the account's CURRENT reputation quality — read once per spawn batch.
|
||
const account = (await inst.db.select().from(schema.account))[0];
|
||
if (!account) throw new Error('account row missing');
|
||
|
||
for (let i = 0; i < needed; i++) {
|
||
await inst.db.insert(schema.packages).values(
|
||
generatePackage({ id: randomUUID(), airports, rng: rand, nowMs: clockMs, reputation: account.reputation }),
|
||
);
|
||
}
|
||
return needed;
|
||
}
|
||
|
||
// Spawn coverage rule (v0.8.0): in addition to topping the market up, every
|
||
// airport that currently has a grounded 'available' plane must have ≥1 OPEN
|
||
// package originating there — so work is always available where the fleet sits
|
||
// (including onboarding at EDDF). One package per uncovered airport, generated
|
||
// with generatePackage and origin forced to that airport. Runs after
|
||
// spawnOpenPackages in tickOnce, so randomly spawned packages count as coverage
|
||
// too; and after deliverPackages, so a plane that just landed gets work spawned
|
||
// at its new location within the same tick. Returns the number created.
|
||
export async function spawnCoveragePackages(
|
||
inst: GameDb,
|
||
clockMs: number,
|
||
rng?: Rng,
|
||
): Promise<number> {
|
||
const [planeRows, openRows] = await Promise.all([
|
||
inst.db.select().from(schema.planes),
|
||
inst.db.select().from(schema.packages).where(eq(schema.packages.status, 'open')),
|
||
]);
|
||
|
||
// Distinct airports with at least one grounded plane (flying planes don't count —
|
||
// they can't take new work until they land).
|
||
const groundedIcas = [
|
||
...new Set(planeRows.filter((p) => p.status === 'available').map((p) => p.locationIcao)),
|
||
];
|
||
if (groundedIcas.length === 0) return 0;
|
||
|
||
const covered = new Set(openRows.map((c) => c.originIcao));
|
||
const missing = groundedIcas.filter((icao) => !covered.has(icao));
|
||
if (missing.length === 0) return 0;
|
||
|
||
const fc = await loadAirportsGeoJson();
|
||
const airports: SeedAirport[] = fc.features.map((f) => ({
|
||
icao: f.properties.icao,
|
||
name: f.properties.name,
|
||
lat: f.properties.lat,
|
||
lon: f.properties.lon,
|
||
}));
|
||
const rand = rng ?? mulberry32(randomInt(0, 2 ** 31));
|
||
// v0.38.0 (ISS-072): same reputation quality as spawnOpenPackages — read once per batch.
|
||
const account = (await inst.db.select().from(schema.account))[0];
|
||
if (!account) throw new Error('account row missing');
|
||
|
||
let n = 0;
|
||
for (const icao of missing) {
|
||
const oi = airports.findIndex((a) => a.icao === icao);
|
||
if (oi < 0) continue; // defensive — the dataset is the source of all ICACs
|
||
// v0.44.0 (ISS-079): cap the random dest at MAX_JOB_LEG_KM like generatePackage's unforced pairs —
|
||
// one draw in the same stream position as the old uncapped pick, so downstream draws are unchanged.
|
||
const di = pickDestWithinCap(airports, oi, rand);
|
||
await inst.db.insert(schema.packages).values(
|
||
generatePackage({
|
||
id: randomUUID(),
|
||
airports,
|
||
rng: rand,
|
||
nowMs: clockMs,
|
||
originIcao: icao,
|
||
...(di >= 0 ? { destIcao: airports[di].icao } : {}), // di < 0 (no within-cap neighbour) → old uncapped behavior
|
||
reputation: account.reputation,
|
||
}),
|
||
);
|
||
n++;
|
||
}
|
||
return n;
|
||
}
|
||
|
||
// --- Public API (singleton DB + lock) — call from every read/action endpoint ---
|
||
|
||
export function tickNow(): Promise<schema.SimStateRow> {
|
||
return withLock(async () => tickOnce(await getGameDb()));
|
||
}
|
||
|
||
// Run a game action atomically with respect to ticks (v0.8.0): the clock is
|
||
// advanced FIRST so validation and mutation see current game time, then fn runs —
|
||
// all under the same promise lock as tickNow(), so no concurrent request can
|
||
// interleave between the tick and the mutation. Action functions in
|
||
// lib/game/actions.ts take an explicit GameDb so unit tests can inject their own.
|
||
export function runAction<T>(fn: (inst: GameDb) => Promise<T>): Promise<T> {
|
||
return withLock(async () => {
|
||
const inst = await getGameDb();
|
||
await tickOnce(inst);
|
||
return fn(inst);
|
||
});
|
||
}
|
||
|
||
// 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). 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' | '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);
|
||
const updated = (await inst.db.select().from(schema.simState))[0];
|
||
if (!updated) throw new Error('sim_state row missing');
|
||
return updated;
|
||
});
|
||
}
|
||
|
||
export function clampTimeScale(v: number): number {
|
||
return Math.min(MAX_TIME_SCALE, Math.max(MIN_TIME_SCALE, v));
|
||
}
|