Jesse.Markowitz/station-master
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

v0.4.9h — a leg that is part of the row, the deck the sheet prints, and regions not miles per hour

Browse Source 
The 0.4.9 line's port of v0.7.2, minus Gitea#18: the Division map redraw is a
multiplayer redesign and does not belong in a build people are mid-playtest on.

Gitea#17 — a 45° leg is an end of the west-to-east row, so backing into a cut
through a curve's south leg no longer couples it back to front, and a crew
pulling out through a leg takes its own cut with it.

Gitea#14 — every count is docs/Deck cards5.xlsx, including removing the Q12
office doubling and the Gap 12 industry tripling.

Gitea#15 — RAR reversed it: the placement is legal; what must hold is that no
train crosses the gap.

Gitea#3 — the printed speeds are scenery. One Stage per printed region, and
where a train starts is what varies.
This commit is contained in:
Jesse.Markowitz
2026-08-26 15:21:49 -04:00
parent f684c60f2e
commit e9683cc8c5
22 changed files with 4079 additions and 3055 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/cut-ordering.test.ts
+92 -4
View File
@@ -13,7 +13,7 @@ import assert from 'node:assert/strict';
import { applyIntent, areaOf, check } from '../src/engine/apply.ts';
import { createGame } from '../src/engine/setup.ts';
import type { CrewTray, GameConfig, GameState, GridCoord, RollingStock, TrackCard } from '../src/engine/state.ts';
import type { CrewTray, GameConfig, GameState, GridCoord, RollingStock, TrackArc, TrackCard } from '../src/engine/state.ts';
import { carsOn, coordKey, turnOf } from '../src/engine/state.ts';
const config: GameConfig = {
@@ -51,12 +51,18 @@ function row(s: GameState, n: number): void {
for (let c = 0; c < n; c++) addCard(s, at(1, c), straight());
}
/**
* `facing` is the PORT the engine points out through, which is not always an east-west one: a train
* standing on a curve points along its 45° leg. `railFacing` carries the east-west sense the train
* arrived with, so it keeps a straight answer whatever port the nose is on (`railFacingOf`).
*/
function placeTray(
s: GameState,
coord: GridCoord,
consist: RollingStock[],
facing: 'e' | 'w',
facing: 'n' | 's' | 'e' | 'w',
engineAt = 0,
railFacing: 'e' | 'w' = facing === 'w' ? 'w' : 'e',
): string {
const id = s.freeTrays.pop()!;
s.trays.set(id, {
@@ -65,9 +71,9 @@ function placeTray(
trainIsExtra: false,
engineAt,
consist,
direction: facing === 'w' ? 'west' : 'east',
direction: railFacing === 'w' ? 'west' : 'east',
facing,
railFacing: facing,
railFacing,
position: { at: 'grid', seat: 0, coord },
movesUsed: 0,
} as CrewTray);
@@ -371,3 +377,85 @@ describe('taking your own cut back is undoing the drop, not a fresh pick-up', ()
);
});
});
// ---------------------------------------------------------------------------
describe('a 45° leg is part of the west-to-east row, not outside it (Gitea#17)', () => {
/**
* Reported: "Cars were West to East Caboose, Loaded boxcar, Loaded boxcar, Loaded boxcar. After
* backing into that square cars were attached to the train Loaded boxcar, Loaded boxcar, Loaded
* boxcar, Caboose, Engine." The caboose came back next to the engine instead of at the far end,
* which also leaves the train badly made up under §8.2.
*
* The square was a `sw` CURVE and the train backed in through its SOUTH leg. `standing` runs west
* to east, and the two places that walk it both asked the PORT which end of the row they were at:
* `exploreMoves` reversed the row for an 'e' entry and for nothing else, and `cutTowards` answered
* "you meet nothing" for a north or south exit. Neither is a property of the port.
*
* A 45° leg leaves through the MIDDLE of its edge, so its end of the run is whichever end the arc
* does not reach: the south leg of a `sw` curve is the row's EAST end, and the south leg of an
* `se` curve is its WEST end. Same port, opposite answers — which is why `rowEndAt` has to ask the
* card.
*/
const curve = (arc: TrackArc, standing: RollingStock[] = [], standingWest = 0): TrackCard => ({
geometry: { kind: 'track', geometry: 'curved', arc, hand: 'right' },
baseOperationalRail: true,
standing,
standingWest,
facility: null,
modifiers: [],
enhancements: [],
});
/**
* The reported board, minimally: a `sw` curve holding the cut, and an `ne` curve below it for the
* train to run from. Both legs lie on the `ne_sw` diagonal, so the two cards actually join.
*/
function board(standing: RollingStock[], standingWest = standing.length): GameState {
const s = game();
addCard(s, at(1, 0), curve('sw', standing, standingWest));
addCard(s, at(0, 0), curve('ne'));
switching(s);
return s;
}
it('backs into a cut through the south leg and meets the EAST end of the row first', () => {
const s = board([car('caboose', true), car('boxcar', true), car('boxcar', true), car('boxcar', true)]);
// Facing east on the `ne` curve, so reversing pulls out through its north leg and into the
// curve above through that card's south leg — the move in the reported save.
const id = placeTray(s, at(0, 0), [], 'e');
const r = applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(1, 0), reverse: true });
assert.ok(r.ok, `the reverse move was refused: ${r.ok ? '' : r.code}`);
// Coupled behind the engine nearest-car-first, and the nearest car is the one at the south end
// — the LAST of a west-to-east row on a `sw` curve. The caboose was westmost, so it ends up
// furthest from the engine, which is where §8.2 needs it.
assert.deepEqual(types(s.trays.get(id)!.consist), ['boxcar', 'boxcar', 'boxcar', 'caboose']);
});
it('meets the WEST end of the row first where the same leg belongs to an `se` curve', () => {
// The mirror, and the reason the port alone cannot answer: an `se` curve's south leg is the
// west end of its row, so the same reverse move meets the caboose first.
const s = game();
addCard(s, at(1, 0), curve('se', [car('caboose', true), car('boxcar', true)], 2));
addCard(s, at(0, 0), curve('nw'));
switching(s);
const id = placeTray(s, at(0, 0), [], 'w');
const r = applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(1, 0), reverse: true });
assert.ok(r.ok, `the reverse move was refused: ${r.ok ? '' : r.code}`);
assert.deepEqual(types(s.trays.get(id)!.consist), ['caboose', 'boxcar']);
});
it('takes its own cut back with it when it pulls out through the south leg (§A.4)', () => {
// The other half of the same assumption: `cutTowards` said a train leaving north or south meets
// nothing, so a crew standing on a curve drove away and left the cars beside it standing —
// exactly what mandatory coupling forbids.
const s = board([car('boxcar', true)], 0);
// `standingWest` 0 puts the boxcar EAST of the train, which on a `sw` curve is between it and
// the south leg it is about to leave by.
const id = placeTray(s, at(1, 0), [], 's');
const r = applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(0, 0), reverse: false });
assert.ok(r.ok, `the move off the curve was refused: ${r.ok ? '' : r.code}`);
assert.deepEqual(types(s.trays.get(id)!.consist), ['boxcar'], 'the cut beside the train was left standing');
assert.deepEqual(standingAt(s, at(1, 0)), [], 'the cars should have come off the card');
});
});
test/harness.test.ts
+22 -8
View File
@@ -226,14 +226,28 @@ describe('the game conserves Rolling Stock', () => {
for (let t = 0; t < 50_000; t++) {
const before = census(s);
const pumped = pump(s);
// §10 — a collision destroys both trains and everything they were carrying. That is the one
// legitimate way the count falls, so the expectation follows it down.
for (const e of pumped) {
if (e.type === 'trainsDestroyed') for (const tr of e.trains) expected -= tr.consist.length;
}
assert.ok(
census(s) === before || pumped.some((e) => e.type === 'trainsDestroyed'),
`seed ${seed}: the engine changed the census by ${census(s) - before} outside a collision`,
/**
* A COLLISION DESTROYS NO CAR, and this used to assume it destroyed all of them.
*
* The subtraction that stood here — `expected -= tr.consist.length` for every train in a
* `trainsDestroyed` event — describes a rule the engine does not have. Gap 2c (`advance.ts`,
* "TAKE THE WRECK OFF THE CARD") sends the wreck's cabooses back to the Division Yard and
* everything else to Classification, so the stock is conserved through a collision like any
* other move. The train is destroyed; its cars are not.
*
* It passed for as long as it did because none of the six seeds below ever collided, so the
* branch never ran. Changing the deck to the sheet's counts (Gitea#14) moved the deals, seed
* 24757 collided, and the test failed claiming the engine had CONJURED three cars — the
* exact opposite of what had happened.
*
* So the census is now held flat, unconditionally, which is both the real invariant and a
* stronger test than the one it replaces: there is no longer any event that excuses a
* change, and `expected` cannot drift away from the supply it was dealt.
*/
assert.equal(
census(s),
before,
`seed ${seed}: the engine changed the census by ${census(s) - before} while pumping`,
);
if (s.status === 'finished') break;
const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
test/mainline-cards.test.ts
+258 -48
View File
@@ -12,6 +12,7 @@
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import type { MainlineKind } from '../src/engine/content.ts';
import { advance } from '../src/engine/advance.ts';
import { applyIntent, areaOf, check } from '../src/engine/apply.ts';
import { legalActions } from '../src/engine/legal.ts';
@@ -40,6 +41,20 @@ const game = (seed = 5): GameState => createGame({ id: 'g', seed, config, player
const at = (row: number, col: number): GridCoord => ({ row, col });
/** Puts a card of `kind`/`key` in hand and returns its id. */
/**
* Puts a specific rules card in hand and returns its id, MINTING ONE IF THE DECK NO LONGER DEALS IT.
*
* A card at `copies: 0` is still a card: the catalogue keeps its row and the engine keeps its rule,
* so the design stays visible and the mechanic works the moment it is dealt again. Poling and the
* sharp curves have been treated that way for a while, and Gitea#14 put the dispatching ladder,
* Facing Point Locks, Flying Switch, Section House and Vandalism there too — none of them are in
* `docs/Deck cards5.xlsx`.
*
* This used to throw when it could not find one, which made "dealt zero copies" and "deleted"
* indistinguishable from a test's point of view: zeroing Flying Switch took five passing tests of a
* rule that had not changed at all down with it. Minting keeps the rule under test independently of
* whether the deck currently deals the card, which is the whole reason for keeping the row.
*/
function hand(s: GameState, kind: string, key: string): string {
for (const [id, card] of s.cards) {
const k = card.kind as { kind: string; key?: string };
@@ -48,7 +63,10 @@ function hand(s: GameState, kind: string, key: string): string {
return id;
}
}
throw new Error(`no ${kind} card: ${key}`);
const id = `zero-copy-${kind}-${key}`;
s.cards.set(id, { id, kind: { kind, key } } as never);
s.decks.hands.set(0, [id]);
return id;
}
/**
@@ -87,53 +105,124 @@ function drawTurn(s: GameState): void {
// ---------------------------------------------------------------------------
describe('grade modifiers change crossing time', () => {
it('a Heavy Grade takes two Stages bare', () => {
assert.equal(crossingStages('heavyGrade', 'fast', false), 2);
/**
* Crossing time on the region model (Gitea#3). `cross` fills in the parts each test does not care
* about, so the numbers below read as the table RAR gave rather than as argument lists.
*/
const cross = (
kind: Parameters<typeof crossingStages>[0],
over: Partial<Parameters<typeof crossingStages>[1]> = {},
): number =>
crossingStages(kind, {
trainSpeed: 'fast',
direction: 'east',
gradeUp: 'east',
modifiers: [],
...over,
});
describe('a card costs one Stage per printed region (Gitea#3)', () => {
/**
* RAR, 2026-08-26, and this REPLACES the two rules that were here before — Q1, "the printed 60/30
* are mph expressed as crossing time", and Q2, "a Slow train adds one Stage to every card".
*
* "Ignore speed signs, they are just graphics. Regions shown on cards indicate how many stages it
* takes to cross. Plains is 1. Double track is 1, tunnel is 2, curves is 2, heavy grade is 3
* unless you have help."
*
* The report that opened the issue was a Slow train taking two Stages to clear Double Track. Q2 is
* what did that, and it is gone.
*/
it('crosses in the number of regions the card prints, whatever the train', () => {
for (const speed of ['fast', 'slow'] as const) {
assert.equal(cross('plains', { trainSpeed: speed }), 1, `plains, ${speed}`);
assert.equal(cross('doubleTrack', { trainSpeed: speed }), 1, `double track, ${speed}`);
assert.equal(cross('trestle', { trainSpeed: speed }), 1, `trestle, ${speed}`);
assert.equal(cross('curves', { trainSpeed: speed }), 2, `curves, ${speed}`);
assert.equal(cross('tunnel', { trainSpeed: speed }), 2, `tunnel, ${speed}`);
assert.equal(cross('heavyGrade', { trainSpeed: speed }), 3, `heavy grade, ${speed}`);
}
});
it('reads Fast/Slow on Hilly and on nothing else', () => {
// "Some cards say fast / slow… Fast / Slow does not apply to every card — just those that say
// fast / slow on them. Currently this is only hilly." A fast train starts in the second region.
assert.equal(cross('hilly', { trainSpeed: 'fast' }), 1);
assert.equal(cross('hilly', { trainSpeed: 'slow' }), 2);
});
it('does not read the consist any more', () => {
// Hilly used to take its split off the printed P60/F30 and decide by whether the train carried a
// coach, so a fast freight crossed slower than a slow passenger train. RAR: "I notice that you
// are basing stages in mainline cards off coach/non-coach. Actually, all trains are rated as
// FAST and SLOW." `crossingStages` no longer takes a consist at all — this test is here so the
// deletion is deliberate rather than incidental.
assert.equal(cross('hilly', { trainSpeed: 'fast' }), cross('hilly', { trainSpeed: 'fast' }));
});
it('runs a train through a siding or an Interchange in one Stage', () => {
// Both print a back region that is not part of the road, so a train passing through starts past
// it. What that region is FOR is tested below and in the collision tests.
assert.equal(cross('uncontrolledSiding'), 1);
assert.equal(cross('interchange'), 1);
});
it('costs the extra Stage to anything starting in that back region', () => {
// The Uncontrolled Siding with a train already on it, and an Extra beginning its run at an
// Interchange. Both start at the back and have the whole card to run.
assert.equal(cross('uncontrolledSiding', { startsAtBack: true }), 2);
assert.equal(cross('interchange', { startsAtBack: true }), 2);
});
});
describe('grade modifiers move the start, not the clock', () => {
it('a Heavy Grade takes three Stages bare', () => {
// Three regions, up from the two the old 30mph reading gave it.
assert.equal(cross('heavyGrade'), 3);
});
it('Brakeman speeds the descent but not the climb', () => {
// Q11 — the card prints "(Up)" and "Player sets orientation", so the last argument is which
// way is UPHILL. With up = east, a westbound train is descending.
assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'west', 'east'), 1);
assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'east', 'east'), 2);
// Q11 — the card prints "(Up)" and "Player sets orientation", so `gradeUp` is which way is
// UPHILL. With up = east, a westbound train is descending.
assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'west' }), 2);
assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'east' }), 3);
});
it('follows the orientation the player chose, not a fixed compass direction', () => {
// The same train on the same card, with the card turned around: Brakeman helps a westbound
// train on an east-climbing grade, and an eastbound one when the grade climbs west.
assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'east', 'west'), 1);
assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'west', 'west'), 2);
assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'west', 'west'), 1);
assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'east', 'west'), 2);
it('follows the orientation the card was dealt, not a fixed compass direction', () => {
// The same train on the same card, with the card turned around.
assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'east', gradeUp: 'west' }), 2);
assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'west', gradeUp: 'west' }), 3);
assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'west', gradeUp: 'west' }), 2);
assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'east', gradeUp: 'west' }), 3);
});
it('Helpers speed the climb but not the descent', () => {
assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'east', 'east'), 1);
assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'west', 'east'), 2);
// RAR: "helpers… helps all trains going up hill by starting 1 region easier — so 2 to traverse,
// not 3."
assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'east' }), 2);
assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'west' }), 3);
});
it('Airbrakes stack with Brakeman on a slow train', () => {
// A slow train pays 3 on a grade; Brakeman and Airbrakes take one Stage each.
assert.equal(crossingStages('heavyGrade', 'slow', false, [], 'west', 'east'), 3);
assert.equal(crossingStages('heavyGrade', 'slow', false, ['brakeman'], 'west', 'east'), 2);
assert.equal(
crossingStages('heavyGrade', 'slow', false, ['brakeman', 'airbrakes'], 'west', 'east'),
1,
);
it('Airbrakes stack on top of Brakeman', () => {
// "Airbrakes is an upgrade from brakemen (which must be played first)", so a fully-equipped
// grade is one Stage downhill — and `check` refuses Airbrakes without Brakeman already there.
assert.equal(cross('heavyGrade', { direction: 'west' }), 3);
assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'west' }), 2);
assert.equal(cross('heavyGrade', { modifiers: ['brakeman', 'airbrakes'], direction: 'west' }), 1);
});
it('never lets a train cross in no time', () => {
// Three modifiers on a three-region card would otherwise put the start past the far edge.
assert.equal(
crossingStages('heavyGrade', 'fast', false, ['brakeman', 'airbrakes'], 'west', 'east'),
cross('heavyGrade', { modifiers: ['brakeman', 'airbrakes', 'helpers'], direction: 'west' }),
1,
);
});
it('leaves non-grade cards alone', () => {
// Brakeman on Plains would be an illegal placement anyway; the maths must not move regardless.
assert.equal(crossingStages('plains', 'fast', false, ['brakeman'], 'west', 'east'), 1);
assert.equal(crossingStages('curves', 'fast', false, ['helpers'], 'east', 'east'), 2);
assert.equal(cross('plains', { modifiers: ['brakeman'], direction: 'west' }), 1);
assert.equal(cross('curves', { modifiers: ['helpers'] }), 2);
});
});
@@ -206,8 +295,8 @@ describe('Realignment converts one Mainline type to another', () => {
assert.ok(r.ok);
assert.equal(node.card, 'plains', 'Curves realigns to Plains');
// The point of the card: Curves is a 30 (two Stages), Plains a 60 (one).
assert.equal(crossingStages(node.card, 'fast', false), 1);
// The point of the card: Curves prints two regions, Plains one, so realigning halves the time.
assert.equal(cross(node.card), 1);
});
it('refuses a card with no conversion listed', () => {
@@ -793,18 +882,35 @@ describe('Q13 — a train that catches the one ahead runs into it', () => {
* then region 1 — so it catches up whichever order the phase happens to process them in.
*/
const twoTrains = (opts: { absSignals?: boolean } = {}): { s: GameState; events: GameEvent[] } => {
const s = createGame({
id: 'rear', seed: 3,
config: {
mode: 'solitaire', victory: 'highestAfterDays', length: 'standard',
optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
},
playerNames: ['bot'],
});
const index = s.division.nodes.findIndex(
(n) => n.kind === 'mainline' && !mainlineProfile(n.card).trainsMayPass,
);
assert.ok(index >= 0, 'no single-track Mainline card in this Division');
/**
* THE SEED IS SEARCHED FOR, NOT WRITTEN DOWN.
*
* This asked for seed 3 and asserted that its Division held a single-track Mainline card. It
* does not any more: the Division is laid out from the same RNG stream the card deck is
* shuffled from, so changing the SIZE of that deck re-deals the Division too. Gitea#14's deck
* counts moved it, and the test failed on its own precondition — "no single-track Mainline card
* in this Division" — which says nothing about the rule under test.
*
* The fixture needs A Division with a card trains may not pass on, not one particular one, so
* it now takes the first seed that provides one. That is stable across any future retune, and
* it fails loudly if such a Division stops being reachable at all.
*/
let s!: GameState;
let index = -1;
for (let seed = 3; seed < 200 && index < 0; seed++) {
s = createGame({
id: 'rear', seed,
config: {
mode: 'solitaire', victory: 'highestAfterDays', length: 'standard',
optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
},
playerNames: ['bot'],
});
index = s.division.nodes.findIndex(
(n) => n.kind === 'mainline' && !mainlineProfile(n.card).trainsMayPass,
);
}
assert.ok(index >= 0, 'no seed under 200 deals a Division holding a single-track Mainline card');
const node = s.division.nodes[index]!;
assert.ok(node.kind === 'mainline');
if (node.kind !== 'mainline') throw new Error('unreachable');
@@ -860,12 +966,116 @@ describe('Q13 — a train that catches the one ahead runs into it', () => {
);
});
it('leaves trains alone on a card that prints "trains may pass"', () => {
// Double Track and Uncontrolled Siding hold two trains because they HAVE two roads. Catching up
// there means going past, which is what the card is for. Without this the mechanic fired 0.41
// times a game while the bot never once granted clearance — the tell that they were all
// passing cards.
/**
* ENTERING an occupied region, as opposed to catching up inside the card (Gitea#3).
*
* A card can be ONE region wide — Plains, Double Track and Trestle all are — so a following train
* granted clearance is in the same place as the train ahead the moment it arrives. Nothing tested
* that: the catch-up check lives inside `stagesRemaining > 1`, which a one-Stage crossing never
* reaches, so entering behind another train on a Plains was silently free.
*/
const enteringBehind = (card: MainlineKind, opts: { absSignals?: boolean } = {}) => {
const s = game();
const index = s.division.nodes.findIndex((n) => n.kind === 'mainline');
const node = s.division.nodes[index]!;
assert.ok(node.kind === 'mainline');
if (node.kind !== 'mainline') throw new Error('unreachable');
node.card = card;
node.transits = [];
if (opts.absSignals) node.absSignals = true;
/**
* THE TRAIN ALREADY THERE IS THE JUNIOR ONE, and that is what makes the situation reachable.
*
* Trains move lowest number first, so a card's occupant normally clears before anything behind
* it is even considered — put train 9 on the card and train 11 at the Division Point and 9 has
* gone by the time 11 enters. The conflict is a SUPERIOR train catching an inferior one that has
* not got out of the way yet, so the numbers run the other way round here.
*/
const leader = s.freeTrays.pop()!;
s.trays.set(leader, {
id: leader, trainNumber: 11, trainIsExtra: false, engineAt: 0,
consist: [{ type: 'boxcar', loaded: false }], direction: 'east',
position: { at: 'mainline', index },
} as never);
const total = crossingStages(card, { trainSpeed: 'fast', direction: 'east', gradeUp: 'east', modifiers: [] });
node.transits.push({ tray: leader, stagesRemaining: total, stagesTotal: total, direction: 'east' });
// And the one arriving, held at the Division Point west of it.
const dp = s.division.nodes[index - 1];
assert.ok(dp && dp.kind === 'divisionPoint', 'expected a Division Point west of the first card');
if (!dp || dp.kind !== 'divisionPoint') throw new Error('unreachable');
const follower = s.freeTrays.pop()!;
s.trays.set(follower, {
id: follower, trainNumber: 9, trainIsExtra: false, engineAt: 0,
consist: [{ type: 'boxcar', loaded: false }], direction: 'east',
position: { at: 'divisionPoint', side: dp.side },
} as never);
dp.holding.push(follower);
/**
* THE SUPERINTENDENT LETS IT IN, which is the whole point.
*
* A same-direction train in the Subdivision is not an absolute bar — §8.1 makes it a judgment
* call, and `advance` stops and asks. Granting it is what puts one train in behind another, and
* §10 is then explicit that the wreck is the Superintendent's fault. So the fixture answers
* `allow: true` whenever it is asked, and the collision below is the consequence of that
* ruling rather than of a rule firing on its own.
*/
s.clock.phase = 'mainline';
const events: GameEvent[] = [];
for (let i = 0; i < 6; i++) {
events.push(...advance(s).events);
if (s.clock.pendingDecision !== null) {
const who = s.clock.superintendent;
const r = applyIntent(s, who, { type: 'mainline.clearance', allow: true });
assert.ok(r.ok, `clearance refused: ${r.ok ? '' : r.code}`);
events.push(...r.events);
}
}
return { s, node, events, follower };
};
it('runs a train into the one ahead when it ENTERS an occupied region', () => {
const { events } = enteringBehind('plains');
const smash = events.find((e) => e.type === 'trainsDestroyed');
assert.ok(smash, 'a train entered a one-region card behind another and nothing happened');
});
it('holds it short instead when the card carries ABS Signals', () => {
// RAR: "ABS. This is played on a mainline card to prevent collisions. If a collision would
// normally occur, the train moving onto the card is instead held back."
const { events } = enteringBehind('plains', { absSignals: true });
assert.ok(!events.some((e) => e.type === 'trainsDestroyed'), 'ABS Signals did not prevent it');
assert.ok(
events.some((e) => e.type === 'trainHeld' && /ABS Signals/.test(e.reason)),
'nothing was held short of the train ahead',
);
});
it('takes the siding instead of colliding on an Uncontrolled Siding', () => {
// "If a train already exists when you arrive, you go in the second stage back — you are in the
// siding and are one behind the other train. This prevents a collision, since you are not in
// same exact location." So: no wreck, both trains on the card, and the newcomer paying the
// extra Stage for the detour.
const { node, events, follower } = enteringBehind('uncontrolledSiding');
assert.ok(!events.some((e) => e.type === 'trainsDestroyed'), 'the siding did not prevent a collision');
const mine = node.transits.find((t) => t.tray === follower);
assert.ok(mine, 'the arriving train never made it onto the card');
assert.equal(mine.stagesTotal, 2, 'it should have entered at the back of the card, not the front');
});
it('leaves trains alone on the one card that prints "trains may pass"', () => {
// Double Track holds two trains because it HAS two roads. Catching up there means going past,
// which is what the card is for.
//
// THE UNCONTROLLED SIDING USED TO BE IN THIS LIST AND IS NOT ANY MORE (Gitea#3). It holds two
// trains as well, but not by letting them share a place: the second one takes the siding and
// sits a region behind, which is what keeps them apart — "you are in the siding and are one
// behind the other train. This prevents a collision, since you are not in same exact location."
// Marked "may pass" it skipped the collision test entirely, so the siding did nothing at all and
// two trains could occupy the same region of it unchallenged.
const passing = MAINLINE_PROFILES.filter((m) => m.trainsMayPass).map((m) => m.kind);
assert.deepEqual(passing, ['doubleTrack', 'uncontrolledSiding']);
assert.deepEqual(passing, ['doubleTrack']);
});
});
test/multiplayer.test.ts
+27 -12
View File
@@ -115,19 +115,34 @@ describe('the Fedora goes round the table', () => {
* decides who sits where, the sequence of player indices is a permutation while the sequence of
* seats is the plain 0, 1, 2, … that the rule describes.
*/
/**
* THE SEED IS SEARCHED FOR, because a game that ends on Day 1 cannot show a rotation.
*
* This took seed 4242 flat. Gitea#14's deck counts re-dealt it, and the three-player game now
* loses on `collisionFloor` at Day 1 Stage 10 — so the Fedora legitimately moves twice and the
* test failed reporting a rotation bug that is not there. Whether a particular deal ends early on
* collisions has nothing to do with whether the Fedora passes to the next seat.
*
* So the fixture asks for what it actually needs: a game that runs far enough to watch. It takes
* the first seed whose game reaches Day 3, which is four shift changes at minimum, and reports
* honestly if no seed in range does.
*/
const superintendentsSeen = (players: number): number[] => {
const s = game(players);
const seen: number[] = [];
const spy = {
name: 'spy',
choose(st: GameState, p: PlayerIndex, opts: Parameters<typeof developerBot.choose>[2]) {
const who = seatOf(st, st.clock.superintendent);
if (seen[seen.length - 1] !== who) seen.push(who);
return developerBot.choose(st, p, opts);
},
};
playGame(s, spy as never, pump);
return seen;
for (let seed = 4242; seed < 4342; seed++) {
const s = game(players, seed);
const seen: number[] = [];
const spy = {
name: 'spy',
choose(st: GameState, p: PlayerIndex, opts: Parameters<typeof developerBot.choose>[2]) {
const who = seatOf(st, st.clock.superintendent);
if (seen[seen.length - 1] !== who) seen.push(who);
return developerBot.choose(st, p, opts);
},
};
playGame(s, spy as never, pump);
if (s.clock.day >= 3) return seen;
}
assert.fail(`${players}p: no seed in range produced a game that reached Day 3`);
};
it('passes the Superintendent to the next seat, wrapping round the table', () => {
test/setup.test.ts
+75 -42
View File
@@ -61,56 +61,73 @@ const gameDealtWith = (startingHand: StartingHand, seed = 1234) =>
describe('card catalogue (component 1)', () => {
it('composes the deck from the design', () => {
// Transcribed from docs/Deck cards2.xlsx. The sheet's own totals are "Sum other 115" and
// "Total track 104", i.e. 219, plus 12 start cards for its grand total of 231.
// THE WHOLE CATALOGUE IS docs/Deck cards5.xlsx NOW (Gitea#14). Sheet 5's own totals are
// "Total track 48" and "Total other (in play) 107", i.e. 155 shuffled, plus 12 start cards for
// its grand total of 167. Card for card, 84 rows agree with it exactly and the only ones that
// do not are listed below — every one of them a deliberate hold, in one direction or the other.
//
// We are at 235 rather than 219 because of three deliberate departures, all flagged in
// content.ts: 18 extra industry cards (Gap 12, industries 9 → 27), 7 extra office cards (Q12,
// offices 7 → 14), and the 8 sharp curves taken back OUT. The first two were tuned against a deck
// that had NO track in it, so both are due a re-measurement now that 96 track cards share the
// draw.
// EVERY COUNT IN THE CATALOGUE IS NOW THE SHEET'S. The two deliberate departures that used to
// sit here are gone with Gitea#14 — the Q12 office doubling (offices 14 → 7) and the Gap 12
// industry tripling (27 → 9) — because both were measured against a deck holding 96 track
// cards, and sheet 5 halves that. content.ts carries the measurements that decided it.
//
// Two entries are dealt ZERO copies and kept in the catalogue so the design stays visible:
// Poling, whose effect is "TBD in the source", and the sharp curves, whose only difference from
// an ordinary curve was a Move cost nothing ever charged.
// DECK_SIZE is the CATALOGUE, 235. The deck actually dealt is smaller: the 22 opponent-directed
// cards are held back in every mode until they are implemented, so `buildDeck` returns 213.
assert.equal(DECK_SIZE, 235);
// We are at 143 rather than the sheet's 155 for ONE reason: the ten Safety, Event, Inspection
// and Space-use cards sheet 5 adds are not built, and stay out until they are (Jesse,
// 2026-08-26) — Cargo Theft, Civic Improvement, Civilian angel, Delayed Clearance, Flares 2,
// Robbery, Service Delays, Shipper complaints, Strike, Union Hall 2. Twelve copies in all.
//
// NOTHING RUNS THE OTHER WAY ANY MORE. Every card sheet 5 does not list is dealt ZERO copies
// rather than deleted, so the design stays visible and the rules stay implemented: the
// Telegraph/Telephone/Radio ladder, Facing Point Locks (both), Flying Switch, Section House and
// Vandalism, all removed from the design on purpose; Poling, whose effect the source records as
// "TBD"; and the sharp curves, whose only difference from an ordinary curve was a Move cost
// nothing ever charged — sheet 5 deals those zero too, so the catalogue and the design agree.
//
// DECK_SIZE is the CATALOGUE, 143. The deck actually dealt is smaller: the 20 opponent-directed
// cards are held back in every mode until they are implemented, so `buildDeck` returns 123.
assert.equal(DECK_SIZE, 143);
assert.equal(buildDeck().length, SOLITAIRE_DECK_SIZE);
});
it('matches the design deck composition exactly', () => {
const byCategory = Object.fromEntries(deckComposition().map((c) => [c.category, c.count]));
assert.deepEqual(byCategory, {
// 96, not the sheet's 104: the 8 SHARP CURVES are dealt zero copies. The only thing that made
// one different from an ordinary curve was a Move cost that nothing ever charged, so they were
// geometric duplicates taking 8 draws. Kept in the catalogue at zero, as Poling is.
track: 96,
// 14, not the sheet's 7 — Q12 office density; see OFFICE_PROFILES.
office: 14,
// 27, not the sheet's 9 — Gap 12 industry density; see INDUSTRY_PROFILES.
industry: 27,
// Sheet 5's track counts exactly (Gitea#14): 16 straights, 8+8 curves, 8+8 turnouts, and the
// sharp curves dealt none — which is where the catalogue already had them, and where sheet 5
// now puts them too.
track: 48,
// The sheet's 7 — the Q12 doubling came out in Gitea#14; see OFFICE_PROFILES.
office: 7,
// The sheet's 9 — the Gap 12 tripling came out in Gitea#14; see INDUSTRY_PROFILES.
industry: 9,
modifier: 23,
train: 22,
spaceUse: 12,
enhancement: 18,
mainlineModifier: 7,
// 6, not 7 — Poling is dealt no copies until its rule is known.
maneuver: 6,
action: 10,
spaceUse: 11,
// 6 — the dispatching ladder and Facing Point Locks are dealt 0 copies (see
// ENHANCEMENT_CARDS), and Interlocking, Water column and ABS Signals came down to the sheet's
// single copies. What is left is the sheet's Enhancements exactly, bar Railroad crossing,
// which sheet 5 moved here from the Action cards and which is still counted there below.
enhancement: 6,
// 5 — Facing Point Locks came out of the Mainline modifiers too.
mainlineModifier: 5,
// 3 — Red Flags is the sheet's 3; Flying Switch and Poling are both dealt none.
maneuver: 3,
// 9 — Vandalism is dealt none. The rest are opponent-directed and held out of every deck.
action: 9,
});
});
it('removes opponent-directed cards from a solitaire deck', () => {
// Q6 took Space-use and Action cards out of solitaire, where they have no legal target. They are
// now out of the COMPETITIVE deck too, until they are implemented: `checkPlay` answers both
// categories NOT_IMPLEMENTED, so dealing them would make 22 of 235 draws (9%) reject outright.
// 206, not 213: the 22 opponent-directed cards come out, and so do the SEVEN that exist only to
// answer them — Facing Point Locks (both the Enhancement and the Mainline modifier, 2 each), two
// Water Columns and one Overpass. A defence with nothing to defend against is the same dead draw
// as the attack would be. `SimpleCard.answers` names the pairing, so they return together.
assert.equal(SOLITAIRE_DECK_SIZE, 206);
assert.equal(DEFENCE_ONLY_COPIES, 7);
// categories NOT_IMPLEMENTED, so dealing them would be a dead draw.
// 121, not 123: the 20 opponent-directed cards come out, and so do the TWO that exist only to
// answer them — one Water Column and one Overpass. A defence with nothing to defend against is
// the same dead draw as the attack would be. `SimpleCard.answers` names the pairing, so they
// return together. It was seven until Gitea#14 dealt Facing Point Locks zero copies: a card at
// zero is already out, so it no longer needs holding back.
assert.equal(SOLITAIRE_DECK_SIZE, 121);
assert.equal(DEFENCE_ONLY_COPIES, 2);
for (const c of DEFENCE_ONLY_CARDS) {
assert.ok(c.answers, `${c.name} is held back without saying what it answers`);
assert.ok(
@@ -129,11 +146,12 @@ describe('card catalogue (component 1)', () => {
});
it('deals track FROM the deck, at the sheet\'s counts', () => {
// Column B of Deck cards2.xlsx, "Number in Deck": 32 straights, 16+16 curves, 16+16 turnouts —
// and 4+4 sharp curves, which are dealt none. An earlier reading took the sheet's LAST column,
// "Track Per Player" (26), as a separate stack outside the deck; it is the sheet's 104 shared out
// among four players, not a second pile.
assert.equal(TRACK_IN_DECK, 96);
// Column B of Deck cards5.xlsx, "Number in Deck": 16 straights, 8+8 curves, 8+8 turnouts, and
// 0+0 sharp curves. Sheet 2 had each of those at double, which is what the deck dealt until
// Gitea#14. An earlier reading took the sheet's LAST column, "Track Per Player" (26), as a
// separate stack outside the deck; it is the sheet's total shared out among four players, not a
// second pile.
assert.equal(TRACK_IN_DECK, 48);
const deck = buildDeck();
for (const t of TRACK_CARDS) {
const n = deck.filter(
@@ -144,11 +162,26 @@ describe('card catalogue (component 1)', () => {
});
it('makes track the largest category in the deck', () => {
// 96 of 235. Building a district is paid for in the industry or train you did not draw, which
// 48 of 121. Building a district is paid for in the industry or train you did not draw, which
// is the whole reason it matters that track is a card rather than a private supply.
//
// This asked for a THIRD of the deck until Gitea#14, which was only ever a rule of thumb. It
// asks its own question now — is track still the biggest single thing you can draw — plus a
// loose band, because the exact share is not settled yet and should not be pinned as though it
// were. Sheet 5 puts track at 48 of the 155 cards it would have you shuffle, i.e. 31%; we read
// 40% because the Space-use, Safety, Event and Inspection cards are held out, which concentrates
// everything that is left. The share falls TOWARDS the sheet as those land, so the band is set
// to hold across that whole journey rather than to be re-edited at each step.
const deck = buildDeck();
const track = deck.filter((c) => c.kind.kind === 'track').length;
assert.ok(track > deck.length / 3, `track is only ${track} of ${deck.length} cards`);
const counts = new Map<string, number>();
for (const c of deck) counts.set(c.kind.kind, (counts.get(c.kind.kind) ?? 0) + 1);
const track = counts.get('track') ?? 0;
for (const [kind, n] of counts) {
if (kind === 'track') continue;
assert.ok(track > n, `${kind} has ${n} cards against track's ${track}`);
}
const share = track / deck.length;
assert.ok(share > 0.28 && share < 0.45, `track is ${(share * 100).toFixed(1)}% of the deck`);
});
it('has 12 timetabled trains, odd westbound and even eastbound', () => {
test/sim.test.ts
+54 -9
View File
@@ -189,15 +189,26 @@ describe('the revenue chain works end to end (regression)', () => {
// only because unloads were mis-scored as completed loads after one Laborer action instead of
// four. Correcting that dropped mean revenue from 24.8 to ~4.6 and the win rate to zero, so
// "did anyone win" is no longer a safe proxy for "does freight work".
/**
* TWO HUNDRED GAMES, up from forty (Gitea#3). Completed freight loads got scarcer when the
* Mainline went onto the region model, and measurably so — on these seeds: 40 games yield 0
* loads, 80 yield 3 (1 game), 120 yield 10 (4 games), 200 yield 21 (9 games). Forty could no
* longer reach the precondition it exists to establish.
*
* WHY it got scarcer is not settled and is worth someone's attention rather than a guess — the
* change speeds crossings up, which ought to put MORE trains through a district, not fewer.
* Freight share of gross fell from 8% to 5% over 100 games across the same change. Recorded in
* TODO.md under Play Balance; the assertion itself is untouched.
*/
const report = simulate({
games: 40,
games: 200,
length: 'standard',
mode: 'solitaire',
players: ['bot'],
policy: developerBot,
});
const freight = report.perGame.reduce((n, g) => n + g.revenue.freightLoad, 0);
assert.ok(freight > 0, 'no freight load completed across 40 games');
assert.ok(freight > 0, 'no freight load completed across 200 games');
});
it('grows the Office Area off the Running Track, on either side', () => {
@@ -349,7 +360,24 @@ describe('end-of-game statistics', () => {
* rule that has become unreachable. Exempted by name so the other forty-odd event checks stay live,
* and so removing this line is what proves the bot has been fixed.
*/
const KNOWN_UNREACHABLE_BY_THE_BOT = ['event flyingSwitch'];
/**
* RED FLAGS JOINS IT (Gitea#3), and for the same reason — the rule is reachable and the bot will
* not take it.
*
* MEASURED over 600 games: `maneuver.redFlags` is OFFERED 4,212 times, first in game 5 — so the
* rule is live and constantly available. The bot PLAYS it 4 times, first in game 252. At 200
* games this canary sees nothing and calls it unreachable, which is the opposite of the truth.
*
* It got rarer for two compounding reasons, neither of them a broken rule: Gitea#14 took Red
* Flags from 5 copies to the sheet's 3, and Gitea#3 shortened most crossings to a single Stage,
* so the window in which a train is STANDING on a Mainline card — the only place the card may be
* played — is now usually one Stage wide.
*
* The bot's unwillingness is the thing worth fixing, and it is in TODO.md under Bot Performance.
* Exempted BY NAME so the other forty-odd checks stay live, and so deleting this line is what
* proves the bot has learned to use it.
*/
const KNOWN_UNREACHABLE_BY_THE_BOT = ['event flyingSwitch', 'event redFlagsSet'];
const found = anomalies(report.perGame);
const never = found
.filter((a) => a.severity === 'never')
@@ -641,12 +669,17 @@ describe('the bot builds sidings that are actually sidings (regression)', () =>
// Measured across 100 games: tank cars boarded a train 0.07 times a game and were dropped by a
// crew ZERO times, while boxcars were 67% of every drop — and 23 of 79 waiting loads were
// sitting at an industry that wanted a tank.
// A HUNDRED GAMES, not thirty — the comment above says the original measurement used 100, and
// the sample has to be that big to mean anything: measured now, a tank is set out in 3% of games
// and a reefer in 5%. Thirty games passed on luck and stopped the moment the opening deal moved
// which cards a seed puts in reach. Deterministic seeds, so this either holds or it does not.
// THREE HUNDRED GAMES, up from a hundred, because the sheet's industry density (Gitea#14) makes
// the rare commodities much rarer. Measured on these exact seeds, the game at which each type is
// first set out by a crew: caboose 5, boxcar 12, hopper 37, reefer 44, coach 64, **tank 216**.
//
// A Refinery is one card in a hundred and fifty now, so a tank moving at all needs that card
// drawn, placed, reached and worked. The old sample of 100 stopped covering it — not because the
// rule broke, but because the deck did what the sheet asks. The sample follows the measurement
// rather than the assertion being softened: tank is still the strict test, for the reason below.
// Deterministic seeds, so this either holds or it does not.
const dropped = new Set<string>();
for (let i = 0; i < 100; i++) {
for (let i = 0; i < 300; i++) {
const s = createGame({
id: `cs-${i}`,
seed: 1000 + i * 7919,
@@ -996,6 +1029,12 @@ describe('the bot does not lay track that cannot work (regression)', () => {
// A TIE-BREAKER rather than a veto, so this is a rate and not a zero: forbidding it outright
// measured WORSE (-0.62 revenue a game), while preferring the cleaner of two equally good
// placements measured better and cut these from 28% of pieces to 7%.
//
// AND IT STAYS A TIE-BREAKER. Gitea#15 was filed as "track placements must connect" and briefly
// became a rule here; RAR reversed it on review (2026-08-26) — a rail may stop dead against its
// neighbour, and such a stub is useful as a siding to park cars on. What the engine must refuse
// is a TRAIN crossing the gap, which is `exploreMoves`' job and is tested in `track.test.ts`.
// So laying one of these is a preference, exactly as it was, and the rate below is the bar.
let laid = 0;
let dead = 0;
/**
@@ -1092,8 +1131,14 @@ describe('the freight figures count both halves (regression)', () => {
* The subject here is the INSTRUMENT — does `freightUnload` count Revenue earned rather than
* unloads started — and `unloads > 0` is only the precondition that makes the comparison mean
* anything. Widening the sample restores the precondition without weakening the assertion.
*
* A HUNDRED AND FIFTY DEALS, up from forty, for the same reason as the commodity test above:
* Gitea#14 put the deck on the sheet's industry density and completed unloads went with it.
* Measured on these seeds, the first deal to EARN unload Revenue is number **46**, and 19 deals
* in 400 earn any — so forty could not reach the precondition it exists to establish. 150 clears
* it with room, and the assertion itself is untouched.
*/
for (let i = 0; i < 40; i++) {
for (let i = 0; i < 150; i++) {
const seed = 1000 + i * 7919;
const s = createGame({
id: `fu-${seed}`, seed,
test/track.test.ts
+94
View File
@@ -540,6 +540,100 @@ describe('placement and drop-off', () => {
assert.ok(!canPlaceAt(area, at(-1, 1), straight()), 'an east-west straight cannot meet a 45° leg');
});
describe('a rail that stops dead against its neighbour (Gitea#15)', () => {
/**
* REPORTED, THEN REVERSED. The issue first read "if a card is placed in that space, it MUST
* connect", against a right-hand curve laid at (1,-1) with an Ice House above it and a turnout
* with a north-facing leg below. **RAR reviewed it and ruled the other way (2026-08-26): the
* placement is fine, and a stub like that has a use — a siding to park cars on.**
*
* "We need to confirm, however, that trains are not allowed to traverse from the turnout below
* to that right-hand curve since the tracks do not connect." That is what these tests are: the
* rule lives in MOVEMENT, not in placement.
*
* The save cannot carry this any more — Gitea#14 took the deck from 206 cards to 121, so its
* card ids no longer exist and the history stops at the first `card.play`. The geometry is what
* mattered, and it is rebuilt here directly.
*/
/** A Modifier card — an Ice House. Not track: no ports on any edge. */
const modifierCard = (): TrackCard => ({
geometry: { kind: 'modifier', modifier: 'iceHouse' },
baseOperationalRail: false,
standing: [],
standingWest: 0,
facility: null,
modifiers: [],
enhancements: [],
});
/** A Grocer's Warehouse — a Facility, so a plain east-west through track. */
const warehouse = (): TrackCard => ({
geometry: { kind: 'facility', facility: 'grocersWarehouse' },
baseOperationalRail: true,
standing: [],
standingWest: 0,
facility: null,
modifiers: [],
enhancements: [],
});
/**
* The reported district. `withCurve` puts the disputed right-hand curve on the square; without
* it, the square is empty and the placement itself is under test.
*
* The turnout's leg goes NORTH on the `nw_se` diagonal; the curve is `ne`, which is `ne_sw` and
* has no south port at all. Two reasons the two do not join, either of which is enough.
*/
const board = (withCurve: boolean): OfficeArea =>
areaFrom(
{
[coordKey(at(0, -1))]: turnout({ stem: 'w', through: 'e', diverge: 'n' }),
[coordKey(at(0, 0))]: officeCard(),
[coordKey(at(1, 0))]: warehouse(),
[coordKey(at(2, -1))]: modifierCard(),
...(withCurve ? { [coordKey(at(1, -1))]: curve('ne') } : {}),
},
at(0, 0),
);
it('allows the reported placement, which connects on one side and nothing else', () => {
// RAR's ruling. The curve joins the warehouse to its east; its north leg faces an Ice House
// that carries no rail, and the turnout below faces its portless south edge. All legal.
assert.ok(canPlaceAt(board(false), at(1, -1), curve('ne')), 'the reported play was refused');
});
it('will not let a train cross from the turnout below onto that curve', () => {
// The confirmation the issue actually asks for. Running west out of the Office and into the
// turnout, the 45° leg goes north — and stops at the curve's blank south edge.
const dests = reachableDestinations(ctxFor(board(true)), at(0, 0), 'w');
assert.ok(!has(dests, 1, -1), 'a train drove across rails that do not meet');
});
it('still reaches the curve from the side that DOES join', () => {
// Otherwise the test above would pass on a card that is simply unreachable, which proves
// nothing. East of the curve is the warehouse, and east-west edges always meet.
const dests = reachableDestinations(ctxFor(board(true)), at(1, 0), 'w');
assert.ok(has(dests, 1, -1), 'the curve was unreachable from the side that joins');
});
it('will not let a train cross a north edge onto a card with no rail at all', () => {
// The Ice House above. A Modifier is scenery beside the rails — Jesse confirmed a rail may
// point at a building — so what stops a train is the same `joins` test, not a placement rule.
const dests = reachableDestinations(ctxFor(board(true)), at(1, 0), 'w');
assert.ok(!has(dests, 2, -1), 'a train drove into an Ice House');
});
it('still allows an exit that faces a BLANK square', () => {
// Unchanged by the reversal, and the reason a district can grow at all: a turnout laid on the
// Running Track with nothing yet beside its diverging leg is a perfectly good play.
const area = areaFrom({ [coordKey(at(0, 0))]: officeCard() }, at(0, 0));
assert.ok(
canPlaceAt(area, at(0, 1), turnout({ stem: 'w', through: 'e', diverge: 'n' })),
'a turnout whose leg faces open space was refused',
);
});
});
it('refuses a card that connects to nothing', () => {
const area = areaFrom({ [coordKey(at(0, 0))]: officeCard() }, at(0, 0));
assert.ok(!canPlaceAt(area, at(3, 3), straight()), 'orphaned track is never legal');
test/web.test.ts
+58 -10
View File
@@ -907,17 +907,29 @@ describe('the page explains itself', () => {
// A played card becomes a cell with a name on it — "turnout", "Freight House", "waiting area" —
// and the explanation that was visible while it sat in hand disappears exactly when it starts
// mattering. Play a long way in so every card kind reaches the grid.
const game = newGame(111);
for (let i = 0; i < 400; i++) {
if (currentActor(game) === null) break;
const { options } = actionGroups(game);
if (options.length === 0) break;
const pick = options.find((o) => o.type === 'card.play' && o.placement) ?? options[0]!;
if (!submit(game, pick)) break;
/**
* THE SEED IS SEARCHED FOR, not written down. This took seed 111 flat and asserted its board
* ended up with more than four cards on it. Gitea#3 changed how fast trains cross, which changes
* how a game unfolds, and 111 stopped building enough of a district — so the test failed on its
* own precondition rather than on anything about tooltips.
*
* It needs A well-built board, not one particular one, so it takes the first seed that gives it.
*/
let game = newGame(111);
for (let seed = 111; seed < 211; seed++) {
game = newGame(seed);
for (let i = 0; i < 400; i++) {
if (currentActor(game) === null) break;
const { options } = actionGroups(game);
if (options.length === 0) break;
const pick = options.find((o) => o.type === 'card.play' && o.placement) ?? options[0]!;
if (!submit(game, pick)) break;
}
if (view(game).cells.length > 4) break;
}
const cells = view(game).cells;
assert.ok(cells.length > 4, 'not enough of the board was built to be a real check');
assert.ok(cells.length > 4, 'no seed under 211 built enough of a board to be a real check');
for (const c of cells) {
assert.ok(c.what.length > 0, `(${c.row},${c.col}) ${c.label} has no explanation`);
// camelCase on the board is the failure that keeps recurring — labels AND descriptions.
@@ -1534,7 +1546,40 @@ describe('the static build', () => {
(target['onclick'] as (() => void) | null)?.();
return true;
};
assert.ok(clickVerb(hand, 'play'), 'no card in hand offers a play verb');
/**
* TRY EVERY PLAY BUTTON, NOT JUST THE FIRST — a card offering "play" does not necessarily play
* ONTO THE BOARD.
*
* This clicked the first play verb it found and then asserted the board had lit up. A train card
* plays to the timetable and a Department discard to the piles, so neither lights a square, and
* whether the first playable card in this deal happens to be a track or facility card is luck.
* Gitea#14's deck counts re-dealt seed 555, the first play verb landed on Train 2, and the test
* failed claiming the page highlighted nothing — when the page was right and the card simply had
* no square to point at.
*
* So it clicks each play button in turn until the board lights, which is the property the test
* is named for. It still fails loudly if NO card in hand can light a square.
*
* EACH BUTTON IS CLICKED EXACTLY ONCE. Picking a card is a toggle, so clicking one to check it
* and then clicking it again inside the loop would UNPICK it — which is how the first draft of
* this managed to fail on a deal whose very first play card was a good one.
*/
const playButtons = (el: Record<string, unknown>): Record<string, unknown>[] => {
const fn = el['querySelectorAll'] as (s: string) => Record<string, unknown>[];
return fn
.call(el, 'button.cardact')
.filter((n) => (n['dataset'] as Record<string, string>)['verb'] === 'play');
};
assert.ok(playButtons(hand).length > 0, 'no card in hand offers a play verb');
let litTheBoard = false;
for (const target of playButtons(hand)) {
(target['onclick'] as (() => void) | null)?.();
const drawn = String(grid['innerHTML']);
if ((grid['highlighted'] as () => unknown[])().length > 0 || /data-ghost="/.test(drawn)) {
litTheBoard = true;
break;
}
}
// Without the board stylesheet every shape is drawn black on a near-black background: the page
// looks empty even though the markup is perfect.
@@ -1547,7 +1592,10 @@ describe('the static build', () => {
assert.match(html, /data-cell="/, 'the board drew no addressable cards');
const lit = (grid['highlighted'] as () => unknown[])();
const ghosts = /data-ghost="/.test(html);
assert.ok(lit.length > 0 || ghosts, 'picking a card highlighted nothing on the board');
assert.ok(
litTheBoard || lit.length > 0 || ghosts,
'no card in hand, picked in turn, ever highlighted a square on the board',
);
/**
* POINTING AT THE SQUARE A BUTTON MEANS — wired on the emitted bundle, not asserted off the menu.