Jesse.MarkowitzandClaude Opus 5
7ade60e21f
Gitea#22: the Division map drew every westbound train in the wrong half of its Mainline card. `regionOfTransit` counts from the end a train entered, which is what the collision rules ask; the map wanted "which printed box, left to right" and used the same number, so an eastbound train came out right by luck and a westbound one came out mirrored. It cost a collision — Train 3 was cleared to follow T5 and ran into TX17, which the picture had drawn ahead of T5 rather than behind it. One mirror in `view.ts`, at the boundary the map is drawn from; the collision rules are untouched. Gitea#21: a second tank car would not come off at a refinery, and "Blocked — why nothing is moving" answered by describing the refinery's green box. The real answer was Train 3's printed rule — the Express works one freight car per location — so the refusal was correct and the panel sent the player to spend a Freight Agent action that could not have helped. No rule changed. The panel now names the budget, asking the reducer's own predicate so its words cannot drift from the rule. Both were replayed from the saves attached to the issues and verified in the exact position each report names. The map fix is proved by mutation: reverting the mirror fails two tests, and making the renderer ignore the region fails a third. Every existing region test ran eastbound, where the mirror is the identity, which is why the bug survived them. 891 tests pass, up from 884. Closes #21 Closes #22 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01E3Qk7uresKCHksdZajXCLg
679 lines
34 KiB
TypeScript
679 lines
34 KiB
TypeScript
/**
|
|
* Component 16 — replay viewer.
|
|
*
|
|
* The important test here is narration coverage: adding an event type without narrating it should
|
|
* fail the build rather than quietly degrading the replay into "something happened".
|
|
*/
|
|
|
|
import { describe, it } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
|
|
import { pump } from '../src/engine/advance.ts';
|
|
import { DEFAULT_MAX_COLLISIONS_PER_DAY, DEFAULT_MAX_COLLISIONS_TOTAL, collectiveRevenueFloor } from '../src/engine/content.ts';
|
|
import type { GameEvent } from '../src/engine/events.ts';
|
|
import { areaOf } from '../src/engine/apply.ts';
|
|
import { createGame } from '../src/engine/setup.ts';
|
|
import { coordKey, turnOf } from '../src/engine/state.ts';
|
|
import type { GameConfig, GameState, GridCoord } from '../src/engine/state.ts';
|
|
import { developerBot, playGame } from '../src/sim/bot.ts';
|
|
import { impediments, isVisible, narrate, phaseLabel } from '../src/sim/narrate.ts';
|
|
import { compress, rehydrateCells, record, renderHtml } from '../src/sim/replay.ts';
|
|
import { summarize } from '../src/sim/stats.ts';
|
|
|
|
// Mirrors `record()`'s own default exactly (`replay.ts`) — "does not drift from the engine" below
|
|
// plays the same seed through both paths and compares outcomes, so they must share one floor.
|
|
const config: GameConfig = {
|
|
mode: 'solitaire',
|
|
days: 5,
|
|
minCombinedRevenue: collectiveRevenueFloor(1, 5),
|
|
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
|
maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
|
|
pvpCardsAllowed: false,
|
|
optionalRules: {
|
|
reducedVisibility: false,
|
|
employeeRotation: false,
|
|
emergencyToolbox: false,
|
|
},
|
|
};
|
|
|
|
/** One representative instance of every event type the engine can emit. */
|
|
const SAMPLES: GameEvent[] = [
|
|
{ type: 'stageBegan', day: 1, stage: 7 },
|
|
{ type: 'phaseBegan', phase: 'mainline' },
|
|
{ type: 'actorChanged', player: 0 },
|
|
{ type: 'localOpsOptionChosen', player: 0, option: 'switch' },
|
|
{ type: 'trayMoved', trayId: 't0', from: { row: 0, col: 0 }, to: { row: 0, col: 1 }, movesRemaining: 5 },
|
|
{ type: 'carsCoupled', trayId: 't0', at: { row: 0, col: 1 }, stock: [{ type: 'hopper', loaded: false }], from: [{ row: 0, col: 1 }], toNose: true },
|
|
{ type: 'carsDropped', trayId: 't0', at: { row: 1, col: 0 }, stock: [{ type: 'hopper', loaded: false }] },
|
|
{ type: 'cardDrawn', player: 0, source: 'homeOffice', cardId: 'c1' },
|
|
{ type: 'cardPlayed', player: 0, cardId: 'c1', placement: { row: 1, col: 0 }, variant: 0 },
|
|
{ type: 'officeUpgraded', player: 0, from: 'whistlePost', to: 'depot' },
|
|
{ type: 'cardDiscarded', player: 0, cardId: 'c1', toSlot: 1 },
|
|
{ type: 'deckReshuffled', order: ['c1', 'c2', 'c3', 'c4'], rngState: 7 },
|
|
{ type: 'departmentRefilled', slot: 0, cardId: 'c2' },
|
|
{ type: 'stockToOutbound', player: 0, at: { row: 1, col: 0 }, stock: { type: 'hopper', loaded: true } },
|
|
{ type: 'inboundCleared', player: 0, at: { row: 1, col: 0 }, stock: { type: 'hopper', loaded: true } },
|
|
{ type: 'facilityUnjammed', player: 0, at: { row: 1, col: 0 }, from: 'menAtWork', stock: { type: 'hopper', loaded: true } },
|
|
{ type: 'trainScheduled', player: 0, trainNumber: 4, roll: 7, slot: 6, rngState: 1 },
|
|
{ type: 'carPlacedOnTrain', player: 0, trayId: 't0', stock: { type: 'coach', loaded: false } },
|
|
{ type: 'carPassed', player: 0, trayId: 't0' },
|
|
{ type: 'clearanceRequested', trainId: 't1', occupiedBy: 't0' },
|
|
{ type: 'clearanceGiven', trainId: 't1', allow: false },
|
|
{ type: 'passengersBoarded', player: 0, at: { row: 0, col: 0 }, trayId: 't0', coachIndex: 0 },
|
|
{ type: 'passengersDetrained', player: 0, at: { row: 0, col: 0 }, trayId: 't0', coachIndex: 0 },
|
|
{ type: 'loadStarted', player: 0, at: { row: 1, col: 0 }, carType: 'hopper' },
|
|
{ type: 'loadAdvanced', player: 0, at: { row: 1, col: 0 }, fromBox: 0, toBox: 1 },
|
|
{ type: 'unloadCompleted', player: 0, at: { row: 1, col: 0 }, carType: 'hopper' },
|
|
{ type: 'loadCompleted', player: 0, at: { row: 1, col: 0 }, carType: 'hopper' },
|
|
{ type: 'unloadBegan', player: 0, at: { row: 1, col: 0 }, carType: 'hopper', carIndex: 0 },
|
|
{ type: 'revenueChanged', player: 0, delta: 1, total: 3, reason: 'freightLoad' },
|
|
{ type: 'phaseEnded', player: 0, phase: 'localOps' },
|
|
];
|
|
|
|
describe('narration', () => {
|
|
it('covers every event type the engine can emit', () => {
|
|
// Guards against a new event type slipping in unnarrated.
|
|
const covered = new Set(SAMPLES.map((e) => e.type));
|
|
const declared = new Set<string>();
|
|
for (const e of SAMPLES) declared.add(e.type);
|
|
assert.equal(covered.size, 30, 'sample list is out of step with GameEvent');
|
|
assert.equal(declared.size, 30);
|
|
});
|
|
|
|
it('gives every event a specific, non-empty sentence', () => {
|
|
for (const e of SAMPLES) {
|
|
const n = narrate(e);
|
|
assert.ok(n.text.length > 3, `${e.type} produced no useful text`);
|
|
assert.ok(!/^\[/.test(n.text), `${e.type} fell through to a fallback`);
|
|
assert.ok(['plain', 'good', 'bad', 'clock', 'quiet', 'phase'].includes(n.tone), `${e.type} bad tone`);
|
|
}
|
|
});
|
|
|
|
it('marks revenue gains good and losses bad', () => {
|
|
const gain = narrate({ type: 'revenueChanged', player: 0, delta: 1, total: 1, reason: 'boarding' });
|
|
const loss = narrate({
|
|
type: 'revenueChanged', player: 0, delta: -5, total: -5, reason: 'collision: no free A/D track',
|
|
});
|
|
assert.equal(gain.tone, 'good');
|
|
assert.equal(loss.tone, 'bad');
|
|
assert.match(loss.text, /COLLISION/i);
|
|
});
|
|
|
|
it('points at the board cell where something happened', () => {
|
|
const n = narrate({ type: 'loadCompleted', player: 0, at: { row: 1, col: 2 }, carType: 'hopper' });
|
|
assert.deepEqual(n.where, { row: 1, col: 2 });
|
|
});
|
|
|
|
it('names phases in words rather than identifiers', () => {
|
|
assert.equal(phaseLabel('loadUnload'), 'Cargo');
|
|
assert.equal(phaseLabel('newTrain'), 'New Train');
|
|
assert.equal(phaseLabel('shiftChange'), 'Supervisor Shift');
|
|
assert.equal(phaseLabel('localOps'), 'Local Operations');
|
|
assert.equal(phaseLabel('mainline'), 'Mainline');
|
|
});
|
|
|
|
it('hides only the events with nothing to show', () => {
|
|
assert.equal(isVisible({ type: 'actorChanged', player: 0 }), false);
|
|
assert.equal(isVisible({ type: 'loadCompleted', player: 0, at: { row: 0, col: 0 }, carType: 'hopper' }), true);
|
|
});
|
|
});
|
|
|
|
describe('impediments', () => {
|
|
it('reports nothing blocked on a fresh game', () => {
|
|
const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
|
|
assert.deepEqual(impediments(s, 0), []);
|
|
});
|
|
|
|
it('warns when every A/D track is occupied', () => {
|
|
// Gap 2d — the next arrival is an automatic collision.
|
|
const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
|
|
s.officeAreas.get(0)!.adOccupancy = ['t0'];
|
|
const found = impediments(s, 0);
|
|
assert.ok(found.some((b) => /A\/D/.test(b.why) && b.severity === 'risk'));
|
|
});
|
|
|
|
it('reports a train held for want of a Crew Tray', () => {
|
|
const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
|
|
s.timetable[s.clock.stage - 1] = 4;
|
|
s.freeTrays = [];
|
|
assert.ok(impediments(s, 0).some((b) => /HELD/.test(b.why)));
|
|
});
|
|
|
|
/** A crew standing on `at`, working the given train, with one empty tank car on the drawbar. */
|
|
const express = (s: GameState, trainNumber: number, at: GridCoord): string => {
|
|
const id = s.freeTrays.pop()!;
|
|
s.trays.set(id, {
|
|
id, trainNumber, trainIsExtra: false, engineAt: 0,
|
|
consist: [{ type: 'tank', loaded: false, origin: 0 }],
|
|
direction: 'east', position: { at: 'grid', seat: 0, coord: at }, movesUsed: 0,
|
|
});
|
|
return id;
|
|
};
|
|
|
|
/**
|
|
* GITEA#21 — THE GAME REFUSED, AND THE PANEL EXPLAINED SOMETHING ELSE.
|
|
*
|
|
* "I wanted to drop two empty tank cars so that the freight agents and men at work could load
|
|
* them later. I dropped the first tank car, but that was all I was allowed to do. Checked
|
|
* 'Blocked — why nothing is moving' and saw: refinery 1,0 — green box empty — nothing to load
|
|
* (needs a Freight Agent action)."
|
|
*
|
|
* Replayed from the attached save (seed 550943578, 181 intents): the crew was Train 3, and the
|
|
* engine's answer was `FREIGHT_WORKED_HERE`. Train 3 is the Express, and the Express prints "May
|
|
* drop or pick up one freight car at every location" — so THE REFUSAL WAS CORRECT and the rule
|
|
* is not what is wrong here. It resets next turn, and the Express may work a car at the next
|
|
* square this turn; that is what makes it an Express rather than a one-car-a-Stage train.
|
|
*
|
|
* What was wrong is that nothing said so. The panel whose entire job is "why is nothing moving?"
|
|
* listed the refinery's green box — a true statement about the FACILITY, and nothing to do with
|
|
* why the drop was refused — so the player was sent to fix a Freight Agent action that would not
|
|
* have helped. The rule was on the train card's own tooltip, which is not where somebody looks
|
|
* when a button they expected is missing.
|
|
*
|
|
* The panel is where a refusal gets explained, so the budget belongs in it.
|
|
*/
|
|
it('says when the Express has spent its one freight car on this square (Gitea#21)', () => {
|
|
const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
|
|
const area = areaOf(s, 0);
|
|
const at = area.officeCoord;
|
|
|
|
// A crew standing at the Office working Train 3 — the Express — with a tank car still on it.
|
|
const trayId = express(s, 3, at);
|
|
|
|
s.clock.phase = 'localOps';
|
|
const turn = turnOf(s, 0);
|
|
turn.option = 'switch';
|
|
|
|
// Nothing to say before it has worked anything here.
|
|
assert.ok(
|
|
!impediments(s, 0).some((b) => /FREIGHT CAR PER LOCATION/i.test(b.why)),
|
|
'the budget was reported spent before the train had worked a car at all',
|
|
);
|
|
|
|
// Now it has set one car out here — exactly the state the save is in at intent 181.
|
|
turn.freightWorked[`${trayId}@${coordKey(at)}`] = 1;
|
|
|
|
const row = impediments(s, 0).find((b) => /FREIGHT CAR PER LOCATION/i.test(b.why));
|
|
assert.ok(
|
|
row,
|
|
`nothing explained the refusal:\n${JSON.stringify(impediments(s, 0), null, 2)}`,
|
|
);
|
|
// It must name the train, or a player with three crews out cannot tell which one it means.
|
|
assert.match(row!.where, /Train 3/);
|
|
// And it must say the limit lifts, or it reads as "this train can never work here again".
|
|
assert.match(row!.why, /turn/i);
|
|
// Amber: this is the printed rule doing its job, not a fault.
|
|
assert.equal(row!.severity, 'waiting');
|
|
});
|
|
|
|
it('leaves every other train alone — the rule is printed on 3 and 4 only (Gitea#21)', () => {
|
|
const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
|
|
const area = areaOf(s, 0);
|
|
const at = area.officeCoord;
|
|
// Train 5 is The Sparrow, which prints no per-location freight limit.
|
|
const trayId = express(s, 5, at);
|
|
s.clock.phase = 'localOps';
|
|
turnOf(s, 0).option = 'switch';
|
|
turnOf(s, 0).freightWorked[`${trayId}@${coordKey(at)}`] = 1;
|
|
|
|
assert.ok(
|
|
!impediments(s, 0).some((b) => /FREIGHT CAR PER LOCATION/i.test(b.why)),
|
|
'a train with no such rule was told it had spent a budget it does not have',
|
|
);
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Gitea#2 — "four porters, two passengers on the platform, and I never get the chance to work them."
|
|
*
|
|
* The engine was faithful at every step; what was missing was any way to SEE why. A Porter action
|
|
* that cannot be taken is simply absent from the menu, and this panel — the one that answers "why is
|
|
* nothing moving?" — opened with `f.kind !== 'freight'`, so a platform had never had anything to say
|
|
* for itself at all.
|
|
*/
|
|
describe('a blocked platform says why (Gitea#2)', () => {
|
|
/** Raise the Whistle Post to a working Terminal: the tier's printed numbers, applied directly. */
|
|
function platform(s: GameState) {
|
|
const area = areaOf(s, 0);
|
|
area.tier = 'terminal';
|
|
const card = area.grid.get(coordKey(area.officeCoord))!;
|
|
const f = card.facility!;
|
|
f.allows = { outbound: true, inbound: true };
|
|
f.porters = 3;
|
|
f.capacity = { outbound: 3, inbound: 3 };
|
|
return { area, f };
|
|
}
|
|
|
|
/** A tray standing on an A/D track at the Office, carrying whatever it is given. */
|
|
function atOffice(s: GameState, consist: { type: 'coach'; loaded: boolean; origin?: number }[]): void {
|
|
const area = areaOf(s, 0);
|
|
const id = s.freeTrays.pop()!;
|
|
s.trays.set(id, {
|
|
id, trainNumber: null, trainIsExtra: false, engineAt: 0, consist,
|
|
direction: 'east', position: { at: 'grid', seat: 0, coord: area.officeCoord }, movesUsed: 0,
|
|
});
|
|
area.adOccupancy.push(id);
|
|
}
|
|
|
|
it('reports passengers standing on a platform with no train to take them', () => {
|
|
// The whole of the bug's second half: before this, `impediments` returned an EMPTY list here.
|
|
const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
|
|
const { f } = platform(s);
|
|
f.outboundBox = [{ type: 'coach', loaded: true }];
|
|
const found = impediments(s, 0);
|
|
const platformRow = found.find((b) => /platform/.test(b.why));
|
|
assert.ok(platformRow, `nothing reported for the platform:\n${JSON.stringify(found, null, 2)}`);
|
|
assert.match(platformRow.why, /passengers waiting, no train at the platform/);
|
|
assert.equal(platformRow.severity, 'waiting');
|
|
});
|
|
|
|
it('names the Office by its tier rather than the word "facility"', () => {
|
|
// A Passenger Facility rides on the `office` card, so the freight branch's `geometry.facility`
|
|
// is not there to read and every passenger row read `facility 0,0` next to `mineTipple 1,-3`.
|
|
const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
|
|
const { f } = platform(s);
|
|
f.outboundBox = [{ type: 'coach', loaded: true }];
|
|
const row = impediments(s, 0).find((b) => /platform/.test(b.why))!;
|
|
assert.match(row.where, /^terminal /, `the Office is unnamed: ${row.where}`);
|
|
});
|
|
|
|
it('explains the coach shortage that made the game look broken', () => {
|
|
// The reported state: a train in with passengers to set down, red slots free, four porters —
|
|
// and §9.2 needs a white coach out of the Division Yard to swap in. There was none, with eight
|
|
// more sitting in the Classification Yard that §2.2 returns only when the Division Yard is BARE.
|
|
const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
|
|
const { f } = platform(s);
|
|
atOffice(s, [{ type: 'coach', loaded: true, origin: 1 }]);
|
|
s.yards.divisionYard = s.yards.divisionYard.filter((c) => !(c.type === 'coach' && !c.loaded));
|
|
s.yards.classificationYard = [
|
|
{ type: 'coach', loaded: false },
|
|
{ type: 'coach', loaded: false },
|
|
];
|
|
const row = impediments(s, 0).find((b) => /§9\.2/.test(b.why));
|
|
assert.ok(row, `the coach shortage was not explained:\n${JSON.stringify(impediments(s, 0), null, 2)}`);
|
|
assert.equal(row.severity, 'stuck', 'a train that cannot be emptied is stuck, not merely waiting');
|
|
assert.match(row.why, /2 coaches are in the Classification Yard/, `where the coaches are is not said: ${row.why}`);
|
|
assert.match(row.why, /Classification returns only when the Division Yard is bare/);
|
|
assert.ok(f.inboundBox.length === 0, 'the red slots were free — the shortage is the only cause');
|
|
});
|
|
|
|
it('says why the game ended in words, not as a raw enum (TODO #34)', () => {
|
|
/**
|
|
* The heading read `loss — revenueFloor` — the exact defect Gitea#16 was filed about on the
|
|
* playable page, still alive here a release after that was fixed, because nothing
|
|
* player-facing pointed at the developer replay. It shares `reasonSentence` with the results
|
|
* screen now, so the two cannot explain one ending in two ways.
|
|
*/
|
|
const rec = record(1234, 'standard');
|
|
for (const raw of ['revenueFloor', 'daysElapsed', 'collisionFloor']) {
|
|
assert.ok(!rec.outcome.includes(raw), `the summary still prints the raw reason "${raw}"`);
|
|
}
|
|
assert.doesNotMatch(rec.outcome, /<[^>]+>/, 'markup leaked into a heading and a console line');
|
|
assert.match(rec.outcome, /Revenue/, 'the summary says nothing about how the game went');
|
|
// And the sentence is the shared one, with this game's own numbers in it.
|
|
assert.match(rec.outcome, /closed short|last on the timetable|declared unsafe/,
|
|
'the ending is not explained in the words the results screen uses');
|
|
});
|
|
|
|
it('says nothing about a platform that is working fine', () => {
|
|
// Passengers waiting AND a train with an empty coach to take them: no impediment.
|
|
const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
|
|
const { f } = platform(s);
|
|
f.outboundBox = [{ type: 'coach', loaded: true }];
|
|
atOffice(s, [{ type: 'coach', loaded: false }]);
|
|
const found = impediments(s, 0).filter((b) => /platform|§9\.2|Porters/.test(b.why));
|
|
assert.deepEqual(found, [], `a working platform reported an impediment:\n${JSON.stringify(found, null, 2)}`);
|
|
});
|
|
});
|
|
|
|
describe('replay recording', () => {
|
|
const rec = record(1234, 'standard');
|
|
|
|
it('produces frames', () => {
|
|
assert.ok(rec.frames.length > 50, `only ${rec.frames.length} frames`);
|
|
});
|
|
|
|
it('never runs time backwards', () => {
|
|
let prev = 0;
|
|
for (const f of rec.frames) {
|
|
const t = f.day * 100 + f.stage;
|
|
assert.ok(t >= prev, `time went backwards at Day ${f.day} Stage ${f.stage}`);
|
|
prev = t;
|
|
}
|
|
});
|
|
|
|
it('always shows the Office card', () => {
|
|
for (const f of rec.frames) {
|
|
assert.ok(f.cells.some((c) => c.kind === 'office'), 'a frame lost the Office');
|
|
}
|
|
});
|
|
|
|
it('does not drift from the engine', () => {
|
|
// A replay that disagrees with the engine is worse than no replay. Replay the same seed
|
|
// through the normal bot path and compare the end state.
|
|
const s = createGame({ id: 'x', seed: 1234, config, playerNames: ['player'] });
|
|
const r = playGame(s, developerBot, pump);
|
|
const stats = summarize(1234, r.events, r.intents, s);
|
|
|
|
const last = rec.frames[rec.frames.length - 1]!;
|
|
assert.equal(last.revenue, stats.revenue.net, 'final revenue disagrees with the engine');
|
|
assert.equal(last.day, s.clock.day, 'final Day disagrees with the engine');
|
|
// The summary says "won"/"lost" rather than the engine's `win`/`loss` (TODO #34 — it is a
|
|
// sentence for a reader now, not an enum). Mapped here so this still checks the two AGREE,
|
|
// which is what the test is for, rather than checking they are spelled the same.
|
|
assert.match(rec.outcome, new RegExp(stats.result === 'win' ? 'won' : 'lost'));
|
|
});
|
|
|
|
it('narrates every frame', () => {
|
|
for (const f of rec.frames) {
|
|
assert.ok(f.lines.length > 0, 'a frame has no narration');
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('replay HTML', () => {
|
|
const html = renderHtml(record(99, 'short'));
|
|
|
|
it('is a complete standalone document', () => {
|
|
assert.match(html, /^<!doctype html>/i);
|
|
assert.match(html, /<\/html>\s*$/);
|
|
});
|
|
|
|
it('embeds no external resources', () => {
|
|
// A strict requirement: the file must open anywhere, offline.
|
|
const externals = html.match(/(?:src|href)\s*=\s*"(?!#)[^"]+"/g) ?? [];
|
|
assert.deepEqual(externals, [], `external references: ${externals.join(', ')}`);
|
|
});
|
|
|
|
it('embeds the frame data and the dictionaries it is packed against', () => {
|
|
// The frames are packed now: a card's identity and its description are written once into
|
|
// CARDS/WHATS and referenced by integer. A page with FRAMES but no dictionaries would draw an
|
|
// empty board rather than fail, so all three are checked.
|
|
assert.match(html, /const PACKED = \{/);
|
|
assert.match(html, /FRAMES = PACKED\.frames/);
|
|
assert.match(html, /CARDS = PACKED\.cards/);
|
|
assert.match(html, /WHATS = PACKED\.whats/);
|
|
// And the unpacking function must be emitted, not just referenced.
|
|
assert.match(html, /const rehydrateCells = function/);
|
|
});
|
|
|
|
it('offers the controls that make it usable', () => {
|
|
for (const id of ['play', 'back', 'fwd', 'scrub', 'stage', 'money', 'crash', 'waste', 'jam', 'decision']) {
|
|
assert.ok(html.includes(`id="${id}"`), `missing control: ${id}`);
|
|
}
|
|
});
|
|
|
|
it('emits a script that actually parses', () => {
|
|
// THE GUARD THAT WAS MISSING. A stray apostrophe inside a single-quoted JS string once broke
|
|
// the entire inline script, so no button handler ever bound — while every other test passed,
|
|
// because they only checked that the markup contained the buttons. Checking the elements exist
|
|
// says nothing about whether the page works.
|
|
const js = html.slice(html.lastIndexOf('<script>') + 8, html.lastIndexOf('</script>'));
|
|
assert.doesNotThrow(() => new Function(js), 'inline script has a syntax error');
|
|
});
|
|
|
|
it('wires a handler to every control', () => {
|
|
const js = html.slice(html.lastIndexOf('<script>') + 8, html.lastIndexOf('</script>'));
|
|
for (const id of ['play', 'back', 'fwd', 'first', 'stage', 'money', 'crash', 'waste', 'jam']) {
|
|
assert.match(js, new RegExp(`\\$\\('${id}'\\)\\.onclick`), `no handler bound to ${id}`);
|
|
}
|
|
assert.match(js, /\$\('scrub'\)\.oninput/, 'no handler bound to scrub');
|
|
});
|
|
|
|
it('runs its render function against the real frames', () => {
|
|
// Executes the page's own JS with a minimal DOM stub. Catches runtime errors in render(),
|
|
// not just parse errors — e.g. a field the renderer expects that frames do not carry.
|
|
const js = html.slice(html.lastIndexOf('<script>') + 8, html.lastIndexOf('</script>'));
|
|
const els = new Map<string, Record<string, unknown>>();
|
|
const stub = {
|
|
getElementById: (id: string) => {
|
|
if (!els.has(id)) {
|
|
// A faithful-enough element. `classList` matters: the page folds the district panel by
|
|
// toggling a class, and a stub without one throws — which is a page that never renders,
|
|
// not a cosmetic gap.
|
|
const classes = new Set<string>();
|
|
els.set(id, {
|
|
textContent: '', innerHTML: '', value: '', style: {}, max: 0, onclick: null,
|
|
classList: {
|
|
add: (c: string) => void classes.add(c),
|
|
remove: (c: string) => void classes.delete(c),
|
|
contains: (c: string) => classes.has(c),
|
|
},
|
|
querySelector: () => null,
|
|
});
|
|
}
|
|
return els.get(id);
|
|
},
|
|
};
|
|
const run = new Function('document', 'setInterval', 'clearInterval', js);
|
|
assert.doesNotThrow(
|
|
() => run(stub, () => 0, () => undefined),
|
|
'the page threw while rendering its first frame',
|
|
);
|
|
// render() ran, so the turn chart should have been filled in — with the same Day/Stage/phase
|
|
// chart the live game draws, from the shared renderer.
|
|
const chart = String(els.get('turnchart')?.innerHTML ?? '');
|
|
assert.match(chart, /Day \d+/, 'the turn chart was not rendered');
|
|
assert.match(chart, /Stage \d+ of 12/);
|
|
assert.match(chart, /class="tc-phase now"/, 'no phase is marked as the current one');
|
|
});
|
|
|
|
it('records what the bot chose, why, and what it passed over', () => {
|
|
// The replay could always show what happened, never what COULD have happened — so a daft move
|
|
// was visible but the alternatives it declined were not, which is what you need to say what it
|
|
// should have done instead.
|
|
const rec = record(202, 'standard');
|
|
const decided = rec.frames.filter((f) => f.decision !== null);
|
|
assert.ok(decided.length > 0, 'no frame carried a decision');
|
|
|
|
for (const f of decided) {
|
|
assert.ok(f.decision!.chose.length > 0, 'a decision with no chosen action');
|
|
assert.ok(f.decision!.why.length > 0, 'a decision with no stated reason');
|
|
assert.ok(f.decision!.totalOptions >= 1, 'a decision offering nothing');
|
|
}
|
|
|
|
// The reasons must come from the bot's own branches, not a generic fallback for everything.
|
|
const reasons = new Set(decided.map((f) => f.decision!.why));
|
|
assert.ok(reasons.size > 5, `only ${reasons.size} distinct reasons — the branches are not reporting`);
|
|
|
|
// Turns with real alternatives must show them, or the panel is decoration.
|
|
assert.ok(
|
|
decided.some((f) => f.decision!.rejected.length > 0),
|
|
'no frame ever recorded a rejected option',
|
|
);
|
|
});
|
|
|
|
it('flags jammed facilities and can tell them from ready ones', () => {
|
|
const rec = record(202, 'standard');
|
|
for (const f of rec.frames) {
|
|
for (const x of f.facilities) {
|
|
// A jam is precisely "work on WORK that cannot come off", so it can never be 'ready'.
|
|
assert.ok(!(x.jammed && x.canFinish), `${x.name} reported both jammed and ready`);
|
|
}
|
|
}
|
|
});
|
|
|
|
it('renders a LATER frame, where the board state is carried forward', () => {
|
|
// The page omits cells/facilities/division when unchanged and resolves them by walking back —
|
|
// 63% of a 5.2 MB payload was the same grid re-serialised every frame. Rendering only frame 0
|
|
// would never exercise that path, because frame 0 always carries everything.
|
|
const js = html.slice(html.lastIndexOf('<script>') + 8, html.lastIndexOf('</script>'));
|
|
const els = new Map<string, Record<string, unknown>>();
|
|
const stub = {
|
|
getElementById: (id: string) => {
|
|
if (!els.has(id)) {
|
|
// A faithful-enough element. `classList` matters: the page folds the district panel by
|
|
// toggling a class, and a stub without one throws — which is a page that never renders,
|
|
// not a cosmetic gap.
|
|
const classes = new Set<string>();
|
|
els.set(id, {
|
|
textContent: '', innerHTML: '', value: '', style: {}, max: 0, onclick: null,
|
|
classList: {
|
|
add: (c: string) => void classes.add(c),
|
|
remove: (c: string) => void classes.delete(c),
|
|
contains: (c: string) => classes.has(c),
|
|
},
|
|
querySelector: () => null,
|
|
});
|
|
}
|
|
return els.get(id);
|
|
},
|
|
};
|
|
// Append a jump to a late frame so render() runs against carried-forward state.
|
|
const run = new Function('document', 'setInterval', 'clearInterval', js + '\n;go(FRAMES.length - 1);');
|
|
assert.doesNotThrow(
|
|
() => run(stub, () => 0, () => undefined),
|
|
'the page threw rendering a frame whose board state was carried forward',
|
|
);
|
|
assert.ok(
|
|
String(els.get('grid')?.innerHTML ?? '').length > 0,
|
|
'the grid rendered empty on a carried-forward frame',
|
|
);
|
|
});
|
|
|
|
it('stays a sane size', () => {
|
|
const mb = Buffer.byteLength(html) / 1024 / 1024;
|
|
assert.ok(mb < 5, `replay is ${mb.toFixed(1)} MB`);
|
|
});
|
|
});
|
|
|
|
describe('the replay wire format is lossless (regression)', () => {
|
|
it('rebuilds every cell exactly, through the same function the page runs', () => {
|
|
// The frames are packed before they reach the page: a card's identity and its description are
|
|
// written once and referenced by integer, and a cell points at its facility instead of carrying
|
|
// a second copy of it. That is 45% of the file — and it is only safe if unpacking is exact.
|
|
//
|
|
// `rehydrateCells` is the function the page itself runs, emitted by toString(), so this checks
|
|
// the real thing rather than a second implementation of it.
|
|
const rec = record(880009, 'standard', 4000);
|
|
const packed = compress(rec.frames);
|
|
|
|
let checked = 0;
|
|
let carried: unknown[] = [];
|
|
let carriedFacs: unknown[] = [];
|
|
for (let i = 0; i < rec.frames.length; i++) {
|
|
const wire = packed.frames[i] as Record<string, unknown>;
|
|
// null means "unchanged since the last frame that carried it", exactly as the page resolves it
|
|
if (wire['cells'] !== null) carried = wire['cells'] as unknown[];
|
|
if (wire['facilities'] !== null) carriedFacs = wire['facilities'] as unknown[];
|
|
|
|
const back = rehydrateCells(carried, packed.cards, packed.whats, carriedFacs);
|
|
assert.deepEqual(back, rec.frames[i]!.cells, `frame ${i} did not survive the round trip`);
|
|
checked++;
|
|
}
|
|
assert.ok(checked > 100, `only ${checked} frames checked`);
|
|
});
|
|
|
|
it("tolerates an older recording's singular train at the trains slot", () => {
|
|
// Before "The Roster Pass" (docs/plans/switching-paths.md), the trains slot held one train
|
|
// object or null — `rehydrateCells` has to make sense of that shape too, with no version flag
|
|
// anywhere in a packed row to key off.
|
|
const cards: unknown[] = [[0, 0, 'office', 'Whistle Post', true, ['ew']]];
|
|
const whats = ['a station'];
|
|
const facs: unknown[] = [];
|
|
const oldTrain = { trayId: 'crew', label: 'crew', cars: [], engineAt: 0, facing: 'e', what: '' };
|
|
|
|
const [withObject] = rehydrateCells([[0, 0, [], [], -1, oldTrain, 1, [], 0]], cards, whats, facs) as {
|
|
trains: unknown[];
|
|
}[];
|
|
assert.deepEqual(withObject!.trains, [oldTrain], 'a lone train object should wrap into a one-train roster');
|
|
|
|
const [withNull] = rehydrateCells([[0, 0, [], [], -1, null, 1, [], 0]], cards, whats, facs) as {
|
|
trains: unknown[];
|
|
}[];
|
|
assert.deepEqual(withNull!.trains, [], 'a null train slot should read as no train at all');
|
|
|
|
const [withArray] = rehydrateCells(
|
|
[[0, 0, [], [], -1, [oldTrain, oldTrain], 1, [], 0]],
|
|
cards,
|
|
whats,
|
|
facs,
|
|
) as { trains: unknown[] }[];
|
|
assert.equal(withArray!.trains.length, 2, 'an array should ride through as-is');
|
|
});
|
|
|
|
it('writes each distinct card and description once, not once per frame', () => {
|
|
const rec = record(880009, 'standard', 4000);
|
|
const packed = compress(rec.frames);
|
|
const cellsSeen = rec.frames.reduce((n, f) => n + f.cells.length, 0);
|
|
assert.ok(
|
|
packed.cards.length < cellsSeen / 20,
|
|
`${packed.cards.length} card entries for ${cellsSeen} cell-frames — identity is not interned`,
|
|
);
|
|
assert.ok(
|
|
packed.whats.length < cellsSeen / 20,
|
|
`${packed.whats.length} descriptions for ${cellsSeen} cell-frames — prose is not interned`,
|
|
);
|
|
});
|
|
});
|
|
|
|
|
|
describe('the replay behaves like the game it is replaying', () => {
|
|
it('carries the sounds each frame earned, and the one implementation that plays them', () => {
|
|
// A replay is for watching a game back, so it should sound and fold like the game. Both use the
|
|
// SAME functions — `cuesFor` decides what happened, `playCue` decides what it sounds like —
|
|
// embedded by toString() exactly as the board renderers are. A second copy would drift, and a
|
|
// replay that sounds different from the game is worse than a replay with no sound.
|
|
// POOLED OVER SEVERAL GAMES, because a single one cannot cover the set: measured over 40 games,
|
|
// the bot couples in only 20% of them and sets cars out in 43%. This used to assert against one
|
|
// seed and passed on luck — the moment the opening deal changed, that seed's game happened to
|
|
// contain no switching at all and four of the six cues vanished. What is under test is the
|
|
// plumbing, not one game, so the frames are pooled.
|
|
/**
|
|
* TWELVE SEEDS, not three — the same lesson as the comment above, learnt again at v0.4.7.
|
|
* Coupling happens in about 39 games in 200, so three deals expect 0.6 of one: the assertion was
|
|
* riding on luck exactly as the single seed had been, and the deck losing seven cards was enough
|
|
* to tip it.
|
|
*
|
|
* TWENTY-FOUR, not twelve, and the difference is instructive: on this stride the first game that
|
|
* couples anything is index 13, so a twelve-seed pool still contained none. The rate is what
|
|
* matters, not the count — measured 39 in 200, with couplers at indices 13, 19, 22, 24, 28 …
|
|
*/
|
|
const recs = Array.from({ length: 24 }, (_, i) => record(1000 + i * 7919, 'standard', 4000));
|
|
const withCues = recs.flatMap((rec) => rec.frames.filter((f) => (f.cues?.length ?? 0) > 0));
|
|
assert.ok(withCues.length > 20, `only ${withCues.length} frames carry a cue`);
|
|
|
|
const kinds = new Set(withCues.flatMap((f) => f.cues ?? []));
|
|
assert.ok(kinds.has('stage'), 'no Stage ever sounded');
|
|
assert.ok(kinds.has('day'), 'no Day ever sounded');
|
|
assert.ok(kinds.has('train'), 'no train was ever announced');
|
|
// Coupling and setting out are what a switching move IS, and both were silent — a car left the
|
|
// board and only history said where it went.
|
|
assert.ok(kinds.has('couple'), 'coupling a cut never made a sound');
|
|
assert.ok(kinds.has('drop'), 'setting cars out never made a sound');
|
|
assert.ok(kinds.has('schedule'), 'the 1D12 that sets a train\'s departure Stage landed silently');
|
|
assert.ok(kinds.has('arrive'), 'a train pulling into an Office never made a sound');
|
|
assert.ok(kinds.has('depart'), 'a train highballing out of an Office never made a sound');
|
|
// Collisions are rare — measured 2 in 40 games — so this is the one cue this pool is not
|
|
// guaranteed to contain on every stride; it happens to (seeds 96028 and 159380) at the current
|
|
// stride and seed count. If this starts failing after either changes, widen the pool rather than
|
|
// deleting the assertion — §10 is the one event a player most needs to hear.
|
|
assert.ok(kinds.has('crash'), 'a collision never made a sound');
|
|
|
|
// One CLOCK cue per Stage boundary, the bell replacing the whistle at a Day — the same
|
|
// accounting the live game is held to. The switching cues are counted separately: they follow
|
|
// what a crew does, not what the clock does.
|
|
let boundaries = 0;
|
|
for (const rec of recs) {
|
|
for (let k = 1; k < rec.frames.length; k++) {
|
|
const a = rec.frames[k - 1]!;
|
|
const b = rec.frames[k]!;
|
|
if (a.day !== b.day || a.stage !== b.stage) boundaries++;
|
|
}
|
|
}
|
|
const clock = withCues
|
|
.flatMap((f) => f.cues ?? [])
|
|
.filter((c) => c === 'stage' || c === 'day').length;
|
|
assert.equal(clock, boundaries, 'Stage boundaries and Stage-or-Day cues disagree');
|
|
});
|
|
|
|
it('serves the controls for both, and embeds the player', () => {
|
|
const html = renderHtml(record(880009, 'standard', 900));
|
|
for (const id of ['sound', 'districttoggle', 'districtsummary']) {
|
|
assert.ok(html.includes(`id="${id}"`), `the replay has no #${id}`);
|
|
}
|
|
assert.match(html, /const playCue = function/, 'the sound player is referenced but not embedded');
|
|
assert.match(html, /#district\.folded/, 'nothing folds the district away');
|
|
});
|
|
});
|