221 lines
10 KiB
TypeScript
221 lines
10 KiB
TypeScript
import { loadAirportsGeoJson } from '@/lib/airports';
|
|
import { haversineKm, initialBearingDeg } from '@/lib/geo';
|
|
import { weatherFor } from '@/lib/weather';
|
|
import { getGameDb } from '@/lib/db/client';
|
|
import { getPlayer } from '@/lib/db/localPlayer';
|
|
import * as schema from '@/lib/db/schema';
|
|
import { catalogEntries, FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION, type CatalogEntry } from './catalog';
|
|
import { fuelAtWeighted, progressAt, positionAt, windBurnFactor } from '@/lib/sim/movement';
|
|
import { JOB_LIFETIME_MS } from './seed';
|
|
|
|
// Read-only game-state snapshot for client polling (GET /api/state).
|
|
|
|
export interface PlaneState {
|
|
id: string;
|
|
model: string;
|
|
// v0.39.0 (ISS-069): 'repairing' = grounded in the shop until repairUntilSimTime passes.
|
|
status: 'available' | 'flying' | 'repairing';
|
|
fuel: number;
|
|
maxFuel: number;
|
|
locationIcao: string;
|
|
locationName: string;
|
|
// Current flight destination (v0.12.0) — set by fly, null when grounded. The
|
|
// origin of the current leg is always locationIcao while flying.
|
|
destIcao: string | null;
|
|
destName: string | null;
|
|
// Sim-clock departure time of the current flight (v0.8.0) — null when grounded,
|
|
// set by fly while flying so clients can compute progress/ETA from the clock.
|
|
departureSimTime: number | null;
|
|
lat: number;
|
|
lon: number;
|
|
// Upcoming legs NOT yet started (v0.25.0, ISS-043) — ordered ICAOs; the active
|
|
// leg is destIcao. The engine auto-chains queue[0] on landing when fuel covers it.
|
|
queue: string[];
|
|
// Structural health in [0, 100] (v0.39.0, ISS-069) — wears down with distance flown; at 0 the
|
|
// plane is broken and cannot fly until repaired (v0.45.0, ISS-089). While 'repairing' this is
|
|
// also the repair progress: it climbs back to 100 over REPAIR_DURATION_MS of sim time.
|
|
health: number;
|
|
// Sim-clock epoch ms when an active repair finishes (v0.39.0, ISS-069); null when not in repair.
|
|
repairUntilSimTime: number | null;
|
|
}
|
|
|
|
// Parse the planes.queue JSON column into an ICAO list (v0.25.0). Guards against
|
|
// null/empty/malformed values so a corrupt cell can never break a snapshot or tick.
|
|
export function parseIcaoQueue(raw: string | null): string[] {
|
|
if (!raw) return [];
|
|
try {
|
|
const v: unknown = JSON.parse(raw);
|
|
return Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string') : [];
|
|
} catch {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// v0.65.0: the airports where a plane can take work — grounded there, flying TO it (its destination
|
|
// joins the pool while airborne), or queued for it (queued legs count even while their plane is in
|
|
// the shop — the work will be waiting at its next stop). A fleet fully repairing with empty queues
|
|
// has no pools until one frees up. Shared by the snapshot's visibility filter and the engine's
|
|
// pool spawner so both agree on exactly which airports keep open jobs.
|
|
export function poolAirports(planes: Array<{ status: string; locationIcao: string; destIcao: string | null; queue: string | null }>): Set<string> {
|
|
const set = new Set<string>();
|
|
for (const p of planes) {
|
|
if (p.status === 'available') set.add(p.locationIcao);
|
|
else if (p.status === 'flying' && p.destIcao) set.add(p.destIcao);
|
|
for (const icao of parseIcaoQueue(p.queue)) set.add(icao);
|
|
}
|
|
return set;
|
|
}
|
|
|
|
export interface PackageState {
|
|
id: string;
|
|
originIcao: string;
|
|
originName: string;
|
|
destIcao: string;
|
|
destName: string;
|
|
reward: number;
|
|
cargoType: string;
|
|
cargoCount: number;
|
|
// Package weight in kg (v0.27.0, ISS-045) — drives load validation + per-kg payout.
|
|
weightKg: number;
|
|
// Special status (v0.37.0, ISS-073) — key into lib/game/specials.ts SPECIALS; null = none.
|
|
special: string | null;
|
|
// Great-circle leg distance in km (v0.48.0, ISS-095) — computed from airport coords, not stored.
|
|
distanceKm: number;
|
|
deadlineSimTime: number;
|
|
status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned';
|
|
planeId: string | null;
|
|
createdSimTime: number;
|
|
// Wall-clock expiry of an OPEN job (v0.65.0) — createdRealMs + JOB_LIFETIME_MS, shown as a live
|
|
// countdown in the right pane; null for every non-open status (loaded cargo still uses deadlineSimTime).
|
|
expiresRealMs: number | null;
|
|
}
|
|
|
|
export interface StateSnapshot {
|
|
account: { cash: number; reputation: number };
|
|
// ISS-117 (v0.52.0): the world rate is a fixed constant (WORLD_TIME_SCALE), not per-save state —
|
|
// only the clock itself is reported here.
|
|
simState: { clockMs: number };
|
|
planes: PlaneState[];
|
|
packages: PackageState[];
|
|
// Market reference data (v0.10.0) — static per build, sent with every snapshot so
|
|
// the client can compute buy/sell previews without a separate endpoint.
|
|
catalog: CatalogEntry[];
|
|
fuelPricePerL: number;
|
|
sellFraction: number;
|
|
}
|
|
|
|
// ISS-133 (v0.59.0): the SSE projection of a snapshot — only the package statuses any component
|
|
// renders: open (market list), loaded + expired (on-board cargo, which keeps its payload slot).
|
|
// Terminal history (delivered/abandoned) is unbounded in the DB and never read by the
|
|
// client, so it stays out of every pushed frame; /api/state and action responses keep the full set.
|
|
export const SSE_PACKAGE_STATUSES = ['open', 'loaded', 'expired'] as const;
|
|
|
|
export function sseFrame(snapshot: StateSnapshot): StateSnapshot {
|
|
return { ...snapshot, packages: snapshot.packages.filter((p) => (SSE_PACKAGE_STATUSES as readonly string[]).includes(p.status)) };
|
|
}
|
|
|
|
// v1.3.0 (ISS-110): the snapshot's `account` field is the ACTING SESSION player's row — same
|
|
// shape as before ({cash, reputation}), sourced per-player. Callers without a session context
|
|
// (the shared SSE broadcast) pass LOCAL_PLAYER.id until per-player frames land (#112).
|
|
export async function getStateSnapshot(playerId: string): Promise<StateSnapshot> {
|
|
const inst = await getGameDb();
|
|
const { db } = inst;
|
|
// NOTE: use plain select(), not the relational db.query.* API — in drizzle-orm
|
|
// 0.45.x the sql-js driver drops the result mapper for relational queries and
|
|
// returns raw rows keyed by SQL column names (snake_case, no type decoding).
|
|
const [player, simRows, planeRows, packageRows] = await Promise.all([
|
|
getPlayer(inst, playerId),
|
|
db.select().from(schema.simState),
|
|
db.select().from(schema.planes),
|
|
db.select().from(schema.packages),
|
|
]);
|
|
const simRow = simRows[0];
|
|
if (!simRow) throw new Error('game state missing sim_state row');
|
|
|
|
const fc = await loadAirportsGeoJson();
|
|
const nameByIcao = new Map(fc.features.map((f) => [f.properties.icao, f.properties.name]));
|
|
const nameOf = (icao: string) => nameByIcao.get(icao) ?? icao;
|
|
const coordsByIcao = new Map(fc.features.map((f) => [f.properties.icao, f.properties]));
|
|
// v0.48.0 (ISS-095): leg distance for the UI — same haversine as live-plane math; 0 if a coord is missing.
|
|
const legDistanceKm = (originIcao: string, destIcao: string) => {
|
|
const from = coordsByIcao.get(originIcao);
|
|
const to = coordsByIcao.get(destIcao);
|
|
return from && to ? haversineKm(from.lat, from.lon, to.lat, to.lon) : 0;
|
|
};
|
|
|
|
// v0.65.0: pool visibility — open packages appear only where a plane can take work (poolAirports);
|
|
// every other status is always visible (on-board cargo, history). Filtered rows are absent from the
|
|
// body entirely, so clients never see jobs they could not dispatch.
|
|
const pool = poolAirports(planeRows);
|
|
|
|
// Analytic movement (v0.7.0): a flying plane's stored lat/lon/fuel are its
|
|
// departure values — live position and fuel are pure functions of the clock.
|
|
const livePlane = (p: schema.PlaneRow) => {
|
|
if (p.status !== 'flying' || p.departureSimTime == null || !p.destIcao) return null;
|
|
const type = PLANE_TYPES[p.model];
|
|
const from = coordsByIcao.get(p.locationIcao);
|
|
const to = coordsByIcao.get(p.destIcao);
|
|
if (!type || !from || !to) return null;
|
|
const distanceKm = haversineKm(from.lat, from.lon, to.lat, to.lon);
|
|
const progress = progressAt(p.departureSimTime, distanceKm, type.speedKmh, simRow.clockMs);
|
|
const pos = positionAt(from.lat, from.lon, to.lat, to.lon, progress);
|
|
// Wind-adjusted burn (v0.36.0) — weather is a pure function of the departure ICAO, so this
|
|
// recomputes exactly the factor the engine used for the leg; no stored state needed.
|
|
const w = weatherFor(p.locationIcao);
|
|
return { ...pos, fuel: fuelAtWeighted(
|
|
p.fuel,
|
|
type.burnPerKm * windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon)),
|
|
type.emptyWeightKg,
|
|
type.maxFuel,
|
|
distanceKm,
|
|
progress,
|
|
) };
|
|
};
|
|
|
|
return {
|
|
account: { cash: player.cash, reputation: player.reputation },
|
|
simState: { clockMs: simRow.clockMs },
|
|
catalog: catalogEntries(),
|
|
fuelPricePerL: FUEL_PRICE_PER_L,
|
|
sellFraction: SELL_FRACTION,
|
|
planes: planeRows.map((p) => {
|
|
const live = livePlane(p);
|
|
return {
|
|
id: p.id,
|
|
model: p.model,
|
|
status: p.status,
|
|
fuel: live?.fuel ?? p.fuel,
|
|
maxFuel: p.maxFuel,
|
|
locationIcao: p.locationIcao,
|
|
locationName: nameOf(p.locationIcao),
|
|
destIcao: p.destIcao,
|
|
destName: p.destIcao ? nameOf(p.destIcao) : null,
|
|
departureSimTime: p.departureSimTime,
|
|
lat: live?.lat ?? p.lat,
|
|
lon: live?.lon ?? p.lon,
|
|
queue: parseIcaoQueue(p.queue),
|
|
health: p.health, // v0.39.0 (ISS-069) — stored value; wear accumulates at landing only
|
|
repairUntilSimTime: p.repairUntilSimTime,
|
|
};
|
|
}),
|
|
packages: packageRows.filter((p) => p.status !== 'open' || pool.has(p.originIcao)).map((p) => ({
|
|
id: p.id,
|
|
originIcao: p.originIcao,
|
|
originName: nameOf(p.originIcao),
|
|
destIcao: p.destIcao,
|
|
destName: nameOf(p.destIcao),
|
|
reward: p.reward,
|
|
cargoType: p.cargoType,
|
|
cargoCount: p.cargoCount,
|
|
weightKg: p.weightKg,
|
|
special: p.special,
|
|
distanceKm: legDistanceKm(p.originIcao, p.destIcao), // v0.48.0 (ISS-095)
|
|
deadlineSimTime: p.deadlineSimTime,
|
|
status: p.status,
|
|
planeId: p.planeId,
|
|
createdSimTime: p.createdSimTime,
|
|
expiresRealMs: p.status === 'open' ? p.createdRealMs + JOB_LIFETIME_MS : null,
|
|
})),
|
|
};
|
|
}
|