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

v0.7.2 — a leg that is part of the row, the deck the sheet prints, regions not miles per hour, and a Division you read left to right

Browse Source 
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. The same
assumption left a crew's own cut standing when it pulled out through a leg,
which is the "cars left behind" report we had failed to reproduce.

Gitea#14 — every count is docs/Deck cards5.xlsx. Track halved, and the Q12
office doubling and Gap 12 industry tripling both come out with it: they were
measured against a deck with twice the track, and keeping them at the sheet's
track count wipes out the reefer chain entirely. 84 rows now match card for
card; the ten Safety, Event and Inspection cards it adds are not built and are
held out. Cards the sheet no longer lists are dealt zero copies rather than
deleted, so their rules stay implemented.

Gitea#15 — RAR reversed it: a rail may stop dead against its neighbour and the
placement is legal. What must hold is that no train crosses the gap, which was
already true and is now pinned against the reported board.

Gitea#3 — the printed speeds are scenery. A card costs one Stage per printed
region and where a train STARTS is what varies; Fast/Slow is read on Hilly
alone. Entering a one-region card behind another is a collision now, which is
what ABS exists to prevent, and ABS no longer holds trains silently.

Gitea#18 — the Division draws as one row, west to east, with no office-area
detail. East is finally always to the right.

Closes #3
Closes #14
Closes #15
Closes #17
Closes #18
This commit is contained in:
Jesse.Markowitz
2026-08-26 15:20:56 -04:00
parent 441447648d
commit 2ab25e320c
23 changed files with 4619 additions and 3264 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/sim/board-svg.ts
+190 -157
View File
@@ -65,7 +65,30 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
* anything outside its own body.
*/
const CW = { dp: 118, ml: 152, run: 78 };
const CH = 58;
/**
* TALL ENOUGH FOR TWO REGISTERS OF CHIPS, on every cell so the rail runs level across the row.
* Was 58, when a cell held one row of trains.
*/
const CH = 76;
/**
* EVERY DISTRICT THE SAME WIDTH, sized for four chips two-by-two and NOT for its A/D count.
*
* Measured over 60 games: one office area holds at most 4 distinct trains, and up to 3 of those
* can be crews switching below the Running Track — which do not occupy A/D tracks at all. So a
* Whistle Post, with its single A/D track, can still have four trains to show, and sizing the cell
* by capacity would overflow it. Sizing by OCCUPANCY is worse still: that is what "The Roster
* Pass" fixed, because the cell then resizes as trains come and go and shoves the rest of the map
* sideways. A fixed two-by-two block holds the map still all game, upgrades included.
*/
const OFFICE_W = 2 * 54 + 12;
/**
* THE VERTICAL ANATOMY OF A CELL, so the two chip registers and the rail cannot drift apart.
* The rail sits above centre; A/D chips straddle it, and the district register hangs below —
* which is where those trains are on the real board (Gitea#18).
*/
const RAIL_Y = 34;
const CHIP_Y = RAIL_Y - 10;
const BELOW_Y = RAIL_Y + 13;
const GAP = 6;
/**
* ONE FIXED SLOT PER A/D TRACK, so the Office Running Track cell is drawn wide enough to hold
@@ -115,6 +138,12 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
seat: number | null;
/** Set on an Office cell when a roster was supplied: whose district this is. */
owner?: { name: string; isTurn: boolean; isYou: boolean } | null;
/**
* Office cells only: trains in the district that are NOT holding an A/D track — a crew switching
* below the Running Track, or a train standing on it away from the Office. Drawn in a second
* register under the rail (Gitea#18).
*/
below?: Cell['trains'];
/** Mainline cards only: §2.1 divides one into two regions. 0 elsewhere — no bars are drawn. */
regions: number;
w: number;
@@ -122,11 +151,8 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
y: number;
};
const cells: Cell[] = [];
const sides: number[][] = [];
let side: number[] = [];
const push = (c: Omit<Cell, 'x' | 'y'>): void => {
side.push(cells.length);
cells.push({ ...c, x: 0, y: 0 });
};
@@ -152,47 +178,54 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
}
: null;
for (const rc of n.running ?? []) {
const isOffice = rc.kind === 'office';
const adLabel = cap === null ? '' : `A/D ${ad.length}/${cap}`;
push({
kind: 'run',
label: isOffice && owner ? owner.name : rc.label,
owner: isOffice ? owner : null,
// With an owner on the headline the tier would otherwise vanish, so it joins the A/D
// count on the line below.
sub: isOffice ? (owner ? [rc.label, adLabel].filter(Boolean).join(' · ') : adLabel) : '',
/**
* A train standing at the Office occupies an A/D track, which is where it is — but it is
* ALSO standing on the Office grid card, so it arrives here in both lists and used to be
* drawn twice. Reported as two T10 chips on one Office.
*/
trains: isOffice
? [...rc.trains, ...ad.filter((t) => !rc.trains.some((r) => r.label === t.label))]
: rc.trains,
cap: isOffice ? cap : null,
tip: owner && isOffice
? `${owner.name}'s ${rc.label}` +
(owner.isYou ? ' — this is your railroad' : '') +
// "their move" is wrong when the reader is the one being waited on.
(owner.isTurn ? (owner.isYou ? ' — it is your move' : ' — it is their move') : '')
: `${rc.label} — ${rc.kind === 'limits' ? 'the end of this district; the Running Track runs between the Limits' : 'Running Track'}`,
seat: n.seat ?? null,
// No regions inside a district: a crew moves by Moves there, not by Stages, so it
// occupies a card outright rather than a part of one.
regions: 0,
w: isOffice && cap !== null ? Math.max(CW.run, cap * CHIP_W + 12) : CW.run,
});
/**
* ONE CELL PER DISTRICT — NO OFFICE-AREA DETAIL ON THIS MAP (Gitea#18).
*
* An Office used to expand into its whole Running Track, Limits to Limits, so this map carried
* every straight, turnout, facility and Limits sign of every district. Two things were wrong
* with that. It is the OFFICE map's job, and it draws all of it properly, with the rails; and
* it made the Division map grow sideways as districts were built, shoving everything east of a
* district along every time somebody laid a card.
*
* TRAINS STAY. "Trains within the office area should definitely be represented on the division
* map" — at a glance the number and which way it is pointing, and the consist on the tooltip.
* They are split into two registers, because a train holding an A/D track and a crew switching
* in the district are not the same thing: A/D occupancy is a hard capacity that causes
* collisions, switching is not. The split is drawn as POSITION rather than colour — A/D on the
* rail, the rest below it — which is where those trains actually are.
*/
const seen = new Set(ad.map((t) => t.label));
const below: typeof ad = [];
for (const t of [...(n.running ?? []).flatMap((rc) => rc.trains), ...(n.switching ?? [])]) {
if (seen.has(t.label)) continue;
seen.add(t.label);
below.push(t);
}
// A crew below the Running Track has no position ON it, so it is reported against the
// district rather than drawn somewhere it is not.
const below = n.switching ?? [];
if (below.length > 0) {
const last = cells[cells.length - 1];
if (last) last.sub = `${below.length} switching below`;
}
sides.push(side);
side = [];
const adLabel = cap === null ? '' : `A/D ${ad.length}/${cap}`;
push({
kind: 'run',
label: owner ? owner.name : n.label,
owner,
sub: [owner ? n.label : '', adLabel, below.length > 0 ? `${below.length} switching` : '']
.filter(Boolean)
.join(' \u00b7 '),
trains: ad,
below,
cap,
tip:
(owner ? `${owner.name}'s ${n.label}` : n.label) +
(owner?.isYou ? ' — this is your railroad' : '') +
// "their move" is wrong when the reader is the one being waited on.
(owner?.isTurn ? (owner.isYou ? ' — it is your move' : ' — it is their move') : '') +
`\n\nThe district itself is drawn on the Office map — this cell is the whole of it, with the ` +
`trains standing in it: those holding an A/D track on the rail, and any crew switching in ` +
`the district below it.`,
seat: n.seat ?? null,
// No regions in a district: a crew moves by Moves there, not by Stages, so it occupies a
// card outright rather than a part of one.
regions: 0,
w: OFFICE_W,
});
continue;
}
const dp = n.kind === 'dp';
@@ -229,58 +262,31 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
w: dp ? CW.dp : CW.ml,
});
}
if (side.length > 0) sides.push(side);
// Each player's side carries their district and the Mainline card leading into it; whatever is
// left over (the last Mainline and the East DP) joins the final side.
const seats = Math.max(1, Math.min(4, nodes.filter((n) => n.kind === 'office').length));
const lanes: number[][] = [];
for (let i = 0; i < seats; i++) lanes.push([]);
sides.forEach((grp, i) => {
const target = Math.min(i, seats - 1);
for (const idx of grp) lanes[target]!.push(idx);
});
// -- lay the sides out around the table -------------------------------------------------------
// top → right → bottom (reversed) → left (reversed), which gives a row, two facing rows, a
// horseshoe open to the west, and a square broken at the same place.
const dir: ('top' | 'right' | 'bottom' | 'left')[] =
seats === 1 ? ['top'] : seats === 2 ? ['top', 'bottom'] : seats === 3 ? ['top', 'right', 'bottom'] : ['top', 'right', 'bottom', 'left'];
const runLen = (idxs: number[]): number =>
idxs.reduce((n, i) => n + cells[i]!.w + GAP, -GAP);
const widest = Math.max(...lanes.map((l) => runLen(l)), 200);
const tall = lanes.length > 1 ? Math.max(...lanes.map((l) => l.length), 1) * (CH + GAP) : CH;
const vertCount = dir.filter((d) => d === 'right' || d === 'left').length;
const boardW = PAD * 2 + widest + (vertCount > 0 ? CW.run + SIDE_GAP : 0);
const boardH = PAD * 2 + (dir.includes('bottom') ? CH * 2 + SIDE_GAP + (vertCount ? tall : 0) : CH) + 30;
lanes.forEach((idxs, i) => {
const d = dir[i]!;
if (d === 'top' || d === 'bottom') {
const y = d === 'top' ? PAD : boardH - PAD - CH - 22;
const order = d === 'bottom' ? [...idxs].reverse() : idxs;
let x = PAD;
for (const idx of order) {
const c = cells[idx]!;
c.x = x;
c.y = y;
x += c.w + GAP;
}
} else {
const x = d === 'right' ? boardW - PAD - CW.run : PAD;
const order = d === 'left' ? [...idxs].reverse() : idxs;
let y = PAD + CH + SIDE_GAP;
for (const idx of order) {
const c = cells[idx]!;
c.x = x;
c.y = y;
c.w = CW.run;
y += CH + GAP;
}
}
});
/**
* ONE ROW, WEST TO EAST (Gitea#18). The West Division Point is at the far left, the East at the
* far right, and nothing wraps.
*
* IT USED TO BE LAID OUT AROUND A TABLE — one row for a single seat, two facing rows for two, a
* horseshoe for three, a square for four — on the reasoning that players sit around a table so the
* route should too. That cost more than it bought, and three separate reports came out of it: the
* buffer stops pointed the wrong way once the route turned a corner, and, the one that decided it,
* **east stopped being to the right**. A player's east could be drawn south, west or north
* depending on which lane their district landed in, on a map whose whole job is saying which way
* a train is going.
*
* A row is wider than a square — roughly 1,580px at four players against 842 — and that is
* accepted: the map scrolls and zooms, and being able to rely on east meaning right is worth the
* scroll.
*/
let x = PAD;
for (const c of cells) {
c.x = x;
c.y = PAD;
x += c.w + GAP;
}
const boardW = x - GAP + PAD;
const boardH = PAD * 2 + CH + 30;
// -- draw -------------------------------------------------------------------------------------
const rail = (x1: number, y: number, x2: number): string => {
@@ -295,20 +301,29 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
return o;
};
// The same rail turned through ninety degrees, for the sides of the table.
const railV = (x: number, y1: number, y2: number): string => {
let o =
`<line class="bs-rail" x1="${x - 2.5}" y1="${y1}" x2="${x - 2.5}" y2="${y2}"/>` +
`<line class="bs-rail" x1="${x + 2.5}" y1="${y1}" x2="${x + 2.5}" y2="${y2}"/>`;
const n = Math.max(2, Math.floor(Math.abs(y2 - y1) / 9));
for (let i = 0; i <= n; i++) {
const ty = y1 + ((y2 - y1) * i) / n;
o += `<line class="bs-tie" x1="${x - 4.5}" y1="${ty}" x2="${x + 4.5}" y2="${ty}"/>`;
}
return o;
};
let out = `<svg class="bs bs-div" viewBox="0 0 ${Math.ceil(boardW)} ${Math.ceil(boardH)}" preserveAspectRatio="xMinYMin meet">`;
/**
* DRAWN AT ITS OWN SIZE, SO IT SCROLLS RATHER THAN SHRINKING (Gitea#18).
*
* An SVG has a viewBox and a drawn size, and the browser scales one to the other. `.bs` is
* `width:100%`, so the map is drawn at whatever the panel is wide — which was harmless while the
* Division was 842px and wrapped around a table, and is not now that a single row is 1,580px. At
* that width in an 800px panel every label renders at half size, on the map that needs reading
* most. Setting the width to the viewBox width makes one unit one pixel, and the containers
* already scroll (`#division`, `#vdivision`).
*
* THE PLAYABLE PAGE DOES NOT NEED THIS — `applyZoom` (`main.ts`) sets exactly the same width from
* the same viewBox after every render, and overrides this when the zoom is not 100%. THE REPLAYS
* DO: neither `replays.ts` nor the standalone `replay.ts` calls it, so without this they get the
* `width:100%` shrink. It is inline rather than in `BOARD_CSS` because only this function knows
* how wide the row came out.
*
* `flex:none` because `#division` is a flex container and a flex item may be shrunk below an
* explicit width; there is no point pinning it and then letting the panel squeeze it anyway.
*/
let out =
`<svg class="bs bs-div" viewBox="0 0 ${Math.ceil(boardW)} ${Math.ceil(boardH)}" ` +
`style="width:${Math.ceil(boardW)}px;flex:none" ` +
`preserveAspectRatio="xMinYMin meet">`;
// The joins between consecutive cells, drawn as rail so a connection is rail meeting rail. A join
// that crosses from one player's side to the next is drawn heavier and labelled: that boundary is
@@ -316,23 +331,7 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
for (let i = 0; i + 1 < cells.length; i++) {
const a = cells[i]!;
const b = cells[i + 1]!;
const sameRow = Math.abs(a.y - b.y) < 1;
const sameCol = Math.abs(a.x - b.x) < 1;
if (sameRow && b.x > a.x) out += rail(a.x + a.w, a.y + CH / 2, b.x);
else if (sameRow && b.x < a.x) out += rail(b.x + b.w, a.y + CH / 2, a.x);
else if (sameCol) {
// Stacked down one side of the table: still one straight run of track, not a turn.
const top = Math.min(a.y + CH, b.y + CH);
const bot = Math.max(a.y, b.y);
out += railV(a.x + a.w / 2, top, bot);
} else {
// A turn between sides: an elbow, so the route is visibly continuous around the table.
const ax = a.x + a.w / 2;
const bx = b.x + b.w / 2;
const ay = a.y + CH;
const by = b.y;
out += `<path class="bs-turn" d="M${ax} ${ay} L${ax} ${(ay + by) / 2} L${bx} ${(ay + by) / 2} L${bx} ${by}"/>`;
}
out += rail(a.x + a.w, a.y + RAIL_Y, b.x);
}
cells.forEach((c) => {
@@ -348,15 +347,14 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
const mark = c.owner ? ` bs-owner${c.owner.isTurn ? ' bs-turn' : ''}${c.owner.isYou ? ' bs-you' : ''}` : '';
const suffix = c.owner?.isYou ? ' (you)' : '';
out += `<text class="bs-name${mark}" x="${c.x + 7}" y="${c.y + 14}">${esc(c.label + suffix)}</text>`;
out += rail(c.x + 6, c.y + 32, c.x + c.w - 6);
out += rail(c.x + 6, c.y + RAIL_Y, c.x + c.w - 6);
if (c.sub) out += `<text class="bs-cap" x="${c.x + 7}" y="${c.y + CH - 6}">${esc(c.sub)}</text>`;
// REGIONS. §2.1 divides a Mainline card into two, and §8.2 moves a train one region per Stage.
// The bars are the card's DISTANCE and never vary; what varies is how fast a train covers them,
// so a 60 card is crossed in one Stage and a slow train on a 30 takes three.
// REGIONS. A Mainline card is 1 to 3 of them (Gitea#3) and a train advances one per Stage. The
// bars are the card's DISTANCE and never vary; where a train STARTS is what does.
const RW = c.regions > 0 ? (c.w - 12) / c.regions : 0;
for (let r = 0; r < c.regions; r++) {
out += `<line class="bs-region" x1="${c.x + 6 + RW * r}" y1="${c.y + 20}" x2="${c.x + 6 + RW * r}" y2="${c.y + 44}"/>`;
out += `<line class="bs-region" x1="${c.x + 6 + RW * r}" y1="${c.y + RAIL_Y - 14}" x2="${c.x + 6 + RW * r}" y2="${c.y + RAIL_Y + 10}"/>`;
}
/**
@@ -371,36 +369,25 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
* So this keeps the two things the Division map is actually for — where a train is and which way
* it is going — and leaves the cars to the tooltip and to the district.
*/
c.trains.forEach((t, k) => {
/**
* A TRAIN IS A CHIP — its number, which way it points, and how many cars.
*
* It was drawn as a full consist here, matching the Office Area card, and reported as too large
* and hard to read. The Office card is where a consist is worth drawing, because that is where
* the switching decisions are made and where there is room to read it. So this keeps the two
* things the Division map is for — where a train is and which way it is going — and leaves the
* cars to the tooltip and to the district.
*/
const chip = (t: NonNullable<Cell['trains']>[number], tx: number, ty: number, w: number): void => {
const cars = t.cars ?? [];
const arrow = t.facing === 'w' ? '\u25c0' : '\u25b6';
const loaded = cars.filter((x) => /^loaded/.test(x) || /caboose/.test(x)).length;
const label = cars.length === 0 ? `${t.label} ${arrow}` : `${t.label} ${arrow}${cars.length}`;
/**
* THE OFFICE RUNNING CELL GETS FIXED SLOTS, ONE PER A/D TRACK — never a centre spread.
*
* Centred spreading pushes its outer chips outward as MORE trains arrive, and the cell was
* sized for the cards it holds, not for its trains — so two chips at a Station used to land at
* x 215–267 and 271–316 inside a cell spanning only 230–308, spilling onto the Limits cards
* either side. A fixed slot per A/D track cannot overflow the cell at any occupancy, because
* the cell was sized for exactly that many slots (see `CHIP_W` above).
*/
const isOfficeRun = c.kind === 'run' && c.cap !== null && c.cap > 0;
const slotW = isOfficeRun ? (c.w - 12) / c.cap! : 0;
const w = isOfficeRun ? Math.min(slotW - 4, label.length * 6.6 + 12) : Math.min(c.w - 8, label.length * 6.6 + 12);
// A train on a Mainline card sits in ITS region; anywhere else it just sits on the card.
const inRegion = c.regions > 1 && typeof t.region === 'number';
const tx = isOfficeRun
? c.x + 6 + slotW * (k + 0.5)
: (inRegion ? c.x + 6 + RW * (t.region ?? 0) + RW / 2 : c.x + c.w / 2) +
(inRegion ? 0 : (k - (c.trains.length - 1) / 2) * (w + 4));
const dir = t.direction === 'west' ? ' \u25c0 west' : t.direction === 'east' ? ' east \u25b6' : '';
const stages =
typeof t.stagesLeft === 'number'
? ` \u00b7 ${t.stagesLeft} Stage${t.stagesLeft === 1 ? '' : 's'} still to run across this card` +
' (Stages, not regions: a card is two regions of fixed distance, and how many Stages a' +
' train takes over them depends on the card speed and the train)'
? ` \u00b7 ${t.stagesLeft} Stage${t.stagesLeft === 1 ? '' : 's'} still to run across this card`
: '';
out += `<g class="bs-train" data-tip="${esc(t.label)} \u2014 carrying ${esc(cars.join(', ') || 'no cars')}${
cars.length ? ` (${loaded} loaded)` : ''
@@ -409,15 +396,61 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
// me?" gets asked, and EXPEDITED is the answer more often than not.
t.what ? `\n\n${esc(t.what)}` : ''
}">` +
`<rect x="${tx - w / 2}" y="${c.y + 22}" width="${w}" height="19" rx="3"/>` +
`<text class="bs-tlab" x="${tx}" y="${c.y + 35}" text-anchor="middle">${esc(label)}</text>`;
`<rect x="${tx - w / 2}" y="${ty}" width="${w}" height="19" rx="3"/>` +
`<text class="bs-tlab" x="${tx}" y="${ty + 13}" text-anchor="middle">${esc(label)}</text>`;
out += '</g>';
};
const textW = (t: NonNullable<Cell['trains']>[number]): number =>
(`${t.label} \u25b6${(t.cars ?? []).length || ''}`).length * 6.6 + 12;
/**
* TWO CHIPS TO A REGISTER ON A DISTRICT, in fixed slots — never a centre spread.
*
* Centred spreading pushes its outer chips outward as more trains arrive, which is how two chips
* at a Station once landed outside the cell that held them. Fixed slots cannot overflow, because
* the cell was sized for exactly that many (`OFFICE_W`).
*/
const isDistrict = c.kind === 'run';
const SLOTS = 2;
const slotW = (c.w - 12) / SLOTS;
c.trains.forEach((t, k) => {
if (isDistrict) {
// Row-major within the A/D register: two across, then wrap under. A district can hold four
// trains and only two fit across it.
const col = k % SLOTS;
const row = Math.floor(k / SLOTS);
chip(t, c.x + 6 + slotW * (col + 0.5), c.y + CHIP_Y + row * 21, Math.min(slotW - 4, textW(t)));
return;
}
// A train on a Mainline card sits in ITS region; anywhere else it just sits on the card.
const inRegion = c.regions > 1 && typeof t.region === 'number';
const w = Math.min(c.w - 8, textW(t));
const tx = (inRegion ? c.x + 6 + RW * (t.region ?? 0) + RW / 2 : c.x + c.w / 2) +
(inRegion ? 0 : (k - (c.trains.length - 1) / 2) * (w + 4));
chip(t, tx, c.y + CHIP_Y, w);
});
/**
* THE SECOND REGISTER, under the rail: trains in the district that hold no A/D track (Gitea#18).
*
* A crew switching below the Running Track and a train standing at an A/D track are different
* things — A/D occupancy is a hard capacity that causes collisions, switching is not — and the
* difference is drawn as POSITION rather than as a colour to learn, because below the rail is
* where those trains actually are.
*/
(c.below ?? []).forEach((t, k) => {
const col = k % SLOTS;
const row = Math.floor(k / SLOTS);
chip(t, c.x + 6 + slotW * (col + 0.5), c.y + BELOW_Y + row * 21, Math.min(slotW - 4, textW(t)));
});
out += '</g>';
});
// THE ENDS. The route stops at both Division Points; drawing buffer stops and naming the gap is
// what stops a seated layout being read as a loop.
// THE ENDS. The route stops at both Division Points, and the buffer stops say so — a Division is
// a LINE, not a loop. With a single row (Gitea#18) they simply face outward at the two ends, west
// on the left and east on the right, which is the bug reported twice against the wrapped layout.
const first = cells[0];
const last = cells[cells.length - 1];
/**
src/sim/view.ts
+15 -24
View File
@@ -10,6 +10,7 @@
* drift into two different pictures of the same board.
*/
import { regionOfTransit } from '../engine/advance.ts';
import {
areaAtSeat,
areaOf,
@@ -32,7 +33,6 @@ import {
MANEUVER_CARDS,
MODIFIER_PROFILES,
REALIGNMENTS,
REGIONS_PER_MAINLINE_CARD,
OFFICE_ORDER,
SPACE_USE_CARDS,
enhancementRule,
@@ -1165,36 +1165,27 @@ export function snapshot(
// Crossing time is in Stages now, so a Mainline card shows its terrain and the trains on it
// with how long each still has to run.
const name = MAINLINE_PROFILES.find((m) => m.kind === n.card)?.name ?? n.card;
const isGrade = MAINLINE_PROFILES.find((m) => m.kind === n.card)?.speed.kind === 'grade';
const isGrade = n.card === 'heavyGrade';
/**
* WHERE ON THE CARD, from what the crossing already cost.
* WHERE ON THE CARD — now simply what the card says.
*
* §2.1 divides a Mainline card into two regions and §8.2 moves a train one region per Stage.
* The engine crosses in `crossingStages` Stages instead, which varies by card speed, train
* speed, passengers and modifiers — so the printed model is recovered by treating the entry
* point as the thing that varies, exactly as the cards do:
* This used to recover a printed two-region model from a crossing time computed out of the
* card's mph, the train's Fast/Slow class, its consist and any modifiers, by treating the
* ENTRY point as the thing that varied: `entry = 2 - stagesTotal`. It even had to cope with a
* negative entry, for a slow train needing three Stages to cross a card with two regions.
*
* entry = REGIONS - stagesTotal position = entry + elapsed
*
* A 60 card is one Stage, so the train enters at the second region and is gone — which is
* what "Start positions further along the card" means on the printed art. A 30 card is two
* Stages, giving one region per Stage, which is §8.2 exactly. A slow train needing three
* Stages cannot fit three steps into two regions, so it holds in the first for a Stage: the
* card's distance is fixed and the train is simply slow across it.
* Gitea#3 turned that the right way up. Regions are the primary thing — printed on the card,
* one per Stage — and the entry point is what the rules actually move. There is nothing left
* to reconstruct.
*/
const place = (t: { stagesRemaining: number; stagesTotal: number }): number => {
// `entry` may be NEGATIVE — a slow train needing three Stages cannot fit three steps into
// two regions, so it notionally starts before the card and spends the extra Stage getting
// to the first region. Clamping only the final position keeps that Stage at the START,
// where being slow shows; clamping `entry` first would have parked it at the exit instead.
const entry = REGIONS_PER_MAINLINE_CARD - t.stagesTotal;
const elapsed = t.stagesTotal - t.stagesRemaining;
return Math.min(REGIONS_PER_MAINLINE_CARD - 1, Math.max(0, entry + elapsed));
};
// One region per Stage, straight off the card's own count: what a train has LEFT to run says
// where it is standing. `regionOfTransit` is the engine's own answer, so the picture and the
// collision rule cannot disagree about who is where.
const place = (t: { stagesRemaining: number }): number => regionOfTransit(n.card, t.stagesRemaining);
return {
kind: 'ml',
label: name,
regions: REGIONS_PER_MAINLINE_CARD,
regions: mainlineProfile(n.card).regions,
trains: [n.transits.map((t) => {
const chip = trainChip(s, t.tray);
return {