5e3bbff636
FIREWALL machine on SIM's catcher shape (input-free catch-mite -> parity-mite), gated behind broadcast-parity-firewall; parity-mite canned item; two commissions that want The Correction alive. All 19 GLB'd machines accented from their actual albedo textures (mosquito-trap corrected to UV-violet, decode-asic to ice-blue). Validator +2: firewall shape guard + a mite-catcher-exists check. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
873 lines
38 KiB
TypeScript
873 lines
38 KiB
TypeScript
/**
|
|
* LANE-DATA territory. Lives beside the JSON it guards (round 3: moved out of
|
|
* src/sim/, which returns fully to LANE-SIM).
|
|
*
|
|
* Validates data/*.json against the contracts. It is the handshake that keeps five
|
|
* parallel lanes from drowning in dangling ids: if a lane references a machine,
|
|
* recipe, item or tech that data doesn't define, this test names it.
|
|
*/
|
|
import { describe, expect, it } from 'vitest';
|
|
import type { CommissionDef, ItemDef, MachineDef, MachineKind, RecipeDef, TechDef } from '../src/contracts';
|
|
import { TICKS_PER_SECOND } from '../src/contracts';
|
|
// LANE-SIM's tuning constants — imported, never retyped (round 5). A hand-copied 0.7
|
|
// keeps passing after the sim moves to 0.65; an import fails loudly, which is the point.
|
|
import {
|
|
HEAT_COOL_DEFAULT, HEAT_COOL_MAX, HEAT_RESTART, HEAT_THROTTLE_START,
|
|
} from '../src/sim/constants';
|
|
|
|
import itemsJson from './items.json';
|
|
import machinesJson from './machines.json';
|
|
import recipesJson from './recipes.json';
|
|
import techJson from './tech.json';
|
|
import commissionsJson from './commissions.json';
|
|
import seamsJson from './seams.json';
|
|
import stationsJson from './stations.json';
|
|
|
|
const items = itemsJson as unknown as ItemDef[];
|
|
const machines = machinesJson as unknown as MachineDef[];
|
|
const recipes = recipesJson as unknown as RecipeDef[];
|
|
const tech = techJson as unknown as TechDef[];
|
|
const commissions = commissionsJson as unknown as CommissionDef[];
|
|
|
|
const KEBAB = /^[a-z0-9]+(-[a-z0-9]+)*$/;
|
|
// Multi-digit section numbers: the codex grew a §10 (THE COMPOSITE SEAM) and the old
|
|
// single-digit form silently rejected every reference into it.
|
|
const CODEX_REF = /^[1-9][0-9]*:[a-z0-9]+(-[a-z0-9]+)*$/;
|
|
const HEX = /^#[0-9a-f]{6}$/;
|
|
|
|
const KINDS: MachineKind[] = [
|
|
'extractor', 'crafter', 'belt', 'splitter', 'power', 'buffer', 'shipper',
|
|
'lab', // v4
|
|
];
|
|
const ERAS: TechDef['era'][] = ['reel', 'broadcast', 'disc', 'stream', 'fortress'];
|
|
|
|
const itemIds = new Set(items.map((i) => i.id));
|
|
const machineIds = new Set(machines.map((m) => m.id));
|
|
const recipeIds = new Set(recipes.map((r) => r.id));
|
|
|
|
/** Collect ids that appear more than once. */
|
|
function duplicates(ids: string[]): string[] {
|
|
const seen = new Set<string>();
|
|
const dupes = new Set<string>();
|
|
for (const id of ids) (seen.has(id) ? dupes : seen).add(id);
|
|
return [...dupes];
|
|
}
|
|
|
|
/** Item ids referenced by a count map that no item defines. */
|
|
function unknownItems(counts: Record<string, number>): string[] {
|
|
return Object.keys(counts).filter((id) => !itemIds.has(id));
|
|
}
|
|
|
|
/** Everything an extractor can pull, closed over every recipe that can then run. */
|
|
function producible(): Set<string> {
|
|
const have = new Set<string>();
|
|
for (;;) {
|
|
const before = have.size;
|
|
for (const r of recipes) {
|
|
if (Object.keys(r.inputs).every((i) => have.has(i))) {
|
|
for (const o of Object.keys(r.outputs)) have.add(o);
|
|
}
|
|
}
|
|
if (have.size === before) return have;
|
|
}
|
|
}
|
|
|
|
describe('ids and formatting', () => {
|
|
it('every collection has unique ids', () => {
|
|
expect(duplicates(items.map((i) => i.id))).toEqual([]);
|
|
expect(duplicates(machines.map((m) => m.id))).toEqual([]);
|
|
expect(duplicates(recipes.map((r) => r.id))).toEqual([]);
|
|
expect(duplicates(tech.map((t) => t.id))).toEqual([]);
|
|
expect(duplicates(commissions.map((c) => c.id))).toEqual([]);
|
|
});
|
|
|
|
it('every id is kebab-case', () => {
|
|
const bad = [...items, ...machines, ...recipes, ...tech, ...commissions]
|
|
.map((d) => d.id)
|
|
.filter((id) => !KEBAB.test(id));
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every item and machine points at a codex section', () => {
|
|
const bad = [...items, ...machines]
|
|
.filter((d) => !CODEX_REF.test(d.codex))
|
|
.map((d) => `${d.id} -> "${d.codex}"`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('items', () => {
|
|
it('every colour is a 6-digit lowercase hex', () => {
|
|
const bad = items.filter((i) => !HEX.test(i.color)).map((i) => `${i.id} -> "${i.color}"`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every tier is 0..3', () => {
|
|
const bad = items.filter((i) => !Number.isInteger(i.tier) || i.tier < 0 || i.tier > 3)
|
|
.map((i) => `${i.id} -> ${i.tier}`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every item has a display name', () => {
|
|
expect(items.filter((i) => !i.name.trim()).map((i) => i.id)).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('machines', () => {
|
|
it('every kind is a known MachineKind', () => {
|
|
const bad = machines.filter((m) => !KINDS.includes(m.kind)).map((m) => `${m.id} -> "${m.kind}"`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every footprint is at least 1x1 in whole tiles', () => {
|
|
const bad = machines.filter((m) => {
|
|
const { x, y } = m.footprint ?? { x: 0, y: 0 };
|
|
return !Number.isInteger(x) || !Number.isInteger(y) || x < 1 || y < 1;
|
|
}).map((m) => m.id);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every listed recipe exists and points back at the machine', () => {
|
|
const missing: string[] = [];
|
|
const mismatched: string[] = [];
|
|
for (const m of machines) {
|
|
for (const rid of m.recipes) {
|
|
const r = recipes.find((x) => x.id === rid);
|
|
if (!r) missing.push(`${m.id} lists unknown recipe "${rid}"`);
|
|
else if (r.machine !== m.id) mismatched.push(`${m.id} lists "${rid}" but that recipe runs on "${r.machine}"`);
|
|
}
|
|
}
|
|
expect(missing).toEqual([]);
|
|
expect(mismatched).toEqual([]);
|
|
});
|
|
|
|
it('belts declare a belt speed and power machines declare generation', () => {
|
|
const bad = [
|
|
...machines.filter((m) => m.kind === 'belt' && !(m.beltSpeed! > 0)).map((m) => `${m.id} has no beltSpeed`),
|
|
...machines.filter((m) => m.kind === 'power' && !(m.powerGen! > 0)).map((m) => `${m.id} has no powerGen`),
|
|
];
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every machine declares a non-negative idle draw and an asset key', () => {
|
|
const bad = machines
|
|
.filter((m) => !(m.powerDraw >= 0) || !KEBAB.test(m.asset))
|
|
.map((m) => `${m.id} -> draw ${m.powerDraw}, asset "${m.asset}"`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
// v2 art direction: RENDER prefers our colour over one derived from outputs, and UI's
|
|
// inspector prints our flavor instead of a hardcoded lookup. Both need full coverage
|
|
// or a machine goes black-on-black / voiceless.
|
|
it('every machine is art-directed: a hex colour and a line of flavor', () => {
|
|
const bad = machines
|
|
.filter((m) => !m.color || !HEX.test(m.color) || !m.flavor?.trim())
|
|
.map((m) => `${m.id} -> color ${m.color ?? 'MISSING'}, flavor ${m.flavor ? 'ok' : 'MISSING'}`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
// v4: the emissive accent falls back to a colour derived from the first output item.
|
|
// A machine with no recipes has no first output, so the fallback has nothing to
|
|
// derive from — those must carry an explicit accent or they render unlit.
|
|
it('every machine with no output to derive from carries an explicit accent', () => {
|
|
const bad = machines
|
|
.filter((m) => m.recipes.length === 0 && !m.accent)
|
|
.map((m) => `${m.id} (${m.kind}) has no recipes and no accent — nothing to derive an accent from`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every accent is a hex colour, and differs from the chassis it sits on', () => {
|
|
const bad = machines
|
|
.filter((m) => m.accent !== undefined)
|
|
.filter((m) => !HEX.test(m.accent!) || m.accent === m.color)
|
|
.map((m) => `${m.id} -> accent ${m.accent} on chassis ${m.color}`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('a cooling aura belongs only to a machine that actually cools', () => {
|
|
const bad = machines
|
|
.filter((m) => m.coolRadius !== undefined)
|
|
.filter((m) => !(m.coolRadius! >= 1) || !Number.isInteger(m.coolRadius) || !(m.coolPerTick! > 0))
|
|
.map((m) => `${m.id} -> coolRadius ${m.coolRadius}, coolPerTick ${m.coolPerTick}`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('exactly one lab exists, and research is impossible without it', () => {
|
|
const labs = machines.filter((m) => m.kind === 'lab');
|
|
expect(labs.map((m) => m.id)).toEqual(['archaeology-lab']);
|
|
});
|
|
|
|
it('only buffers declare a capacity, and they all do', () => {
|
|
const bad = [
|
|
...machines.filter((m) => m.kind === 'buffer' && !(m.bufferCap! > 0))
|
|
.map((m) => `${m.id} is a buffer with no bufferCap`),
|
|
...machines.filter((m) => m.kind !== 'buffer' && m.bufferCap !== undefined)
|
|
.map((m) => `${m.id} is not a buffer but declares bufferCap`),
|
|
];
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('machine heat is a sane 0..1 per-tick trickle, never an instant scram', () => {
|
|
const bad = machines.filter((m) => m.heatPerTick !== undefined)
|
|
.filter((m) => !(m.heatPerTick! > 0 && m.heatPerTick! <= 0.05))
|
|
.map((m) => `${m.id} -> heatPerTick ${m.heatPerTick}`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('the ASIC stays cool and the software decoder does not', () => {
|
|
// The codex's whole point (§4): cool-and-inflexible vs hot-and-mighty. If this
|
|
// flips, the power choice has stopped being a choice.
|
|
const asic = machines.find((m) => m.id === 'decode-asic')!;
|
|
const soft = machines.find((m) => m.id === 'software-decoder')!;
|
|
expect(asic.heatPerTick).toBeUndefined();
|
|
expect(soft.heatPerTick).toBeGreaterThan(0);
|
|
expect(soft.powerGen!).toBeGreaterThan(asic.powerGen!);
|
|
});
|
|
});
|
|
|
|
// Round 2 shipped heat numbers that could never fire: every heatPerTick sat below the
|
|
// sim's always-on cooling, so heat was decorative. These lock the arithmetic down so a
|
|
// well-meaning tweak can't quietly make it decorative again.
|
|
describe('the heat curve actually fires', () => {
|
|
// Round 5: these were hand-copied from src/sim/index.ts and went stale in silence by
|
|
// design — a copy of 0.7 doesn't fail when the sim moves to 0.65. LANE-SIM exports them
|
|
// now, so the copies are retired and this arithmetic is pinned to the real curve.
|
|
const TPS = TICKS_PER_SECOND;
|
|
const THROTTLE_START = HEAT_THROTTLE_START;
|
|
const RESTART = HEAT_RESTART;
|
|
const SIM_DEFAULT_COOL = HEAT_COOL_DEFAULT;
|
|
|
|
const soft = machines.find((m) => m.id === 'software-decoder')!;
|
|
const cool = (m: MachineDef) => m.coolPerTick ?? SIM_DEFAULT_COOL;
|
|
/** Net heat per tick while the machine is working. Negative = can never overheat. */
|
|
const net = (m: MachineDef) => (m.heatPerTick ?? 0) - cool(m);
|
|
|
|
it('every heat source out-heats its own cooling — or it is just decoration', () => {
|
|
const decorative = machines
|
|
.filter((m) => m.heatPerTick !== undefined)
|
|
.filter((m) => net(m) <= 0)
|
|
.map((m) => `${m.id}: heats ${m.heatPerTick}/tick but cools ${cool(m)}/tick — never warms up`);
|
|
expect(decorative).toEqual([]);
|
|
});
|
|
|
|
it('every heated recipe banks more than its machine sheds during the craft', () => {
|
|
// A recipe's heat lands once per craft, but the machine cools every tick of it.
|
|
// heat <= ticks * coolPerTick means the number is a comment, not a mechanic.
|
|
const decorative = recipes
|
|
.filter((r) => r.heat !== undefined)
|
|
.map((r) => ({ r, m: machines.find((x) => x.id === r.machine)! }))
|
|
.filter(({ r, m }) => r.heat! <= r.ticks * cool(m))
|
|
.map(({ r, m }) =>
|
|
`${r.id}: banks ${r.heat} per craft but ${m.id} sheds ${(r.ticks * cool(m)).toFixed(3)} over its ${r.ticks} ticks`);
|
|
expect(decorative).toEqual([]);
|
|
});
|
|
|
|
it('the software decoder throttles at ~10s and scrams at 13-15s of continuous load', () => {
|
|
const secondsTo = (heat: number) => heat / net(soft) / TPS;
|
|
expect(secondsTo(THROTTLE_START)).toBeGreaterThan(8);
|
|
expect(secondsTo(THROTTLE_START)).toBeLessThan(12);
|
|
expect(secondsTo(1)).toBeGreaterThan(13);
|
|
expect(secondsTo(1)).toBeLessThan(15);
|
|
});
|
|
|
|
it('the software decoder duty-cycles at ~25s, and is still worth its footprint', () => {
|
|
// Steady state after the first scram: heat swings RESTART -> 1 -> RESTART.
|
|
const upTicks = (1 - RESTART) / net(soft);
|
|
const downTicks = (1 - RESTART) / cool(soft);
|
|
const periodS = (upTicks + downTicks) / TPS;
|
|
expect(periodS).toBeGreaterThan(20);
|
|
expect(periodS).toBeLessThan(30);
|
|
|
|
// Generation is throttled linearly from 1.0 down to 0.5 across the throttle window,
|
|
// and is zero while scrammed. Average it over the whole cycle.
|
|
const fullTicks = (THROTTLE_START - RESTART) / net(soft); // un-throttled
|
|
const throttledTicks = (1 - THROTTLE_START) / net(soft); // 1.0 -> 0.5 output
|
|
const energy = soft.powerGen! * (fullTicks + throttledTicks * 0.75);
|
|
const average = energy / (upTicks + downTicks);
|
|
|
|
const asic = machines.find((m) => m.id === 'decode-asic')!;
|
|
// Same 2x2 footprint, so if the hot one doesn't beat the cool one on average,
|
|
// nobody would ever build it and the codex's "burst gen" is a lie.
|
|
expect(average).toBeGreaterThan(asic.powerGen! * 1.2);
|
|
});
|
|
|
|
it('the hex splicer runs a lesser fever than the decoder', () => {
|
|
const splicer = machines.find((m) => m.id === 'hex-splicer')!;
|
|
const secondsToScram = Math.min(
|
|
...recipes.filter((r) => r.machine === 'hex-splicer' && r.heat)
|
|
.map((r) => (1 / (r.heat! - r.ticks * cool(splicer))) * r.ticks / TPS),
|
|
);
|
|
expect(secondsToScram).toBeGreaterThan(30); // lesser...
|
|
expect(secondsToScram).toBeLessThan(90); // ...but a fever
|
|
expect(secondsToScram).toBeGreaterThan(1 / net(soft) / TPS); // slower than the decoder
|
|
});
|
|
});
|
|
|
|
describe('recipes', () => {
|
|
it('every recipe runs on a machine that exists', () => {
|
|
const bad = recipes.filter((r) => !machineIds.has(r.machine)).map((r) => `${r.id} -> "${r.machine}"`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every recipe is listed by the machine it runs on', () => {
|
|
const orphans = recipes.filter((r) => {
|
|
const m = machines.find((x) => x.id === r.machine);
|
|
return m && !m.recipes.includes(r.id);
|
|
}).map((r) => `${r.id} is not listed by ${r.machine}`);
|
|
expect(orphans).toEqual([]);
|
|
});
|
|
|
|
it('every input and output item exists', () => {
|
|
const bad: string[] = [];
|
|
for (const r of recipes) {
|
|
for (const id of unknownItems(r.inputs)) bad.push(`${r.id} consumes unknown item "${id}"`);
|
|
for (const id of unknownItems(r.outputs)) bad.push(`${r.id} produces unknown item "${id}"`);
|
|
}
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every recipe produces something in whole positive counts', () => {
|
|
const bad: string[] = [];
|
|
for (const r of recipes) {
|
|
if (Object.keys(r.outputs).length === 0) bad.push(`${r.id} has no outputs`);
|
|
for (const [id, n] of [...Object.entries(r.inputs), ...Object.entries(r.outputs)]) {
|
|
if (!Number.isInteger(n) || n < 1) bad.push(`${r.id} -> "${id}" count ${n}`);
|
|
}
|
|
}
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every recipe takes a whole positive number of ticks', () => {
|
|
const bad = recipes.filter((r) => !Number.isInteger(r.ticks) || r.ticks < 1)
|
|
.map((r) => `${r.id} -> ${r.ticks} ticks`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('only extractors and traps run input-free recipes', () => {
|
|
// An input-free recipe takes something from the world rather than off a belt.
|
|
// Extractors take it from the ground; the mosquito trap takes a live swarm, which
|
|
// is wildlife in the snapshot and never an item on a belt. LANE-SIM identifies a
|
|
// trap by exactly this shape — an empty-input recipe yielding the swarm item — so
|
|
// giving `bait-swarm` ingredients would quietly stop it being a trap at all.
|
|
// Round 6: the FIREWALL joins the trap. It cans a live PARITY MITE the same way —
|
|
// an input-free recipe whose "input" is a creature in the world, not cargo on a belt.
|
|
const CATCHES_WILDLIFE = new Set(['bait-swarm', 'catch-mite']);
|
|
const bad = recipes.filter((r) => Object.keys(r.inputs).length === 0)
|
|
.filter((r) => !CATCHES_WILDLIFE.has(r.id))
|
|
.filter((r) => machines.find((m) => m.id === r.machine)?.kind !== 'extractor')
|
|
.map((r) => `${r.id} conjures items on non-extractor ${r.machine}`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('the trap keeps the shape LANE-SIM detects traps by', () => {
|
|
// src/sim/wildlife.test.ts: "The sim identifies traps by that recipe shape, not by a
|
|
// machine id." If this drifts, the trap silently becomes an ordinary crafter that
|
|
// conjures mosquitoes from nothing.
|
|
const trap = recipes.find((r) => r.id === 'bait-swarm')!;
|
|
expect(Object.keys(trap.inputs)).toEqual([]);
|
|
expect(trap.outputs['mosquito-swarm']).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('the firewall keeps the shape LANE-SIM detects wildlife-catchers by', () => {
|
|
// Round 6, coordinated with SIM: a firewall is spotted by recipe shape exactly like a
|
|
// trap — empty inputs, output is the canned creature (here the parity mite). Ingredients
|
|
// would silently demote it to an ordinary crafter that mints The Correction from nothing.
|
|
const fw = recipes.find((r) => r.id === 'catch-mite')!;
|
|
expect(Object.keys(fw.inputs)).toEqual([]);
|
|
expect(fw.outputs['parity-mite']).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('something can catch the parity mite the fax orders alive', () => {
|
|
// correction-specimen wants ONE UNIT OF THE CORRECTION, ALIVE. If nothing cans a mite,
|
|
// the fax opens an order it can never fill and never celebrates its first catch.
|
|
const catcher = recipes.find(
|
|
(r) => (r.outputs['parity-mite'] ?? 0) > 0 && Object.keys(r.inputs).length === 0);
|
|
expect(catcher, 'no input-free recipe cans a parity mite').toBeTruthy();
|
|
const wanters = commissions.filter((c) => (c.wants['parity-mite'] ?? 0) > 0).map((c) => c.id);
|
|
expect(wanters.length, 'no commission wants a canned mite').toBeGreaterThan(0);
|
|
});
|
|
|
|
it('every heat value is a 0..1 fraction per craft', () => {
|
|
const bad = recipes.filter((r) => r.heat !== undefined && !(r.heat >= 0 && r.heat <= 1))
|
|
.map((r) => `${r.id} -> heat ${r.heat}`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('tech', () => {
|
|
it('every era is a known era', () => {
|
|
const bad = tech.filter((t) => !ERAS.includes(t.era)).map((t) => `${t.id} -> "${t.era}"`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every cost is paid in items that exist, in whole positive counts', () => {
|
|
const bad: string[] = [];
|
|
for (const t of tech) {
|
|
for (const id of unknownItems(t.cost)) bad.push(`${t.id} costs unknown item "${id}"`);
|
|
for (const [id, n] of Object.entries(t.cost)) {
|
|
if (!Number.isInteger(n) || n < 1) bad.push(`${t.id} -> "${id}" count ${n}`);
|
|
}
|
|
if (Object.keys(t.cost).length === 0) bad.push(`${t.id} is free`);
|
|
}
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every unlock names a machine or a recipe that exists', () => {
|
|
const bad: string[] = [];
|
|
for (const t of tech) {
|
|
if (t.unlocks.length === 0) bad.push(`${t.id} unlocks nothing`);
|
|
for (const u of t.unlocks) {
|
|
if (!machineIds.has(u) && !recipeIds.has(u)) bad.push(`${t.id} unlocks unknown "${u}"`);
|
|
}
|
|
}
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('no two techs unlock the same thing', () => {
|
|
expect(duplicates(tech.flatMap((t) => t.unlocks))).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('commissions', () => {
|
|
it('every want names an item that exists', () => {
|
|
const bad: string[] = [];
|
|
for (const c of commissions) {
|
|
for (const id of unknownItems(c.wants)) bad.push(`${c.id} wants unknown item "${id}"`);
|
|
}
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every commission wants a whole positive quantity of something', () => {
|
|
const bad: string[] = [];
|
|
for (const c of commissions) {
|
|
if (Object.keys(c.wants).length === 0) bad.push(`${c.id} wants nothing`);
|
|
for (const [id, n] of Object.entries(c.wants)) {
|
|
if (!Number.isInteger(n) || n < 1) bad.push(`${c.id} -> "${id}" count ${n}`);
|
|
}
|
|
}
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every commission has fax text and a positive reward', () => {
|
|
const bad = commissions
|
|
.filter((c) => !c.flavor.trim() || !(c.rewardBandwidth > 0))
|
|
.map((c) => `${c.id} -> reward ${c.rewardBandwidth}`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('opens on the first rung of the ladder — the queue order is the tutorial', () => {
|
|
// Round 5: the head used to be 'first-taste' (one MELT), which asked a brand-new
|
|
// player to build the entire M1 chain before the first fax cleared. The teaching
|
|
// ladder now occupies the front of the queue; see 'the commission ladder' below.
|
|
expect(commissions[0].id).toBe('raw-payload');
|
|
});
|
|
|
|
it('rewards climb monotonically down the queue', () => {
|
|
const slips = commissions
|
|
.map((c, i) => ({ c, prev: commissions[i - 1] }))
|
|
.filter(({ c, prev }) => prev && c.rewardBandwidth < prev.rewardBandwidth)
|
|
.map(({ c, prev }) => `${c.id} (${c.rewardBandwidth}) pays less than ${prev.id} (${prev.rewardBandwidth})`);
|
|
expect(slips).toEqual([]);
|
|
});
|
|
|
|
it('has standing orders, and they are the ones that can actually repeat', () => {
|
|
const standing = commissions.filter((c) => c.repeat);
|
|
expect(standing.length).toBeGreaterThanOrEqual(2);
|
|
// A repeating order must be re-fillable forever: nothing it wants may be
|
|
// forward canon, or the factory jams on a standing order it can never clear.
|
|
const bad = standing
|
|
.flatMap((c) => Object.keys(c.wants).map((w) => ({ c, w })))
|
|
.filter(({ w }) => !producible().has(w))
|
|
.map(({ c, w }) => `standing order ${c.id} wants unproducible "${w}"`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
});
|
|
|
|
// The v4 gating rule ("a machine/recipe id in ANY TechDef.unlocks is locked until that
|
|
// tech completes") turned the tech tree from decoration into a lock on the whole game.
|
|
// It also turned three rounds of tech authoring into a bootstrap deadlock: every pack
|
|
// chain was gated behind packs you could not yet make, so 0 of 24 nodes were reachable
|
|
// and first-taste was impossible. These tests are why that can't come back.
|
|
describe('the bootstrap: what the player can do before researching anything', () => {
|
|
const gated = new Set(tech.flatMap((t) => t.unlocks));
|
|
/** Under the v4 rule a recipe is runnable only if neither it nor its machine is gated. */
|
|
const ungated = recipes.filter((r) => !gated.has(r.id) && !gated.has(r.machine));
|
|
|
|
/** Items reachable from a given set of runnable recipes. */
|
|
function reachableFrom(rs: RecipeDef[]): Set<string> {
|
|
const have = new Set<string>();
|
|
for (;;) {
|
|
const before = have.size;
|
|
for (const r of rs) {
|
|
if (Object.keys(r.inputs).every((i) => have.has(i))) {
|
|
for (const o of Object.keys(r.outputs)) have.add(o);
|
|
}
|
|
}
|
|
if (have.size === before) return have;
|
|
}
|
|
}
|
|
|
|
it('MELT is craftable at tick 0 — the opening commission must be possible', () => {
|
|
// first-taste wants 1 melt and is the head of the queue. If the melt chain is gated,
|
|
// the game opens on a commission the player cannot fill and research they cannot start.
|
|
expect([...reachableFrom(ungated)]).toContain('melt');
|
|
});
|
|
|
|
it('at least one science pack is craftable at tick 0, or research can never start', () => {
|
|
const day0 = reachableFrom(ungated);
|
|
const packs = items.filter((i) => i.id.endsWith('-pack')).map((i) => i.id);
|
|
const bootstrap = packs.filter((p) => day0.has(p));
|
|
expect(bootstrap.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('every tech is eventually affordable — no node is stranded behind its own output', () => {
|
|
// Walk the real loop: research what you can afford, which unlocks recipes, which makes
|
|
// more packs, which affords more research. Anything left over can never be bought.
|
|
const open = new Set(ungated.map((r) => r.id));
|
|
let have = reachableFrom(recipes.filter((r) => open.has(r.id)));
|
|
const unlocked = new Set<string>();
|
|
for (;;) {
|
|
let moved = false;
|
|
for (const t of tech) {
|
|
if (unlocked.has(t.id)) continue;
|
|
if (Object.keys(t.cost).every((c) => have.has(c))) {
|
|
unlocked.add(t.id);
|
|
for (const u of t.unlocks) {
|
|
for (const r of recipes) if (r.id === u || r.machine === u) open.add(r.id);
|
|
}
|
|
moved = true;
|
|
}
|
|
}
|
|
if (!moved) break;
|
|
have = reachableFrom(recipes.filter((r) => open.has(r.id)));
|
|
}
|
|
const stranded = tech
|
|
.filter((t) => !unlocked.has(t.id))
|
|
.map((t) => `${t.id} costs ${JSON.stringify(t.cost)} — unaffordable no matter what you build`);
|
|
expect(stranded).toEqual([]);
|
|
});
|
|
|
|
it('the lab is starting equipment', () => {
|
|
const labs = machines.filter((m) => m.kind === 'lab').map((m) => m.id);
|
|
const lockedLabs = labs.filter((id) => gated.has(id));
|
|
expect(lockedLabs).toEqual([]); // a lab behind research is a lab you can never build
|
|
});
|
|
});
|
|
|
|
describe('economy reachability', () => {
|
|
it('the M1 flow reaches MELT from raw ore', () => {
|
|
expect([...producible()]).toContain('melt');
|
|
});
|
|
|
|
it('every item is either producible or declared forward canon', () => {
|
|
// Forward canon: named in the codex and shippable one day, but nothing makes them yet.
|
|
// Keep this list short and delete entries as recipes land. Round 2 retired
|
|
// container-pack (the moov line exists now); wildlife needs traps, cinema needs
|
|
// the Fortress.
|
|
// Round 5 retired 'mosquito-swarm' — the trap catches them now, which finally makes
|
|
// `vaporwave-sunset` fillable after four rounds of wanting live mosquitoes.
|
|
const FORWARD_CANON = new Set([
|
|
'gibbs-wraith', // §6: must come "willingly". Nothing coerces one yet.
|
|
'cinema-pack', // needs the Fortress (§7).
|
|
'sodium-light', // §10: The Correction hoards the prisms.
|
|
]);
|
|
const have = producible();
|
|
const orphans = items
|
|
.map((i) => i.id)
|
|
.filter((id) => !have.has(id) && !FORWARD_CANON.has(id));
|
|
expect(orphans).toEqual([]);
|
|
});
|
|
|
|
it('the forward-canon allowlist has no stowaways', () => {
|
|
// The allowlist is a licence to be unreachable. The moment a recipe makes one of
|
|
// these, it must leave the list, or it stops proving anything.
|
|
const have = producible();
|
|
const retired = ['container-pack', 'mosquito-swarm'].filter((id) => !have.has(id));
|
|
expect(retired).toEqual([]);
|
|
});
|
|
|
|
it('no recipe is a free lunch: every craft that only recycles its own output loses something', () => {
|
|
const bad = recipes.filter((r) => {
|
|
const ids = Object.keys(r.outputs).filter((o) => r.inputs[o] !== undefined);
|
|
return ids.length > 0 && ids.every((o) => r.outputs[o] > r.inputs[o]) &&
|
|
Object.keys(r.inputs).every((i) => r.outputs[i] !== undefined);
|
|
}).map((r) => `${r.id} multiplies its own inputs`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------- the ground
|
|
//
|
|
// data/seams.json is consumed by SIM (an extractor only runs while its footprint
|
|
// overlaps a seam) and RENDER (era skins the ground). Nothing else in the repo knows
|
|
// where the ore is, so a bad rect here is an unmineable world.
|
|
|
|
interface SeamRect { x: number; y: number; w: number; h: number }
|
|
interface SeamDef {
|
|
id: string; era: TechDef['era']; resource: string;
|
|
rect: SeamRect; richness: number; hidden?: boolean;
|
|
}
|
|
const seams = seamsJson.seams as unknown as SeamDef[];
|
|
const relicReserve = seamsJson.relicReserve as unknown as SeamRect;
|
|
|
|
/** Do two tile rects touch? Both are inclusive of their min corner, w/h tiles wide. */
|
|
function rectsOverlap(a: SeamRect, b: SeamRect): boolean {
|
|
return !(a.x > b.x + b.w - 1 || a.x + a.w - 1 < b.x ||
|
|
a.y > b.y + b.h - 1 || a.y + a.h - 1 < b.y);
|
|
}
|
|
|
|
describe('seams', () => {
|
|
it('every seam has a unique kebab-case id and a known era', () => {
|
|
expect(duplicates(seams.map((s) => s.id))).toEqual([]);
|
|
const bad = seams
|
|
.filter((s) => !KEBAB.test(s.id) || !ERAS.includes(s.era))
|
|
.map((s) => `${s.id} -> era "${s.era}"`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every seam yields an item that exists', () => {
|
|
const bad = seams.filter((s) => !itemIds.has(s.resource)).map((s) => `${s.id} -> "${s.resource}"`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('every seam is a real rect inside the grid', () => {
|
|
// GRID_MIN/GRID_MAX are LANE-SIM's (src/sim/geom.ts). A seam outside them is ground
|
|
// the player can never stand on.
|
|
const bad: string[] = [];
|
|
for (const s of seams) {
|
|
const { x, y, w, h } = s.rect;
|
|
if (![x, y, w, h].every(Number.isInteger) || w < 1 || h < 1) bad.push(`${s.id} rect ${JSON.stringify(s.rect)}`);
|
|
if (x < -32 || y < -32 || x + w - 1 > 31 || y + h - 1 > 31) bad.push(`${s.id} out of the -32..31 grid`);
|
|
if (!(s.richness > 0 && s.richness <= 1)) bad.push(`${s.id} richness ${s.richness}`);
|
|
}
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('no two seams overlap — a tile belongs to one stratum', () => {
|
|
const clashes: string[] = [];
|
|
for (let i = 0; i < seams.length; i++) {
|
|
for (let j = i + 1; j < seams.length; j++) {
|
|
if (rectsOverlap(seams[i].rect, seams[j].rect)) clashes.push(`${seams[i].id} / ${seams[j].id}`);
|
|
}
|
|
}
|
|
expect(clashes).toEqual([]);
|
|
});
|
|
|
|
it('the relic reserve is genuinely seam-free', () => {
|
|
// SIM plants the optical fossil 18-28 tiles out, "never on a seam". If seams creep
|
|
// into the reserved corner there may be nowhere legal left to put it.
|
|
const intruders = seams.filter((s) => rectsOverlap(s.rect, relicReserve)).map((s) => s.id);
|
|
expect(intruders).toEqual([]);
|
|
});
|
|
|
|
it('the reference factory stands on ore', () => {
|
|
// SIM's reference factory puts three 2x2 extractors here. Off-seam they idle with
|
|
// 'no seam' and the whole demo produces nothing.
|
|
const REFERENCE_EXTRACTORS = [{ x: -30, y: 0 }, { x: -30, y: -3 }, { x: -30, y: 3 }];
|
|
const stranded = REFERENCE_EXTRACTORS
|
|
.filter((e) => !seams.some((s) => rectsOverlap(s.rect, { x: e.x, y: e.y, w: 2, h: 2 })))
|
|
.map((e) => `extractor at (${e.x},${e.y}) is off-seam`);
|
|
expect(stranded).toEqual([]);
|
|
});
|
|
|
|
it('there are hidden bonus seams for the numbers station to point at', () => {
|
|
expect(seams.filter((s) => s.hidden).length).toBeGreaterThanOrEqual(2);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------- the band
|
|
|
|
describe('stations', () => {
|
|
const stations = stationsJson.stations as unknown as Array<Record<string, any>>;
|
|
const byId = (id: string) => stations.find((s) => s.id === id)!;
|
|
|
|
it('every station has a unique id, a known band and a positive frequency', () => {
|
|
expect(duplicates(stations.map((s) => s.id as string))).toEqual([]);
|
|
const bad = stations
|
|
.filter((s) => !KEBAB.test(s.id) || !['AM', 'FM', 'SW'].includes(s.band) || !(s.freq > 0))
|
|
.map((s) => `${s.id} -> ${s.band} ${s.freq}`);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('no two stations sit on the same spot on the dial', () => {
|
|
const dial = stations.map((s) => `${s.band} ${s.freq}`);
|
|
expect(duplicates(dial)).toEqual([]);
|
|
});
|
|
|
|
it('every station has a name, a format tag and a line of flavor', () => {
|
|
const bad = stations
|
|
.filter((s) => !String(s.name).trim() || !String(s.format).trim() || !String(s.flavor).trim())
|
|
.map((s) => s.id as string);
|
|
expect(bad).toEqual([]);
|
|
});
|
|
|
|
it('THE STANDARD can broadcast for ten minutes without repeating itself', () => {
|
|
// At the ~20s a chyron line needs to be readable, ten minutes is 30 lines.
|
|
const lines = byId('the-standard').chyron as string[];
|
|
expect(lines.length).toBeGreaterThanOrEqual(30);
|
|
expect(duplicates(lines)).toEqual([]);
|
|
expect(lines.filter((l) => !l.trim())).toEqual([]);
|
|
});
|
|
|
|
it('the numbers station really does encode the hidden seams', () => {
|
|
// The treasure map has to point at treasure. Recompute the planted groups from
|
|
// seams.json: if a hidden seam moves and the broadcast does not, this fails.
|
|
const n = byId('numbers').numbers;
|
|
const encode = (s: SeamDef) =>
|
|
String(s.rect.x + 32).padStart(2, '0') +
|
|
String(s.rect.y + 32).padStart(2, '0') +
|
|
String(Math.round(s.richness * 9));
|
|
const expected = seams.filter((s) => s.hidden).map(encode).sort();
|
|
expect([...(n.plantedGroups as string[])].sort()).toEqual(expected);
|
|
});
|
|
|
|
it('every broadcast group is the right shape, and the decoys lead nowhere', () => {
|
|
const n = byId('numbers').numbers;
|
|
const groups = [...(n.plantedGroups as string[]), ...(n.decoyPool as string[])];
|
|
const malformed = groups.filter((g) => !new RegExp(`^[0-9]{${n.groupSize}}$`).test(g));
|
|
expect(malformed).toEqual([]);
|
|
expect(duplicates(groups)).toEqual([]);
|
|
|
|
// A decoy that decodes onto ANY seam — hidden OR visible — isn't a decoy, it's a leak:
|
|
// it hands the player a real dig site the station never meant to give away. Round 6:
|
|
// the old check only guarded the three hidden 1x1 tiles, and two decoys (08127, 27503)
|
|
// were quietly sitting on reel-beds-deep and broadcast-shelf-south. Now every decoy is
|
|
// decoded to a tile and checked against every seam rect, and the leak is named.
|
|
const point = (x: number, y: number): SeamRect => ({ x, y, w: 1, h: 1 });
|
|
const leaks = (n.decoyPool as string[])
|
|
.map((g) => ({ g, x: Number(g.slice(0, 2)) - 32, y: Number(g.slice(2, 4)) - 32 }))
|
|
.flatMap(({ g, x, y }) =>
|
|
seams
|
|
.filter((s) => rectsOverlap(point(x, y), s.rect))
|
|
.map((s) => `decoy ${g} decodes to (${x},${y}), inside real seam ${s.id}`));
|
|
expect(leaks).toEqual([]);
|
|
});
|
|
|
|
it('dead air has its one ghost', () => {
|
|
const ghost = byId('dead-air').ghost;
|
|
expect(String(ghost.line).trim().length).toBeGreaterThan(0);
|
|
expect(ghost.everyMinutes).toBeGreaterThan(0);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------- the ladder
|
|
//
|
|
// The fax is the tutorial. The first four commissions teach one mechanic each, in
|
|
// order, and the first one has to be completable by someone who has never seen the
|
|
// game. These guard the teaching order the way the tick-0 guard protects the bootstrap.
|
|
|
|
describe('the commission ladder', () => {
|
|
const gated = new Set(tech.flatMap((t) => t.unlocks));
|
|
const ungatedRecipes = recipes.filter((r) => !gated.has(r.id) && !gated.has(r.machine));
|
|
|
|
/**
|
|
* The smallest set of machine types that can produce `target` from bare ground at
|
|
* tick 0, or null if nothing ungated makes it. Fixpoint over recipes, keeping the
|
|
* cheapest producer for each item — "how many different machines must a new player
|
|
* build to fill this order".
|
|
*/
|
|
const cheapest = new Map<string, Set<string>>();
|
|
for (;;) {
|
|
let improved = false;
|
|
for (const r of ungatedRecipes) {
|
|
const inputs = Object.keys(r.inputs);
|
|
if (!inputs.every((i) => cheapest.has(i))) continue;
|
|
const need = new Set<string>([r.machine]);
|
|
for (const i of inputs) for (const m of cheapest.get(i)!) need.add(m);
|
|
for (const o of Object.keys(r.outputs)) {
|
|
const known = cheapest.get(o);
|
|
if (!known || need.size < known.size) { cheapest.set(o, need); improved = true; }
|
|
}
|
|
}
|
|
if (!improved) break;
|
|
}
|
|
const machinesToMake = (target: string): Set<string> | null => cheapest.get(target) ?? null;
|
|
|
|
const RUNGS = ['raw-payload', 'first-refinement', 'dust-quota', 'first-taste'];
|
|
|
|
it('opens on the teaching ladder, in teaching order', () => {
|
|
expect(commissions.slice(0, RUNGS.length).map((c) => c.id)).toEqual(RUNGS);
|
|
});
|
|
|
|
it('rung 1 is buildable at tick 0 out of a handful of machines', () => {
|
|
// "A belt, a drill, an uplink." If rung 1 needs research or a deep chain, the game
|
|
// opens by asking a new player for something they cannot possibly make.
|
|
const rung1 = commissions[0];
|
|
for (const want of Object.keys(rung1.wants)) {
|
|
const needed = machinesToMake(want);
|
|
expect(needed, `rung 1 wants ${want}, which cannot be made at tick 0`).not.toBeNull();
|
|
// + the belt and the uplink, which carry it but craft nothing.
|
|
expect(needed!.size, `rung 1 should need few machine types, needs ${[...needed!]}`)
|
|
.toBeLessThanOrEqual(2);
|
|
}
|
|
});
|
|
|
|
it('every rung is craftable at tick 0 — the tutorial never gates itself', () => {
|
|
const blocked: string[] = [];
|
|
for (const id of RUNGS) {
|
|
const c = commissions.find((x) => x.id === id)!;
|
|
for (const want of Object.keys(c.wants)) {
|
|
if (machinesToMake(want) === null) blocked.push(`${id} wants ${want}, unmakeable at tick 0`);
|
|
}
|
|
}
|
|
expect(blocked).toEqual([]);
|
|
});
|
|
|
|
it('each rung teaches strictly more machinery than the one before', () => {
|
|
// The ladder should climb. If a later rung needs no more than an earlier one, it is
|
|
// not teaching anything new and the slot is wasted.
|
|
const depth = RUNGS.map((id) => {
|
|
const c = commissions.find((x) => x.id === id)!;
|
|
return Math.max(...Object.keys(c.wants).map((w) => machinesToMake(w)?.size ?? 0));
|
|
});
|
|
const flat = depth.slice(1).map((d, i) => ({ d, prev: depth[i], id: RUNGS[i + 1] }))
|
|
.filter(({ d, prev }) => d <= prev)
|
|
.map(({ id, d, prev }) => `${id} needs ${d} machine types, no more than the rung before (${prev})`);
|
|
expect(flat).toEqual([]);
|
|
});
|
|
|
|
it('the ladder is cheap and the rewards climb', () => {
|
|
const rungs = RUNGS.map((id) => commissions.find((x) => x.id === id)!);
|
|
// Rewards ascend across the ladder and none of the tutorial rungs out-pays the
|
|
// ordinary queue that follows.
|
|
for (let i = 1; i < rungs.length; i++) {
|
|
expect(rungs[i].rewardBandwidth).toBeGreaterThan(rungs[i - 1].rewardBandwidth);
|
|
}
|
|
expect(rungs[rungs.length - 1].rewardBandwidth).toBeLessThan(commissions[RUNGS.length].rewardBandwidth);
|
|
// No standing orders in the tutorial — a repeating rung would never let the player
|
|
// off the first step.
|
|
expect(rungs.filter((c) => c.repeat).map((c) => c.id)).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('the cooler pairing', () => {
|
|
const soft = machines.find((m) => m.id === 'software-decoder')!;
|
|
const cooler = machines.find((m) => m.id === 'asic-cooler')!;
|
|
const cool = (m: MachineDef) => m.coolPerTick ?? HEAT_COOL_DEFAULT;
|
|
/** Contracts v5: auras are ADDITIVE, capped at HEAT_COOL_MAX. */
|
|
const withCoolers = (n: number) =>
|
|
Math.min(cool(soft) + n * cooler.coolPerTick!, HEAT_COOL_MAX);
|
|
const duty = (c: number) => {
|
|
const net = soft.heatPerTick! - c;
|
|
if (net <= 0) return 1; // never heats
|
|
const up = (1 - HEAT_RESTART) / net;
|
|
return up / (up + (1 - HEAT_RESTART) / c);
|
|
};
|
|
|
|
it('one cooler is a real upgrade, not a rounding error', () => {
|
|
expect(duty(withCoolers(1))).toBeGreaterThan(duty(withCoolers(0)) * 1.5);
|
|
});
|
|
|
|
it('a bare decoder still throttles, and one cooler does not make it immortal', () => {
|
|
// The codex's decoder "throttles theatrically" — that is its whole character. A
|
|
// single cooler must not switch the mechanic off.
|
|
expect(soft.heatPerTick!).toBeGreaterThan(withCoolers(0));
|
|
expect(soft.heatPerTick!).toBeGreaterThan(withCoolers(1));
|
|
});
|
|
|
|
it('immortality costs an absurd shrine of coolers, not a casual pair', () => {
|
|
expect(soft.heatPerTick!).toBeGreaterThan(withCoolers(2)); // two is not enough
|
|
expect(withCoolers(3)).toBeGreaterThanOrEqual(soft.heatPerTick!); // three is
|
|
});
|
|
});
|