Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Jesse.MarkowitzandClaude Opus 5
|
7c35e002af |
-10
@@ -15,7 +15,6 @@ Thumbs.db
|
||||
# "tsc: not found" and 20 tests failed for a reason that had nothing to do with the code.
|
||||
node_modules
|
||||
dist/
|
||||
dist-test/
|
||||
build/
|
||||
target/
|
||||
__pycache__/
|
||||
@@ -41,12 +40,3 @@ __pycache__/
|
||||
# website's replay viewer. It was therefore never committed, and a fresh clone was missing a page
|
||||
# the build copies unconditionally. Only the throwaway files this directory collects are ignored.
|
||||
/replay*.html
|
||||
|
||||
# Playtest saves — somebody's game, attached to a bug report.
|
||||
#
|
||||
# ANCHORED, and with the README exempted: the directory has to exist and say what it is for, while
|
||||
# nothing that lands in it is ever committed. A save is a seed plus the moves made, it belongs to
|
||||
# whoever sent it, and it goes stale the moment the rules move. `public/replays/` is the place for
|
||||
# one that is worth publishing.
|
||||
/playtests/*
|
||||
!/playtests/README.md
|
||||
|
||||
+3
-1435
File diff suppressed because it is too large
Load Diff
@@ -10,48 +10,29 @@ train into an occupied Subdivision. Get that wrong and two trains meet at speed.
|
||||
|
||||
## Status
|
||||
|
||||
**Solitaire is playable in a browser and multiplayer runs against a server.** The solitaire game runs
|
||||
entirely client-side — the engine is pure, imports nothing outside itself, and never touches
|
||||
`Math.random`, so a static host is all it needs. Multiplayer adds an authoritative server for the
|
||||
seats a shared game requires.
|
||||
**v0.4.8 — solitaire is playable in a browser.** The whole game runs client-side: the engine is pure,
|
||||
imports nothing outside itself, and never touches `Math.random`, so a static host is all it needs.
|
||||
|
||||
The current version is in [`package.json`](package.json), and every page stamps it with the commit
|
||||
and build date, so what is deployed can always be identified from the page itself. This section
|
||||
deliberately no longer names one: it went stale for six releases.
|
||||
|
||||
- **Rules** — specified. Thirteen gaps in the original prototype rules were found and closed, and the
|
||||
three that came after were all settled in v0.5.0: a coach may be set out at the Office (§A.4),
|
||||
Poling stays out of the deck at zero copies since the source records its effect only as "TBD", and
|
||||
**a Heavy Grade's orientation is rolled from the seed, never chosen by a player** — see
|
||||
[`docs/rules/implications.md`](docs/rules/implications.md) §10 for each ruling and its reasoning.
|
||||
- **Rules** — specified, with **three open questions** left. Thirteen gaps in the original prototype
|
||||
rules were found and closed; three more came after, and are in `TODO.md`: where the Local's coach
|
||||
stands while its engine works (a §A.4 question), Poling — the one card in the deck with no defined
|
||||
behaviour — and whether a Heavy Grade's orientation is rolled or chosen at setup.
|
||||
- **Card faces** — every card's printed values specified.
|
||||
- **Architecture** — seven documents, including a 20-component build plan and the multiplayer plan.
|
||||
- **Code** — the engine, the bot, the balance harness, the replay viewer, the playable page, and the
|
||||
server. A game can be saved, shared, replayed and stepped back through.
|
||||
- **Multiplayer — built and running.** `src/server/` serves a lobby (create, join, preview, leave,
|
||||
add a bot, start, and a stream), turn submission, per-session state and persistence, with its own
|
||||
tests under `test/server/`. Games survive a release rather than being destroyed by one. A player
|
||||
weighing a join reads the **whole rule set before taking a seat**; a seat survives a browser
|
||||
reload; anybody may leave and the host may clear a chair; and the four transient signals that make
|
||||
a game feel alive — sound, the timetable flash, an announcement, the badge on the card you just
|
||||
drew — reach a remote client, which they did not before v0.7.0. What is still open is in `TODO.md`
|
||||
under Multiplayer — chiefly that **a player cannot see what the others did**, and that a lost
|
||||
session token still locks someone out of a running game from a genuinely fresh browser.
|
||||
- **Not built** — the opponent-directed cards (the Action and Space-use categories, held out of every
|
||||
deck until they have an implementation, along with the defensive cards whose only purpose is to
|
||||
answer them), and real audio. No screen offers a control for the opponent cards any more: the
|
||||
toggle could not do anything, so both screens state the fact in words instead.
|
||||
- **Code** — the engine, the bot, the balance harness, the replay viewer and the playable page. A
|
||||
game can be saved, shared, replayed and stepped back through.
|
||||
- **Not built** — the multiplayer server (Phases 0 and 1 of the plan are done: seat and player are
|
||||
separate, turn state is per player, and the page talks to a `Session` rather than to the engine, so
|
||||
a remote one drops in without the page changing — but there is no server, no turn submission and no
|
||||
per-player push), the 22 opponent-directed cards, and real audio.
|
||||
|
||||
Balance is *not* where it should be, and this file no longer quotes a figure for it. It used to say
|
||||
"the developer bot averages 7.0 Revenue against a target of 20", which stopped being true the moment
|
||||
the transit rule it names was defaulted to off — that rule was worth ~5.4 of the 7.0, for traffic
|
||||
nobody had to work. Measured at the current defaults the bot means about **zero**.
|
||||
|
||||
The three rates — passenger per coach, freight per load, train per transit — are **settings fixed when
|
||||
the game is dealt**, along with the opening hand and where an Extra may start, so the economy can be
|
||||
read on its own and the alternatives played rather than argued about. Run
|
||||
`node src/sim/harness.ts 400 standard` for today's number rather than trusting one written here;
|
||||
`TODO.md` says which of the gap is the bot and which is the deck.
|
||||
Balance is *not* where it should be: the developer bot averaged 7.0 Revenue against a target of 20 —
|
||||
of which ~5.4 was the "one Revenue per train that completes its run" rule, so the working freight and
|
||||
passenger economy is still only ~2. That rule is now a **setting that defaults to off**, along with
|
||||
the passenger and freight rates and the opening hand, so the economy can be read on its own and the
|
||||
alternatives can be played rather than argued about. Nothing in this file or in `TODO.md` has been
|
||||
re-measured at the new defaults; `TODO.md` says why, and says which of it is the bot and which is the
|
||||
deck.
|
||||
|
||||
Versions follow the convention at the top of [`CHANGELOG.md`](CHANGELOG.md): third digit for fixes,
|
||||
second for a set of features, 1.0 for the first release that deserves the name.
|
||||
@@ -65,18 +46,14 @@ station-master/
|
||||
├── docs/
|
||||
│ ├── rules/ ← the ruleset, card reference, glossary, decision record
|
||||
│ ├── architecture/ ← how it is built, and what the pieces are
|
||||
│ ├── plans/ ← worked plans for a single change, kept for the reasoning
|
||||
│ └── design/ ← board layout studies and rendering samples
|
||||
├── public/
|
||||
│ ├── replays/ ← saved games published to the site's replay directory
|
||||
│ └── images/ ← art the build copies into the site
|
||||
├── public/replays/ ← saved games published to the site's replay directory
|
||||
├── scripts/ ← build and deploy the static site
|
||||
├── src/
|
||||
│ ├── engine/ ← pure rules engine: no I/O, no clock, deterministic from a seed
|
||||
│ ├── server/ ← the authoritative multiplayer server: lobby, sessions, persistence
|
||||
│ ├── sim/ ← bot, harness, replay, board rendering
|
||||
│ └── web/ ← the playable site: splash, game, lobby, replay viewer
|
||||
└── test/ ← including test/server/ for the server's own suite
|
||||
│ └── web/ ← the playable site: splash, game, replay viewer
|
||||
└── test/
|
||||
```
|
||||
|
||||
Start with [`docs/design.md`](docs/design.md) — it indexes everything. Commit messages stay high
|
||||
@@ -85,9 +62,7 @@ level; [`CHANGELOG.md`](CHANGELOG.md) carries the reasoning and the measurements
|
||||
|
||||
## Development
|
||||
|
||||
Requires **Node 22.18+**, which runs TypeScript directly by type stripping — so there is no compile
|
||||
step, and the engine, the bot and the tests all run straight from source. (`npm run build:web` is a
|
||||
separate thing: it assembles the static SITE into `dist/`.)
|
||||
Requires **Node 22.18+**, which runs TypeScript directly by type stripping. There is no build step.
|
||||
|
||||
```sh
|
||||
npm install
|
||||
@@ -129,56 +104,16 @@ is the thing this machinery exists to prevent.
|
||||
`fromSave` replays it exactly — that one property gives save, share, undo, restart recovery and
|
||||
post-game replay. Events are a DERIVED stream: they narrate what happened and drive the display,
|
||||
and they do not reconstruct the position. The phase driver mutates state and then describes it, so
|
||||
roughly a third of the event types are never reduced at all. Anything that needs to rebuild a game
|
||||
fourteen of the forty-six event types are never reduced. Anything that needs to rebuild a game
|
||||
replays the intents.
|
||||
- **Never call `Math.random()`.** One ambient random call silently breaks replay.
|
||||
- **The Mainline Phase can stop and ask, and there are three questions it asks.** §8.1's clearance
|
||||
ruling goes to the Superintendent; the Yard Office offer and the Red Flag prompt go to the owner of
|
||||
the district a train is arriving at. `pendingDecision` is a discriminated union and `decisionActor`
|
||||
is the single place that maps a question to whoever must answer it — a new question adds a case
|
||||
there and nowhere else. **Ask before the move is committed:** returning `needsClearance` unwinds
|
||||
the whole phase and the driver re-enters from the top, so anything already mutated is applied
|
||||
twice or left half-done.
|
||||
- **A game ends by PAUSING, and the first ending is the real one.** Running out of Days, or closing
|
||||
short of the combined Revenue floor, puts the game in `awaitingExtension` rather than `finished`:
|
||||
the table is asked whether to play one more Day, unanimously, and asked again at the end of every
|
||||
Day it grants. `state.official` is written at the first ending and never rewritten, so the winner
|
||||
is always the one decided at `config.days` however long play carries on — `config.days` itself
|
||||
never moves, and `state.extraDays` counts the borrowed ones. A §3.4 collision breach is the
|
||||
exception and finishes outright, during an extended Day exactly as during the scheduled game.
|
||||
Because a save is a replay, the vote is an intent (`game.extend`), and it is the one intent that
|
||||
**carries its own player**: every seat may vote in any order, so a replay cannot derive who did.
|
||||
- **Statistics are folded, not recorded.** `state.tally` counts what the event stream says happened —
|
||||
trains through the Division and how many of them did any switching, loads made up and broken — and
|
||||
is hooked
|
||||
at the two boundaries every event crosses exactly once, `applyIntent` and `advance`. It is not
|
||||
hooked in `reduce`, which never sees the phase driver's events at all. Nothing in the rules reads
|
||||
it, so adding a counter is always safe; it rides the `Frame`, so a multiplayer client gets the same
|
||||
numbers as solitaire from one implementation. **What it cannot count is anything the events do not
|
||||
say.** `trainStoodStill` fires once per game for the X18 Circus alone, so "the longest an engine sat
|
||||
on a siding" has no signal behind it — see `TODO.md` #36 rather than assuming an event means what
|
||||
its name suggests.
|
||||
- **A game is one of four TYPES, and a type is a set of defaults rather than a ruleset.** Co-op,
|
||||
Competitive, Cutthroat and Solitaire (`src/web/presets.ts`) each name an opening hand, an Extra
|
||||
rule, three revenue rates and the victory conditions; picking one fills the form, and changing any
|
||||
of them selects **Custom**, which keeps the scoring of the type it came from. The type is *derived*
|
||||
from the numbers rather than stored, so a saved game carries no name that can disagree with what it
|
||||
actually is. Both screens that deal a game — the lobby and the New Game dialog — ask the same
|
||||
eleven questions through one shared block (`src/web/settings-form.ts`), because for two releases
|
||||
they each had a question the other lacked. What separates the types: Co-op alone pays for a
|
||||
transit, Cutthroat alone lets an Extra be planted in another player's district and has no shared
|
||||
failure condition at all beyond three collisions in a Day, and the Revenue floor is a formula in
|
||||
the table size and the length (3 per player per Day in Co-op, 2 in Competitive) rather than a
|
||||
number.
|
||||
- **Track is a deck card, but the opening district is dealt.** Track is the largest category in the
|
||||
deck by a distance — so a district is built from what you draw, and building it costs you the
|
||||
industry or train you drew instead. The opening hand is the exception, and it is **chosen when the
|
||||
game is dealt**: three random cards (the prototype rule), six random cards, or three track and
|
||||
three other from two separately shuffled piles. The last of those is the only one that guarantees
|
||||
you a district to build; deal six and you open over the limit of three, so the first turn is spent
|
||||
choosing. **Every game type now deals six** (Jesse’s call, v0.7.0) — the engine's own fallback,
|
||||
`SOLO_CONFIG`, deliberately did not move with it, because every sim measurement is taken against
|
||||
that. See `TODO.md`.
|
||||
- **Track is a deck card, but the opening district is dealt.** 96 of the 235 cards are track — the
|
||||
largest category — so a district is built from what you draw, and building it costs you the
|
||||
industry or train you drew instead. The opening hand is the exception, and it is now **chosen when
|
||||
the game is dealt**: three random cards (the default, and the prototype rule), six random cards, or
|
||||
three track and three other from two separately shuffled piles. The last of those is the only one
|
||||
that guarantees you a district to build; deal six and you open over the limit of three, so the
|
||||
first turn is spent choosing. See `TODO.md`.
|
||||
- **What the work pays is a setting too.** Passenger revenue per coach, freight revenue per load and
|
||||
train revenue per transit each run 0–5 and are fixed when the game is dealt. The first two default
|
||||
to 1 and pay at both ends of a movement — boarding *and* detraining, loading *and* unloading. The
|
||||
|
||||
Binary file not shown.
@@ -98,18 +98,11 @@ Playing a timetabled train card rolls the seeded D12 and places its number in th
|
||||
|
||||
The listed consist is a maximum, not a minimum: a train may depart with fewer cars, but must not exceed the listed categories, put a car behind a caboose, or leave with the engine buried among cars. A Crew Tray holds no more than four rolling-stock cars.
|
||||
|
||||
> **Changed 2026-08-22 (Gitea#7), Jesse's call:** the coach counts on **1/2 Crack Limited** and
|
||||
> **5/6 The Sparrow** were swapped — the Limited drops from three coaches to two, the Sparrow rises
|
||||
> from two to three. This is a change to the CARDS, not a correction to this table: `Trains3.pdf` and
|
||||
> the transcription in [`rules/implications.md`](rules/implications.md) §5 still show the original
|
||||
> numbers, and are right about what the printed cards said. `src/engine/content.ts` and this table
|
||||
> carry what the game plays.
|
||||
|
||||
| Train | Speed | Direction | Listed maximum consist | Implemented special rule |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| 1/2 Crack Limited | Fast | 1 west / 2 east | **2 coaches** | No switching; passenger work only at Terminals; expedited. |
|
||||
| 1/2 Crack Limited | Fast | 1 west / 2 east | 3 coaches | No switching; passenger work only at Terminals; expedited. |
|
||||
| 3/4 Express | Fast | 3 west / 4 east | 2 freight | May exchange at most one freight car at each grid location during its switching turn; expedited. |
|
||||
| 5/6 The Sparrow | Fast | 5 west / 6 east | **3 coaches** | No switching; expedited. |
|
||||
| 5/6 The Sparrow | Fast | 5 west / 6 east | 2 coaches | No switching; expedited. |
|
||||
| 7/8 Local | Slow | 7 west / 8 east | 1 freight, 1 coach | Its coach may not be set out during switching. |
|
||||
| 9/10 Heavy Freight | Slow | 9 west / 10 east | 3 freight, 1 caboose | — |
|
||||
| 11/12 Drag Freight | Slow | 11 west / 12 east | 2 freight, 1 caboose | — |
|
||||
|
||||
@@ -38,20 +38,16 @@ The PDF art labels this card “Yard”; this reference uses the implementation
|
||||
| Plains | 60 mph; one Stage for Fast, two for Slow. The implementation has one Plains *type* rather than the PDF’s two physical copies. |
|
||||
| Curves | 30 mph; two Stages for Fast, three for Slow. |
|
||||
| Hilly | Passenger train: 60 mph. Freight-only train: 30 mph. Add one Stage if Slow. |
|
||||
| Heavy Grade | Starts at 30 mph; two Stages for Fast, three for Slow. The card prints “Player sets orientation”; **the game deliberately overrides that and rolls the uphill direction from the seed** — settled in v0.5.0 and re-confirmed 2026-08-23, see the note below. Grade modifiers can reduce the time, to a minimum of one Stage. |
|
||||
| Heavy Grade | Starts at 30 mph; two Stages for Fast, three for Slow. The card requires the player to select its uphill direction; v0.4.5 instead selects that direction from the game seed during setup. Grade modifiers can reduce the time, to a minimum of one Stage. |
|
||||
| Double Track | 60 mph. Printed capability: trains may pass. The traffic-resolution rule is in Rules §4.5. |
|
||||
| Uncontrolled Siding | 60 mph. Printed capability: trains may pass. The traffic-resolution rule is in Rules §4.5. |
|
||||
| Tunnel | 30 mph. |
|
||||
| Trestle | 60 mph. |
|
||||
| Interchange | 60 mph. A train may be reordered there only through the card’s printed “sort cars” concept; the current engine does **not** provide a Mainline sorting action for it. |
|
||||
|
||||
### PDF/code mismatch — CORRECTED
|
||||
### PDF/code mismatch requiring correction
|
||||
|
||||
**Was:** `src/engine/content.ts` defines nine `MAINLINE_PROFILES` types: one Plains entry plus the eight other terrain types above. `setup.ts` selected uniformly from that nine-type list, **with replacement**. The second Plains card shown in `Mainline Cards.pdf` was therefore not represented as a duplicate card or as extra Plains weight in setup — and, worse than a weighting error, a Division could be dealt two Interchanges, two Tunnels or two Trestles, none of which the deck contains.
|
||||
|
||||
**Now:** `MAINLINE_DECK` in `content.ts` is the inventory table above — ten drawable cards, Plains twice and the other eight once each — and `buildDivision` deals from it without replacement. The two Division Point cards are not in that deck: they are the fixed ends of the Division, laid by `buildDivision` itself rather than drawn.
|
||||
|
||||
The Interchange is what forced the correction. §7 lets an Extra be started at the Interchange "if one is on the board" (see `docs/rules/implications.md`, §7), which only reads as a rule if the board can hold at most one.
|
||||
`src/engine/content.ts` defines nine `MAINLINE_PROFILES` types: one Plains entry plus the eight other terrain types above. `setup.ts` selects uniformly from that nine-type list. The second Plains card shown in `Mainline Cards.pdf` is therefore not represented as a duplicate card or as extra Plains weight in setup. If the PDF inventory is authoritative, the setup selection needs a second Plains entry (or an equivalent weighted selection).
|
||||
|
||||
The executable state represents East and West Division Points as fixed end nodes, not as card records. They are functionally present at the ends of the Division, but are not represented as the two PDF cards in the deck/state model.
|
||||
|
||||
@@ -70,16 +66,6 @@ For the grade cards, “uphill” should be the direction selected by the player
|
||||
|
||||
## What is not implemented
|
||||
|
||||
- There is no player choice or physical placement interaction for Mainline cards; setup deals them automatically from the seeded random stream. There **is** a finite draw pile as of v0.6.2 — the deck above, dealt without replacement, so no Division can hold two of a card printed once.
|
||||
- There is no finite draw pile, player choice, or physical placement interaction for Mainline cards; setup selects their types automatically from the seeded random stream.
|
||||
- Interchange is catalogued as a “sort cars” card, but v0.4.5 has no operation that reorders a train on the Interchange. The Small Yard in an Office Area is the implemented sorting mechanism.
|
||||
- Interchange now has one player-facing use: an Extra Train may be **started** there, made up in its yard and highballing onto the Mainline when the Subdivision is clear (§7, v0.6.2). Car sorting remains unimplemented.
|
||||
|
||||
## Heavy Grade orientation is settled, not missing
|
||||
|
||||
Heavy Grade orientation is rolled from the seed rather than chosen by a player. **This is a decision, not a gap, and it is not awaiting a player-selection step.**
|
||||
|
||||
The card prints “(Up)” and “Player sets orientation”, which assumes the card has an owner. This one does not: `buildDivision` lays the Division as `DP · Mainline · Office · Mainline · … · DP`, so a Heavy Grade always sits **between two districts**, or beyond an end Division Point next to one — never inside a single player’s own district.
|
||||
|
||||
Orientation is not cosmetic: Brakeman and Airbrakes each take a Stage off a train running **downhill**, Helpers takes one off a train running **uphill**, and odd-numbered trains run west while even run east. Turning the card around therefore decides which of those modifier cards are worth anything and which direction of traffic is favoured — permanently, for the whole game. Handing that to one of the two neighbours advantages them over the other, and no player has a fair claim to it.
|
||||
|
||||
**Re-opened and closed again on 2026-08-23**, when the option of giving the choice to the Superintendent was considered and rejected. Jesse’s call: v0.5.0’s ruling stands. Rolling from the seed is deterministic, roughly even (51/49 east/west over 400 games), identical for solitaire and multiplayer, and keeps setup non-interactive — the game has no setup phase, so the question would have to interrupt play before the first Local Operations, in the minority of games that deal the card at all (20% at one player, rising to 50% at four).
|
||||
- Heavy Grade orientation is seeded automatically rather than chosen by a player. The implementation needs a player-selection step to match the card.
|
||||
|
||||
@@ -44,10 +44,8 @@ Real accounts can be layered on later without touching the rules engine, which i
|
||||
## 2. Creating and joining
|
||||
|
||||
```
|
||||
Lobby.Create { secret, config, displayName, players, seed } → { gameId, gameCode, token, player }
|
||||
Lobby.Preview { secret, gameCode } → { gameCode, hostName, config, players, seated }
|
||||
Lobby.Join { secret, gameCode, displayName } → { gameId, gameCode, token, player }
|
||||
Lobby.Leave { token, seat? } → { ok, closed? }
|
||||
Lobby.Create { secret, config } → { gameId, gameCode, token }
|
||||
Lobby.Join { secret, gameCode, displayName } → { token, player }
|
||||
```
|
||||
|
||||
**These four messages are the one family with no types behind them**, because the engine has no
|
||||
@@ -62,28 +60,7 @@ per-origin, alongside the token.
|
||||
|
||||
A **game code** — short, human-speakable, e.g. `RAIL-4471` — is the discovery mechanism *inside* the
|
||||
door. No matchmaking, no browsing, no public game list. Players are already talking to each other; the
|
||||
code just needs to survive being read aloud. The seating screen also offers it as an invite **link**
|
||||
(`…/play.html?lobby&code=RAIL-4471`), which is what a chat message wants — the link carries the code
|
||||
and never the join secret, because the secret is the door key and travels out of band by design.
|
||||
|
||||
**A player reads the rules before taking a chair.** `Lobby.Preview` answers the same join secret with
|
||||
the whole config, the host's name and who is seated, and takes no seat — added 2026-08-23, when the
|
||||
alternative was sitting down blind and (until the same pass) having no way back out. **It never
|
||||
carries the seed**: the seed decides every shuffle and every roll in the game, so it belongs to the
|
||||
host alone.
|
||||
|
||||
**Two players may not share a display name.** The name labels the district on the Division map, it is
|
||||
what the turn chart means by "waiting on Jesse", and `record()` puts it in front of every line that
|
||||
player causes — so two of them make all three ambiguous, and the names lock at `Lobby.Start`. A
|
||||
clashing join is refused (`NAME_TAKEN`, compared trimmed and case-insensitively) rather than silently
|
||||
suffixed: a player should play under the name they chose, or be asked for another.
|
||||
|
||||
**Anybody may leave, and the host may clear a chair.** `Lobby.Leave` frees the seat, drops the token
|
||||
from `joinOrder`, and passes host rights on exactly as a dropped connection does. Naming somebody
|
||||
else's `seat` is host-only. When the last human leaves, the lobby is deleted outright — code, file and
|
||||
index row — rather than left as a table of bots waiting for a host who no longer exists. Before this
|
||||
existed a mis-join or a player who wandered off wedged the whole table, since Start needs every chair
|
||||
filled and a bot may not be dropped onto an occupied seat.
|
||||
code just needs to survive being read aloud.
|
||||
|
||||
**One game at a time per person is expected usage and is deliberately not enforced** (`multiplayer.md`
|
||||
§10). Enforcing it needs cross-game state whose only job is deciding when to release someone, and
|
||||
@@ -111,27 +88,15 @@ The cap is about what has been played, not about what the game can do.
|
||||
|
||||
## 3. Configuration, and when it locks
|
||||
|
||||
Set before start, immutable after — the whole of `GameConfig` (`state.ts`), which the host fills in
|
||||
by choosing a **game type** and then editing whatever they like:
|
||||
Set before start, immutable after:
|
||||
|
||||
```
|
||||
mode : solitaire | competitive | coop
|
||||
days : how long the game runs
|
||||
minCombinedRevenue, maxCollisionsPerDay, maxCollisionsTotal (0 = that condition is off)
|
||||
pvpCardsAllowed : a property of the type, not a control — the cards are unbuilt (setup.ts)
|
||||
optionalRules : { reducedVisibility, employeeRotation, emergencyToolbox }
|
||||
houseRules : { startingHand, extraStart, revenue }
|
||||
mode : solitaire | competitive | coop
|
||||
victory : firstToTarget | highestAfterDays
|
||||
length : short | standard | campaign
|
||||
optionalRules : { reducedVisibility, sisterTrains, employeeRotation, emergencyToolbox }
|
||||
```
|
||||
|
||||
**The four game types** (`src/web/presets.ts`, Jesse's design 2026-08-23) are Co-op, Competitive,
|
||||
Cutthroat and Solitaire, plus **Custom** — which is not a fifth type but the state of having edited
|
||||
one, and is scored as whichever type it was edited away from. The type is *derived* by comparing a
|
||||
config against the four, never stored, so a saved game carries no label that can disagree with its own
|
||||
numbers. Seed, player count and Day count sit ABOVE the type on both screens as **parameters**: the
|
||||
types are formulas in the table size and the length (the Revenue floor is 3 per player per Day in
|
||||
Co-op, 2 in Competitive, nothing in Cutthroat), so changing one re-derives rather than making the game
|
||||
Custom.
|
||||
|
||||
These must lock at `Lobby.Start`. Changing `length` mid-game would move the finish line; changing
|
||||
`mode` would switch which failure floors apply (§3.4, §3.5). Neither has a coherent meaning
|
||||
mid-game, so the server should refuse rather than try.
|
||||
@@ -176,12 +141,6 @@ to hide it. Show the chain forming.
|
||||
**Solitaire is unchanged and must stay so:** one player is one seat, seating is trivially `[0]`, and
|
||||
every published replay depends on that.
|
||||
|
||||
**What a seat is told as the game begins** (2026-08-23). The board used to simply appear, mid-Local
|
||||
Operations, with a log already several bot turns deep and nothing marking where the game began. The
|
||||
page now holds a deliberate beat on a handoff curtain, announces the game and its type, marks the top
|
||||
of the log, and shows the code and the type in the header for the rest of the game — none of which is
|
||||
new *data*, only the first time any of it was drawn.
|
||||
|
||||
**Employee Rotation** (Appendix B), if enabled, moves every player one seat left at the end of each
|
||||
Day, carrying their Revenue and the Fedora with them. **The model supports this as of v0.4.0**:
|
||||
offices and districts are keyed by seat, hands and Revenue and the Fedora by player, and `seating[]`
|
||||
@@ -204,16 +163,6 @@ if it was their turn. Broadcast a disconnect notice so everyone else can see why
|
||||
server-layer news about a *connection*, not about the game, so it belongs with the transport rather
|
||||
than in `GameEvent`, which must stay replayable from a seed.
|
||||
|
||||
**On connect, a client is told about every other seat at once** (2026-08-23). A change notice alone
|
||||
answered "who just left", never "who is here" — so a player arriving at a table where two people had
|
||||
not opened the game yet was told nothing about them at all, which is precisely the question at the
|
||||
moment a game starts. Each entry carries `seen`, separating **was here and dropped** from **has never
|
||||
opened the game**: the first will probably be back, the second needs somebody to send them the link.
|
||||
`seen` is remembered only for as long as the process runs, so after a restart every absent seat reads
|
||||
as "not here yet" — the more cautious of the two. **Bot seats are never reported**: a bot holds no
|
||||
connection and never will, and listing one puts "waiting on Bot 1" on every screen for the whole game
|
||||
(found by playing a three-seat game, not by reading the code).
|
||||
|
||||
**On reconnect:** the client presents its token and the server replies with a **full current view**.
|
||||
Not an event tail — a returning client needs the position, not the history of how it got there, and
|
||||
the server can always produce the position because it holds the game
|
||||
|
||||
@@ -245,31 +245,9 @@ special handling: `pump` stops, and the next push simply carries a `Menu` contai
|
||||
POST /api/lobby/create, /api/lobby/join lobby
|
||||
POST /api/intent { gameId, seq, intent }
|
||||
GET /api/stream EventSource — per-seat frames, with Last-Event-ID resume
|
||||
GET /api/health { ok, service, engineVersion, games } — unauthenticated; see below
|
||||
GET /api/games every game and lobby, summarised ┐
|
||||
GET /api/games/<id>/save the save, for keeping or replaying ├ ADMIN_SECRET
|
||||
DELETE /api/games/<id> ends a game, and returns its save ┘
|
||||
GET / the client
|
||||
```
|
||||
|
||||
`/api/health` exists because the client cannot otherwise tell a server from a static host. The same
|
||||
`dist/` is served both ways and the bundle is identical (D4), and every other route 404s an unknown
|
||||
path exactly as a static host does — so the splash asks, and closes its multiplayer door only when
|
||||
nothing names itself in reply. It is unauthenticated on purpose: it reveals that a Station Master
|
||||
server is answering and nothing else, no game and no seat. Its `games` field — `{ active, lobby }`
|
||||
— is what the StartOS package's health check reports as "3 games in progress".
|
||||
|
||||
**The three administrative routes are gated by `ADMIN_SECRET`, which is deliberately not the join
|
||||
secret.** Every player holds the join secret, so gating a delete with it would let anyone at the
|
||||
table destroy anyone else's game; this one belongs to whoever runs the server. It arrives in an
|
||||
`x-admin-secret` header rather than the query string, so it stays out of logs and referrers. When
|
||||
the variable is unset the routes answer 404 exactly as any unknown path does, so a server that was
|
||||
never given an administrator does not advertise that it has one.
|
||||
|
||||
**A delete returns the deleted game's save.** The intents are the game (D5), so what comes back is
|
||||
the whole thing and not a summary of it — the record survives even though the game does not, and
|
||||
nothing is destroyed without being handed to whoever destroyed it first.
|
||||
|
||||
Chosen over WebSocket because this game is **idle most of the time** — turn-based with human
|
||||
think-time means a connection sits silent for minutes, exactly when proxies reap sockets. SSE's
|
||||
reconnection and `Last-Event-ID` resume are handled by the browser, and it needs no `Upgrade` support
|
||||
@@ -360,7 +338,7 @@ all it needs.
|
||||
| **D15** | **Build to `deployment.md`'s five portability rules; package as an `.s9pk`** | This is a StartOS packaging workspace and the toolchain is on disk. |
|
||||
| **D16** | **The server serves the client** | Required for same-origin, which is what makes multiple access addresses work without CORS. |
|
||||
| **D17** | **Undo is solitaire-only** | Other players have seen the result. |
|
||||
| **D18** | **Player cap 2-4** for competitive/coop (solitaire is 1) | Per `lobby-and-sessions.md` §2 — sized to what is actually exercised (`test/multiplayer.test.ts` plays 2, 3 and 4 to a finish), not to a guess. This entry read "6" until Phase 4 (v0.5.1); that number was never implemented or tested anywhere and the two docs had drifted apart. Raise it once somebody has played a bigger game and reported back, not before. |
|
||||
| **D18** | **Player cap 6** | Per `lobby-and-sessions.md` §2. |
|
||||
| **D19** | **Per-player turn state now; parallel turns deferred** | The model change is behaviour-neutral and cheap today. Whether local work should run off-cursor depends on how often humans choose to switch — 13% for the bot, and the benefit ranges from ~8 minutes to ~27 off an hour-long game between 13% and 50%. Measure with real players, then flip one function. |
|
||||
| **D20** | **Replay reveals everything once the game ends** | Most useful for learning and for arguing about it afterwards; costs nothing extra to retain. |
|
||||
|
||||
|
||||
@@ -103,17 +103,6 @@ Two consequences worth knowing before adding an event:
|
||||
- **Events are not what goes over the wire.** The server applies the intent and pushes the resulting
|
||||
`Frame` (`multiplayer.md` D2/D3). Events are narration and cues, not the protocol — and a reconnect
|
||||
gets a fresh `Frame` rather than the tail it missed.
|
||||
- **What events EARN does go over the wire, as four transient signals** (2026-08-23): the sound cues,
|
||||
the timetable slot a D12 just filled, a one-line announcement, and the id of the card that just came
|
||||
into this seat's hand. They ride beside the `Frame` rather than on it because they mark a *moment*
|
||||
and are consumed — putting them on the Frame would re-fire them on every redraw. Before this a
|
||||
remote client got none of them, so multiplayer had no sound at all, no flash and no announcements
|
||||
while solitaire had all three. The first three are shared and identical in every seat's push; the
|
||||
fourth is **not** — `game.justDrawn` is one field for the whole game and does not say whose card it
|
||||
is, so the server remembers who drew and sends it to that seat alone
|
||||
(`test/server/session.test.ts`, "the four transient signals"). A reconnect gets none of the shared
|
||||
three: a fresh connection is drawing a state, and replaying the sounds of everything it missed is a
|
||||
burst of noise about the past.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -42,37 +42,33 @@ Operational Rail wheel icon, an industry track of the stated length, Laborer ico
|
||||
| --- | --- | --- | ---: | ---: | ---: | ---: | ---: |
|
||||
| Mine Tipple | Hopper | Outbound only | 3 | 3 | — | 4 | 2 |
|
||||
| Produce Shed | Reefer | Outbound only | 2 | 2 | — | 3 | 2 |
|
||||
| Grocer's Warehouse | Boxcar or reefer | Inbound only | 1 | — | 1 | 3 | 3 |
|
||||
| Oil Refinery | Tank car | Outbound only | 1 | 1 | — | 4 | 3 |
|
||||
| Power Plant | Hopper or tank car | Inbound only | 3 | — | 3 | 4 | 2 |
|
||||
| Freight House | Boxcar | Both | 1 | 1 | 1 | — | 6 |
|
||||
| Grocer's Warehouse | Boxcar | Inbound only | 2 | — | 2 | 3 | 2 |
|
||||
| Oil Refinery | Tank car | Outbound only | 3 | 2 | — | 4 | 2 |
|
||||
| Power Plant | Hopper | Inbound only | 3 | — | 3 | 4 | 2 |
|
||||
|
||||
Directions follow the commodity: coal originates at a Mine Tipple and is consumed at a Power Plant;
|
||||
produce ships out; a warehouse receives. This gives §9 all three of its cases — outbound-only,
|
||||
inbound-only, and both — with the **Freight House the one card that does both**.
|
||||
|
||||
**"Freight House" IS a card** (corrected v0.5.0) — a sixth industry, dealt 6 copies, one Laborer and
|
||||
one slot each direction. An earlier pass here read §9.3/Appendix A's "Passenger Facilities and
|
||||
Freight Houses permit cars to move each direction" as meaning "Freight House" was only ever a
|
||||
*collective term* for the Grocer's Warehouse and the Oil Refinery, never a card of its own — that
|
||||
reading was wrong; the engine deals it as a real sixth industry (`content.ts`'s `freightHouse`
|
||||
profile) and this table follows the engine.
|
||||
**The Grocer's Warehouse and the Oil Refinery are ONE-WAY** (corrected v0.4.9e, from gameplay
|
||||
testing): "Grocer's Warehouse should be receive only, does not ship anything out"; "Refinery: only
|
||||
ships out tanks, does not receive anything" (Jesse). The Direction column read "Both" for both, on the
|
||||
reading below that "Freight House" named exactly those two.
|
||||
|
||||
**The Grocer's Warehouse and the Oil Refinery are ONE-WAY** (corrected v0.4.9e). The Direction column
|
||||
read "Both" for both of them, and that was the *other half* of the same mistaken reading: if "Freight
|
||||
House" named those two, §9.3 had to be describing them, so they had to be two-way. Once the Freight
|
||||
House is its own card the argument evaporates, and playtesting settled it — "Grocer's Warehouse
|
||||
should be receive only, does not ship anything out"; "Refinery: only ships out tanks, does not
|
||||
receive anything" (Jesse). `StationMaster-Home-Deck-v0.4.5.md` prints both that way, and the modifier
|
||||
set agrees: all three Refinery modifiers (Pipelines, Oil Depot, Viscosity Breakers) grant **+1
|
||||
outbound**, which would be an odd card set for a facility that receives half the time.
|
||||
<!-- TODO v0.5.0: Mine Tipple, Produce Shed and Power Plant above (3/3/4, 2/2/3, 3/3/4) were NOT
|
||||
re-verified against the engine in this pass — only Grocer's Warehouse, Oil Refinery and Freight
|
||||
House were. `mineTipple` and `powerPlant` in `content.ts` are also base 1/1/1, same as the three
|
||||
corrected here, so these three rows and the "Throughput" reasoning below (built on the OLD
|
||||
2–3-Laborer numbers) may be stale too. Flagged in TODO.md rather than silently rewritten — this
|
||||
needs the same kind of decision Jesse made for Grocer's/Refinery/Freight House, not an assumption
|
||||
that the same correction applies. -->
|
||||
**And that reading is wrong.** §9.3/Appendix A's "Passenger Facilities and Freight Houses permit cars
|
||||
to move each direction" names a CARD: the engine deals a `freightHouse` industry, 6 copies, one
|
||||
Laborer and one slot each direction (`content.ts`), and has since before v0.4.9. This paragraph used
|
||||
to read "'Freight House' is not a card — it is the collective term for a freight facility that loads
|
||||
*and* unloads, the Grocer's Warehouse and the Oil Refinery", and that premise is what made those two
|
||||
two-way. `StationMaster-Home-Deck-v0.4.5.md` prints them one-way, and the modifier set agrees: all
|
||||
three Refinery modifiers (Pipelines, Oil Depot, Viscosity Breakers) grant **+1 outbound**, which would
|
||||
be an odd card set for a facility that receives half the time.
|
||||
|
||||
<!-- The Laborer and capacity numbers in the rows above were NOT re-verified against the engine in
|
||||
this pass — only the Direction column was, which is what playtesting reported on. `content.ts`
|
||||
gives every industry base 1 out / 1 in / 1 Laborer, so the table's 2s and 3s and the "Throughput"
|
||||
reasoning built on them are likely stale. Flagged rather than silently rewritten: Laborer counts
|
||||
are a balance question, not only a docs one. -->
|
||||
|
||||
### Throughput — why these Laborer counts
|
||||
|
||||
|
||||
@@ -25,7 +25,7 @@ Every defined term, alphabetized for lookup. The core comes from the Definitions
|
||||
| **Extra Train** | A one-and-done train; its card returns to the Salvage Yard on completion. Head-on card image, so the drawing player picks its direction. Numbered with an "X" prefix; the following number gives its seniority, and it yields to the Timetabled train of that number. | §2.3, §8 |
|
||||
| **Facility** | A business which loads/unloads cargo and freight. | §2.5 |
|
||||
| **Freight Facility** | Mine Tipples, Produce Sheds, Grocer's Warehouses, Oil Refineries, Power Plants, Freight Houses. Some allow only outbound, some only inbound, some both. Per-card values in §12.5. | §9, §12.5 |
|
||||
| **Freight House** | A sixth Freight Facility card (corrected v0.5.0 — an earlier pass here read it as a collective term for the Grocer's Warehouse and the Oil Refinery rather than a card of its own; it is dealt like any other industry). **The only industry that permits both directions** — the Grocer's Warehouse receives and the Oil Refinery ships, one way each (v0.4.9e). | §9.3, §12.5 |
|
||||
| **Freight House** | A sixth Freight Facility card, dealt like any other industry (`content.ts`) — this entry used to read "not a card, the collective term for the Grocer's Warehouse and the Oil Refinery", which the engine never agreed with. **The only industry that permits both directions**: the Grocer's Warehouse receives and the Oil Refinery ships, one way each (v0.4.9e). | §9.3, §12.5 |
|
||||
| **Highball** | When a train holding at an Office automatically departs. | §2.4 |
|
||||
| **Home Office** | The primary face-down deck cards are drawn from. 52 cards. | §2.6, §12.1 |
|
||||
| **Hopper** | Coal rolling stock (brown = loaded, white = empty). | §2.2 |
|
||||
|
||||
+9
-227
@@ -40,9 +40,8 @@ All nine answers are implemented, **170 tests passing**:
|
||||
|
||||
| Answer | Implemented as |
|
||||
| --- | --- |
|
||||
| ~~Q1 crossing time~~ | **SUPERSEDED 2026-08-26 — see Q1a below.** Was: a 60 card takes 1 Stage, a 30 takes 2. |
|
||||
| ~~Q2 Fast/Slow~~ | **SUPERSEDED 2026-08-26 — see Q1a below.** Was: Slow adds one Stage to every card; Hilly reads the consist. |
|
||||
| Q1a crossing time | `crossingStages()` — a card costs one Stage per **region printed on it**, and where a train STARTS is what varies. Plains 1, Double Track 1, Trestle 1, Curves 2, Tunnel 2, Heavy Grade 3. The printed mph are scenery. Fast/Slow is read on Hilly and nowhere else. |
|
||||
| Q1 crossing time | `crossingStages()` — a 60 card takes 1 Stage, a 30 takes 2. Mainline nodes now carry a **terrain type** dealt at setup, and trains count down Stages instead of stepping through regions. The `Region` model is gone. |
|
||||
| Q2 Fast/Slow | Slow adds one Stage to every card. Hilly reads the consist (any coach = passenger). |
|
||||
| Q3 Expedite | An expedited train departs the Stage it arrives — it gets a second `moveTrain` in the same Mainline Phase, still subject to §8.1 clearance. |
|
||||
| Q4 Lockouts | `isLockedOut()` rejects the placement with `FACILITY_LOCKED`. |
|
||||
| Q5 Run-around | Nothing to do — reachability is geometric, so a built bypass already works. |
|
||||
@@ -77,73 +76,16 @@ Crossing time never falls below one Stage — a train cannot cross in no time.
|
||||
there is nothing to build. A test asserts it remains TBD, to stop anyone "fixing" it by inventing
|
||||
an effect; a silent no-op would be worse than a rejection.
|
||||
|
||||
**Q1a, answered by RAR 2026-08-26 (Gitea#3), and it replaces Q1 and Q2 together.**
|
||||
|
||||
> "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… Some cards say fast / slow. This is an indication that if on the train card, the
|
||||
> train is listed as fast or slow, that's starting position / how many stages it takes to traverse
|
||||
> the card. Fast / Slow does not apply to every card — just those that say fast / slow on them.
|
||||
> Currently this is only hilly."
|
||||
|
||||
What this changes, against what was recorded before:
|
||||
|
||||
- **The printed 60/30 mean nothing.** Q1 read them as crossing time; they are ambiance.
|
||||
- **Fast/Slow is not a global penalty.** Q2 added a Stage to every card for a Slow train, which is
|
||||
what made a Slow train take two Stages to clear Double Track — the report that opened the issue.
|
||||
It now applies on Hilly alone, where a fast train starts in the second region.
|
||||
- **Hilly no longer reads the consist.** RAR: "I notice that you are basing stages in mainline cards
|
||||
off coach/non-coach. Actually, all trains are rated as FAST and SLOW."
|
||||
- **Heavy Grade is three regions, not two**, and the modifiers move the START rather than cutting the
|
||||
clock: Helpers start an uphill train a region on, Brakeman a downhill one, Airbrakes another again.
|
||||
- **The Uncontrolled Siding and the Interchange print a back region** that is not part of the road. A
|
||||
train running through starts past it; a train arriving to find the siding occupied takes it and
|
||||
runs a region behind, which is what keeps the two apart, and an Extra beginning its run at an
|
||||
Interchange starts there too.
|
||||
- **ABS holds a train off the card** rather than letting it collide, on any Mainline card.
|
||||
|
||||
Measured consequence, replacing the one recorded under Q2: on a **3-player Division the Mainline
|
||||
cards themselves now cost a fast train ~5.6 Stages and a slow train ~6.0**, against ~5.4 and ~9.4
|
||||
before. Fast traffic is unchanged; **slow traffic is about a third quicker**, and the Fast/Slow gap
|
||||
across a whole Division collapses from roughly four Stages to less than one. The Q2 note that "every
|
||||
Slow train is still on the road when the next Day begins, holding its Crew Tray" no longer holds, so
|
||||
the `players + 3` tray count is due a re-examination — RAR's own closing worry: "been worried about
|
||||
the time it takes to cross the division. More thunking on this is needed."
|
||||
|
||||
**Q11, answered from the source.** The Heavy Grade card prints **"(Up)"** and **"Player sets
|
||||
orientation"**, so which way it climbs is a property of the placed card, not a fixed compass
|
||||
direction. `DivisionNode.gradeUp` records the direction a train travels when **climbing**; a train
|
||||
going the other way is descending. Brakeman and Airbrakes apply to the descent, Helpers to the
|
||||
climb, so turning the card around swaps which trains each card helps.
|
||||
|
||||
**Settled (v0.5.0): orientation is never a player choice, and this overrides the card's own printed
|
||||
"Player sets orientation."** A Heavy Grade sits on the shared west-to-east Division chain, between
|
||||
two players (§4.2) or beyond an end Division Point next to one — never inside a single player's own
|
||||
district — so whichever direction climbs advantages one neighbour over the other, and no one player
|
||||
has a fair claim to the decision. Orientation is **rolled** from the seed instead — deterministic,
|
||||
and roughly even (51/49 east/west across 400 games) — identically for solitaire and multiplayer.
|
||||
|
||||
**Re-opened and closed again, 2026-08-23.** The question came back as "did we ever fix Heavy Grade
|
||||
to allow user placement of direction?", and the option of handing the choice to the **Superintendent**
|
||||
— the neutral office, which rotates with the Fedora every three Stages — was considered and rejected.
|
||||
Jesse's call: v0.5.0's ruling stands. What the re-examination surfaced, worth recording so this is not
|
||||
asked a third time:
|
||||
|
||||
- **The advantage is permanent; the office is not.** Orientation decides which modifier cards pay for
|
||||
the whole game (Brakeman and Airbrakes on the descent, Helpers on the climb) and therefore which
|
||||
direction of traffic is favoured — and odd trains run west while even run east. A rotating office
|
||||
making a one-way, once-and-for-all call does not dissolve the fairness problem, it just moves it.
|
||||
- **There is no setup phase to ask in.** `createGame` is pure and synchronous and the game opens at
|
||||
Day 1, Stage 1, Local Operations. The question would have to interrupt play before the first turn,
|
||||
and `clock.pendingDecision` is typed for clearance alone (`SuperintendentClearance | null`, read in
|
||||
19 places), so a second decision kind would be most of the work.
|
||||
- **Most games never meet the card.** Since v0.6.2 deals the Mainline deck without replacement there
|
||||
is at most one Heavy Grade in ten cards, drawn `players + 1` times: **20%** of solitaire games,
|
||||
rising to 50% at four players. A pre-game interrupt for a rule four games in five never see.
|
||||
|
||||
The docs were the actual defect. `README.md` still listed it among three open rules questions (all
|
||||
three closed in v0.5.0) and `StationMaster-Mainline-Deck-v0.4.5.md` still said "the implementation
|
||||
needs a player-selection step to match the card". Both now say settled, and why.
|
||||
One gap remains, and it is a **setup** gap rather than a rules one: `createGame` is synchronous and
|
||||
returns a ready state, so there is no point at which a player can be asked. Orientation is currently
|
||||
**rolled** — deterministic from the seed, and roughly even (51/49 east/west across 400 games) — and
|
||||
should become a real player choice when setup gains an interactive phase.
|
||||
|
||||
**Still not implemented**: the Action (10) and Space-use (12) cards, which are genuinely
|
||||
multiplayer-only. Playing them is rejected with `NOT_IMPLEMENTED`.
|
||||
@@ -544,19 +486,13 @@ Hotel) are what grow them.
|
||||
|
||||
| # | Name | Speed | Consist | Rule |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| 1/2 | Crack Limited | Fast | 3 coaches † | Stop at Terminals only. No switching. Expedite. |
|
||||
| 1/2 | Crack Limited | Fast | 3 coaches | Stop at Terminals only. No switching. Expedite. |
|
||||
| 3/4 | Express | Fast | 2 freight | May drop or pick up one freight car at every location. Expedite. |
|
||||
| 5/6 | The Sparrow | Fast | 2 coaches † | No switching. Expedite. |
|
||||
| 5/6 | The Sparrow | Fast | 2 coaches | No switching. Expedite. |
|
||||
| 7/8 | Local | Slow | 1 freight + 1 coach | Coach must remain on station track if switching. |
|
||||
| 9/10 | Heavy Freight | Slow | 3 freight + caboose | |
|
||||
| 11/12 | Drag Freight | Slow | 2 freight + caboose | |
|
||||
|
||||
† **The two coach counts have since been swapped by Jesse** (Gitea#7, 2026-08-22): the Crack Limited
|
||||
now carries **2** coaches and The Sparrow **3**. The table above is left as `Trains3.pdf` prints it,
|
||||
because that is what this section is for — what the design SAYS. What the game plays is
|
||||
`src/engine/content.ts`, with the per-card table in
|
||||
[`../StationMaster-Home-Deck-v0.4.5.md`](../StationMaster-Home-Deck-v0.4.5.md).
|
||||
|
||||
### Extras (X13–X22) — ten distinct trains, not four generic ones
|
||||
|
||||
Appleseed Extra (MT freight only, may drop but not pick up), Fruit Growers Express (reefers only),
|
||||
@@ -598,7 +534,7 @@ We modelled a Mainline card as **2 regions, uniform**. The design has **ten dist
|
||||
| Plains | 60 | |
|
||||
| Curves | 30 | |
|
||||
| Hilly | **P60 / F30** | different speeds for passenger and freight |
|
||||
| Heavy Grade (Up) | **G** | player sets orientation †; Brakeman/Airbrakes/Helpers unlock better start positions |
|
||||
| Heavy Grade (Up) | **G** | player sets orientation; Brakeman/Airbrakes/Helpers unlock better start positions |
|
||||
| Double Track | 60 | **trains may pass** |
|
||||
| Uncontrolled Siding | 60 | trains may pass; separate "no pass" and "passing" starts |
|
||||
| Tunnel | 30 | |
|
||||
@@ -606,10 +542,6 @@ We modelled a Mainline card as **2 regions, uniform**. The design has **ten dist
|
||||
| Interchange | 60 | **sort cars into any new order**; has a Yard Limit. Printed "Yard" on the prototype card and renamed after play — it shared a word with the Division Yard, the Classification Yard, the Salvage Yard, the Yard Office and the Small Yard, and is none of them |
|
||||
| East / West Division Point | — | the ends |
|
||||
|
||||
† **"Player sets orientation" is deliberately NOT implemented** — the table records what the card
|
||||
prints, which is what this section is for. The game rolls the uphill direction from the seed instead;
|
||||
settled v0.5.0, re-confirmed 2026-08-23, reasoning in §10 Q11 above.
|
||||
|
||||
Each card shows **Start positions** — where a train enters depending on direction, train type, and
|
||||
which modifier cards are in play. The Heavy Grade card has five distinct starts (plain, brakemen,
|
||||
airbrakes, plain, helpers), so playing Brakeman literally moves your entry point further along.
|
||||
@@ -851,153 +783,3 @@ Crossing is counted in Stages (Q1), so both trains simply run their counters dow
|
||||
Until this is settled the clearance buttons describe only what the engine actually does — they say
|
||||
the train "closes up behind" rather than promising a −5 risk that cannot occur. Wording that invents
|
||||
a consequence is worse than wording that under-sells one.
|
||||
|
||||
---
|
||||
|
||||
## §7 — where an Extra starts, and which way it runs
|
||||
|
||||
**Reported from playing v0.4.9e** (Gitea#4): "When extras are played the player doing so may choose
|
||||
where the extra starts. They may choose either division point. And if the interchange mainline card
|
||||
has been played, they may start the extra on that card and choose the direction from there. If there
|
||||
is potential for conflict with other trains in that area the superintendent may hold the extra."
|
||||
|
||||
**This supersedes an earlier ruling**, and the supersession is the interesting part. §2.3 gives every
|
||||
train its direction from its number — odd runs west, even runs east — and an earlier pass extended
|
||||
that to Extras explicitly: *"the number decides, like everything else on the timetable."* That reading
|
||||
cannot survive "either Division Point". An odd Extra placed at the WEST end would run west, leave the
|
||||
Division on its first move having crossed nothing, and be paid the completion Revenue for the run.
|
||||
|
||||
So for **Extras only**, the start decides the direction:
|
||||
|
||||
| Start | Direction |
|
||||
| --- | --- |
|
||||
| Western Division Point | east |
|
||||
| Eastern Division Point | west |
|
||||
| Interchange | player's choice |
|
||||
| Control Point (any Office above a Whistle Post) | player's choice |
|
||||
|
||||
A timetabled train is unchanged: its number still decides. The Extra cards were always printed
|
||||
`direction: 'playerChoice'` (§5) and the engine had been overriding it; they now mean it.
|
||||
|
||||
### The Interchange start is a YARD, not a spot on the running line
|
||||
|
||||
§7's last clause — "the superintendent may hold the extra" — is what settles how this is modelled.
|
||||
An Extra started at an Interchange stands in that card's **yard**, off the running line, and highballs
|
||||
onto the card itself at a later Mainline Phase. Three things follow, all of them Jesse's rule rather
|
||||
than an implementation convenience:
|
||||
|
||||
1. **Placing it can never force a collision**, however busy the card is. It is not on the road yet.
|
||||
2. **A guaranteed collision holds it in the yard** for another Stage, and it tries again next Stage.
|
||||
3. **A potential collision is the Superintendent's to rule on.**
|
||||
|
||||
Those last two are exactly §8.1's two answers — an absolute bar against a facing train, a judgment
|
||||
call against a following one — so the Extra leaves the yard through the same clearance check a train
|
||||
leaves a Division Point through. Nothing new decides collisions.
|
||||
|
||||
The Interchange keeps its printed "sort cars in new order" concept, still unimplemented (§6). Being
|
||||
the card with a Yard Limit is what makes it the one Mainline card a train can be made up on.
|
||||
|
||||
### Which starts are offered is a setting
|
||||
|
||||
The Division Points and the Interchange sit on shared ground and belong to nobody; starting an Extra
|
||||
inside a player's own district does not. That is a table preference rather than a rule, so it is set
|
||||
when the game is dealt (`extraStart`): Division Points and Interchange only, plus the playing
|
||||
player's own Control Point, or plus any player's Control Point. A **Whistle Post never qualifies at
|
||||
any setting** — being a place an Extra can start is part of what upgrading buys (§11).
|
||||
|
||||
### Two bugs found underneath it
|
||||
|
||||
- **The Mainline cards were rolled, not dealt.** `buildDivision` drew uniformly from the nine card
|
||||
TYPES **with replacement**, so a Division could be dealt two Interchanges or two Tunnels, and
|
||||
Plains — printed twice in the deck — carried the same weight as cards printed once.
|
||||
`docs/StationMaster-Mainline-Deck-v0.4.5.md` had already flagged the mismatch as needing
|
||||
correction; "an Extra may start at the Interchange if one is on the board" is what forced it, since
|
||||
that only reads as a rule if the board holds at most one. Now dealt from the printed ten-card deck
|
||||
without replacement.
|
||||
- **An Extra started anywhere but a Division Point ran empty.** `isBeingMadeUp` asked only "is this
|
||||
tray standing at a Division Point", which was the whole truth while that was the only place to
|
||||
build a train — so the Control Point start had shipped since it was added with a train that could
|
||||
never be given a consist, and the Interchange start would have shipped the same way. Found by
|
||||
playing it, not by the tests, which had only ever asserted where the tray landed.
|
||||
|
||||
---
|
||||
|
||||
## §6.2 — which train cards may be discarded
|
||||
|
||||
**SUPERSEDED ONCE. Read both rulings; the second narrows the first.**
|
||||
|
||||
**Gitea#6, v0.4.9e playtest:** "Players are not allowed to discard Train cards. They may keep the
|
||||
card in their hand for multiple stages and even multiple days, but they may not discard it. If a
|
||||
player has three train cards in their hand, and they draw a fourth, then they must play one of those
|
||||
cards." Extras counted: an Extra is a train.
|
||||
|
||||
**Gitea#9, 2026-08-24 — the ruling in force:** "Timetabled trains are at the choice of the player:
|
||||
they can either play or discard. If someone else wants to pick it up, they are more than able to.
|
||||
The reason: I don't want, if you decide to play a game longer than five days, to decide that maybe
|
||||
there are too many trains, the stations are jammed, and the railroad doesn't need any more. You can
|
||||
toss it. Someone else might disagree and pick it up."
|
||||
|
||||
So the rule is now:
|
||||
|
||||
- a **Timetabled** train may be discarded;
|
||||
- an **Extra** may not. It never joins the timetable, so it can never be what jams it, and the only
|
||||
rule it would dodge by being thrown away is the hand limit;
|
||||
- **on `main` the Timetabled half is a New Game setting** (`discardTimetabled`, on by default),
|
||||
because Jesse's reasoning is explicitly about LONG games and a five-Day game may well want
|
||||
Gitea#6's pressure. The 0.4.9 playtest line has no scaffolding for a setting and takes the plain
|
||||
rule. Both lines behave identically at their defaults.
|
||||
|
||||
**"Someone else might disagree and pick it up" needed no machinery.** A discard already goes face-up
|
||||
onto a Department pile, and a Department pile is exactly what a rival draws from. The second half of
|
||||
the ruling was already built; only the first half was a change.
|
||||
|
||||
§6.2 as transcribed says only "the player must reduce his hand to no more than three cards" with no
|
||||
exception for any card type, so both of these are rulings rather than gaps — the prototype rules do
|
||||
not address it either way.
|
||||
|
||||
### It needs no forcing mechanism, and that is the point
|
||||
|
||||
The interesting property of the rule is that the forced play falls out of two rules that already
|
||||
exist rather than needing a third:
|
||||
|
||||
1. an undiscardable card is not among the ways to shed a card; and
|
||||
2. `draw.end` already refuses while the hand is over the limit (§6.2).
|
||||
|
||||
A player holding four undiscardable trains therefore has exactly one legal way to conclude the turn —
|
||||
play one — without anything in the engine ever computing "you must play a train". The corner cannot
|
||||
lock a player in, because **playing a train card is unconditionally legal**: `card.play`'s train case
|
||||
refuses only a board placement, and a train card played when the timetable is full still leaves the
|
||||
hand (it simply schedules nothing). Confirmed by playing it: such a hand offers zero discards, no
|
||||
`draw.end`, and four plays.
|
||||
|
||||
**Gitea#9 does not retire that corner, it narrows the way in.** With the setting on, the only hand
|
||||
that reaches it is four Extras; with the setting off it is any four trains, exactly as before.
|
||||
|
||||
### One place decides, and the card says which rule refused
|
||||
|
||||
`keepReason` (`src/engine/apply.ts`) returns the sentence a player should read, or `null` if the card
|
||||
may be discarded. `check`, the hand panel and the blocked "End Local Operations" button all ask it,
|
||||
so none of them can drift from the rule. It returns a SENTENCE rather than a boolean because there
|
||||
are now two distinct reasons — "an Extra is never discarded" and "not in this game" — and a panel
|
||||
that hard-codes one of them tells half the players the wrong thing. It reaches the page as the
|
||||
Frame's `handKeepWhy`.
|
||||
|
||||
The bot needed no rule of its own either. `legal.ts` enumerates candidates and filters them through
|
||||
`check`, so the option stops being offered; and the developer bot already reaches for `card.play`
|
||||
before it reaches for a discard. Measured over 400 games: 400/400 finished, revenue unmoved, and
|
||||
**trains scheduled 1.2 → 1.3** — the rule's intended effect, small because a bot rarely held four.
|
||||
|
||||
### Consequences
|
||||
|
||||
- **Two of the three published replays discarded train cards** (2 and 15 of them) and were retired
|
||||
and re-recorded. Jesse's call: "I'm okay with retiring the replays that no longer work under those
|
||||
old rules."
|
||||
- **The opening six-card hand is not exempt.** Under *six random cards* a player opens holding six
|
||||
against a limit of three; if four or more are trains, they all go onto the timetable on turn one.
|
||||
Jesse's call: "If the opening hand has lots of trains, then lots of trains will be placed on the
|
||||
board." Rare — roughly 1.5% of deals — but deliberate.
|
||||
- **The player is told, on the card and on the button.** `handDiscardable` on the Frame marks which
|
||||
cards may be shed, the hand panel says so in the card's own tooltip, and when EVERY card held is a
|
||||
train the blocked end-turn button changes its text to say a train must be played. That is the
|
||||
Gitea#2 lesson applied: a rule the player cannot see is a board with nothing to click and no reason
|
||||
given.
|
||||
|
||||
@@ -723,12 +723,10 @@ leave no way at all to speed up a slow facility. Section Gang is the sole worker
|
||||
keeps that power scarce. Capacity modifiers are stronger than they sound, since banking room rather
|
||||
than worker count is what limits output.
|
||||
|
||||
**Sub-decision — what a "Freight House" is. SUPERSEDED (v0.5.0).** §9.3 and Appendix A refer to
|
||||
Freight Houses, but §9's facility list never defines one. This originally concluded it was **not a
|
||||
card** — the collective term for a freight facility that both loads and unloads, under 10a the
|
||||
Grocer's Warehouse and the Oil Refinery. That reading was wrong: it **is** a card, a sixth Freight
|
||||
Facility dealt 6 copies (`content.ts`'s `freightHouse` profile), which the engine has implemented
|
||||
all along. Left here for the reasoning; do not read this entry as current.
|
||||
**Sub-decision — what a "Freight House" is.** §9.3 and Appendix A refer to Freight Houses, but §9's
|
||||
facility list never defines one. It is **not a card**: it is the collective term for a freight
|
||||
facility that both loads and unloads — under 10a, the Grocer's Warehouse and the Oil Refinery. This
|
||||
reconciles every reference without adding a card type or disturbing Gap 4a's deck composition.
|
||||
|
||||
### 10e — Revenue/Day revalidated, and the Gap 6 targets revised
|
||||
|
||||
|
||||
@@ -452,10 +452,9 @@ Loading and unloading of Rolling Stock (passengers and freight) takes place in t
|
||||
(§11). A Whistle Post is not a Passenger Facility, so a player who has not upgraded has no
|
||||
passenger business at all.
|
||||
- **Freight Facilities:** Mine Tipples, Produce Sheds, Grocer's Warehouses, Oil Refineries, Power
|
||||
Plants, Freight Houses. Per-card values in §12.5.
|
||||
- **Freight House:** a Freight Facility card in its own right (corrected v0.5.0 — **[Gap 10d]**
|
||||
previously read this as a collective term for the Grocer's Warehouse and the Oil Refinery rather
|
||||
than a card of its own). Permits both directions, the same as those two.
|
||||
Plants. Per-card values in §12.5.
|
||||
- **Freight House:** **[Gap 10d]** not a facility type of its own, but the collective term for a
|
||||
freight facility permitting both directions — the Grocer's Warehouse and the Oil Refinery.
|
||||
- **Modifier Facilities:** Cards that, placed adjacent (on any of the nine nearby spots), increase a
|
||||
passenger or freight facility's capacities. If two Facilities are adjacent to the Modifier, its
|
||||
effects may only be used on one Facility per **Stage** **[Gap 7]**.
|
||||
@@ -754,11 +753,11 @@ Modifier effects, and track geometries — is catalogued in
|
||||
| Extra Platform | +1 green and +1 red slot (passenger) |
|
||||
| Section Gang | +1 Laborer or +1 Porter |
|
||||
|
||||
**"Freight House"** (§9.3, Appendix A) is a Freight Facility card (corrected v0.5.0 — previously
|
||||
read as not a card, only a collective term for a facility that both loads and unloads). It is the
|
||||
**only** industry that permits both directions: the Grocer's Warehouse receives and the Oil Refinery
|
||||
ships, one way each (corrected v0.4.9e from playtesting — the "Both" reading was the other half of
|
||||
the same mistake about what "Freight House" meant).
|
||||
**"Freight House"** (§9.3, Appendix A) is a Freight Facility card, dealt like any other industry —
|
||||
this used to read "not a card, only the collective term for a facility that both loads and unloads",
|
||||
which the engine never agreed with. It is the **only** industry that permits both directions: the
|
||||
Grocer's Warehouse receives and the Oil Refinery ships, one way each (corrected v0.4.9e from gameplay
|
||||
testing — the "Both" reading was the other half of the same mistake about what "Freight House" meant).
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -1,301 +0,0 @@
|
||||
{
|
||||
"seed": 116956197,
|
||||
"history": [
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 0
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c27"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c30"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c4"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c2"
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 2
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c197",
|
||||
"placement": {
|
||||
"row": 0,
|
||||
"col": -1
|
||||
},
|
||||
"variant": 1
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 2
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c163",
|
||||
"placement": {
|
||||
"row": 1,
|
||||
"col": -1
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c41",
|
||||
"placement": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 0
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c127",
|
||||
"placement": {
|
||||
"row": 0,
|
||||
"col": 1
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c183",
|
||||
"placement": {
|
||||
"row": 0,
|
||||
"col": 2
|
||||
},
|
||||
"variant": 1
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c150",
|
||||
"placement": {
|
||||
"row": 1,
|
||||
"col": 2
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 1
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c136",
|
||||
"placement": {
|
||||
"row": 1,
|
||||
"col": 1
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.discard",
|
||||
"cardId": "c77",
|
||||
"toSlot": 1
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.discard",
|
||||
"cardId": "c171",
|
||||
"toSlot": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray3",
|
||||
"carType": "boxcar",
|
||||
"loaded": false
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray3",
|
||||
"carType": "boxcar",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.discard",
|
||||
"cardId": "c153",
|
||||
"toSlot": 1
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c9"
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray2",
|
||||
"carType": "coach",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray2",
|
||||
"carType": "coach",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "switch"
|
||||
}
|
||||
],
|
||||
"rules": {
|
||||
"startingHand": "sixRandom",
|
||||
"revenue": {
|
||||
"passengerPerCoach": 1,
|
||||
"freightPerLoad": 1,
|
||||
"trainPerTransit": 0
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,714 +0,0 @@
|
||||
{
|
||||
"seed": 116956197,
|
||||
"history": [
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 0
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c27"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c30"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c4"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c2"
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 2
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c197",
|
||||
"placement": {
|
||||
"row": 0,
|
||||
"col": -1
|
||||
},
|
||||
"variant": 1
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 2
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c163",
|
||||
"placement": {
|
||||
"row": 1,
|
||||
"col": -1
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c41",
|
||||
"placement": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 0
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c127",
|
||||
"placement": {
|
||||
"row": 0,
|
||||
"col": 1
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c183",
|
||||
"placement": {
|
||||
"row": 0,
|
||||
"col": 2
|
||||
},
|
||||
"variant": 1
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c150",
|
||||
"placement": {
|
||||
"row": 1,
|
||||
"col": 2
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 1
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c136",
|
||||
"placement": {
|
||||
"row": 1,
|
||||
"col": 1
|
||||
},
|
||||
"variant": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromDepartment",
|
||||
"slot": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.discard",
|
||||
"cardId": "c77",
|
||||
"toSlot": 1
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.discard",
|
||||
"cardId": "c171",
|
||||
"toSlot": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray3",
|
||||
"carType": "boxcar",
|
||||
"loaded": false
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray3",
|
||||
"carType": "boxcar",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.discard",
|
||||
"cardId": "c153",
|
||||
"toSlot": 1
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.play",
|
||||
"cardId": "c9"
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray2",
|
||||
"carType": "coach",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray2",
|
||||
"carType": "coach",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "switch"
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray3",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": -2
|
||||
},
|
||||
"reverse": false
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray3",
|
||||
"to": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"reverse": true
|
||||
},
|
||||
{
|
||||
"type": "switch.dropCars",
|
||||
"trayId": "tray3",
|
||||
"count": 1
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray3",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": -2
|
||||
},
|
||||
"reverse": false
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray3",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
},
|
||||
"reverse": true
|
||||
},
|
||||
{
|
||||
"type": "switch.end"
|
||||
},
|
||||
{
|
||||
"type": "laborer.beginUnload",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"carIndex": 0
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.discard",
|
||||
"cardId": "c162",
|
||||
"toSlot": 2
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "porter.detrain",
|
||||
"at": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "porter.detrain",
|
||||
"at": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "laborer.advanceLoad",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"box": 2
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "freightAgent"
|
||||
},
|
||||
{
|
||||
"type": "freightAgent.clearInbound",
|
||||
"at": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
},
|
||||
"index": 0
|
||||
},
|
||||
{
|
||||
"type": "laborer.advanceLoad",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"box": 1
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "freightAgent"
|
||||
},
|
||||
{
|
||||
"type": "freightAgent.clearInbound",
|
||||
"at": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
},
|
||||
"index": 0
|
||||
},
|
||||
{
|
||||
"type": "laborer.advanceLoad",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"box": 0
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "freightAgent"
|
||||
},
|
||||
{
|
||||
"type": "freightAgent.stockOutbound",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"carType": "boxcar"
|
||||
},
|
||||
{
|
||||
"type": "laborer.startLoad",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "freightAgent"
|
||||
},
|
||||
{
|
||||
"type": "freightAgent.stockOutbound",
|
||||
"at": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
},
|
||||
"carType": "coach"
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray2",
|
||||
"carType": "boxcar",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray2",
|
||||
"carType": "boxcar",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray2",
|
||||
"carType": "boxcar",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray2",
|
||||
"carType": "caboose",
|
||||
"loaded": true
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "freightAgent"
|
||||
},
|
||||
{
|
||||
"type": "freightAgent.clearInbound",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"index": 0
|
||||
},
|
||||
{
|
||||
"type": "laborer.advanceLoad",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"box": 0
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "freightAgent"
|
||||
},
|
||||
{
|
||||
"type": "freightAgent.stockOutbound",
|
||||
"at": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
},
|
||||
"carType": "coach"
|
||||
},
|
||||
{
|
||||
"type": "laborer.advanceLoad",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"box": 1
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "draw"
|
||||
},
|
||||
{
|
||||
"type": "draw.fromHomeOffice"
|
||||
},
|
||||
{
|
||||
"type": "card.discard",
|
||||
"cardId": "c50",
|
||||
"toSlot": 0
|
||||
},
|
||||
{
|
||||
"type": "draw.end"
|
||||
},
|
||||
{
|
||||
"type": "laborer.advanceLoad",
|
||||
"at": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"box": 2
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "switch"
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": -2
|
||||
},
|
||||
"reverse": true
|
||||
},
|
||||
{
|
||||
"type": "switch.dropCars",
|
||||
"trayId": "tray2",
|
||||
"count": 1
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": 3
|
||||
},
|
||||
"reverse": false,
|
||||
"via": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"reverse": true
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": 3
|
||||
},
|
||||
"reverse": false
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": 1
|
||||
},
|
||||
"reverse": true
|
||||
},
|
||||
{
|
||||
"type": "switch.dropCars",
|
||||
"trayId": "tray2",
|
||||
"count": 1
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": 3
|
||||
},
|
||||
"reverse": false
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray3",
|
||||
"carType": "tank",
|
||||
"loaded": false
|
||||
},
|
||||
{
|
||||
"type": "newTrain.placeCar",
|
||||
"trayId": "tray3",
|
||||
"carType": "tank",
|
||||
"loaded": false
|
||||
},
|
||||
{
|
||||
"type": "loadUnload.end"
|
||||
},
|
||||
{
|
||||
"type": "localOps.choose",
|
||||
"option": "switch"
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 1,
|
||||
"col": 0
|
||||
},
|
||||
"reverse": true
|
||||
},
|
||||
{
|
||||
"type": "switch.dropCars",
|
||||
"trayId": "tray2",
|
||||
"count": 3
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": 3
|
||||
},
|
||||
"reverse": false
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": -2
|
||||
},
|
||||
"reverse": true,
|
||||
"via": {
|
||||
"row": 0,
|
||||
"col": 1
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "switch.move",
|
||||
"trayId": "tray2",
|
||||
"to": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
},
|
||||
"reverse": false
|
||||
},
|
||||
{
|
||||
"type": "switch.end"
|
||||
}
|
||||
],
|
||||
"rules": {
|
||||
"startingHand": "sixRandom",
|
||||
"revenue": {
|
||||
"passengerPerCoach": 1,
|
||||
"freightPerLoad": 1,
|
||||
"trainPerTransit": 0
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,195 +0,0 @@
|
||||
# Station Master 0.5.0 — Test Plan
|
||||
|
||||
Written 2026-08-21, against an uncommitted working tree. Covers only the changes made in this
|
||||
session's work — victory-condition unification, the New Train phase fix, and the multiplayer server
|
||||
(Phases 2-3). Nothing here is committed yet; see the Coordination Note below before running any of it
|
||||
against a tree that has since moved.
|
||||
|
||||
## Coordination note — shared working tree
|
||||
|
||||
Another thread is bug-fixing the 0.4.9 series **in this same uncommitted working tree**, concurrently.
|
||||
`git status` shows changes I did not make in: `apply.ts`, `events.ts`, `track.ts`, `board-svg.ts`,
|
||||
`docs/rules/*.md`, `package-lock.json`, `scripts/build-web.ts`, `.gitignore`, plus new
|
||||
`docs/station-master-seed*.json` files still appearing as of this writing. **This plan does not cover
|
||||
any of that** — it is scoped to the files below, which are the ones I actually touched.
|
||||
|
||||
Practical implications:
|
||||
- Before running this plan, confirm the files under "Files this plan covers" still read the way this
|
||||
document describes them — the other thread's commits could in principle touch the same functions
|
||||
(`apply.ts`'s `check()` is used directly by `src/server/session.ts`, for instance).
|
||||
- Run the full regression gate (`npm run typecheck && npm test`) fresh, not from a memory of an earlier
|
||||
green run — both threads are editing live.
|
||||
- The two bodies of work are unrelated in intent (0.4.9 patch fixes vs. 0.5.0 multiplayer groundwork)
|
||||
but share a tree, so a clean split into separate commits before either is finalized is worth doing
|
||||
deliberately rather than by accident.
|
||||
|
||||
### Files this plan covers
|
||||
|
||||
```
|
||||
Engine: src/engine/advance.ts, src/engine/content.ts, src/engine/setup.ts, src/engine/state.ts
|
||||
Web: src/web/game.ts, src/web/main.ts, src/web/play.html, src/web/session.ts
|
||||
Sim: src/sim/view.ts, src/sim/frame-delta.ts (new), src/sim/compare.ts, src/sim/harness.ts,
|
||||
src/sim/replay.ts
|
||||
Server: src/server/ (new — index.ts, http.ts, session.ts, persistence.ts)
|
||||
Tests: test/advance.test.ts, test/multiplayer.test.ts, test/web.test.ts, test/setup.test.ts,
|
||||
test/redaction.test.ts (new), test/frame-delta.test.ts (new), test/server/ (new)
|
||||
Docs: TODO.md, package.json (test script only)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 0. Automated regression gate — run first, every time
|
||||
|
||||
```
|
||||
npm run typecheck
|
||||
npm test
|
||||
```
|
||||
|
||||
Expected: typecheck clean, **all tests passing** (632 at the time this plan was written — the exact
|
||||
number will drift as the other thread's work lands; what matters is zero failures). If either command
|
||||
is red, stop and diagnose before doing anything below — a red gate means the manual steps are testing
|
||||
against a broken build.
|
||||
|
||||
**If you only have time for one thing before the break ends, run this.** Everything else in this
|
||||
document is either already covered by it, or is the manual/live verification that can't be — flagged
|
||||
per-section below.
|
||||
|
||||
---
|
||||
|
||||
## 1. Regression baseline — solitaire must play exactly as before
|
||||
|
||||
The engine and dialog changes touch shared code paths solitaire also uses. None of this should have
|
||||
changed solitaire's actual behavior.
|
||||
|
||||
| # | Test | Steps | Expected |
|
||||
|---|---|---|---|
|
||||
| 1.1 | Fresh deal | `npm run serve:web`, open `/play.html`, no URL params | A new random-seed solitaire game deals normally, board and hand render |
|
||||
| 1.2 | Full game to completion | Play (or let a bot/harness play) a solitaire game to Day 5 | Game ends with a win/loss exactly as it would have before — `minCombinedRevenue` defaults to `collectiveRevenueFloor(1,5)=15`, not the old fixed `20`; a game scoring 15-19 that used to lose now wins (**intentional** — see §3, not a bug) |
|
||||
| 1.3 | Save / restore | Play a few turns, reload the page (auto-restores from `localStorage`) | Game resumes exactly where it left off, house rules and victory dials intact |
|
||||
| 1.4 | Save file download | Click "Save replay" mid-game | Downloads a small JSON; re-opening it in the replay viewer plays back identically |
|
||||
| 1.5 | Undo | Play a few turns, click Undo repeatedly to the start | Each step back is clean; log never shows a move that "un-happened" |
|
||||
| 1.6 | Existing published replays | Open each file under `public/replays/` in the replay viewer | All three still play back — `LEGACY_HOUSE_RULES` fallback for saves with no `houseRules` field is unaffected by this session's changes |
|
||||
|
||||
Automated coverage: `test/advance.test.ts`, `test/web.test.ts`, `test/session.test.ts` already assert
|
||||
most of this at the unit level. §1 is about confirming nothing *visibly* changed for a solitaire
|
||||
player, which only a live playthrough shows.
|
||||
|
||||
---
|
||||
|
||||
## 2. New Train phase car-placement rotation (engine fix)
|
||||
|
||||
**What changed:** the Superintendent used to place every car of every train alone, even in
|
||||
competitive mode, against §7's written rule. Now the round rotates Superintendent-then-left, one car
|
||||
per player, per `tray.consist.length`.
|
||||
|
||||
Automated: `test/multiplayer.test.ts`, "the New Train phase car-placement round rotates (§7, Gap 9)" —
|
||||
asserts the exact actor sequence for 2p (wraps: 0,1,0) and 3p (no wrap: 0,1,2) against a real train
|
||||
profile.
|
||||
|
||||
| # | Test | Steps | Expected |
|
||||
|---|---|---|---|
|
||||
| 2.1 | Manual multi-seat check | Drive a 3-4 player competitive game via the bot harness (`node src/sim/harness.ts`) or by hand through `src/server/`, and watch a Timetabled train get made up | Car-placement decisions visibly move between seats rather than one player filling the whole consist |
|
||||
| 2.2 | Solitaire unaffected | Play any solitaire game where a train is made up | No visible change — one player, nothing to rotate, `tray.consist.length % 1 === 0` always |
|
||||
|
||||
Not covered, flagged in `TODO.md` (do not re-test, it's expected to be unreachable): `newTrain.passCar`
|
||||
still has a dormant `check()`/`reduce()` gap, harmless because `trainNeedingCars` never offers a tray
|
||||
with nothing suitable in the yard.
|
||||
|
||||
---
|
||||
|
||||
## 3. Victory conditions unified (`GameConfig` dials)
|
||||
|
||||
**What changed:** `days`, `minCombinedRevenue`, `maxCollisionsPerDay`, `maxCollisionsTotal`,
|
||||
`pvpCardsAllowed` replace the old `length`-preset/`target`/flat collision constant, across all three
|
||||
modes. Automated coverage: `test/advance.test.ts`'s "victory conditions (§3, Gap 10e) — unified
|
||||
2026-08-20" describe block (8 tests) covers every case below at the engine level already. This section
|
||||
is for confirming the *dialog* actually produces the numbers the engine then honors.
|
||||
|
||||
| # | Test | Steps | Expected |
|
||||
|---|---|---|---|
|
||||
| 3.1 | `minCombinedRevenue` — loss | New Game, set it to a number higher than achievable, play to Day N | Loss, reason `revenueFloor`, regardless of individual score |
|
||||
| 3.2 | `minCombinedRevenue` — win | Set it to 0, play to Day N with any score | Win — `0` genuinely disables the floor |
|
||||
| 3.3 | `maxCollisionsPerDay` — **new solitaire behavior** | Set to 1, deliberately cause 1 collision (e.g. leave every A/D track occupied on an arrival) | Game ends **immediately**, mid-Stage, loss, reason `collisionFloor` — solitaire could never lose this way before this change |
|
||||
| 3.4 | `maxCollisionsTotal` | Set `maxCollisionsPerDay=0` (off), `maxCollisionsTotal=2`, cause 2 collisions across different Days | Game ends on the 2nd collision, whichever Day it falls on |
|
||||
| 3.5 | Both collision caps at 0 | Set both to 0, cause several collisions | Game does **not** end early — same as pre-change solitaire (collisions still cost Revenue, just don't end the game) |
|
||||
| 3.6 | Mode radio defaults | Open New Game, click Competitive | `minCombinedRevenue` suggests `3 × 4 × days` (nominal 4-player assumption — no lobby yet to ask real seat count), `pvpCardsAllowed` checks and enables, Deal disables with a "needs a server" note |
|
||||
| 3.7 | Mode radio — Co-op | Click Co-op | `pvpCardsAllowed` unchecks and **greys out** (forced off, not just defaulted off — no valid target when everyone's on one side), Deal disables |
|
||||
| 3.8 | Mode radio — back to Solitaire | Click Solitaire again | Deal re-enables, `pvpCardsAllowed` unchecks and greys, all four dials show the numbers the *currently playing* game actually has (not the preset) |
|
||||
| 3.9 | URL round-trip | Deal a game with non-default `days`/`minrev`/`colday`/`coltotal`, copy the URL, open it in a new tab | Identical settings — all four now travel via `?days=&minrev=&colday=&coltotal=` alongside the existing `?hand=&passenger=&freight=&transit=` |
|
||||
|
||||
**Not yet clicked through in a real browser** (no browser binary in the sandbox this was built in —
|
||||
verified only via a simulated-DOM test harness, `test/web.test.ts`'s "the New Game dialog" describe
|
||||
block, which drives the actual compiled bundle). §3.6-3.9 specifically should get a real click-through
|
||||
before calling this done.
|
||||
|
||||
---
|
||||
|
||||
## 4. Multiplayer server — Phase 2 (session core)
|
||||
|
||||
New in this release: `src/server/` (session host, HTTP/SSE, static serving), `src/web/session.ts`'s
|
||||
`createRemoteSession`, `src/sim/frame-delta.ts`. Automated: `test/server/session.test.ts` (12 cases,
|
||||
pure logic, no sockets), `test/redaction.test.ts` (4 cases — the exhaustive "no seat sees another
|
||||
seat's secrets" check), `test/frame-delta.test.ts` (5 cases).
|
||||
|
||||
| # | Test | Steps | Expected |
|
||||
|---|---|---|---|
|
||||
| 4.1 | Boot | `JOIN_SECRET=x PORT=8081 node src/server/index.ts` | Starts, logs the bind address and `dist/` path |
|
||||
| 4.2 | Join secret gate | `curl -X POST localhost:8081/api/game` (no `?secret=`) | `403 bad or missing secret` |
|
||||
| 4.3 | Create game | `POST /api/game?secret=x` with `{config, playerNames}` | `200 {ok:true, playerCount:N}`; a second call while a game exists → `409` |
|
||||
| 4.4 | Per-seat SSE | Open `/api/stream?seat=0` and `?seat=1` for a 2-player game | Only the current actor's push has a non-null `menu`; the other seat's is `null` |
|
||||
| 4.5 | Turn enforcement | `POST /api/intent` as the **non-acting** seat | `{ok:false, code:"NOT_YOUR_TURN"}`, no broadcast, no state change |
|
||||
| 4.6 | Accept + broadcast | `POST /api/intent` as the acting seat, a legal intent | `{ok:true}`; **both** SSE streams receive a push with fresh narration |
|
||||
| 4.7 | Idempotent resend | Submit the same `{seq, intent}` twice | Second call: `{ok:true}`, **no** new SSE push (already applied, silently ignored) |
|
||||
| 4.8 | Illegal intent | Submit something `check()` would reject | `{ok:false, code:"<real RejectionCode>"}`; the rejection text does **not** appear in the *other* seat's narration (private feedback, §session.ts's design note) |
|
||||
| 4.9 | Board delta | Submit an intent that doesn't move anything on the board (e.g. `localOps.choose`) | The next push's `frame.division`/`frame.cells` are `null` (unchanged-since-last-push-to-this-seat) |
|
||||
| 4.10 | Heartbeat | Hold an SSE connection open >20s idle | A `: ping` comment line appears (EventSource ignores it; keeps a proxy from reaping the socket) |
|
||||
| 4.11 | **Real browser — not yet done** | Two actual browser tabs, `?seat=0` and `?seat=1`, playing a shared game by clicking | Confirm the whole loop works through the actual UI, not just curl: turn indicator, disabled controls for the non-acting seat, board updates on both sides, a rejected action shows *something* sensible on screen rather than silently doing nothing |
|
||||
|
||||
§4.1-4.10 were run live against a real server process during this session (not just unit-tested) — see
|
||||
the session transcript for the actual curl commands and captured output. §4.11 genuinely was not done;
|
||||
no browser was available in the environment this was built in.
|
||||
|
||||
---
|
||||
|
||||
## 5. Multiplayer server — Phase 3 (persistence and resumption)
|
||||
|
||||
New: `src/server/persistence.ts`, `game.ts`'s `fromMultiplayerSave`, `session.ts`'s `exportSave`/
|
||||
`resumeSession`/turn-timing tracking. Automated: `test/server/persistence.test.ts` (6 cases),
|
||||
`test/server/session.test.ts`'s "turn timings" and "persistence hooks" describe blocks.
|
||||
|
||||
| # | Test | Steps | Expected |
|
||||
|---|---|---|---|
|
||||
| 5.1 | Immediate persistence | `POST /api/game`, then check `DATA_DIR/game.json` | Exists immediately, empty `history`, correct `engineVersion` (= `package.json`'s `version`) |
|
||||
| 5.2 | History grows | Submit a few intents | `game.json`'s `history` array grows by one entry per accepted intent, in order |
|
||||
| 5.3 | Turn timings recorded | Submit enough intents to cross a full turn (player/phase/day/stage change) | `DATA_DIR/turn-timings.json` gains an entry: `{player, phase, day, stage, startedAt, endedAt}`, `endedAt >= startedAt` |
|
||||
| 5.4 | **Restart and resume** (the actual "done when" for Phase 3) | Kill the server process mid-game, restart it against the same `DATA_DIR` | Log line: `"Resumed a saved game... N intents replayed"`; reconnecting both `?seat=` streams shows the exact same Day/Stage/phase/whose-turn as before the kill, correct narration attribution ("Player X chose to...", not anonymous) |
|
||||
| 5.5 | Version-mismatch refusal | Hand-edit `game.json`'s `engineVersion` to a bogus value, restart | Log line refusing to load, naming both versions; server starts with **no** active game (confirm via `POST /api/game` succeeding, not `409`ing); the file is **not** deleted or modified |
|
||||
| 5.6 | Atomic writes, no stray temp files | After several intents, check `DATA_DIR` | Only `game.json`/`turn-timings.json` present — no leftover `.tmp` files from an interrupted write |
|
||||
|
||||
§5.1-5.6 were all run live during this session (kill-and-restart included) — see the transcript. This
|
||||
is the most thoroughly live-verified section of the whole plan.
|
||||
|
||||
---
|
||||
|
||||
## 6. Things this session found but did *not* fix — verify they're still correctly deferred
|
||||
|
||||
These are logged in `TODO.md`, not bugs to chase here — listed so a tester doesn't rediscover them and
|
||||
assume something regressed.
|
||||
|
||||
| Item | Where | Current state to confirm |
|
||||
|---|---|---|
|
||||
| `fromSave`'s replay loses "Player X" narration attribution | `src/web/game.ts` | Still present in `fromSave` (untouched, out of scope); **fixed** in the new `fromMultiplayerSave` — §5.4's narration check is what confirms the fix landed where it needed to |
|
||||
| `newTrain.passCar`'s `check()`/`reduce()` gap | `src/engine/apply.ts` | Still dormant/unreachable — confirm no new caller has started exercising it (would only matter if the *other* thread's 0.4.9 work touches this area) |
|
||||
| No real browser click-through | This session | §3.6-3.9, §4.11 — the two gaps a human still needs to close |
|
||||
|
||||
---
|
||||
|
||||
## Summary checklist
|
||||
|
||||
- [ ] §0 automated gate green
|
||||
- [ ] §1 solitaire regression (six checks)
|
||||
- [ ] §2 New Train rotation, manual multi-seat check
|
||||
- [ ] §3 victory conditions, especially §3.6-3.9 (dialog, not yet browser-verified)
|
||||
- [ ] §4 server core, especially §4.11 (real browser, not yet done)
|
||||
- [ ] §5 persistence — already live-verified this session; worth a second independent run
|
||||
- [ ] §6 confirm the three known-and-deferred items are still exactly as described
|
||||
Generated
+2
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "station-master",
|
||||
"version": "0.7.0",
|
||||
"version": "0.4.8",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "station-master",
|
||||
"version": "0.7.0",
|
||||
"version": "0.4.8",
|
||||
"devDependencies": {
|
||||
"@types/node": "^26.1.2",
|
||||
"typescript": "^7.0.2"
|
||||
|
||||
+2
-3
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "station-master",
|
||||
"version": "0.7.5",
|
||||
"version": "0.4.9e",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"description": "Station Master — a railroad operations game",
|
||||
@@ -9,8 +9,7 @@
|
||||
},
|
||||
"scripts": {
|
||||
"typecheck": "tsc --noEmit",
|
||||
"pretest": "node scripts/build-web.ts",
|
||||
"test": "node --test test/*.test.ts test/**/*.test.ts",
|
||||
"test": "node --test test/**/*.test.ts",
|
||||
"build:web": "node scripts/build-web.ts",
|
||||
"serve:web": "node scripts/build-web.ts && npx --yes http-server dist -p 8080 -c-1",
|
||||
"deploy:web": "node scripts/deploy-web.ts"
|
||||
|
||||
@@ -1,28 +0,0 @@
|
||||
# Playtest saves
|
||||
|
||||
Save files that came in with a bug report, or that were kept from a session worth re-reading.
|
||||
|
||||
**Nothing in here is committed** — `.gitignore` keeps the directory empty as far as git is
|
||||
concerned, except for this file. They are somebody's game, not part of the project, and they go
|
||||
stale the moment the rules move.
|
||||
|
||||
## What a save is
|
||||
|
||||
A seed and the list of moves made — a few hundred bytes of JSON. That is enough to rebuild the
|
||||
whole game, which is why a replay can be emailed like a text file. Written by **Save replay** on the
|
||||
play screen; a multiplayer game's copy lives on the server, under its data directory.
|
||||
|
||||
## How to open one
|
||||
|
||||
Open `replays.html` on the site (or a local `npm run serve:web`) and use **Open a save file** at the
|
||||
bottom of the page — it takes a file straight off disk, no upload anywhere. Step through it frame by
|
||||
frame to find the position being reported.
|
||||
|
||||
A save replays only under the rules it was dealt with; every save records them, and one written
|
||||
before a rules change may stop part-way. That is expected, and it is why these are kept beside a
|
||||
report rather than in the repository.
|
||||
|
||||
## Publishing one
|
||||
|
||||
A replay worth keeping for everyone goes in `public/replays/` instead, where the build publishes it
|
||||
into the site's replay directory with an index entry.
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -15,13 +15,7 @@ import { dirname, join } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
const root = join(dirname(fileURLToPath(import.meta.url)), '..');
|
||||
/**
|
||||
* Overridable so a test can point the build at an isolated directory instead of the shared
|
||||
* `dist/` the rest of the suite reads — see `test/web.test.ts`'s "builds, and needs nothing but a
|
||||
* static host". Must be a sibling of `dist/`, not nested inside it: this script's own `rmSync`
|
||||
* below wipes the whole directory it is given, so nesting one inside the other would still race.
|
||||
*/
|
||||
const dist = join(root, process.env['BUILD_DIST_DIR'] ?? 'dist');
|
||||
const dist = join(root, 'dist');
|
||||
|
||||
rmSync(dist, { recursive: true, force: true });
|
||||
mkdirSync(dist, { recursive: true });
|
||||
|
||||
+32
-93
@@ -1,29 +1,11 @@
|
||||
/**
|
||||
* Build the solitaire site and push it to a FileBrowser instance.
|
||||
* Build the solitaire site and push it to a File Browser instance.
|
||||
*
|
||||
* REWRITTEN FOR **FileBrowser Quantum** (2026-08-23). The host was upgraded from File Browser v2.63
|
||||
* to the Quantum fork, whose API is different in three ways at once, and every deploy failed with
|
||||
* `login failed: 404 404 page not found` — the old `/api/login` simply is not there any more.
|
||||
* Written against File Browser v2.63's REST API, read from its own bundle rather than guessed:
|
||||
*
|
||||
* Read from the running instance's own bundle rather than guessed, the same way the v2.63 version
|
||||
* was (`/public/static/assets/index-*.js`, gzipped — pipe it through `gunzip` before grepping), and
|
||||
* each path confirmed against the live host by the response code: an endpoint that exists answers a
|
||||
* bad password with **401**, one that does not answers **404**.
|
||||
*
|
||||
* POST /api/auth/login?username=<u>&recaptcha=
|
||||
* headers X-Password: <urlencoded>, X-Secret: <otp or empty> -> sets a session COOKIE
|
||||
* GET /api/settings/sources -> the named sources
|
||||
* POST /api/resources?path=<p>&source=<s>&isDir=true -> create a directory
|
||||
* POST /api/resources?path=<p>&source=<s>&override=true body=bytes -> upload
|
||||
*
|
||||
* THREE THINGS MOVED, and each would break on its own:
|
||||
* 1. AUTH IS A COOKIE, not an `X-Auth: <jwt>` header. Login returns no usable token in its body;
|
||||
* the session arrives in `Set-Cookie` and every later request has to carry it back.
|
||||
* 2. THE PASSWORD IS A HEADER, `X-Password`, URL-encoded — not a JSON body field.
|
||||
* 3. THE PATH IS A QUERY PARAMETER, `?path=`, not part of the URL, and every resource call also
|
||||
* needs a **`source`** naming which configured store to write to. Quantum throws "no source
|
||||
* provided" without it. `FB_SOURCE` names it; left unset, the sole configured source is used,
|
||||
* and if there is more than one this stops and lists them rather than guessing.
|
||||
* POST /api/login {username, password, recaptcha} -> JWT as plain text
|
||||
* POST /api/resources/<dir>/ X-Auth: <jwt> -> create a directory
|
||||
* POST /api/resources/<file>?override=true X-Auth: <jwt>, body = bytes -> upload
|
||||
*
|
||||
* File Browser is the STORE, not the server — Start9 Pages serves the uploaded folder as the site.
|
||||
* So the job here is simply to land the built files in the right folder, intact.
|
||||
@@ -36,8 +18,6 @@
|
||||
* Optional:
|
||||
* FB_URL default https://phoenix.local:58157
|
||||
* FB_DEST default websites/stationmaster — the folder Start9 Pages serves from
|
||||
* FB_SOURCE which configured source to write to; discovered automatically when there is one
|
||||
* FB_OTP the one-time code, if the account has two-factor enabled
|
||||
* FB_INSECURE set to 1 for a self-signed certificate (usual for a .local StartOS host)
|
||||
* SITE_URL default https://65.78.82.12:54697/ — the public address Start9 Pages serves at
|
||||
* --dry-run list what would be sent, contact nothing
|
||||
@@ -64,8 +44,6 @@ const URL_BASE = (process.env['FB_URL'] ?? 'https://phoenix.local:58157').replac
|
||||
const DEST = `/${(process.env['FB_DEST'] ?? 'websites/stationmaster').replace(/^\/+|\/+$/g, '')}`;
|
||||
const USER = process.env['FB_USER'] ?? '';
|
||||
const PASS = process.env['FB_PASS'] ?? '';
|
||||
const OTP = process.env['FB_OTP'] ?? '';
|
||||
const SOURCE_ENV = process.env['FB_SOURCE'] ?? '';
|
||||
const DRY = process.argv.includes('--dry-run');
|
||||
|
||||
/**
|
||||
@@ -97,80 +75,37 @@ const CONTENT_TYPES: Record<string, string> = {
|
||||
'.txt': 'text/plain',
|
||||
};
|
||||
|
||||
/**
|
||||
* Log in and return the session cookie every later request must carry.
|
||||
*
|
||||
* The password goes in a HEADER and URL-encoded, which is Quantum's own client does
|
||||
* (`X-Password: encodeURIComponent(password)`). The body carries nothing useful on success — the
|
||||
* session is in `Set-Cookie`, so a deploy that ignored the cookie would authenticate and then be
|
||||
* rejected by every upload.
|
||||
*/
|
||||
async function login(): Promise<string> {
|
||||
const url = `${URL_BASE}/api/auth/login?username=${encodeURIComponent(USER)}&recaptcha=`;
|
||||
const res = await fetch(url, {
|
||||
const res = await fetch(`${URL_BASE}/api/login`, {
|
||||
method: 'POST',
|
||||
headers: { 'X-Password': encodeURIComponent(PASS), 'X-Secret': OTP },
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ username: USER, password: PASS, recaptcha: '' }),
|
||||
});
|
||||
const body = await res.text();
|
||||
if (!res.ok) {
|
||||
// 401 here is a wrong username/password; 404 would mean this build has moved the API again.
|
||||
throw new Error(`login failed: ${res.status} ${body || res.statusText}`);
|
||||
}
|
||||
const cookies = res.headers.getSetCookie();
|
||||
if (cookies.length === 0) throw new Error('login succeeded but set no session cookie');
|
||||
return cookies.map((c) => c.split(';')[0]).join('; ');
|
||||
if (!res.ok) throw new Error(`login failed: ${res.status} ${body || res.statusText}`);
|
||||
if (!body.trim()) throw new Error('login returned an empty token');
|
||||
return body.trim();
|
||||
}
|
||||
|
||||
/**
|
||||
* WHICH STORE TO WRITE TO. Quantum can serve several named sources and refuses any resource call
|
||||
* that does not name one ("no source provided"), which is the parameter the v2.63 API had no
|
||||
* concept of. One configured source is the normal case and is used without asking; more than one is
|
||||
* ambiguous, and guessing would silently deploy the site into the wrong store.
|
||||
*/
|
||||
async function resolveSource(cookie: string): Promise<string> {
|
||||
if (SOURCE_ENV) return SOURCE_ENV;
|
||||
const res = await fetch(`${URL_BASE}/api/settings/sources`, { headers: { cookie } });
|
||||
if (!res.ok) throw new Error(`could not list sources: ${res.status} ${await res.text()}`);
|
||||
const names = Object.keys((await res.json()) ?? {});
|
||||
if (names.length === 1) return names[0]!;
|
||||
if (names.length === 0) throw new Error('the server reports no sources at all');
|
||||
throw new Error(`several sources configured (${names.join(', ')}) — pick one with FB_SOURCE=<name>`);
|
||||
}
|
||||
|
||||
function resourceUrl(source: string, path: string, extra: Record<string, string>): string {
|
||||
const params = new URLSearchParams({ path, source, ...extra });
|
||||
return `${URL_BASE}/api/resources?${params}`;
|
||||
}
|
||||
|
||||
async function makeDir(cookie: string, source: string, path: string): Promise<void> {
|
||||
const res = await fetch(resourceUrl(source, path, { isDir: 'true' }), {
|
||||
async function makeDir(jwt: string, path: string): Promise<void> {
|
||||
// Trailing slash is what marks a directory in this API. A 409 means it already exists, which is
|
||||
// the normal case on every deploy after the first.
|
||||
const res = await fetch(`${URL_BASE}/api/resources${encodePath(path)}/`, {
|
||||
method: 'POST',
|
||||
headers: { cookie },
|
||||
headers: { 'X-Auth': jwt },
|
||||
});
|
||||
if (res.ok) return;
|
||||
/**
|
||||
* "Already there" is the normal case on every deploy after the first, and Quantum is not
|
||||
* consistent about which code it reports it with. So the two failures worth stopping for are
|
||||
* named — a rejected session, and a server that broke — and every other 4xx is treated as the
|
||||
* directory already existing. A directory that genuinely is not there fails loudly at the upload
|
||||
* a moment later, which is a better place to find out than a guess here.
|
||||
*/
|
||||
const fatal = res.status === 401 || res.status === 403 || res.status >= 500;
|
||||
if (fatal) throw new Error(`could not create ${path}: ${res.status} ${await res.text()}`);
|
||||
if (!res.ok && res.status !== 409) {
|
||||
throw new Error(`could not create ${path}: ${res.status} ${await res.text()}`);
|
||||
}
|
||||
}
|
||||
|
||||
async function upload(
|
||||
cookie: string,
|
||||
source: string,
|
||||
localPath: string,
|
||||
remotePath: string,
|
||||
): Promise<void> {
|
||||
async function upload(jwt: string, localPath: string, remotePath: string): Promise<void> {
|
||||
const bytes = readFileSync(localPath);
|
||||
const ext = remotePath.slice(remotePath.lastIndexOf('.'));
|
||||
const res = await fetch(resourceUrl(source, remotePath, { override: 'true' }), {
|
||||
const res = await fetch(`${URL_BASE}/api/resources${encodePath(remotePath)}?override=true`, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
cookie,
|
||||
'X-Auth': jwt,
|
||||
'Content-Type': CONTENT_TYPES[ext] ?? 'application/octet-stream',
|
||||
'Content-Length': String(bytes.byteLength),
|
||||
},
|
||||
@@ -179,6 +114,11 @@ async function upload(
|
||||
if (!res.ok) throw new Error(`upload ${remotePath} failed: ${res.status} ${await res.text()}`);
|
||||
}
|
||||
|
||||
/** Encode each segment but keep the separators, so a path stays a path. */
|
||||
function encodePath(p: string): string {
|
||||
return p.split('/').map(encodeURIComponent).join('/');
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
console.log('building…');
|
||||
@@ -207,16 +147,15 @@ if (DRY) {
|
||||
);
|
||||
}
|
||||
|
||||
const cookie = await login();
|
||||
const source = await resolveSource(cookie);
|
||||
console.log(`logged in — writing to source "${source}"`);
|
||||
const jwt = await login();
|
||||
console.log('logged in');
|
||||
|
||||
await makeDir(cookie, source, DEST);
|
||||
for (const d of dirs) await makeDir(cookie, source, `${DEST}/${d}`);
|
||||
await makeDir(jwt, DEST);
|
||||
for (const d of dirs) await makeDir(jwt, `${DEST}/${d}`);
|
||||
|
||||
let done = 0;
|
||||
for (const f of files) {
|
||||
await upload(cookie, source, join(dist, f), `${DEST}/${f}`);
|
||||
await upload(jwt, join(dist, f), `${DEST}/${f}`);
|
||||
done++;
|
||||
console.log(` [${String(done).padStart(2)}/${files.length}] ${f}`);
|
||||
}
|
||||
|
||||
+118
-737
File diff suppressed because it is too large
Load Diff
+77
-473
@@ -33,9 +33,9 @@ import {
|
||||
officeProfile,
|
||||
trainProfile,
|
||||
} from './content.ts';
|
||||
import type { CarType, Direction, FreightKind, Hand, MainlineKind, ModifierKind, ModifierProfile, TrackGeometry, TrainRules } from './content.ts';
|
||||
import type { CarType, FreightKind, Hand, MainlineKind, ModifierKind, ModifierProfile, TrackGeometry, TrainRules } from './content.ts';
|
||||
import type { GameEvent } from './events.ts';
|
||||
import type { ExtraStart, Intent, RejectionCode } from './intents.ts';
|
||||
import type { Intent, RejectionCode } from './intents.ts';
|
||||
import type {
|
||||
CardId,
|
||||
CrewTray,
|
||||
@@ -52,14 +52,11 @@ import type {
|
||||
TrayId,
|
||||
TurnoutOrientation,
|
||||
} from './state.ts';
|
||||
import { tallyEvent } from './tally.ts';
|
||||
import { createRng } from './rng.ts';
|
||||
import {
|
||||
carsOn,
|
||||
coordKey,
|
||||
cutTowards,
|
||||
decisionActor,
|
||||
officeNodeFor,
|
||||
isOperationalRail,
|
||||
playerAtSeat,
|
||||
pooled,
|
||||
@@ -80,7 +77,6 @@ import {
|
||||
facilityVariants,
|
||||
opposite,
|
||||
reachableDestinations,
|
||||
rowEndAt,
|
||||
variantsFor,
|
||||
withinLimits,
|
||||
} from './track.ts';
|
||||
@@ -126,12 +122,7 @@ function trayCoord(s: GameState, trayId: TrayId): GridCoord | null {
|
||||
}
|
||||
|
||||
/** A tray sitting on the Office card occupies an A/D track (§2.1). */
|
||||
/**
|
||||
* Exported for `advance.ts`'s Yard Office walk (Gitea#5), which has to ask the SAME occupancy
|
||||
* question a switching move asks — a second copy would be free to drift into a different answer
|
||||
* about which cards are free.
|
||||
*/
|
||||
export function occupancyFor(s: GameState, player: PlayerIndex, self: TrayId): Occupancy {
|
||||
function occupancyFor(s: GameState, player: PlayerIndex, self: TrayId): Occupancy {
|
||||
const area = areaOf(s, player);
|
||||
return {
|
||||
trayAt: (c) => {
|
||||
@@ -340,15 +331,6 @@ function checkTurnoutUpgrade(existing: TrackCard, proto: TrackCard): RejectionCo
|
||||
|
||||
if (existing.standing.length > 0) return 'UPGRADE_OCCUPIED';
|
||||
if (existing.enhancements.length > 0) return 'UPGRADE_ENHANCED';
|
||||
/**
|
||||
* NOTHING IS ASKED ABOUT THE NEIGHBOURS, deliberately (Gitea#15).
|
||||
*
|
||||
* A turnout adds a 45° leg the card underneath did not have, and that leg may well point into an
|
||||
* occupied square with nothing to meet it. That is legal: RAR ruled (2026-08-26) that a rail may
|
||||
* stop dead against its neighbour, and an upgrade is no different from laying the piece there in
|
||||
* the first place. What must hold either way is that no train can cross the gap, which is
|
||||
* `exploreMoves`' business and is tested in `track.test.ts`.
|
||||
*/
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -434,111 +416,6 @@ export function canDetrain(s: GameState, player: PlayerIndex, at: GridCoord, tra
|
||||
return passengerWork(s, player, 'detrain', trayId) !== null;
|
||||
}
|
||||
|
||||
/**
|
||||
* A Timetabled or Extra train card (§6.2) — the one place that decides what "a train card" means.
|
||||
*/
|
||||
export function isTrainCard(s: GameState, cardId: CardId): boolean {
|
||||
const kind = s.cards.get(cardId)?.kind.kind;
|
||||
return kind === 'timetabledTrain' || kind === 'extraTrain';
|
||||
}
|
||||
|
||||
/**
|
||||
* WHY THIS CARD CANNOT BE THROWN AWAY, or `null` if it can (§6.2, Gitea#9 superseding Gitea#6).
|
||||
*
|
||||
* The one place that answers the question, so `check`, the hand panel and the blocked "End Local
|
||||
* Operations" button all give the same reason rather than three hand-written approximations of it.
|
||||
* Gitea#6 made every train card unconditionally undiscardable; Gitea#9 narrows that:
|
||||
*
|
||||
* - a TIMETABLED train is discardable unless the `discardTimetabled` house rule is off. Jesse's
|
||||
* reasoning is about a long game whose timetable has filled up — "the stations are jammed and
|
||||
* the railroad doesn't need any more. You can toss it";
|
||||
* - an EXTRA is never discardable. It never joins the timetable, so it cannot jam it, and the
|
||||
* rule it would otherwise dodge is the hand limit.
|
||||
*
|
||||
* Returns the sentence rather than a code because it is written for a player, and the two cases
|
||||
* fail for genuinely different reasons — "not in this game" and "not ever".
|
||||
*/
|
||||
export function keepReason(s: GameState, cardId: CardId): string | null {
|
||||
const kind = s.cards.get(cardId)?.kind.kind;
|
||||
if (kind === 'extraTrain') {
|
||||
return 'An Extra is never discarded. It runs once and ends in the Salvage Yard, so it can only ' +
|
||||
'be played — hold it for as many Stages and Days as you like.';
|
||||
}
|
||||
if (kind === 'timetabledTrain' && !houseRules(s.config).discardTimetabled) {
|
||||
return 'A train card is never discarded in this game. The only way it leaves your hand is onto ' +
|
||||
'the timetable — hold it for as many Stages and Days as you like.';
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* WHERE AN EXTRA STARTS AND WHICH WAY IT RUNS — the one answer `check`, `execute` and the reducer
|
||||
* all use, so a placement can never be checked against one square and made on another.
|
||||
*
|
||||
* §7 lets the player who played the card choose the start, and Jesse's ruling makes the start
|
||||
* decide the direction rather than the number (`runDirection`'s comment carries the supersession):
|
||||
*
|
||||
* - a DIVISION POINT runs the train away from itself — the west end runs east, the east end west.
|
||||
* `direction` on the intent is ignored rather than refused, because there is only one answer;
|
||||
* - an INTERCHANGE or a CONTROL POINT sits in the middle of the railroad, where both ways are real
|
||||
* runs, so the intent must say which.
|
||||
*
|
||||
* Which of those are on offer is the `extraStart` house rule. The two that belong to nobody — the
|
||||
* Division Points and the Interchange — are always available; an Office is a seat's own ground and
|
||||
* is gated, to `ownOffice` (the player who played the card) or `anyOffice`.
|
||||
*
|
||||
* Returns a refusal code rather than throwing, so `check` can hand it straight back.
|
||||
*/
|
||||
export function resolveExtraStart(
|
||||
s: GameState,
|
||||
player: PlayerIndex,
|
||||
i: { trainNumber: number; atSeat?: SeatIndex | null; start?: ExtraStart; direction?: Direction },
|
||||
): { at: ExtraStart; direction: Direction } | RejectionCode {
|
||||
/**
|
||||
* A save written before the choice existed. `atSeat` null meant the Division Point the NUMBER
|
||||
* sent the train to, a seat meant that Office, and both ran in the number's direction — so that
|
||||
* is what these replay as, whatever the rules say today.
|
||||
*/
|
||||
if (!i.start) {
|
||||
const direction = runDirection(i.trainNumber);
|
||||
if (i.atSeat === null || i.atSeat === undefined) {
|
||||
return { at: { kind: 'divisionPoint', side: startingDivisionPoint(i.trainNumber) }, direction };
|
||||
}
|
||||
return { at: { kind: 'office', seat: i.atSeat }, direction };
|
||||
}
|
||||
|
||||
const start = i.start;
|
||||
if (start.kind === 'divisionPoint') {
|
||||
if (!s.division.nodes.some((n) => n.kind === 'divisionPoint' && n.side === start.side)) {
|
||||
return 'NO_SUCH_DIVISION_POINT';
|
||||
}
|
||||
// Away from the end it is standing at. Nothing else is a run.
|
||||
return { at: start, direction: start.side === 'west' ? 'east' : 'west' };
|
||||
}
|
||||
|
||||
if (i.direction === undefined) return 'NO_DIRECTION_CHOSEN';
|
||||
|
||||
if (start.kind === 'mainline') {
|
||||
const node = s.division.nodes[start.node];
|
||||
if (!node || node.kind !== 'mainline') return 'NO_SUCH_CARD';
|
||||
// The Interchange is the one Mainline card an Extra may be made up on — it is the one with a
|
||||
// yard. `sortsCars` is what the card prints and the only thing that distinguishes it.
|
||||
if (!mainlineProfile(node.card).sortsCars) return 'NOT_AN_INTERCHANGE';
|
||||
return { at: start, direction: i.direction };
|
||||
}
|
||||
|
||||
const rule = houseRules(s.config).extraStart;
|
||||
if (rule === 'divisionPointsOnly') return 'OFFICE_STARTS_NOT_ALLOWED';
|
||||
if (rule === 'ownOffice' && start.seat !== seatOf(s, player)) return 'NOT_YOUR_OFFICE';
|
||||
const area = s.officeAreas.get(start.seat);
|
||||
if (!area) return 'NO_SUCH_FACILITY';
|
||||
// A Control Point is any Office above a Whistle Post (§8). A Whistle Post is not one, which is
|
||||
// the whole reason upgrading buys a place for an Extra to start — and no setting of the house
|
||||
// rule lets one in.
|
||||
if (!officeProfile(area.tier).isControlPoint) return 'NOT_A_CONTROL_POINT';
|
||||
return { at: start, direction: i.direction };
|
||||
}
|
||||
|
||||
/**
|
||||
* WHICH TRAIN, AND WHICH COACH ON IT — the one answer `check`, `execute` and the reducer all use.
|
||||
*
|
||||
@@ -609,21 +486,6 @@ function freightWorkedKey(trayId: TrayId, at: GridCoord): string {
|
||||
|
||||
const isFreight = (c: RollingStock): boolean => c.type !== 'coach' && c.type !== 'caboose';
|
||||
|
||||
/**
|
||||
* IS THIS CAR CARRYING A LOAD? A CABOOSE NEVER IS, whatever its `loaded` flag says.
|
||||
*
|
||||
* `ROLLING_STOCK_SUPPLY` mints all six cabooses as `{ loaded: 6, empty: 0 }` because §2.2's
|
||||
* "a coloured car is loaded, a white car is empty" is doing double duty there as a PIECE COUNT,
|
||||
* and a caboose has no white version — there is no such thing as an empty one to make up a train
|
||||
* from. Every other reading of `.loaded` in this file is already scoped to a coach or to a named
|
||||
* car type, so the flag's second meaning only ever escaped here.
|
||||
*
|
||||
* Reported as Gitea#8: X22 Pee-Dee, whose whole card is "may only pick up MTs", could not couple a
|
||||
* caboose at all — including the one it was made up with. Drop it and it was stranded, which made
|
||||
* the train unplayable rather than merely restricted.
|
||||
*/
|
||||
const carriesLoad = (c: RollingStock): boolean => c.loaded && c.type !== 'caboose';
|
||||
|
||||
/**
|
||||
* May this train work these freight cars on this square?
|
||||
*
|
||||
@@ -723,7 +585,7 @@ function refusesThisOffice(s: GameState, player: PlayerIndex, tray: CrewTray): b
|
||||
* this works out whether a card is the reason. Without it a Military train standing at the platform
|
||||
* reported "no train at the Office", which is both wrong and unhelpful.
|
||||
*/
|
||||
export function passengerRefusal(
|
||||
function passengerRefusal(
|
||||
s: GameState,
|
||||
player: PlayerIndex,
|
||||
at: GridCoord,
|
||||
@@ -777,64 +639,16 @@ export function passengerRefusal(
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCode | null {
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — asked ABOVE the status guard, because the whole point of the
|
||||
* vote is that it is the one thing the rules will take from a game that has stopped.
|
||||
*
|
||||
* Out of turn like `mainline.clearance` below, and unlike it open to every seat at once: it is a
|
||||
* table decision rather than a ruling, so there is no actor to be.
|
||||
*/
|
||||
if (i.type === 'game.extend') {
|
||||
if (s.status !== 'awaitingExtension') return 'NOT_AWAITING_EXTENSION';
|
||||
// The intent NAMES its voter so that a save can be replayed (`intents.ts`), which makes it a
|
||||
// claim until it is checked against the seat the caller authenticated. One seat may not vote
|
||||
// for another.
|
||||
if (i.player !== player) return 'NOT_YOUR_TURN';
|
||||
if (s.extensionVotes[player] !== null) return 'ALREADY_VOTED';
|
||||
return null;
|
||||
}
|
||||
|
||||
if (s.status !== 'active') return 'WRONG_PHASE';
|
||||
|
||||
// The clearance ruling is the one intent that arrives out of turn order: it interrupts the
|
||||
// automatic Mainline Phase and goes to the Superintendent (§8.1, fourth condition).
|
||||
if (i.type === 'mainline.clearance') {
|
||||
if (s.clock.pendingDecision?.kind !== 'clearance') return 'NO_PENDING_DECISION';
|
||||
if (s.clock.pendingDecision === null) return 'NO_PENDING_DECISION';
|
||||
if (s.clock.superintendent !== player) return 'NOT_SUPERINTENDENT';
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* §Q (Gitea#19) — the Red Flag prompt, the third interruption of the Mainline Phase.
|
||||
*
|
||||
* Only ever raised for a player who holds the card, so `flag: true` can always be paid for; the
|
||||
* card is checked again here because `check` is the authority and a hand can change between the
|
||||
* prompt being raised and answered.
|
||||
*/
|
||||
if (i.type === 'mainline.redFlag') {
|
||||
if (s.clock.pendingDecision?.kind !== 'redFlag') return 'NO_RED_FLAG_PROMPT';
|
||||
if (decisionActor(s) !== player) return 'NOT_YOUR_TURN';
|
||||
if (!i.flag) return null;
|
||||
const held = (s.decks.hands.get(player) ?? []).find((id) => {
|
||||
const c = s.cards.get(id);
|
||||
return c?.kind.kind === 'maneuver' && c.kind.key === 'redFlags';
|
||||
});
|
||||
if (!held) return 'NO_SUCH_CARD';
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* §11 (Gitea#5) — the Yard Office offer, the second interruption of the Mainline Phase.
|
||||
*
|
||||
* Goes to the district's owner rather than the Superintendent, which is the whole reason
|
||||
* `pendingDecision` became a union. `decisionActor` is the single place that mapping lives.
|
||||
*/
|
||||
if (i.type === 'mainline.yardOffice') {
|
||||
if (s.clock.pendingDecision?.kind !== 'yardOffice') return 'NO_YARD_OFFICE_OFFER';
|
||||
if (decisionActor(s) !== player) return 'NOT_YOUR_TURN';
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!isActor(s, player)) return 'NOT_YOUR_TURN';
|
||||
|
||||
switch (i.type) {
|
||||
@@ -886,7 +700,7 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
|
||||
*/
|
||||
if (rules.noSwitching) return 'PICKUP_NOT_ALLOWED';
|
||||
if (rules.dropOnly) return 'PICKUP_NOT_ALLOWED';
|
||||
if (rules.pickUpEmptiesOnly && fresh.some(carriesLoad)) return 'EMPTIES_ONLY';
|
||||
if (rules.pickUpEmptiesOnly && fresh.some((c) => c.loaded)) return 'EMPTIES_ONLY';
|
||||
const freight = fresh.filter(isFreight).length;
|
||||
if (freight > 0 && !freightBudgetLeft(s, player, tray, i.to, freight)) return 'FREIGHT_WORKED_HERE';
|
||||
}
|
||||
@@ -921,24 +735,25 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
|
||||
? tray.consist.slice(0, i.count)
|
||||
: tray.consist.slice(tray.consist.length - i.count);
|
||||
const dropRules = rulesOf(tray);
|
||||
const dropArea = areaOf(s, player);
|
||||
const atOffice = here.row === dropArea.officeCoord.row && here.col === dropArea.officeCoord.col;
|
||||
/**
|
||||
* Trains 7/8 Local — "coach must remain on station track if switching" — the coach may never
|
||||
* be set out anywhere ELSE while switching. §A.4 now carries an exception for the Office
|
||||
* square (v0.5.0, Jesse's call): any train may cut a coach loose there, which is exactly what
|
||||
* "station track" meant on the card all along. So the coach is refused everywhere except the
|
||||
* Office, rather than everywhere.
|
||||
* Trains 7/8 Local — "coach must remain on station track if switching", i.e. the coach is
|
||||
* never set out during switching at all.
|
||||
*
|
||||
* The intended reading was "set out only at the Office", but §A.4 makes that unimplementable:
|
||||
* `canDropCarsAt` refuses the Office square outright — "the Office track is Operational Rail,
|
||||
* but Rolling Stock may not be left there" — so "only at the Office" and "nowhere" are the same
|
||||
* rule. What is left is the effect that matters: the Local may shunt its freight car around the
|
||||
* district, and may not abandon its coach at an industry or on a siding while it does.
|
||||
* Flagged in `TODO.md` in case the station track is meant to become a real place to leave one.
|
||||
*/
|
||||
if (dropRules.coachStaysOnStationTrack && cut.some((c) => c.type === 'coach') && !atOffice) {
|
||||
if (dropRules.coachStaysOnStationTrack && cut.some((c) => c.type === 'coach')) {
|
||||
return 'COACH_MUST_STAY';
|
||||
}
|
||||
const droppedFreight = cut.filter(isFreight).length;
|
||||
if (droppedFreight > 0 && !freightBudgetLeft(s, player, tray, here, droppedFreight)) {
|
||||
return 'FREIGHT_WORKED_HERE';
|
||||
}
|
||||
const coachesOnly = cut.every((c) => c.type === 'coach');
|
||||
return canDropCarsAt(dropArea, here, i.count, coachesOnly) ? null : 'CANNOT_DROP_HERE';
|
||||
return canDropCarsAt(areaOf(s, player), here, i.count) ? null : 'CANNOT_DROP_HERE';
|
||||
}
|
||||
|
||||
case 'switch.sortConsist': {
|
||||
@@ -989,30 +804,11 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
|
||||
return checkPlay(s, player, i.cardId, i.placement, i.variant, i.node);
|
||||
}
|
||||
|
||||
/**
|
||||
* §6.2 — WHICH TRAIN CARDS MAY BE THROWN AWAY (Gitea#9, superseding Gitea#6).
|
||||
*
|
||||
* `keepReason` holds the rule; this asks it. A Timetabled train is discardable unless the
|
||||
* `discardTimetabled` house rule is off, and an Extra never is.
|
||||
*
|
||||
* WHERE THE DISCARD GOES IS THE OTHER HALF OF THE RULING. "If someone else wants to pick it up,
|
||||
* they are more than able to" — a discard goes face-up on a Department pile, which is exactly
|
||||
* where a rival can draw it from, so the second half needed no machinery at all.
|
||||
*
|
||||
* The corner Gitea#6 created still exists when the setting is off, and is still deliberate: a
|
||||
* player holding four undiscardable trains has one way forward, which is to PLAY one. `draw.end`
|
||||
* refuses while the hand is over the limit, and playing a train card is unconditionally legal
|
||||
* (`card.play`'s `timetabledTrain` case refuses only a board placement), so it can never lock.
|
||||
*
|
||||
* `legal.ts` enumerates candidates and filters them through here, so an undiscardable card
|
||||
* simply stops being offered; the bot needs no separate rule.
|
||||
*/
|
||||
case 'card.discard': {
|
||||
if (!inPhase(s, 'localOps')) return 'WRONG_PHASE';
|
||||
const hand = s.decks.hands.get(player) ?? [];
|
||||
if (!hand.includes(i.cardId)) return 'CARD_NOT_IN_HAND';
|
||||
if (i.toSlot < 0 || i.toSlot > 2) return 'SLOT_EMPTY';
|
||||
if (keepReason(s, i.cardId) !== null) return 'TRAINS_ARE_NEVER_DISCARDED';
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -1028,12 +824,11 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
|
||||
if (!node || node.kind !== 'mainline') return 'NO_PLACEMENT';
|
||||
const on = node.modifiers ?? [];
|
||||
if (on.includes(rule.key)) return 'OPTION_ALREADY_CHOSEN';
|
||||
if (rule.gradeOnly && node.card !== 'heavyGrade') return 'NOT_A_GRADE';
|
||||
if (rule.gradeOnly && mainlineProfile(node.card).speed.kind !== 'grade') return 'NOT_A_GRADE';
|
||||
if (rule.requiresOnCard && !on.includes(rule.requiresOnCard)) return 'NOT_CONNECTED';
|
||||
// "Not while a train is on it" — realigning under a moving train is exactly the situation the
|
||||
// restriction exists to prevent. A train standing in the Interchange's yard counts: it is on
|
||||
// the card, and it is about to pull out onto the very rail being relaid.
|
||||
if (node.transits.length > 0 || (node.holding?.length ?? 0) > 0) return 'TRAIN_ON_CARD';
|
||||
// restriction exists to prevent.
|
||||
if (node.transits.length > 0) return 'TRAIN_ON_CARD';
|
||||
if (rule.key === 'realignment' && !REALIGNMENTS.some((r) => r.from === node.card)) {
|
||||
return 'NO_PLACEMENT';
|
||||
}
|
||||
@@ -1044,9 +839,14 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
|
||||
const card = s.cards.get(i.cardId);
|
||||
if (!card || !(s.decks.hands.get(player) ?? []).includes(i.cardId)) return 'NO_SUCH_CARD';
|
||||
if (card.kind.kind !== 'maneuver' || card.kind.key !== 'redFlags') return 'WRONG_INTENT';
|
||||
// §Q (Gitea#19) — a flag goes on your OWN Limits. There is no target train to name and no
|
||||
// placement to find: the district is yours, and the only question is which side.
|
||||
if (officeNodeFor(s, seatOf(s, player))?.redFlag === i.side) return 'ALREADY_FLAGGED';
|
||||
const tray = s.trays.get(i.trayId);
|
||||
if (!tray) return 'NO_SUCH_TRAY';
|
||||
// "A STOPPED train is prevented from being hit" — it protects a train that is standing on a
|
||||
// Mainline card, which is the only place a rear-ender can happen.
|
||||
if (tray.position.at !== 'mainline') return 'NO_PLACEMENT';
|
||||
const node = s.division.nodes[tray.position.index];
|
||||
if (!node || node.kind !== 'mainline') return 'NO_PLACEMENT';
|
||||
if ((node.redFlagged ?? []).includes(i.trayId)) return 'OPTION_ALREADY_CHOSEN';
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -1153,22 +953,14 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
|
||||
// -- New Train ------------------------------------------------------------
|
||||
case 'newTrain.startExtra': {
|
||||
if (!inPhase(s, 'newTrain')) return 'WRONG_PHASE';
|
||||
const pending = s.pendingExtras.find((x) => x.trainNumber === i.trainNumber);
|
||||
if (!pending) return 'NO_EXTRA_PENDING';
|
||||
// §7 — "the player who played the card MAY place the Crew Tray": it is theirs to place, and
|
||||
// nobody else's to place for them.
|
||||
if (pending.player !== player) return 'NOT_YOUR_EXTRA';
|
||||
if (!s.pendingExtras.includes(i.trainNumber)) return 'NO_EXTRA_PENDING';
|
||||
if (s.freeTrays.length === 0) return 'NO_FREE_TRAY';
|
||||
const where = resolveExtraStart(s, player, i);
|
||||
if (typeof where === 'string') return where;
|
||||
if (where.at.kind === 'divisionPoint') return null;
|
||||
if (where.at.kind === 'mainline') {
|
||||
// Nothing to refuse. The train is made up in the Interchange's yard, off the running line,
|
||||
// so however busy the card is this cannot be the collision §7 says it must not force. What
|
||||
// it may not do is get OUT — that is §8.1's question, asked at the Mainline Phase.
|
||||
return null;
|
||||
}
|
||||
const area = s.officeAreas.get(where.at.seat)!;
|
||||
if (i.atSeat === null) return null;
|
||||
// A Control Point is any Office above a Whistle Post (§8). A Whistle Post is not one, which is
|
||||
// the whole reason upgrading buys a place for an Extra to start.
|
||||
const area = s.officeAreas.get(i.atSeat);
|
||||
if (!area) return 'NO_SUCH_FACILITY';
|
||||
if (!officeProfile(area.tier).isControlPoint) return 'NOT_A_CONTROL_POINT';
|
||||
// It still has to fit: an Extra starting here takes an A/D track like any other arrival.
|
||||
return area.adOccupancy.length >= officeProfile(area.tier).adTracks ? 'NO_FREE_AD_TRACK' : null;
|
||||
}
|
||||
@@ -1192,7 +984,7 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
|
||||
// This was not enforced at all: any car could be added in any quantity, so Train 9 "Heavy
|
||||
// Freight" — a card calling for 3 freight AND a caboose — was made up with four hoppers and
|
||||
// no caboose. Fewer is allowed; more, or of the wrong category, is not.
|
||||
return acceptsCar(tray, i.carType, i.loaded, s.yards.divisionYard) ? null : 'NO_SUITABLE_CAR';
|
||||
return acceptsCar(tray, i.carType) ? null : 'NO_SUITABLE_CAR';
|
||||
}
|
||||
|
||||
case 'newTrain.secondSection': {
|
||||
@@ -1531,7 +1323,7 @@ export function ownCutFor(s: GameState, player: PlayerIndex, trayId: TrayId, rev
|
||||
const facing = facingPort(s, trayId);
|
||||
const exit: Port = reverse ? reversePort(s, player, here, facing) : facing;
|
||||
const card = areaOf(s, player).grid.get(coordKey(here)) ?? emptyCard();
|
||||
return cutTowards(card, carsOn(card), rowEndAt(card, exit));
|
||||
return cutTowards(card, carsOn(card), exit);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -1583,33 +1375,6 @@ export function movesFor(
|
||||
|
||||
function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
|
||||
switch (i.type) {
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — the vote, and what it settles.
|
||||
*
|
||||
* Decided HERE rather than in `reduce` because the answer depends on the votes as they stand
|
||||
* BEFORE this one lands, and `execute` is the half that still sees that. Three outcomes:
|
||||
*
|
||||
* - a refusal ends it immediately. Unanimity means one "no" is decisive, so nobody is made to
|
||||
* wait on a player who has already said no (Jesse's call, 2026-08-28);
|
||||
* - the last outstanding "yes" grants the Day — ONE Day, and the question is put again at the
|
||||
* end of it;
|
||||
* - anything else is just a vote recorded, and the table waits.
|
||||
*/
|
||||
case 'game.extend': {
|
||||
const vote: GameEvent = { type: 'extensionVoted', player, agree: i.agree };
|
||||
if (!i.agree) return [vote, { type: 'playConcluded', declinedBy: player }];
|
||||
const after = s.extensionVotes.map((v, p) => (p === player ? true : v));
|
||||
return after.every((v) => v === true)
|
||||
? [vote, { type: 'dayExtended', day: s.config.days + s.extraDays + 1 }]
|
||||
: [vote];
|
||||
}
|
||||
|
||||
case 'mainline.yardOffice': {
|
||||
const pending = s.clock.pendingDecision;
|
||||
const trainId = pending?.kind === 'yardOffice' ? pending.train : '';
|
||||
return [{ type: 'yardOfficeRuled', player, trainId, take: i.take }];
|
||||
}
|
||||
|
||||
case 'localOps.choose':
|
||||
return [{ type: 'localOpsOptionChosen', player, option: i.option }];
|
||||
|
||||
@@ -1676,16 +1441,14 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
|
||||
*/
|
||||
const grid = areaOf(s, player).grid;
|
||||
const startCard = grid.get(coordKey(from)) ?? emptyCard();
|
||||
const startCut = cutTowards(startCard, carsOn(startCard), rowEndAt(startCard, exitPort));
|
||||
const startCut = cutTowards(startCard, carsOn(startCard), exitPort);
|
||||
const lifted = [
|
||||
...(startCut.length > 0 ? [from] : []),
|
||||
...dest.path.map((step) => step.coord),
|
||||
i.to,
|
||||
].filter((c) => carsOn(grid.get(coordKey(c)) ?? emptyCard()).length > 0);
|
||||
const sides = standingSides(startCard, carsOn(startCard));
|
||||
// The OTHER end's cut, which stays behind — so it is the other end of the row, not the
|
||||
// other port. A 45° leg is an end of the row too (`rowEndAt`, Gitea#17).
|
||||
const stayed = rowEndAt(startCard, exitPort) === 'e' ? sides.west : sides.east;
|
||||
const stayed = exitPort === 'e' ? sides.west : exitPort === 'w' ? sides.east : [];
|
||||
// §A.3 — "engines also have couplers on the front end, so a train can pick cars up onto
|
||||
// its nose". Running forward the engine meets cars head-on and takes them in front; backing
|
||||
// up, they couple behind. Which end they land on is the whole point of a run-around: it
|
||||
@@ -1843,25 +1606,10 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
|
||||
];
|
||||
}
|
||||
|
||||
case 'maneuver.redFlags':
|
||||
return [{ type: 'redFlagsSet', player, cardId: i.cardId, seat: seatOf(s, player), side: i.side }];
|
||||
|
||||
case 'mainline.redFlag': {
|
||||
const pending = s.clock.pendingDecision;
|
||||
const trainId = pending?.kind === 'redFlag' ? pending.train : '';
|
||||
const seat = pending?.kind === 'redFlag' ? pending.seat : 0;
|
||||
const side = pending?.kind === 'redFlag' ? pending.from : 'east';
|
||||
if (!i.flag) return [{ type: 'redFlagRuled', player, trainId, flag: false }];
|
||||
const cardId =
|
||||
i.cardId ??
|
||||
(s.decks.hands.get(player) ?? []).find((id) => {
|
||||
const c = s.cards.get(id);
|
||||
return c?.kind.kind === 'maneuver' && c.kind.key === 'redFlags';
|
||||
})!;
|
||||
return [
|
||||
{ type: 'redFlagsSet', player, cardId, seat, side },
|
||||
{ type: 'redFlagRuled', player, trainId, flag: true },
|
||||
];
|
||||
case 'maneuver.redFlags': {
|
||||
const tray = s.trays.get(i.trayId)!;
|
||||
const index = tray.position.at === 'mainline' ? tray.position.index : -1;
|
||||
return [{ type: 'redFlagsSet', player, cardId: i.cardId, trayId: i.trayId, node: index }];
|
||||
}
|
||||
|
||||
case 'maneuver.flyingSwitch': {
|
||||
@@ -1890,13 +1638,8 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
|
||||
return [{ type: 'facilityUnjammed', player, at: i.at, from: i.from, stock }];
|
||||
}
|
||||
|
||||
case 'newTrain.startExtra': {
|
||||
// `check` has already accepted this, so the resolve cannot fail here.
|
||||
const where = resolveExtraStart(s, player, i) as { at: ExtraStart; direction: Direction };
|
||||
return [
|
||||
{ type: 'extraStarted', player, trainNumber: i.trainNumber, at: where.at, direction: where.direction },
|
||||
];
|
||||
}
|
||||
case 'newTrain.startExtra':
|
||||
return [{ type: 'extraStarted', player, trainNumber: i.trainNumber, atSeat: i.atSeat }];
|
||||
|
||||
case 'newTrain.placeCar':
|
||||
return [
|
||||
@@ -2035,37 +1778,6 @@ function findTimetableSlot(s: GameState, from: number): number | null {
|
||||
|
||||
export function reduce(s: GameState, e: GameEvent): void {
|
||||
switch (e.type) {
|
||||
// -- §3.3, extended play (Gitea#11)
|
||||
case 'extensionVoted':
|
||||
s.extensionVotes[e.player] = e.agree;
|
||||
break;
|
||||
|
||||
/**
|
||||
* One more Day, and the votes are wiped: agreeing once does not agree to the rest of the game.
|
||||
*
|
||||
* `config.days` is deliberately untouched. It is what the OFFICIAL result was decided at
|
||||
* (`state.ts`'s `FinalReport`), so leaving it alone is what makes "the winner is decided at the
|
||||
* original game length" a fact about the code rather than a comment on it. `outcome` is left
|
||||
* alone too — it is the last evaluation, and it is what the results screen shows while the extra
|
||||
* Day is played.
|
||||
*/
|
||||
case 'dayExtended':
|
||||
s.extraDays += 1;
|
||||
s.extensionVotes = s.players.map(() => null);
|
||||
s.status = 'active';
|
||||
break;
|
||||
|
||||
case 'playConcluded':
|
||||
s.status = 'finished';
|
||||
break;
|
||||
|
||||
// §11 (Gitea#5) — the same shape as `clearanceGiven`: clear the question, record the answer for
|
||||
// the arriving train to consume, or the driver asks again for ever.
|
||||
case 'yardOfficeRuled':
|
||||
s.clock.pendingDecision = null;
|
||||
s.clock.decisionAnswer = { kind: 'yardOffice', train: e.trainId, take: e.take };
|
||||
break;
|
||||
|
||||
case 'localOpsOptionChosen':
|
||||
turnOf(s, e.player).option = e.option;
|
||||
break;
|
||||
@@ -2290,23 +2002,14 @@ export function reduce(s: GameState, e: GameEvent): void {
|
||||
}
|
||||
|
||||
case 'redFlagsSet': {
|
||||
const node = officeNodeFor(s, e.seat);
|
||||
if (node) node.redFlag = e.side;
|
||||
const node = s.division.nodes[e.node];
|
||||
if (node?.kind === 'mainline') {
|
||||
node.redFlagged = [...(node.redFlagged ?? []), e.trayId];
|
||||
}
|
||||
spendCard(s, e.player, e.cardId);
|
||||
break;
|
||||
}
|
||||
|
||||
/**
|
||||
* §Q (Gitea#19) — `redFlagSpent` is NOT reduced, deliberately. It is emitted only by the phase
|
||||
* driver, which mutates state itself and then describes it (`advance.ts`'s `spendFlag`), so a
|
||||
* case here would be dead code that reads as the live one.
|
||||
*/
|
||||
|
||||
case 'redFlagRuled':
|
||||
s.clock.pendingDecision = null;
|
||||
s.clock.decisionAnswer = { kind: 'redFlag', train: e.trainId, flag: e.flag };
|
||||
break;
|
||||
|
||||
case 'flyingSwitch': {
|
||||
const tray = s.trays.get(e.trayId);
|
||||
const area = areaOf(s, e.player);
|
||||
@@ -2445,8 +2148,7 @@ export function reduce(s: GameState, e: GameEvent): void {
|
||||
}
|
||||
|
||||
case 'extraQueued':
|
||||
// §7 hands this train to the player who played the card, so the queue records them.
|
||||
s.pendingExtras.push({ trainNumber: e.trainNumber, player: e.player });
|
||||
s.pendingExtras.push(e.trainNumber);
|
||||
break;
|
||||
|
||||
case 'secondSectionOrdered':
|
||||
@@ -2470,60 +2172,29 @@ export function reduce(s: GameState, e: GameEvent): void {
|
||||
break;
|
||||
}
|
||||
|
||||
/**
|
||||
* THE THREE PLACES AN EXTRA MAY BE MADE UP (§7, Jesse's ruling) — and all three leave it
|
||||
* STANDING somewhere it must later highball out of, never already running.
|
||||
*/
|
||||
case 'extraStarted': {
|
||||
const trayId = s.freeTrays.pop()!;
|
||||
s.pendingExtras = s.pendingExtras.filter((x) => x.trainNumber !== e.trainNumber);
|
||||
const { direction } = e;
|
||||
const base = {
|
||||
id: trayId, trainNumber: e.trainNumber, trainIsExtra: true, engineAt: 0,
|
||||
consist: [] as RollingStock[], direction, movesUsed: 0,
|
||||
// The queue is emptied here, before a single car goes on, so the tray carries the owner
|
||||
// from now on — §7 lets the player who played it load the consist as they choose.
|
||||
builtBy: e.player,
|
||||
};
|
||||
// Which way the tray physically points, for the cards it will pick up. A Division Point start
|
||||
// does not set it: those trays have never carried a facing and `enterMainline` does not read
|
||||
// one, so writing it here would be inventing state the DP path has always done without.
|
||||
const facing = { facing: direction === 'west' ? ('w' as const) : ('e' as const),
|
||||
railFacing: direction === 'west' ? ('w' as const) : ('e' as const) };
|
||||
|
||||
if (e.at.kind === 'divisionPoint') {
|
||||
const side = e.at.side;
|
||||
s.trays.set(trayId, { ...base, position: { at: 'divisionPoint', side } });
|
||||
s.pendingExtras = s.pendingExtras.filter((n) => n !== e.trainNumber);
|
||||
const direction = runDirection(e.trainNumber);
|
||||
if (e.atSeat === null) {
|
||||
const side = startingDivisionPoint(e.trainNumber);
|
||||
s.trays.set(trayId, {
|
||||
id: trayId, trainNumber: e.trainNumber, trainIsExtra: true, engineAt: 0, consist: [],
|
||||
direction, position: { at: 'divisionPoint', side }, movesUsed: 0,
|
||||
});
|
||||
const dp = s.division.nodes.find((n) => n.kind === 'divisionPoint' && n.side === side);
|
||||
if (dp?.kind === 'divisionPoint') dp.holding.push(trayId);
|
||||
break;
|
||||
}
|
||||
|
||||
if (e.at.kind === 'mainline') {
|
||||
/**
|
||||
* IN THE INTERCHANGE'S YARD, NOT ON THE MAINLINE — the distinction §7 turns on.
|
||||
*
|
||||
* `holding` rather than `transits`, so the card can be nose to tail with traffic and this
|
||||
* placement still forces no collision. It joins the running line at a later Mainline Phase
|
||||
* through `evaluateClearance`, which is what gives the Superintendent the hold Jesse asked
|
||||
* for: an automatic one against a facing train, a ruling against a following one.
|
||||
*/
|
||||
const node = s.division.nodes[e.at.node];
|
||||
} else {
|
||||
// Starting at a Control Point: it stands on the Office card and takes an A/D track, exactly
|
||||
// as though it had arrived there.
|
||||
const area = areaAtSeat(s, e.atSeat);
|
||||
s.trays.set(trayId, {
|
||||
...base, ...facing, beingMadeUp: true, position: { at: 'mainline', index: e.at.node },
|
||||
id: trayId, trainNumber: e.trainNumber, trainIsExtra: true, engineAt: 0, consist: [],
|
||||
direction, facing: direction === 'west' ? 'w' : 'e', railFacing: direction === 'west' ? 'w' : 'e',
|
||||
position: { at: 'grid', seat: e.atSeat, coord: area.officeCoord }, movesUsed: 0,
|
||||
});
|
||||
if (node?.kind === 'mainline') (node.holding ??= []).push(trayId);
|
||||
break;
|
||||
area.adOccupancy.push(trayId);
|
||||
}
|
||||
|
||||
// Starting at a Control Point: it stands on the Office card and takes an A/D track, exactly
|
||||
// as though it had arrived there.
|
||||
const area = areaAtSeat(s, e.at.seat);
|
||||
s.trays.set(trayId, {
|
||||
...base, ...facing, beingMadeUp: true,
|
||||
position: { at: 'grid', seat: e.at.seat, coord: area.officeCoord },
|
||||
});
|
||||
area.adOccupancy.push(trayId);
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -2663,7 +2334,7 @@ export function reduce(s: GameState, e: GameEvent): void {
|
||||
case 'clearanceGiven':
|
||||
s.clock.pendingDecision = null;
|
||||
// Recorded for the asking train to consume; otherwise the driver asks again forever.
|
||||
s.clock.decisionAnswer = { kind: 'clearance', train: e.trainId, allow: e.allow };
|
||||
s.clock.clearanceRuling = { train: e.trainId, allow: e.allow };
|
||||
break;
|
||||
|
||||
default:
|
||||
@@ -3066,20 +2737,7 @@ function extendLimitsIfNeeded(area: OfficeArea, placed: GridCoord): void {
|
||||
* this. A second copy stalled the game outright: the phase believed a car could be added while
|
||||
* `check` rejected every option, so the Stage never completed.
|
||||
*/
|
||||
export function acceptsCar(
|
||||
tray: CrewTray,
|
||||
carType: CarType,
|
||||
/**
|
||||
* Whether the car being offered is loaded, and what the Division Yard still holds.
|
||||
*
|
||||
* Both optional so that a caller asking the SHAPE question — "does this card take a car of this
|
||||
* category at all?" — need not answer the loading question. `trainNeedingCars` asks the shape
|
||||
* question of every car in the yard; `check` asks the full one about a specific car a player has
|
||||
* named. Omitting them skips the loading rules rather than guessing at them.
|
||||
*/
|
||||
loaded?: boolean,
|
||||
yard?: readonly RollingStock[],
|
||||
): boolean {
|
||||
export function acceptsCar(tray: CrewTray, carType: CarType): boolean {
|
||||
const profile = trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra);
|
||||
if (!profile) return true;
|
||||
|
||||
@@ -3102,56 +2760,15 @@ export function acceptsCar(
|
||||
const types = profile.consist.freightTypes;
|
||||
if (adding === 'freight' && types && !types.includes(carType)) return false;
|
||||
|
||||
if (loaded === undefined) return true;
|
||||
|
||||
/**
|
||||
* X13 APPLESEED — "may drop MTs but not pick up anything", and its consist prints EMPTIES ONLY.
|
||||
*
|
||||
* `emptiesOnly` was declared on the card, RENDERED to the player as "(empties only)" by both
|
||||
* `web/game.ts` and `sim/view.ts`, and enforced by nothing: the Appleseed could be made up with
|
||||
* loaded cars while its own card said it could not. Found while building Gitea#13, which is the
|
||||
* same rule pointing the other way, and fixed with it rather than left as the odd one out.
|
||||
*
|
||||
* A caboose is exempt. Every caboose in `ROLLING_STOCK_SUPPLY` is `loaded: true` — there is no
|
||||
* such thing as an empty one — so applying this to the caboose would bar the Appleseed from the
|
||||
* caboose its own consist calls for.
|
||||
*/
|
||||
if (profile.consist.emptiesOnly && loaded && adding !== 'caboose') return false;
|
||||
|
||||
/**
|
||||
* MUST RUN LOADED (Gitea#13) — a preference order, not a flat requirement.
|
||||
*
|
||||
* "If not loaded, then empty, and if none available, run without." So an EMPTY is refused only
|
||||
* while the yard can still supply a loaded car this train would accept; once it cannot, the empty
|
||||
* becomes legal and the train may also simply depart short. Asked of the yard rather than
|
||||
* remembered on the tray, because the yard is what the rule is about and it changes under the
|
||||
* train as other consists are built.
|
||||
*
|
||||
* The caboose is exempt for the same reason as above.
|
||||
*/
|
||||
if (profile.rules.mustRunLoaded && !loaded && adding !== 'caboose' && yard) {
|
||||
const loadedAvailable = yard.some(
|
||||
(c) => c.loaded && cat(c.type) === adding && acceptsCar(tray, c.type),
|
||||
);
|
||||
if (loadedAvailable) return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* §7 — IS THIS TRAY THE ONE BEING MADE UP?
|
||||
*
|
||||
* A train is made up where it is built and only until its consist matches its card. Everything else
|
||||
* with a Crew Tray — a train working your district, a train halfway across the Division — is
|
||||
* running, not being assembled.
|
||||
*
|
||||
* WHERE that is used to be the whole test: "standing at a Division Point". True while a Division
|
||||
* Point was the only place to build one, and wrong once an Extra could be started at a Control Point
|
||||
* or in an Interchange's yard (§7) — those trains were never offered a car and ran empty. The extra
|
||||
* clause is `beingMadeUp` (state.ts), a flag set on exactly those trays and cleared when they start
|
||||
* running, rather than a second positional rule: a train STANDING at an Office is usually one that
|
||||
* arrived, and must not be fillable from the yard.
|
||||
* A train is made up where it is built, standing at a Division Point, and only until its consist
|
||||
* matches its card. Everything else with a Crew Tray — a train working your district, a train
|
||||
* halfway across the Division — is running, not being assembled.
|
||||
*
|
||||
* SHARED with the New Train Phase, which uses it to decide whether to stop and ask. It has to be:
|
||||
* `check` accepted any tray with room in its consist, so during a New Train Phase the Division Yard
|
||||
@@ -3161,7 +2778,7 @@ export function acceptsCar(
|
||||
*/
|
||||
export function isBeingMadeUp(tray: CrewTray): boolean {
|
||||
if (tray.trainNumber === null) return false;
|
||||
if (tray.position.at !== 'divisionPoint' && !tray.beingMadeUp) return false;
|
||||
if (tray.position.at !== 'divisionPoint') return false;
|
||||
const profile = trainProfile(tray.trainNumber, tray.trainIsExtra);
|
||||
if (!profile) return false;
|
||||
return tray.consist.length < consistSize(profile.consist);
|
||||
@@ -3176,21 +2793,11 @@ export function isBeingMadeUp(tray: CrewTray): boolean {
|
||||
export function trainNeedingCars(s: GameState): TrayId | null {
|
||||
for (const [id, tray] of s.trays) {
|
||||
if (!isBeingMadeUp(tray)) continue;
|
||||
/**
|
||||
* Consists are specified by CATEGORY — "Freight (2)" is any two freight cars — so any car in
|
||||
* the yard is potentially suitable unless the card narrows it. Ask the SAME predicate `check`
|
||||
* uses: a separate copy of this test stalled the game, because the phase believed a car could
|
||||
* be added while `check` rejected every option, so the Stage never ended.
|
||||
*
|
||||
* ASKED PER CAR, WITH ITS LOADED STATE, since Gitea#13. The shape question alone is no longer
|
||||
* the same question `check` answers: an `emptiesOnly` train looking at a yard of nothing but
|
||||
* loaded cars, or a `mustRunLoaded` train offered only empties while loaded ones remain, would
|
||||
* both be told a car was available and then refused every one of them — the very stall this
|
||||
* comment was written about.
|
||||
*/
|
||||
if (s.yards.divisionYard.some((c) => acceptsCar(tray, c.type, c.loaded, s.yards.divisionYard))) {
|
||||
return id;
|
||||
}
|
||||
// Consists are specified by CATEGORY — "Freight (2)" is any two freight cars — so any car in
|
||||
// the yard is potentially suitable unless the card narrows it. Ask the SAME predicate `check`
|
||||
// uses: a separate copy of this test stalled the game, because the phase believed a car could
|
||||
// be added while `check` rejected every option, so the Stage never ended.
|
||||
if (s.yards.divisionYard.some((c) => acceptsCar(tray, c.type))) return id;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@@ -3242,9 +2849,6 @@ export function applyIntent(s: GameState, player: PlayerIndex, i: Intent): Apply
|
||||
|
||||
const events = execute(s, player, i);
|
||||
for (const e of events) reduce(s, e);
|
||||
// Gitea#16 — the intent half of the fold; `advance` does the phase driver's half. See `tally.ts`
|
||||
// for why it cannot simply live inside `reduce`.
|
||||
for (const e of events) tallyEvent(s, e);
|
||||
return { ok: true, events };
|
||||
}
|
||||
|
||||
|
||||
+217
-494
File diff suppressed because it is too large
Load Diff
+5
-42
@@ -19,15 +19,13 @@
|
||||
* reconstruct the whole board to draw one frame.
|
||||
*/
|
||||
|
||||
import type { CarType, Direction, OfficeTier } from './content.ts';
|
||||
import type { ExtraStart, LocalOpsOption } from './intents.ts';
|
||||
import type { CarType, OfficeTier } from './content.ts';
|
||||
import type { LocalOpsOption } from './intents.ts';
|
||||
import type { CardId, GridCoord, PlayerIndex, RollingStock, SeatIndex, TrayId } from './state.ts';
|
||||
|
||||
export type GameEvent =
|
||||
// -- clock
|
||||
| { type: 'stageBegan'; day: number; stage: number }
|
||||
/** Employee Rotation (Appendix B) — every player has moved one chair left for the new Day. */
|
||||
| { type: 'seatsRotated'; day: number; seating: PlayerIndex[] }
|
||||
| { type: 'phaseBegan'; phase: string }
|
||||
| { type: 'actorChanged'; player: PlayerIndex | null }
|
||||
// -- local operations
|
||||
@@ -87,12 +85,7 @@ export type GameEvent =
|
||||
/** `variant` is the chosen orientation (Gap 11); it must be replayable, so it rides the event. */
|
||||
| { type: 'cardPlayed'; player: PlayerIndex; cardId: CardId; placement?: GridCoord; variant?: number }
|
||||
| { type: 'mainlineModified'; player: PlayerIndex; cardId: CardId; node: number; key: string; became?: string }
|
||||
/** §Q (Gitea#19) — a flag planted on one side of a district's Limits. */
|
||||
| { type: 'redFlagsSet'; player: PlayerIndex; cardId: CardId; seat: SeatIndex; side: Direction }
|
||||
/** §Q (Gitea#19) — the flag stopped a train and came down with it. One card, one train. */
|
||||
| { type: 'redFlagSpent'; seat: SeatIndex; side: Direction; trainNumber: number }
|
||||
/** §Q (Gitea#19) — the district's owner answered the out-of-phase "flag against this train?". */
|
||||
| { type: 'redFlagRuled'; player: PlayerIndex; trainId: TrayId; flag: boolean }
|
||||
| { type: 'redFlagsSet'; player: PlayerIndex; cardId: CardId; trayId: TrayId; node: number }
|
||||
| {
|
||||
type: 'trainsDestroyed';
|
||||
player: PlayerIndex;
|
||||
@@ -161,18 +154,7 @@ export type GameEvent =
|
||||
*/
|
||||
| { type: 'trainCompleted'; trainNumber: number; isExtra: boolean; side: 'east' | 'west'; consist: RollingStock[] }
|
||||
/** An Extra took a Crew Tray and started its run — at a Division Point, or at a Control Point. */
|
||||
/**
|
||||
* Carries the RESOLVED start and direction (`resolveExtraStart`), not the raw intent fields, so
|
||||
* the reducer never re-answers a question `check` already answered — the same shape as
|
||||
* `passengersBoarded` carrying its tray and coach index.
|
||||
*/
|
||||
| {
|
||||
type: 'extraStarted';
|
||||
player: PlayerIndex;
|
||||
trainNumber: number;
|
||||
at: ExtraStart;
|
||||
direction: Direction;
|
||||
}
|
||||
| { type: 'extraStarted'; player: PlayerIndex; trainNumber: number; atSeat: SeatIndex | null }
|
||||
| { type: 'carPlacedOnTrain'; player: PlayerIndex; trayId: TrayId; stock: RollingStock }
|
||||
| { type: 'carPassed'; player: PlayerIndex; trayId: TrayId }
|
||||
| { type: 'dispatchBonusUsed'; key: string; bonus: number; trainNumber: number; againstTrain: number }
|
||||
@@ -200,25 +182,6 @@ export type GameEvent =
|
||||
| { type: 'unloadBegan'; player: PlayerIndex; at: GridCoord; carType: CarType; carIndex: number }
|
||||
// -- consequences
|
||||
| { type: 'revenueChanged'; player: PlayerIndex; delta: number; total: number; reason: string }
|
||||
| { type: 'phaseEnded'; player: PlayerIndex; phase: string }
|
||||
// -- §3.3, extended play (Gitea#11)
|
||||
/**
|
||||
* One seat's answer to "play one more Day?". Every seat votes; the vote is unanimous, and one
|
||||
* refusal ends it. In the log so that a table can see who is still being waited on, and who
|
||||
* called time.
|
||||
*/
|
||||
| { type: 'extensionVoted'; player: PlayerIndex; agree: boolean }
|
||||
/** The table agreed. `day` is the Day the extra one becomes — `config.days + extraDays`. */
|
||||
| { type: 'dayExtended'; day: number }
|
||||
/**
|
||||
* Play is over for good — somebody declined the extension.
|
||||
*
|
||||
* Distinct from the ending itself, which `checkVictory` already announced by way of the result: an
|
||||
* ending that COULD have been played past and was not is a decision the table made, and the log
|
||||
* should say so rather than simply stopping.
|
||||
*/
|
||||
| { type: 'playConcluded'; declinedBy: PlayerIndex }
|
||||
/** §11 (Gitea#5) — the district's owner answered the Yard Office offer. */
|
||||
| { type: 'yardOfficeRuled'; player: PlayerIndex; trainId: TrayId; take: boolean };
|
||||
| { type: 'phaseEnded'; player: PlayerIndex; phase: string };
|
||||
|
||||
export type EventType = GameEvent['type'];
|
||||
|
||||
+10
-111
@@ -13,17 +13,6 @@ import type { CardId, GridCoord, PlayerIndex, SeatIndex, TrayId } from './state.
|
||||
|
||||
export type LocalOpsOption = 'switch' | 'draw' | 'freightAgent';
|
||||
|
||||
/**
|
||||
* Where an Extra is placed when it is started (§7).
|
||||
*
|
||||
* `mainline` names a node index in `division.nodes` and is only ever an Interchange; `office` names
|
||||
* a SEAT, which is what an Office Area belongs to, and only ever a Control Point.
|
||||
*/
|
||||
export type ExtraStart =
|
||||
| { kind: 'divisionPoint'; side: Direction }
|
||||
| { kind: 'mainline'; node: number }
|
||||
| { kind: 'office'; seat: SeatIndex };
|
||||
|
||||
export type Intent =
|
||||
| { type: 'localOps.choose'; option: LocalOpsOption }
|
||||
// -- switch (§6.1, Appendix A)
|
||||
@@ -85,31 +74,12 @@ export type Intent =
|
||||
| { type: 'newTrain.placeCar'; trayId: TrayId; carType: CarType; loaded: boolean }
|
||||
| { type: 'newTrain.passCar'; trayId: TrayId }
|
||||
/**
|
||||
* §7 — "the player who played the card may place the Crew Tray at EITHER Division Point for
|
||||
* immediate departure", plus Jesse's ruling on where else and which way.
|
||||
*
|
||||
* The number does not decide an Extra's direction — the START does. Either Division Point may be
|
||||
* chosen and the train runs away from it (west end runs east, east end runs west, since the other
|
||||
* reading is a train that leaves the Division having crossed nothing). At an Interchange or a
|
||||
* Control Point, which are in the middle of the railroad, both ways are real runs and `direction`
|
||||
* says which; it is required there and ignored at a Division Point.
|
||||
*
|
||||
* WHICH STARTS ARE OFFERED is the `extraStart` house rule (content.ts) — Division Points and the
|
||||
* Interchange always, Offices by setting.
|
||||
*
|
||||
* `atSeat` IS LEGACY AND WRITE-ONCE. Saves written before this choice existed carry only that
|
||||
* field: `null` meant "the Division Point this train's number sends it to" and a seat meant that
|
||||
* Office, both running in the number's direction. `start` absent is exactly what those saves said,
|
||||
* so they replay unchanged; everything written from now on carries `start` and `atSeat` is
|
||||
* omitted. `resolveExtraStart` (apply.ts) is the single place that reads either.
|
||||
* §7 — "the player who played the card may place the Crew Tray in either division point for
|
||||
* immediate departure", extended by Jesse: an Extra starts at the Division Point its NUMBER sends
|
||||
* it to (odd runs west, even east, exactly as a timetabled train), or at any Control Point — any
|
||||
* Office above a Whistle Post — at the player's choice. `atSeat` null means the Division Point.
|
||||
*/
|
||||
| {
|
||||
type: 'newTrain.startExtra';
|
||||
trainNumber: number;
|
||||
atSeat?: SeatIndex | null;
|
||||
start?: ExtraStart;
|
||||
direction?: Direction;
|
||||
}
|
||||
| { type: 'newTrain.startExtra'; trainNumber: number; atSeat: SeatIndex | null }
|
||||
/** Q9 — run a second, identical section behind a train that is due out this Stage. */
|
||||
| { type: 'newTrain.secondSection'; trainNumber: number }
|
||||
// -- Mainline Phase (§8.1) — the Superintendent's clearance ruling
|
||||
@@ -120,24 +90,10 @@ export type Intent =
|
||||
*/
|
||||
| { type: 'mainline.modify'; cardId: CardId; node: number }
|
||||
/**
|
||||
* §Q, RED FLAGS (Gitea#19) — plant a flag on one side of your own district.
|
||||
*
|
||||
* "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits from
|
||||
* that direction (i.e. Flag East holds westbound trains). You can do this if you see a problem or
|
||||
* wish to complete switching."
|
||||
*
|
||||
* `side` names the side of the district the flag goes on, so a train arriving from that side is
|
||||
* held. It REPLACES the old rule, which was played on a stopped train out on the Mainline and
|
||||
* protected it from a rear-ender: measured at 4,212 offers and 4 plays across 600 games, a
|
||||
* mechanic nobody used. ABS Signals already protects a train standing on a Mainline card.
|
||||
* Red Flags — protect a stopped train. The flagged train cannot be hit; an approaching train is
|
||||
* held instead of colliding.
|
||||
*/
|
||||
| { type: 'maneuver.redFlags'; cardId: CardId; side: Direction }
|
||||
/**
|
||||
* The same card, played OUT OF PHASE at the moment of danger (Gitea#19) — "COLLISION RISK! FLAG
|
||||
* AGAINST T2?". Answers a pending `redFlag` decision; `flag: false` declines and lets the
|
||||
* collision happen. The side is not asked for: the train is already coming from one.
|
||||
*/
|
||||
| { type: 'mainline.redFlag'; flag: boolean; cardId?: CardId }
|
||||
| { type: 'maneuver.redFlags'; cardId: CardId; trayId: TrayId }
|
||||
/**
|
||||
* Flying Switch — cut cars off behind the engine and roll them into an adjacent industry, without
|
||||
* the engine entering it.
|
||||
@@ -161,37 +117,7 @@ export type Intent =
|
||||
| { type: 'laborer.startLoad'; at: GridCoord }
|
||||
| { type: 'laborer.advanceLoad'; at: GridCoord; box: number }
|
||||
| { type: 'laborer.beginUnload'; at: GridCoord; carIndex: number }
|
||||
| { type: 'loadUnload.end' }
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — one vote on whether to play one more Day.
|
||||
*
|
||||
* ARRIVES OUT OF TURN, like `mainline.clearance`, and unlike it goes to EVERY seat rather than to
|
||||
* the Superintendent: it is a table decision, not a ruling. Unanimous, and one `agree: false`
|
||||
* ends the game immediately — nobody waits on a player who has already refused.
|
||||
*
|
||||
* It is an intent, rather than a button the client handles by itself, because a save is
|
||||
* `{ seed, config, history }` replayed through the engine: a decision that is not in the history
|
||||
* did not happen, and an extended game would evaporate on the next reload, Undo, or server
|
||||
* restart. This is the record of the table agreeing.
|
||||
*
|
||||
* CARRIES ITS VOTER, uniquely among intents, and it has to. A saved history is a flat `Intent[]`
|
||||
* with no seat recorded against each move: the replay DERIVES who acted from the turn order
|
||||
* (`fromMultiplayerSave`). That works for every other intent, including `mainline.clearance`,
|
||||
* because there is exactly one seat it could have been. Here there is not — every seat may vote,
|
||||
* in any order — so a vote whose voter is not written down cannot be replayed at all, and a
|
||||
* resumed server would refuse the save with `NO_ACTOR`. The server checks this against the seat
|
||||
* it authenticated (`NOT_YOUR_TURN`), so it is a record, never a claim.
|
||||
*/
|
||||
| { type: 'game.extend'; player: PlayerIndex; agree: boolean }
|
||||
/**
|
||||
* §11 (Gitea#5) — take the Yard Office, or the standard Office.
|
||||
*
|
||||
* Interrupts the Mainline Phase like `mainline.clearance`, and like it goes to one named player:
|
||||
* whoever sits in the district the train is arriving at. Offered only when a route exists, so
|
||||
* `take: true` always has somewhere to go — though it may still meet cars on the lead and crash,
|
||||
* which is the point of the rule.
|
||||
*/
|
||||
| { type: 'mainline.yardOffice'; take: boolean };
|
||||
| { type: 'loadUnload.end' };
|
||||
|
||||
export type IntentType = Intent['type'];
|
||||
|
||||
@@ -302,35 +228,8 @@ export type RejectionCode =
|
||||
| 'NO_EMPTY_COACH_IN_YARD'
|
||||
| 'NOT_A_CONTROL_POINT'
|
||||
| 'NO_EXTRA_PENDING'
|
||||
/** §7 gives an Extra to the player who played the card; another seat may not place it for them. */
|
||||
| 'NOT_YOUR_EXTRA'
|
||||
| 'NO_FREE_TRAY'
|
||||
| 'NO_FREE_AD_TRACK'
|
||||
// -- §7, where an Extra may be started (`resolveExtraStart`)
|
||||
| 'NO_SUCH_DIVISION_POINT'
|
||||
/** Only the Interchange has a yard an Extra can be made up in. */
|
||||
| 'NOT_AN_INTERCHANGE'
|
||||
/** In the middle of the railroad both ways are real runs, so the intent has to say which. */
|
||||
| 'NO_DIRECTION_CHOSEN'
|
||||
/** The `extraStart` house rule is `divisionPointsOnly`. */
|
||||
| 'OFFICE_STARTS_NOT_ALLOWED'
|
||||
/** The `extraStart` house rule is `ownOffice` and this is somebody else's district. */
|
||||
| 'NOT_YOUR_OFFICE'
|
||||
/**
|
||||
* §6.2, Jesse's ruling (Gitea#6) — a train card is never discarded. Hold it as long as you like;
|
||||
* the only way it leaves your hand is onto the timetable.
|
||||
*/
|
||||
| 'TRAINS_ARE_NEVER_DISCARDED'
|
||||
/** §3.3 (Gitea#11) — `game.extend` when the game is not waiting on an extension vote. */
|
||||
| 'NOT_AWAITING_EXTENSION'
|
||||
/** §3.3 (Gitea#11) — this seat has already voted on this extension. */
|
||||
| 'ALREADY_VOTED'
|
||||
/** §11 (Gitea#5) — answering a Yard Office offer that is not open. */
|
||||
| 'NO_YARD_OFFICE_OFFER'
|
||||
/** §Q (Gitea#19) — answering a Red Flag prompt that is not open. */
|
||||
| 'NO_RED_FLAG_PROMPT'
|
||||
/** §Q (Gitea#19) — this district already has a flag on that side. */
|
||||
| 'ALREADY_FLAGGED';
|
||||
| 'NO_FREE_AD_TRACK';
|
||||
|
||||
export type Rejection = { code: RejectionCode; message: string };
|
||||
|
||||
|
||||
+12
-55
@@ -13,7 +13,7 @@
|
||||
*/
|
||||
|
||||
import type { CarType, Hand, TrackGeometry } from './content.ts';
|
||||
import { enhancementRule, mainlineProfile } from './content.ts';
|
||||
import { enhancementRule } from './content.ts';
|
||||
import { check, areaOf, destinationsFor } from './apply.ts';
|
||||
import type { Intent } from './intents.ts';
|
||||
import type { GameState, GridCoord, PlayerIndex } from './state.ts';
|
||||
@@ -68,44 +68,18 @@ export function isLegal(s: GameState, player: PlayerIndex, i: Intent): boolean {
|
||||
function candidates(s: GameState, player: PlayerIndex): Intent[] {
|
||||
const out: Intent[] = [];
|
||||
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — the only thing on offer when the timetable has run out and the
|
||||
* table is being asked whether to play on.
|
||||
*
|
||||
* Returned EARLY rather than added to the list, because nothing else is legal in this state and
|
||||
* the phase switch below would otherwise generate a boardful of candidates for `check` to reject
|
||||
* one at a time. It also puts the vote in front of the bot driver through the ordinary path, which
|
||||
* is what lets a bot seat answer without the engine having to know which seats are bots.
|
||||
*/
|
||||
if (s.status === 'awaitingExtension') {
|
||||
if (s.extensionVotes[player] === null) {
|
||||
out.push({ type: 'game.extend', player, agree: true });
|
||||
out.push({ type: 'game.extend', player, agree: false });
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// The two interruptions of the Mainline Phase. Each goes to one named player — `check` is the
|
||||
// authority on which — so both are generated here and filtered there.
|
||||
if (s.clock.pendingDecision?.kind === 'clearance') {
|
||||
// The clearance ruling arrives out of turn order and goes to the Superintendent (§8.1).
|
||||
if (s.clock.pendingDecision !== null) {
|
||||
out.push({ type: 'mainline.clearance', allow: true });
|
||||
out.push({ type: 'mainline.clearance', allow: false });
|
||||
}
|
||||
if (s.clock.pendingDecision?.kind === 'yardOffice') {
|
||||
out.push({ type: 'mainline.yardOffice', take: true });
|
||||
out.push({ type: 'mainline.yardOffice', take: false });
|
||||
}
|
||||
if (s.clock.pendingDecision?.kind === 'redFlag') {
|
||||
out.push({ type: 'mainline.redFlag', flag: true });
|
||||
out.push({ type: 'mainline.redFlag', flag: false });
|
||||
}
|
||||
|
||||
switch (s.clock.phase) {
|
||||
case 'localOps':
|
||||
out.push(...localOpsCandidates(s, player));
|
||||
break;
|
||||
case 'newTrain':
|
||||
out.push(...newTrainCandidates(s, player));
|
||||
out.push(...newTrainCandidates(s));
|
||||
break;
|
||||
case 'loadUnload':
|
||||
out.push(...loadUnloadCandidates(s, player));
|
||||
@@ -119,8 +93,7 @@ function candidates(s: GameState, player: PlayerIndex): Intent[] {
|
||||
for (const cardId of s.decks.hands.get(player) ?? []) {
|
||||
const k = s.cards.get(cardId)?.kind;
|
||||
if (k?.kind !== 'maneuver' || k.key !== 'redFlags') continue;
|
||||
// §Q (Gitea#19) — a flag goes on one side of your own district, so the only choice is which.
|
||||
for (const side of ['east', 'west'] as const) out.push({ type: 'maneuver.redFlags', cardId, side });
|
||||
for (const [trayId] of s.trays) out.push({ type: 'maneuver.redFlags', cardId, trayId });
|
||||
}
|
||||
|
||||
out.push({ type: 'redFlag.play' });
|
||||
@@ -284,7 +257,7 @@ function localOpsCandidates(s: GameState, player: PlayerIndex): Intent[] {
|
||||
return out;
|
||||
}
|
||||
|
||||
function newTrainCandidates(s: GameState, player: PlayerIndex): Intent[] {
|
||||
function newTrainCandidates(s: GameState): Intent[] {
|
||||
const out: Intent[] = [];
|
||||
for (const [trayId] of s.trays) {
|
||||
for (const carType of CAR_TYPES) {
|
||||
@@ -298,30 +271,14 @@ function newTrainCandidates(s: GameState, player: PlayerIndex): Intent[] {
|
||||
out.push({ type: 'newTrain.secondSection', trainNumber: due });
|
||||
}
|
||||
/**
|
||||
* WHERE A PENDING EXTRA MAY START (§7, Jesse's ruling) — every candidate offered, with `check`
|
||||
* doing the filtering, so "is this a Control Point" and "does the house rule allow it" have one
|
||||
* implementation each rather than two.
|
||||
*
|
||||
* BOTH Division Points, not the one the number dictates: an Extra's direction comes from where it
|
||||
* is placed. In the middle of the railroad — an Interchange, a Control Point — both ways are real
|
||||
* runs, so those are offered twice, once per direction.
|
||||
* Where a pending Extra starts: its own Division Point, decided by its number, or any Control
|
||||
* Point. `check` refuses a Whistle Post and a full Office, so every seat is offered and the rules
|
||||
* do the filtering — one implementation of "is this a Control Point", not two.
|
||||
*/
|
||||
// Only the player who played it is offered anywhere to put it (§7) — `check` refuses anyone else
|
||||
// with NOT_YOUR_EXTRA, and offering options that are certain to be refused is how a menu lies.
|
||||
for (const { trainNumber } of s.pendingExtras.filter((x) => x.player === player)) {
|
||||
for (const side of ['west', 'east'] as const) {
|
||||
out.push({ type: 'newTrain.startExtra', trainNumber, start: { kind: 'divisionPoint', side } });
|
||||
}
|
||||
for (const [node, n] of s.division.nodes.entries()) {
|
||||
if (n.kind !== 'mainline' || !mainlineProfile(n.card).sortsCars) continue;
|
||||
for (const direction of ['west', 'east'] as const) {
|
||||
out.push({ type: 'newTrain.startExtra', trainNumber, start: { kind: 'mainline', node }, direction });
|
||||
}
|
||||
}
|
||||
for (const trainNumber of s.pendingExtras) {
|
||||
out.push({ type: 'newTrain.startExtra', trainNumber, atSeat: null });
|
||||
for (const seat of s.officeAreas.keys()) {
|
||||
for (const direction of ['west', 'east'] as const) {
|
||||
out.push({ type: 'newTrain.startExtra', trainNumber, start: { kind: 'office', seat }, direction });
|
||||
}
|
||||
out.push({ type: 'newTrain.startExtra', trainNumber, atSeat: seat });
|
||||
}
|
||||
}
|
||||
return out;
|
||||
|
||||
+19
-46
@@ -17,7 +17,7 @@ import {
|
||||
MODIFIER_PROFILES,
|
||||
OFFICE_PROFILES,
|
||||
OPENING_DEALS,
|
||||
MAINLINE_DECK,
|
||||
MAINLINE_PROFILES,
|
||||
houseRules,
|
||||
mainlineProfile,
|
||||
TRACK_CARDS,
|
||||
@@ -43,7 +43,7 @@ import type {
|
||||
TrackCard,
|
||||
TrayId,
|
||||
} from './state.ts';
|
||||
import { coordKey, emptyTally, freshTurns } from './state.ts';
|
||||
import { coordKey, freshTurns } from './state.ts';
|
||||
|
||||
export type SetupOptions = {
|
||||
id: string;
|
||||
@@ -53,16 +53,13 @@ export type SetupOptions = {
|
||||
};
|
||||
|
||||
/** Builds the 52-card Home Office deck (§12.1). Unshuffled; caller shuffles with the seeded RNG. */
|
||||
export function buildDeck(mode: GameConfig['mode'] = 'competitive', pvpCardsAllowed = false): Card[] {
|
||||
export function buildDeck(mode: GameConfig['mode'] = 'competitive'): Card[] {
|
||||
/**
|
||||
* THE 22 OPPONENT-DIRECTED CARDS ARE OUT OF EVERY DECK REGARDLESS OF `pvpCardsAllowed`, for now.
|
||||
* THE 22 OPPONENT-DIRECTED CARDS ARE OUT OF EVERY DECK FOR NOW, not just the solitaire one.
|
||||
*
|
||||
* Q6 took them out of solitaire because they have no legal target in a one-player game. They are
|
||||
* out of the competitive deck too because `checkPlay` answers both categories `NOT_IMPLEMENTED`:
|
||||
* leaving them in would make ~9% of draws reject outright, which is worse than not dealing them.
|
||||
* `pvpCardsAllowed` (`GameConfig`, wired 2026-08-20) is the player-facing toggle, but ANDing it
|
||||
* with `cardsImplemented` keeps it inert until Phase 5 actually builds the cards — flipping
|
||||
* `pvpCardsAllowed` on today must not turn a working game into one where ~9% of draws reject.
|
||||
*
|
||||
* AND SO ARE THE SEVEN CARDS THAT ANSWER THEM — see below. They used to be dealt and sit dormant,
|
||||
* which is the same dead draw by another name. Recorded in TODO.md as multiplayer work.
|
||||
@@ -71,8 +68,7 @@ export function buildDeck(mode: GameConfig['mode'] = 'competitive', pvpCardsAllo
|
||||
* for these two categories today.
|
||||
*/
|
||||
void mode;
|
||||
const cardsImplemented = false;
|
||||
const opponentCardsInDeck = pvpCardsAllowed && cardsImplemented;
|
||||
const opponentCardsInDeck = false;
|
||||
const cards: Card[] = [];
|
||||
let n = 0;
|
||||
const push = (kind: Card['kind']): void => {
|
||||
@@ -224,41 +220,23 @@ function buildPassengerFacility(tier: Parameters<typeof officeProfile>[0]): NonN
|
||||
* placed between each player"), which is what gives the Division its terrain and therefore its
|
||||
* crossing times.
|
||||
*/
|
||||
/**
|
||||
* THE MAINLINE CARDS ARE DEALT FROM A DECK, NOT ROLLED.
|
||||
*
|
||||
* `MAINLINE_PROFILES` is a list of card TYPES and this drew from it uniformly WITH replacement, so
|
||||
* a Division could be handed two Interchanges or two Tunnels, and Plains — printed twice in the
|
||||
* deck — carried the same weight as cards printed once. `MAINLINE_DECK` is the printed inventory
|
||||
* (`docs/StationMaster-Mainline-Deck-v0.4.5.md`, which flagged this as needing correction), and the
|
||||
* deal is now a deal: take cards out of it and do not put them back.
|
||||
*
|
||||
* The Extra-start rules are what forced the issue. "An Extra may start at the Interchange if one is
|
||||
* on the board" only reads as a rule if the board can hold at most one.
|
||||
*
|
||||
* A Division needs `players + 1` cards, so four players draw five from ten and the deck is never
|
||||
* close to exhausted; the throw is there because a silent short Division would be very hard to see.
|
||||
*/
|
||||
function buildDivision(players: number, rng: Rng): DivisionNode[] {
|
||||
const nodes: DivisionNode[] = [];
|
||||
const deck = [...MAINLINE_DECK];
|
||||
const kinds = MAINLINE_PROFILES.map((m) => m.kind);
|
||||
const mainline = (): DivisionNode => {
|
||||
if (deck.length === 0) throw new Error('the Mainline deck ran out — too many players for it');
|
||||
const card = deck.splice(rng.nextInt(deck.length), 1)[0]!;
|
||||
const card = kinds[rng.nextInt(kinds.length)]!;
|
||||
const node: DivisionNode = { kind: 'mainline', card, transits: [] };
|
||||
if (card === 'heavyGrade') {
|
||||
// The Heavy Grade card says "Player sets orientation", but setup has no decision point yet —
|
||||
// createGame is synchronous and returns a ready state. Rolled for now so the orientation is at
|
||||
// least deterministic and varies between games; it should become a real player choice when
|
||||
// setup gains an interactive phase. See implications.md §10 Q11.
|
||||
if (mainlineProfile(card).speed.kind === 'grade') {
|
||||
/**
|
||||
* SETTLED, not provisional (v0.5.0, Jesse's call) — this overrides the card's own printed
|
||||
* "Player sets orientation". A Heavy Grade sits on the shared west-to-east chain BETWEEN two
|
||||
* players (§4.2), or beyond an end Division Point next to one — never inside one player's own
|
||||
* district — so whichever direction climbs advantages one neighbour over the other, and there
|
||||
* is no single player who owns that call fairly. Orientation is rolled from the seed instead,
|
||||
* identically for solitaire and multiplayer, and this is not expected to change when setup
|
||||
* eventually gains an interactive phase for other decisions.
|
||||
*
|
||||
* RE-CONFIRMED 2026-08-23, when the question was raised again and giving the choice to the
|
||||
* Superintendent was considered and rejected — the office rotates every three Stages, the
|
||||
* advantage it would hand out does not. See implications.md §10 Q11.
|
||||
* TEMPORARY, and flagged in TODO. The card prints "(Up)" and "Player sets orientation", so
|
||||
* which way a Heavy Grade climbs is the player's decision — but it is dealt during setup, and
|
||||
* setup has no decision point at all. Rolled from the seed until it gains one, because the
|
||||
* orientation MATTERS: it decides which direction climbs, and therefore what a Brakeman or
|
||||
* Helpers card is worth.
|
||||
*/
|
||||
node.gradeUp = rng.nextInt(2) === 0 ? 'east' : 'west';
|
||||
}
|
||||
@@ -339,7 +317,7 @@ export function createGame(opts: SetupOptions): GameState {
|
||||
*/
|
||||
const rules = houseRules(config);
|
||||
const deal = OPENING_DEALS[rules.startingHand];
|
||||
const deck = buildDeck(config.mode, config.pvpCardsAllowed);
|
||||
const deck = buildDeck(config.mode);
|
||||
const cards = new Map<CardId, Card>();
|
||||
for (const c of deck) cards.set(c.id, c);
|
||||
|
||||
@@ -424,20 +402,15 @@ export function createGame(opts: SetupOptions): GameState {
|
||||
phase: 'localOps',
|
||||
currentActor: superintendent,
|
||||
pendingDecision: null,
|
||||
decisionAnswer: null,
|
||||
clearanceRuling: null,
|
||||
superintendent,
|
||||
actorOffset: 0,
|
||||
},
|
||||
turns: freshTurns(playerCount, MOVES_PER_LOCAL_OPS),
|
||||
movedThisPhase: new Set(),
|
||||
collisionsToday: 0,
|
||||
collisionsTotal: 0,
|
||||
status: 'active',
|
||||
outcome: null,
|
||||
extraDays: 0,
|
||||
extensionVotes: players.map(() => null),
|
||||
official: null,
|
||||
tally: emptyTally(playerCount),
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
+42
-426
@@ -12,6 +12,7 @@ import type {
|
||||
Hand,
|
||||
MainlineKind,
|
||||
FreightKind,
|
||||
GameLength,
|
||||
HouseRuleOverrides,
|
||||
ModifierKind,
|
||||
OfficeTier,
|
||||
@@ -354,32 +355,6 @@ export type CrewTray = {
|
||||
/** null while a local crew is switching without a train card. */
|
||||
trainNumber: number | null;
|
||||
trainIsExtra: boolean;
|
||||
/**
|
||||
* STILL BEING ASSEMBLED, somewhere that is not a Division Point.
|
||||
*
|
||||
* `isBeingMadeUp` used to read the position alone — "standing at a Division Point" — which was
|
||||
* true of every train being built when the only place to build one WAS a Division Point. An Extra
|
||||
* may now be started at a Control Point or in an Interchange's yard (§7), and those trains could
|
||||
* not be given a consist at all: they ran empty, and so did every Control Point Extra since that
|
||||
* option was added. Jesse's report says it plainly — an Extra started at the Interchange "would be
|
||||
* loaded with cars".
|
||||
*
|
||||
* Set when such an Extra is placed and cleared the moment it starts running (`enterMainline`), so
|
||||
* it names a train that is being made up rather than one that merely happens to be standing
|
||||
* somewhere. That distinction is load-bearing: a train that ARRIVED at an Office must never be
|
||||
* fillable from the Division Yard, which is the "cars appearing on a train nobody was making up"
|
||||
* bug `isBeingMadeUp` was tightened to kill, and an arriving train never carries this.
|
||||
*/
|
||||
beingMadeUp?: boolean;
|
||||
/**
|
||||
* WHOSE TRAIN THIS IS TO BUILD, for an Extra only.
|
||||
*
|
||||
* §7's Extra is loaded by the player who played the card, not by the Superintendent-first round
|
||||
* that fills a Timetabled train — so the tray has to remember them: `pendingExtras` is emptied the
|
||||
* moment the Extra starts, which is before a single car goes on. Undefined on every Timetabled
|
||||
* train, where the round decides instead.
|
||||
*/
|
||||
builtBy?: PlayerIndex;
|
||||
/**
|
||||
* WHERE THE ENGINE SITS IN THE TRAY, as an index into `consist`.
|
||||
*
|
||||
@@ -391,12 +366,6 @@ export type CrewTray = {
|
||||
*
|
||||
* The engine is NOT one of the `consist` entries: §8.2 counts the consist as Rolling Stock, and
|
||||
* the four-car limit (§A.4) is a limit on cars, not on the locomotive hauling them.
|
||||
*
|
||||
* This only records POSITION, not a supply — and that is not a gap. `rules-v0.2.md`:339 (Gap 4b)
|
||||
* ties Crew Trays and engine pieces together as one combined resource, `player count + 3`
|
||||
* (`crewTrayCount` in `content.ts`), so engine scarcity IS tray scarcity: `freeTrays` running out
|
||||
* already blocks a new train exactly when the engine supply would. There is no state for "a tray
|
||||
* with no engine" because the rules never separate the two.
|
||||
*/
|
||||
engineAt: number;
|
||||
/**
|
||||
@@ -445,27 +414,20 @@ export type CrewTray = {
|
||||
position: NodeRef;
|
||||
movesUsed: number;
|
||||
/**
|
||||
* X18 Circus / X17 Campaign — Office Areas this train has already been paid for setting up in
|
||||
* (Gitea#13).
|
||||
* X18 Circus Train — "one turn stopped on any track (circus set-up) earns 1 point", claimed once.
|
||||
*
|
||||
* "Once per stop in an office area. In a multiplayer game, each player could score if the circus
|
||||
* stops in their area" (Jesse, 2026-08-29). So the claim is per SEAT, not per train: a Circus
|
||||
* touring three districts is paid three times, and one that parks in the same district for six
|
||||
* Stages is paid once.
|
||||
*
|
||||
* Recorded on the tray, which also gives the other half of Jesse's ruling for free — "if the
|
||||
* circus train gets recycled and played a second time as a second extra, then it could again
|
||||
* score points later too". A train is made up onto a FRESH tray object every time, so a re-played
|
||||
* Extra starts with an empty list and no reset code is needed.
|
||||
* Recorded on the tray rather than the player because it is the TRAIN that sets up, and an Extra
|
||||
* runs once and is gone; there is no second visit to claim it on.
|
||||
*/
|
||||
stopPointSeats?: SeatIndex[];
|
||||
stopPointClaimed?: boolean;
|
||||
/**
|
||||
* X17 Campaign Train — "one turn at station (speeches) then expedite".
|
||||
*
|
||||
* It makes its speech at the first Office it reaches: that arrival is an ordinary stop, and from
|
||||
* then on the train is expedited — it may be switched normally, but it faults (Q3) if it is left
|
||||
* off the Office square when a Mainline Phase begins. Recorded on the tray for the same reason as
|
||||
* `stopPointSeats` — it is the TRAIN that stops, and a re-played Extra gets a fresh tray.
|
||||
* `stopPointClaimed` — it is the TRAIN that stops, and an Extra runs once, so there is no later
|
||||
* visit to hang it on.
|
||||
*/
|
||||
speechMade?: boolean;
|
||||
};
|
||||
@@ -503,20 +465,6 @@ export type DivisionNode =
|
||||
kind: 'mainline';
|
||||
card: MainlineKind;
|
||||
transits: Transit[];
|
||||
/**
|
||||
* TRAINS STANDING IN THE INTERCHANGE'S YARD — not out on the running line.
|
||||
*
|
||||
* Only an Interchange ever has these. An Extra started there (§7, Jesse's ruling) is made up
|
||||
* in the yard beside the Mainline, which is why placing it can never be a collision however
|
||||
* busy the card is: it is not on the road yet. It highballs onto this same card at a later
|
||||
* Mainline Phase, through the ordinary §8.1 clearance check — held automatically against a
|
||||
* facing train, put to the Superintendent against a following one — and becomes a `Transit`
|
||||
* at that moment, exactly like a train leaving a Division Point.
|
||||
*
|
||||
* A tray listed here has `position.at === 'mainline'` with this node's index and NO entry in
|
||||
* `transits`. That pair is what distinguishes standing from crossing.
|
||||
*/
|
||||
holding?: TrayId[];
|
||||
absSignals?: boolean;
|
||||
/** Brakeman / Airbrakes / Helpers / Realignment laid on this card. */
|
||||
modifiers?: string[];
|
||||
@@ -525,23 +473,10 @@ export type DivisionNode =
|
||||
* "Player sets orientation", so the direction is chosen when the card is placed.
|
||||
*/
|
||||
gradeUp?: Direction;
|
||||
/** Red Flags protecting a stopped train here, by tray. */
|
||||
redFlagged?: TrayId[];
|
||||
}
|
||||
| {
|
||||
kind: 'office';
|
||||
seat: SeatIndex;
|
||||
/**
|
||||
* §Q, RED FLAGS (Gitea#19) — the side of this district a flag is planted on.
|
||||
*
|
||||
* "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits
|
||||
* from that direction (i.e. Flag East holds westbound trains)." So the value names the SIDE,
|
||||
* and a train arriving from that side is held: a westbound train comes from the east.
|
||||
*
|
||||
* SPENT ON THE TRAIN IT STOPS (Jesse's ruling, 2026-08-29). One card, one train — the flag
|
||||
* comes down as it is used, so there is no lifting action to build, nothing to forget, and a
|
||||
* flag cannot quietly strangle the Division.
|
||||
*/
|
||||
redFlag?: Direction;
|
||||
};
|
||||
| { kind: 'office'; seat: SeatIndex };
|
||||
|
||||
/** Ordered west to east. For N players: N Office nodes and N+1 Mainline cards. */
|
||||
export type Division = { nodes: DivisionNode[] };
|
||||
@@ -605,42 +540,10 @@ export type Yards = {
|
||||
export type Phase = 'localOps' | 'newTrain' | 'mainline' | 'loadUnload' | 'shiftChange';
|
||||
|
||||
/** §8.1 fourth condition — the Superintendent rules on a following train. */
|
||||
/**
|
||||
* AN INTERRUPTION TO THE AUTOMATIC MAINLINE PHASE — a question the driver cannot answer itself.
|
||||
*
|
||||
* There was one of these and it was hardcoded to one question asked of one player: the §8.1
|
||||
* clearance ruling, always to the Superintendent. Gitea#5 and Gitea#19 each need to stop the same
|
||||
* phase and ask a DIFFERENT player something different, so the shape is a union and `decisionActor`
|
||||
* below decides who answers.
|
||||
*
|
||||
* Every member names the `train` the question is about, because the answer has to be matched back
|
||||
* to it — see `DecisionAnswer`.
|
||||
*/
|
||||
export type PendingDecision =
|
||||
/** §8.1 — a following train in the same Subdivision. The Superintendent rules. */
|
||||
| { kind: 'clearance'; train: TrayId; occupiedBy: TrayId }
|
||||
/**
|
||||
* §11 (Gitea#5) — an inbound freight may take the Yard Office instead of the Train Order Office.
|
||||
* Asked of whoever sits in `seat`, on the Mainline Phase the train arrives.
|
||||
*/
|
||||
| { kind: 'yardOffice'; train: TrayId; seat: SeatIndex }
|
||||
/**
|
||||
* §Q (Gitea#19) — a train is about to enter this district into a collision, and its owner holds a
|
||||
* Red Flags card. "You can play the card normally or out of phase, but only if you need it."
|
||||
*/
|
||||
| { kind: 'redFlag'; train: TrayId; seat: SeatIndex; from: Direction };
|
||||
|
||||
/**
|
||||
* The answer, waiting to be consumed by the train that asked.
|
||||
*
|
||||
* Without this the driver would re-evaluate the same train, ask the same question, and never
|
||||
* advance. Keyed by `kind` as well as `train` so an answer can never be mistaken for the reply to a
|
||||
* different question about the same train.
|
||||
*/
|
||||
export type DecisionAnswer =
|
||||
| { kind: 'clearance'; train: TrayId; allow: boolean }
|
||||
| { kind: 'yardOffice'; train: TrayId; take: boolean }
|
||||
| { kind: 'redFlag'; train: TrayId; flag: boolean };
|
||||
export type SuperintendentClearance = {
|
||||
train: TrayId;
|
||||
occupiedBy: TrayId;
|
||||
};
|
||||
|
||||
export type Clock = {
|
||||
day: number;
|
||||
@@ -649,10 +552,13 @@ export type Clock = {
|
||||
phase: Phase;
|
||||
/** Exactly one player may act at a time. Null during automatic Mainline movement. */
|
||||
currentActor: PlayerIndex | null;
|
||||
/** Interrupts the Mainline Phase to ask a player something (§8.1, §11). */
|
||||
pendingDecision: PendingDecision | null;
|
||||
/** The answer to `pendingDecision`, waiting to be consumed by the train that asked. */
|
||||
decisionAnswer: DecisionAnswer | null;
|
||||
/** Interrupts the Mainline Phase to ask the Superintendent (§8.1). */
|
||||
pendingDecision: SuperintendentClearance | null;
|
||||
/**
|
||||
* The Superintendent's answer, waiting to be consumed by the train that asked. Without this the
|
||||
* driver would re-evaluate the same train and ask the same question forever.
|
||||
*/
|
||||
clearanceRuling: { train: TrayId; allow: boolean } | null;
|
||||
superintendent: PlayerIndex;
|
||||
/**
|
||||
* How far round the table the current phase has got. Acting order starts at the Superintendent
|
||||
@@ -674,44 +580,15 @@ export type Player = {
|
||||
};
|
||||
|
||||
export type GameMode = 'solitaire' | 'competitive' | 'coop';
|
||||
export type VictoryCondition = 'firstToTarget' | 'highestAfterDays';
|
||||
|
||||
/**
|
||||
* VICTORY CONDITIONS — designed 2026-08-20, unified across all three modes.
|
||||
*
|
||||
* Replaces the old `length`-preset lookup (`LENGTH_PROFILES.target`) and the dead
|
||||
* `VictoryCondition: 'firstToTarget'` (grepped: never selected anywhere in the codebase). Winner is
|
||||
* whoever has the most Revenue when `days` run out — solitaire's own player counts as "everyone" —
|
||||
* unless `minCombinedRevenue` was missed, in which case everyone loses. Coop keeps summing every
|
||||
* player's Revenue into one table score, now against a configurable floor instead of
|
||||
* `profile.target * players.length`.
|
||||
*
|
||||
* `0` means "off" for every numeric field below. `minCombinedRevenue`'s natural default is
|
||||
* `collectiveRevenueFloor(players, days)` (`content.ts`), computed by whoever authors the config —
|
||||
* the engine only ever reads a concrete number here, never resolves one lazily, because player count
|
||||
* is not always known at config-authoring time (a lobby, a CLI flag, a dialog).
|
||||
*
|
||||
* `maxCollisionsPerDay`/`maxCollisionsTotal` are deliberately FLAT, not scaled by player count: more
|
||||
* players means more independent chances to collide, not a bigger shared budget, so a multiplayer
|
||||
* table is genuinely riskier than solitaire at the same default (Jesse's call).
|
||||
*/
|
||||
export type GameConfig = {
|
||||
mode: GameMode;
|
||||
/** How many Days the game runs. */
|
||||
days: number;
|
||||
/** Everyone loses if the table's total Revenue is below this when `days` run out. 0 = off. */
|
||||
minCombinedRevenue: number;
|
||||
/** Everyone loses immediately, mid-game, once collisions in one Day reach this. 0 = off. */
|
||||
maxCollisionsPerDay: number;
|
||||
/** Same, summed across the whole game, never reset. 0 = off. */
|
||||
maxCollisionsTotal: number;
|
||||
/**
|
||||
* Whether the 22 opponent-directed cards are in the deck (`setup.ts`'s `buildDeck`). Forced off in
|
||||
* `solitaire` and `coop` — neither has a valid target for them — on by default in `competitive`.
|
||||
* Has no effect until those cards are built (Phase 5); see `TODO.md`.
|
||||
*/
|
||||
pvpCardsAllowed: boolean;
|
||||
victory: VictoryCondition;
|
||||
length: GameLength;
|
||||
optionalRules: {
|
||||
reducedVisibility: boolean;
|
||||
sisterTrains: boolean;
|
||||
employeeRotation: boolean;
|
||||
emergencyToolbox: boolean;
|
||||
};
|
||||
@@ -725,7 +602,11 @@ export type GameConfig = {
|
||||
houseRules?: HouseRuleOverrides;
|
||||
};
|
||||
|
||||
export type OutcomeReason = 'daysElapsed' | 'collisionFloor' | 'revenueFloor';
|
||||
export type OutcomeReason =
|
||||
| 'targetReached'
|
||||
| 'daysElapsed'
|
||||
| 'collisionFloor'
|
||||
| 'revenueFloor';
|
||||
|
||||
export type Outcome = {
|
||||
result: 'win' | 'loss';
|
||||
@@ -733,139 +614,6 @@ export type Outcome = {
|
||||
reason: OutcomeReason;
|
||||
};
|
||||
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — which endings may be played past.
|
||||
*
|
||||
* Both days-based endings offer another Day: running out of timetable, and closing short of the
|
||||
* combined Revenue floor, are the same event seen twice — the last Day ended and this is what the
|
||||
* books say. A `collisionFloor` ending is NOT extendable, and neither is a collision breach that
|
||||
* happens during an extended Day: §3.4 stopped the game because the railroad was declared unsafe,
|
||||
* and carrying on regardless would contradict the rule that stopped it (Jesse's call, 2026-08-28).
|
||||
*/
|
||||
export function isExtendable(reason: OutcomeReason): boolean {
|
||||
return reason === 'daysElapsed' || reason === 'revenueFloor';
|
||||
}
|
||||
|
||||
/**
|
||||
* Running counts of everything interesting that has happened, tallied from the event stream
|
||||
* (Gitea#16).
|
||||
*
|
||||
* WHY IT LIVES ON `GameState` rather than being computed by whoever happens to want it. Three
|
||||
* reasons, in ascending order of how much they cost to work around:
|
||||
*
|
||||
* 1. `snapshot()` already takes a `GameState`, so every number here reaches a MULTIPLAYER client
|
||||
* through the `Frame` it is already being sent — no new server route, no new `Push` field, no
|
||||
* new `Session` method, and no second implementation that can disagree with the first.
|
||||
* 2. It is REPLAY-EXACT. A save is `{ seed, config, history }` replayed through the engine
|
||||
* (`web/game.ts`'s `fromSave`), so a tally folded from the events that replay emits is rebuilt
|
||||
* identically every time — which is what makes Undo and a server restart correct here for free.
|
||||
* 3. The official result freezes a COPY of this at the moment the timetable ran out (`official`
|
||||
* below), and a frozen copy has to be taken from something that already exists.
|
||||
*
|
||||
* Aggregate counts only. Nothing here is seat-secret — no card ids, no hands — which is why
|
||||
* `test/redaction.test.ts` stays green with the whole thing on the Frame.
|
||||
*
|
||||
* NOT SCORING. Nothing in here feeds a rule; it is read by the results screen and by the badge work
|
||||
* that Gitea#16 leaves to a second pass. Adding a counter is always safe.
|
||||
*/
|
||||
export type Tally = {
|
||||
/** §8.3 — a train that ran the length of the Division and left it. */
|
||||
trainsCompleted: number;
|
||||
/**
|
||||
* Of those, how many did some switching between being made up and leaving.
|
||||
*
|
||||
* The join Gitea#16 asks for by name ("a player who completes an entire game where every train
|
||||
* that passed through did some switching on"). Counted as the train completes, against whether
|
||||
* that tray has coupled or dropped anything since it was made up — which is why `switchedSince`
|
||||
* below exists rather than this being derivable afterwards.
|
||||
*/
|
||||
trainsCompletedWithWork: number;
|
||||
/** §10 — trains lost to a collision, and the cars that went with them. */
|
||||
trainsDestroyed: number;
|
||||
carsDestroyed: number;
|
||||
/** §6 — switching volume, both directions. */
|
||||
carsCoupled: number;
|
||||
carsDropped: number;
|
||||
/** §9.1 — the MEN | AT | WORK pipeline: begun, and carried all the way through. */
|
||||
loadsStarted: number;
|
||||
loadsCompleted: number;
|
||||
unloadsBegun: number;
|
||||
unloadsCompleted: number;
|
||||
/** §9.2 — passenger work. */
|
||||
passengersBoarded: number;
|
||||
passengersDetrained: number;
|
||||
/** Colour, and the vocabulary the badge pass will draw on. */
|
||||
flyingSwitches: number;
|
||||
officeUpgrades: number;
|
||||
dispatchBonusesUsed: number;
|
||||
facilitiesUnjammed: number;
|
||||
expediteFaults: number;
|
||||
trainsHeld: number;
|
||||
trainsDiverted: number;
|
||||
secondSections: number;
|
||||
extrasStarted: number;
|
||||
cardsDrawn: number;
|
||||
cardsPlayed: number;
|
||||
cardsDiscarded: number;
|
||||
clearancesRequested: number;
|
||||
/** §8.1 — rulings that let the other train through. A refusal is a ruling too, but not this one. */
|
||||
clearancesAllowed: number;
|
||||
/**
|
||||
* X18 CIRCUS SET-UPS — a train that spent a Stage standing still and was paid for it (§X18).
|
||||
*
|
||||
* NOT "the longest an engine sat on a siding", which is what Gitea#16 asks for and what the
|
||||
* comment on that issue assumed this was. `trainStoodStill` is emitted ONCE IN A GAME PER SUCH
|
||||
* TRAIN — only for a train whose profile has `stopEarnsPoint`, and `advance.ts` sets
|
||||
* `stopPointClaimed` so it can never fire twice. There is no per-Stage "this train did not move"
|
||||
* signal in the engine at all, so a longest-stand streak cannot be folded from the event stream:
|
||||
* it needs an engine-side signal that does not exist yet. Recorded in `TODO.md` for the badge
|
||||
* pass rather than shipped as a statistic that would read "1 Stage" for ever.
|
||||
*/
|
||||
circusStops: { trainNumber: number; where: string }[];
|
||||
/**
|
||||
* Train numbers that have coupled or dropped something since they were made up, for
|
||||
* `trainsCompletedWithWork`. Cleared when the train is made up and when it leaves the Division.
|
||||
*/
|
||||
switchedSince: number[];
|
||||
/** Indexed by PLAYER. Only events that name a player reach these. */
|
||||
byPlayer: PlayerTally[];
|
||||
};
|
||||
|
||||
export type PlayerTally = {
|
||||
loads: number;
|
||||
unloads: number;
|
||||
passengersBoarded: number;
|
||||
passengersDetrained: number;
|
||||
cardsPlayed: number;
|
||||
/** §10 — collisions this player was faulted for, not collisions they were caught in. */
|
||||
collisions: number;
|
||||
/** Revenue gained and Revenue lost, kept apart: the net is already on `players[i].revenue`. */
|
||||
revenueGained: number;
|
||||
revenueLost: number;
|
||||
};
|
||||
|
||||
/**
|
||||
* THE OFFICIAL RESULT, frozen at the moment the timetable ran out (Gitea#11).
|
||||
*
|
||||
* "The winner is based upon the original game length. In a five-day game, even if it's extended to
|
||||
* eight or nine days, the winner and the official answer is the winner at the end of five days"
|
||||
* (Jesse, 2026-08-28). So this is written ONCE, at the first ending, and never overwritten —
|
||||
* including by a §3.4 collision breach during an extended Day, which ends play without touching it.
|
||||
*
|
||||
* `state.outcome` keeps moving: it is always the CURRENT evaluation, which is what the live game
|
||||
* wants. Once `official` exists, everything after it is informational.
|
||||
*/
|
||||
export type FinalReport = {
|
||||
/** The Day the game was scheduled to end on — always `config.days`. */
|
||||
day: number;
|
||||
outcome: Outcome;
|
||||
/** Every player's Revenue at that moment, in player order. */
|
||||
revenues: number[];
|
||||
collisionsTotal: number;
|
||||
/** The Tally as it stood when the timetable ran out. */
|
||||
tally: Tally;
|
||||
};
|
||||
|
||||
/**
|
||||
* Per-Stage transient bookkeeping for the acting player. Reset when the actor changes.
|
||||
*
|
||||
@@ -908,66 +656,6 @@ export function freshTurns(players: number, moves: number): Map<PlayerIndex, Tur
|
||||
return turns;
|
||||
}
|
||||
|
||||
/** A Tally with everything at zero — the state every game starts in (Gitea#16). */
|
||||
export function emptyTally(players: number): Tally {
|
||||
return {
|
||||
trainsCompleted: 0,
|
||||
trainsCompletedWithWork: 0,
|
||||
trainsDestroyed: 0,
|
||||
carsDestroyed: 0,
|
||||
carsCoupled: 0,
|
||||
carsDropped: 0,
|
||||
loadsStarted: 0,
|
||||
loadsCompleted: 0,
|
||||
unloadsBegun: 0,
|
||||
unloadsCompleted: 0,
|
||||
passengersBoarded: 0,
|
||||
passengersDetrained: 0,
|
||||
flyingSwitches: 0,
|
||||
officeUpgrades: 0,
|
||||
dispatchBonusesUsed: 0,
|
||||
facilitiesUnjammed: 0,
|
||||
expediteFaults: 0,
|
||||
trainsHeld: 0,
|
||||
trainsDiverted: 0,
|
||||
secondSections: 0,
|
||||
extrasStarted: 0,
|
||||
cardsDrawn: 0,
|
||||
cardsPlayed: 0,
|
||||
cardsDiscarded: 0,
|
||||
clearancesRequested: 0,
|
||||
clearancesAllowed: 0,
|
||||
circusStops: [],
|
||||
switchedSince: [],
|
||||
byPlayer: Array.from({ length: players }, () => ({
|
||||
loads: 0,
|
||||
unloads: 0,
|
||||
passengersBoarded: 0,
|
||||
passengersDetrained: 0,
|
||||
cardsPlayed: 0,
|
||||
collisions: 0,
|
||||
revenueGained: 0,
|
||||
revenueLost: 0,
|
||||
})),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* A deep copy, for freezing the official result (`FinalReport`).
|
||||
*
|
||||
* Written out rather than reached for via `structuredClone` because a Tally is a flat bag of numbers
|
||||
* with two containers in it, and spelling the copy out means a field added later that needs deep
|
||||
* copying is a compile error here rather than a shared reference discovered in a results screen.
|
||||
*/
|
||||
export function cloneTally(t: Tally): Tally {
|
||||
return {
|
||||
...t,
|
||||
circusStops: t.circusStops.map((c) => ({ ...c })),
|
||||
switchedSince: [...t.switchedSince],
|
||||
byPlayer: t.byPlayer.map((p) => ({ ...p })),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* WHICH WAY TO DRAW THE ENGINE — east or west, for every train, everywhere.
|
||||
*
|
||||
@@ -1013,25 +701,22 @@ export function standingSides(
|
||||
}
|
||||
|
||||
/**
|
||||
* The cut a train would run into if it left this card by the `exit` END OF THE ROW — the cars
|
||||
* between it and that end. Returned in the order the train MEETS them, nearest first, which is what
|
||||
* `carsCoupled` wants.
|
||||
* The cut a train would run into if it left this card through `exit` — the cars between it and that
|
||||
* end of the card.
|
||||
*
|
||||
* `exit` IS AN END OF THE ROW, NOT A PORT. It used to be a raw `Port`, and answered "you meet
|
||||
* nothing" for north and south on the reasoning that a leg leaving through an edge is not running
|
||||
* along the west-to-east row. It is: a `sw` curve's south leg IS the east end of that row, so a
|
||||
* crew standing on the curve pulled out through the leg and drove away leaving the cars beside it
|
||||
* standing, against §A.4's mandatory coupling (Gitea#17). Callers resolve the leg with `rowEndAt`
|
||||
* (`track.ts`), which lives there because only the card's arc can say which end a leg is — and the
|
||||
* narrowed type is what makes every caller do it.
|
||||
* Only 'e' and 'w' can hold a cut: the array is a west-to-east row, so a train leaving north or
|
||||
* south off a curve or a spur is not running along it and meets nothing. Returned in the order the
|
||||
* train MEETS them, nearest first, which is what `carsCoupled` wants.
|
||||
*/
|
||||
export function cutTowards(
|
||||
tray: { standingWest?: number | undefined },
|
||||
cars: readonly RollingStock[],
|
||||
exit: 'e' | 'w',
|
||||
exit: 'n' | 's' | 'e' | 'w',
|
||||
): RollingStock[] {
|
||||
const { west, east } = standingSides(tray, cars);
|
||||
return exit === 'e' ? east : [...west].reverse();
|
||||
if (exit === 'e') return east;
|
||||
if (exit === 'w') return [...west].reverse();
|
||||
return [];
|
||||
}
|
||||
|
||||
export function turnOf(s: GameState, player: PlayerIndex): TurnState {
|
||||
@@ -1085,15 +770,8 @@ export type GameState = {
|
||||
/**
|
||||
* §7 — Extra Trains played from hand, waiting for a free Crew Tray. An Extra is not scheduled:
|
||||
* it runs once, immediately, then its card goes to the Salvage Yard (§2.3).
|
||||
*
|
||||
* CARRIES WHO PLAYED IT (2026-08-23, Jesse's call). §7 gives an Extra to the player who played the
|
||||
* card — "may place the Crew Tray at either Division Point ... and may load the consist as he
|
||||
* chooses" — which is a different rule from the Timetabled make-up round, where the table goes
|
||||
* round starting at the Superintendent. This was a bare `number[]`, so the engine could not tell
|
||||
* whose Extra it was and asked whoever the acting order happened to be on: correct in solitaire,
|
||||
* where there is only one player, and wrong at every table.
|
||||
*/
|
||||
pendingExtras: { trainNumber: number; player: PlayerIndex }[];
|
||||
pendingExtras: number[];
|
||||
/**
|
||||
* Q9 — train numbers ordered to run a second section. The next New Train Phase makes up an
|
||||
* identical train behind the first, if a Crew Tray is free.
|
||||
@@ -1104,38 +782,10 @@ export type GameState = {
|
||||
turns: Map<PlayerIndex, TurnState>;
|
||||
/** Transient: trains already moved in the current Mainline Phase. Cleared when it ends. */
|
||||
movedThisPhase: Set<TrayId>;
|
||||
/** §3.4 — resets at the start of each Day; checked against `config.maxCollisionsPerDay`. */
|
||||
/** §3.4 — resets at the start of each Day. */
|
||||
collisionsToday: number;
|
||||
/** §3.4 — never reset; checked against `config.maxCollisionsTotal`. */
|
||||
collisionsTotal: number;
|
||||
/**
|
||||
* `awaitingExtension` is Gitea#11: the timetable has run out, the result is recorded, and the
|
||||
* table is being asked whether to play one more Day. It is a PAUSE, not an ending — `advance`
|
||||
* reports `needsInput` there, the server resumes it like any live game, and the only intent the
|
||||
* rules will accept is `game.extend`.
|
||||
*/
|
||||
status: 'setup' | 'active' | 'awaitingExtension' | 'finished';
|
||||
/** The CURRENT evaluation, re-decided at the end of every Day including extended ones. */
|
||||
status: 'setup' | 'active' | 'finished';
|
||||
outcome: Outcome | null;
|
||||
/**
|
||||
* §3.3 (Gitea#11) — Days granted beyond `config.days`, one vote at a time.
|
||||
*
|
||||
* `config.days` is deliberately never touched: it is what the official result was decided at, so
|
||||
* leaving it alone is what makes "the winner is decided at the original game length" a fact about
|
||||
* the code rather than a comment on it.
|
||||
*/
|
||||
extraDays: number;
|
||||
/**
|
||||
* Per PLAYER, while `awaitingExtension`. `null` means they have not voted yet.
|
||||
*
|
||||
* Unanimous, and one refusal is decisive: nobody is made to wait on a player who has already said
|
||||
* no (Jesse's call, 2026-08-28). Solitaire is the same code with one voter.
|
||||
*/
|
||||
extensionVotes: (boolean | null)[];
|
||||
/** Frozen at the FIRST ending and never overwritten. See `FinalReport`. */
|
||||
official: FinalReport | null;
|
||||
/** Gitea#16. Folded from the event stream; see `Tally`. */
|
||||
tally: Tally;
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -1180,40 +830,6 @@ export function playerAtSeat(state: GameState, seat: SeatIndex): PlayerIndex {
|
||||
return p;
|
||||
}
|
||||
|
||||
/** This seat's node on the Division — where its Limits, and any Red Flag on them, live. */
|
||||
export function officeNodeFor(
|
||||
state: GameState,
|
||||
seat: SeatIndex,
|
||||
): Extract<DivisionNode, { kind: 'office' }> | null {
|
||||
for (const n of state.division.nodes) if (n.kind === 'office' && n.seat === seat) return n;
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* WHO MUST ANSWER the interruption, or null when nothing is pending.
|
||||
*
|
||||
* The one place that knows which player each kind of question goes to. §8.1's clearance is the
|
||||
* Superintendent's ruling wherever it happens; the Yard Office is offered to whoever sits in the
|
||||
* district the train is arriving at, because it is their card and their yard.
|
||||
*/
|
||||
export function decisionActor(state: GameState): PlayerIndex | null {
|
||||
const d = state.clock.pendingDecision;
|
||||
if (!d) return null;
|
||||
return d.kind === 'clearance' ? state.clock.superintendent : playerAtSeat(state, d.seat);
|
||||
}
|
||||
|
||||
/**
|
||||
* WHOSE MOVE IT IS RIGHT NOW — a pending interruption's owner if there is one, else the phase's
|
||||
* own actor.
|
||||
*
|
||||
* Written out six times across the engine, the sim, the web client and the tests as
|
||||
* `pendingDecision !== null ? superintendent : currentActor`, which stopped being right the moment
|
||||
* a second kind of question existed. One copy now, so a new decision kind cannot be half-adopted.
|
||||
*/
|
||||
export function actingPlayer(state: GameState): PlayerIndex | null {
|
||||
return decisionActor(state) ?? state.clock.currentActor;
|
||||
}
|
||||
|
||||
/** Where this player is sitting, and therefore which Office Area is theirs. */
|
||||
/**
|
||||
* The player `n` seats to the LEFT of this one, wrapping round the table.
|
||||
|
||||
@@ -1,201 +0,0 @@
|
||||
/**
|
||||
* The event tally — Gitea#16's statistics, folded from the event stream into `GameState.tally`.
|
||||
*
|
||||
* WHERE IT IS HOOKED, and why it is not in `reduce`. `apply.ts`'s `reduce` sees only the events an
|
||||
* INTENT produced; `advance.ts` mutates state directly and pushes its events without reducing them
|
||||
* at all — and `advance` is where `trainCompleted`, `trainsDestroyed` and `trainStoodStill` come
|
||||
* from, which are exactly the numbers this issue asks for. So the fold is hooked at the two places
|
||||
* every event in the game passes through exactly once on its way to a caller:
|
||||
*
|
||||
* - `applyIntent` (`apply.ts`), beside its `reduce` loop;
|
||||
* - `advance` (`advance.ts`), which now wraps the phase driver and folds what it returns.
|
||||
*
|
||||
* Exactly once matters in both directions: an event folded twice inflates a count, and an event
|
||||
* folded nowhere is a statistic that silently reads zero. `test/tally.test.ts` pins both by playing
|
||||
* real games and checking the tally against an independent count over the same event array.
|
||||
*
|
||||
* NOTHING HERE IS A RULE. The tally is read by the results screen and by the badge work Gitea#16
|
||||
* leaves to a second pass; no engine decision consults it. That is what makes adding a counter
|
||||
* always safe.
|
||||
*
|
||||
* WHAT IS NOT COUNTED PER PLAYER, and why. `carsCoupled` and `carsDropped` carry a `trayId` and no
|
||||
* `player` — switching is done BY a crew, and the event says which crew rather than which person.
|
||||
* Rather than guess an owner from whose turn it happened to be, those two are table totals only.
|
||||
* The events that do name a player (`loadCompleted`, `passengersBoarded`, `cardPlayed`,
|
||||
* `revenueChanged`, `trainsDestroyed`) are the ones `byPlayer` reports.
|
||||
*/
|
||||
|
||||
import type { GameEvent } from './events.ts';
|
||||
import type { GameState } from './state.ts';
|
||||
|
||||
/**
|
||||
* Fold one event into `s.tally`.
|
||||
*
|
||||
* The switch is deliberately not exhaustive — most of the 49 event types say nothing a player would
|
||||
* want counted, and listing them all to `break` would bury the ones that do. A `default` that does
|
||||
* nothing is the honest shape.
|
||||
*/
|
||||
export function tallyEvent(s: GameState, e: GameEvent): void {
|
||||
const t = s.tally;
|
||||
const mine = 'player' in e && typeof e.player === 'number' ? t.byPlayer[e.player] : undefined;
|
||||
|
||||
switch (e.type) {
|
||||
/**
|
||||
* §X18 — the Circus train set up and was paid for the Stage it spent standing.
|
||||
*
|
||||
* NOT a "longest stand" streak, which is what Gitea#16 wants and what its comment assumed this
|
||||
* event was. It fires once in a game per such train: only trains whose profile sets
|
||||
* `stopEarnsPoint` emit it at all, and `advance.ts` claims it once with `stopPointClaimed`. So
|
||||
* there is nothing to count a run of, and the honest thing to report is the event itself.
|
||||
*/
|
||||
case 'trainStoodStill':
|
||||
t.circusStops.push({ trainNumber: e.trainNumber, where: e.where });
|
||||
break;
|
||||
|
||||
/**
|
||||
* DID THIS TRAIN DO ANY SWITCHING — Gitea#16's "switching master" join, kept as it happens
|
||||
* rather than reconstructed afterwards.
|
||||
*
|
||||
* The two halves of the join are in different currencies: switching events name a `trayId` and
|
||||
* completion names a `trainNumber`, and no event carries both. The tray is looked up in LIVE
|
||||
* state, which is sound precisely here — a crew that has just coupled or dropped is still on the
|
||||
* board — where re-deriving it at completion time would not be, the tray having been released by
|
||||
* then. A lookup that misses costs one train its mark on a statistic; it cannot affect a rule.
|
||||
*/
|
||||
case 'carsCoupled':
|
||||
t.carsCoupled += e.stock.length;
|
||||
markSwitched(s, e.trayId);
|
||||
break;
|
||||
|
||||
case 'carsDropped':
|
||||
t.carsDropped += e.stock.length;
|
||||
markSwitched(s, e.trayId);
|
||||
break;
|
||||
|
||||
case 'flyingSwitch':
|
||||
t.flyingSwitches += 1;
|
||||
markSwitched(s, e.trayId);
|
||||
break;
|
||||
|
||||
// A tray is reused run after run, so a fresh train starts with a clean sheet.
|
||||
case 'trainMadeUp':
|
||||
t.switchedSince = t.switchedSince.filter((n) => n !== e.trainNumber);
|
||||
break;
|
||||
|
||||
case 'trainCompleted':
|
||||
t.trainsCompleted += 1;
|
||||
if (t.switchedSince.includes(e.trainNumber)) t.trainsCompletedWithWork += 1;
|
||||
t.switchedSince = t.switchedSince.filter((n) => n !== e.trainNumber);
|
||||
break;
|
||||
|
||||
case 'trainsDestroyed':
|
||||
t.trainsDestroyed += e.trains.length;
|
||||
for (const train of e.trains) t.carsDestroyed += train.consist.length;
|
||||
if (mine) mine.collisions += 1;
|
||||
break;
|
||||
|
||||
case 'officeUpgraded':
|
||||
t.officeUpgrades += 1;
|
||||
break;
|
||||
|
||||
case 'dispatchBonusUsed':
|
||||
t.dispatchBonusesUsed += 1;
|
||||
break;
|
||||
|
||||
case 'facilityUnjammed':
|
||||
t.facilitiesUnjammed += 1;
|
||||
break;
|
||||
|
||||
case 'expediteFault':
|
||||
t.expediteFaults += 1;
|
||||
break;
|
||||
|
||||
case 'trainHeld':
|
||||
t.trainsHeld += 1;
|
||||
break;
|
||||
|
||||
case 'trainDiverted':
|
||||
t.trainsDiverted += 1;
|
||||
break;
|
||||
|
||||
case 'secondSectionOrdered':
|
||||
t.secondSections += 1;
|
||||
break;
|
||||
|
||||
case 'extraStarted':
|
||||
t.extrasStarted += 1;
|
||||
break;
|
||||
|
||||
case 'cardDrawn':
|
||||
t.cardsDrawn += 1;
|
||||
break;
|
||||
|
||||
case 'cardPlayed':
|
||||
t.cardsPlayed += 1;
|
||||
if (mine) mine.cardsPlayed += 1;
|
||||
break;
|
||||
|
||||
case 'cardDiscarded':
|
||||
t.cardsDiscarded += 1;
|
||||
break;
|
||||
|
||||
case 'clearanceRequested':
|
||||
t.clearancesRequested += 1;
|
||||
break;
|
||||
|
||||
// §8.1 — a ruling is given either way; only a YES let the other train through.
|
||||
case 'clearanceGiven':
|
||||
if (e.allow) t.clearancesAllowed += 1;
|
||||
break;
|
||||
|
||||
case 'loadStarted':
|
||||
t.loadsStarted += 1;
|
||||
break;
|
||||
|
||||
case 'loadCompleted':
|
||||
t.loadsCompleted += 1;
|
||||
if (mine) mine.loads += 1;
|
||||
break;
|
||||
|
||||
case 'unloadBegan':
|
||||
t.unloadsBegun += 1;
|
||||
break;
|
||||
|
||||
case 'unloadCompleted':
|
||||
t.unloadsCompleted += 1;
|
||||
if (mine) mine.unloads += 1;
|
||||
break;
|
||||
|
||||
case 'passengersBoarded':
|
||||
t.passengersBoarded += 1;
|
||||
if (mine) mine.passengersBoarded += 1;
|
||||
break;
|
||||
|
||||
case 'passengersDetrained':
|
||||
t.passengersDetrained += 1;
|
||||
if (mine) mine.passengersDetrained += 1;
|
||||
break;
|
||||
|
||||
/**
|
||||
* Gained and lost are kept APART because the net is already on `players[i].revenue`. What the
|
||||
* results screen cannot otherwise say is how much of a modest final score was earned and then
|
||||
* handed back at a grade crossing — which is the whole difference between a quiet game and an
|
||||
* eventful one.
|
||||
*/
|
||||
case 'revenueChanged':
|
||||
if (mine) {
|
||||
if (e.delta >= 0) mine.revenueGained += e.delta;
|
||||
else mine.revenueLost += -e.delta;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
function markSwitched(s: GameState, trayId: string): void {
|
||||
const n = s.trays.get(trayId)?.trainNumber;
|
||||
if (n === undefined || n === null) return;
|
||||
if (!s.tally.switchedSince.includes(n)) s.tally.switchedSince.push(n);
|
||||
}
|
||||
+9
-73
@@ -188,40 +188,6 @@ export function joins(a: TrackCard, p: Port, b: TrackCard): boolean {
|
||||
return slopeAt(a, p) === slopeAt(b, opposite(p));
|
||||
}
|
||||
|
||||
/**
|
||||
* WHICH END OF THE WEST-TO-EAST ROW A PORT SITS AT.
|
||||
*
|
||||
* `TrackCard.standing` is ordered west to east (§A.3), so whether a train meets the row front to
|
||||
* back or back to front depends on which end it enters by — and a port is not always at one of
|
||||
* those two extremes. Every 45° leg leaves through the MIDDLE of its north or south edge, so its
|
||||
* end of the run is whichever end the arc does NOT reach: a `sw` curve's south leg is the EAST end
|
||||
* of the row, and an `se` curve's south leg is the WEST end. Same port, opposite answers, which is
|
||||
* why this has to ask the card rather than read the port.
|
||||
*
|
||||
* Gitea#17 is what both callers looked like without it. `exploreMoves` reversed the row for an 'e'
|
||||
* entry and for nothing else, so backing into a cut through a `sw` curve's south leg coupled it up
|
||||
* back to front — the caboose came out next to the engine, which §8.2 then calls badly made up.
|
||||
* `cutTowards` answered "you meet nothing" for a north or south exit, so a crew standing on a curve
|
||||
* pulled out through the leg and left the cars beside it standing, which §A.4 forbids.
|
||||
*
|
||||
* There is no north-south straight anywhere on the printed sheet (see the module comment), so a run
|
||||
* touching a 45° leg always has an east or west port at its other end and the answer is never
|
||||
* undefined. A TURNOUT is the one card whose row has three ends rather than two — and it is also
|
||||
* the one card no cut can ever stand on, since a train may not stop there (§A.1) and so never sets
|
||||
* anything out there. Its stem answers for it.
|
||||
*/
|
||||
export function rowEndAt(card: TrackCard, p: Port): 'e' | 'w' {
|
||||
if (p === 'e' || p === 'w') return p;
|
||||
for (const [a, b] of connectionsFor(card)) {
|
||||
const other = a === p ? b : b === p ? a : null;
|
||||
if (other === 'e') return 'w';
|
||||
if (other === 'w') return 'e';
|
||||
}
|
||||
// Not a card the printed sheet can produce. Reading the leg as the west end leaves the row in the
|
||||
// order it is stored rather than inventing a reversal on a card nothing knows the shape of.
|
||||
return 'w';
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Orientation (Gap 11)
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -484,7 +450,7 @@ export function exploreMoves(
|
||||
*
|
||||
* Ordered nearest-first like every other card's, so it simply seeds the accumulator.
|
||||
*/
|
||||
const ownCut = cutTowards(startCard, carsOn(startCard), rowEndAt(startCard, initialExit));
|
||||
const ownCut = cutTowards(startCard, carsOn(startCard), initialExit);
|
||||
const startKey = coordKey(start);
|
||||
const queue: Frontier[] = [
|
||||
{
|
||||
@@ -536,15 +502,12 @@ export function exploreMoves(
|
||||
* overfill the tray is illegal, not a move that picks up fewer cars.
|
||||
*
|
||||
* NEAREST FIRST ALONG THE DIRECTION OF TRAVEL. `carsOn` runs west to east, so a train entering
|
||||
* at the row's EAST end meets them back to front and the row has to be reversed. Without this
|
||||
* the same parked cut produced an identical consist whichever way it was approached, when the
|
||||
* two must mirror — which is the difference between a run-around being worth a Move and being
|
||||
* pointless.
|
||||
*
|
||||
* `rowEndAt` rather than `node.entry === 'e'`: a 45° leg is an end of the row too, and which
|
||||
* end it is depends on the card's arc (Gitea#17).
|
||||
* through the card's EAST port meets them back to front and the row has to be reversed. Without
|
||||
* this the same parked cut produced an identical consist whichever way it was approached, when
|
||||
* the two must mirror — which is the difference between a run-around being worth a Move and
|
||||
* being pointless.
|
||||
*/
|
||||
const met = rowEndAt(card, node.entry) === 'e' ? [...carsOn(card)].reverse() : carsOn(card);
|
||||
const met = node.entry === 'e' ? [...carsOn(card)].reverse() : carsOn(card);
|
||||
const couples = [...node.couples, ...met];
|
||||
const nodeKey = coordKey(node.coord);
|
||||
const origins = [...node.origins, ...met.map(() => nodeKey)];
|
||||
@@ -695,26 +658,6 @@ export function canPlaceAt(area: OfficeArea, coord: GridCoord, card: TrackCard):
|
||||
// into a stub and cutting the Office off from the Limits.
|
||||
if (coord.row === area.runningRow && !carriesThroughTrack(card)) return false;
|
||||
|
||||
/**
|
||||
* ONE NEIGHBOUR MUST JOIN. THE OTHERS NEED NOT — AND THIS RULE HAS BEEN BOTH WAYS (Gitea#15).
|
||||
*
|
||||
* A card may be laid with an exit facing a card that has nothing to meet it. The rail stops dead
|
||||
* at that edge, and that is legal.
|
||||
*
|
||||
* The issue was filed the other way round — "if a card is placed in that space, it MUST connect" —
|
||||
* against a right-hand curve laid with its north leg against an Ice House and the turnout below it
|
||||
* pointing at its portless south edge. **RAR reversed it on review (2026-08-26): placing it is
|
||||
* fine, and a stub like that is useful — a siding to park cars on.**
|
||||
*
|
||||
* WHAT MATTERS INSTEAD IS THAT NOTHING CAN DRIVE ACROSS THE GAP, so the real requirement is on
|
||||
* MOVEMENT rather than on placement: two cards touching are not connected, and `exploreMoves` must
|
||||
* refuse the hop. It does — every step is gated on `joins`, never on a bare pair of `hasPort`
|
||||
* calls — and `track.test.ts` pins the reported geometry against exactly that.
|
||||
*
|
||||
* SO DO NOT ADD A PER-EDGE CHECK HERE. One was written and taken out again when the ruling
|
||||
* arrived. What survives is the weaker rule that was always here: the piece must touch the network
|
||||
* SOMEWHERE, which is what stops orphaned track being laid in an empty corner of the board.
|
||||
*/
|
||||
const ports: Port[] = ['n', 's', 'e', 'w'];
|
||||
for (const p of ports) {
|
||||
const neighbourCard = cardAt(area, neighbour(coord, p));
|
||||
@@ -724,19 +667,12 @@ export function canPlaceAt(area: OfficeArea, coord: GridCoord, card: TrackCard):
|
||||
}
|
||||
|
||||
/**
|
||||
* §A.4 — the Office track is Operational Rail, but Rolling Stock may not be left there — WITH ONE
|
||||
* EXCEPTION (Jesse's call, v0.5.0): any train may set out one or more coaches at the Office. It is
|
||||
* the one car type a passenger platform is meant to hold, and it is what makes the ENGINE-boxcar-
|
||||
* coach Local arrangement workable — the coach drops here while the engine and freight car switch
|
||||
* freely. Freight and cabooses stay banned at the Office for every train, no exception.
|
||||
*
|
||||
* §A.4 — the Office track is Operational Rail, but Rolling Stock may not be left there.
|
||||
* An industry track also has a finite length (§9.3), so it can be full.
|
||||
*/
|
||||
export function canDropCarsAt(area: OfficeArea, coord: GridCoord, count = 1, coachesOnly = false): boolean {
|
||||
export function canDropCarsAt(area: OfficeArea, coord: GridCoord, count = 1): boolean {
|
||||
if (sameCoord(coord, area.officeCoord)) return false;
|
||||
const card = cardAt(area, coord);
|
||||
if (sameCoord(coord, area.officeCoord)) {
|
||||
return coachesOnly && !!card && isOperationalRail(card) && spaceOn(card) >= count;
|
||||
}
|
||||
if (!card || !isOperationalRail(card)) return false;
|
||||
return spaceOn(card) >= count;
|
||||
}
|
||||
|
||||
@@ -1,710 +0,0 @@
|
||||
/**
|
||||
* The HTTP/SSE wiring — Phase 2 of `docs/architecture/multiplayer.md` (§8-9, §12 steps 8 and 12),
|
||||
* extended for Phase 4 (§12 steps 17-20) to a lobby and more than one game.
|
||||
*
|
||||
* Plain `node:http`, no framework: the project has zero runtime dependencies
|
||||
* (`package.json`), and `scripts/build-web.ts` already shells out to `tsc` directly rather than
|
||||
* reaching for a bundler — this matches that everywhere-else choice rather than introducing the
|
||||
* first framework dependency for one route table.
|
||||
*
|
||||
* All the game logic lives in `session.ts` and `lobby.ts`; this file is deliberately thin — routing,
|
||||
* the join-secret gate on the DOOR (create/join), token resolution once a player is through it, SSE
|
||||
* mechanics, and static file serving for the built client (`dist/`, D16: the server serves the
|
||||
* client, which is what makes same-origin work with no CORS).
|
||||
*
|
||||
* TOKENS REPLACE `?seat=&secret=` ON THE RUNNING-GAME ROUTES. `lobby-and-sessions.md` §1: the token
|
||||
* already proves "I am the player who was in this game," which is the only identity claim `/api/stream`
|
||||
* and `/api/intent` need — the join secret's job ends at the lobby door.
|
||||
*/
|
||||
|
||||
import { createServer } from 'node:http';
|
||||
import type { IncomingMessage, ServerResponse } from 'node:http';
|
||||
import { createReadStream } from 'node:fs';
|
||||
import { stat } from 'node:fs/promises';
|
||||
import { extname, join, normalize } from 'node:path';
|
||||
|
||||
import type { Intent } from '../engine/intents.ts';
|
||||
import type { GameConfig, PlayerIndex } from '../engine/state.ts';
|
||||
import {
|
||||
appendTiming,
|
||||
deleteGame,
|
||||
deleteLobby,
|
||||
gameDir,
|
||||
readIndex,
|
||||
removeIndexEntry,
|
||||
upsertIndexEntry,
|
||||
writeGame,
|
||||
writeLobby,
|
||||
writeSessions,
|
||||
} from './persistence.ts';
|
||||
import { createSession } from './session.ts';
|
||||
import type { GameSession, Push } from './session.ts';
|
||||
import {
|
||||
createLobby,
|
||||
leaveLobby,
|
||||
freshGameCode,
|
||||
playerCountAllowed,
|
||||
joinLobby,
|
||||
reassignHost,
|
||||
setBotSeat,
|
||||
startLobby,
|
||||
} from './lobby.ts';
|
||||
import type { Lobby, PlayerSession } from './lobby.ts';
|
||||
|
||||
export type ServerOptions = {
|
||||
port: number;
|
||||
bindAddress: string;
|
||||
/** D14 — a server-wide secret, passed out of band. Gates lobby creation and joining — the door;
|
||||
* once a player is through it and holds a token, the token alone authenticates them. */
|
||||
joinSecret: string;
|
||||
/** The built client (`npm run build:web`'s `dist/`), served at `/` (D16). */
|
||||
distDir: string;
|
||||
/** Where every game's files live, one subdirectory per `gameId` (`persistence.ts`'s `gameDir`). */
|
||||
dataDir: string;
|
||||
/** `package.json`'s version — stamped onto every write, checked on every load (§12 step 15). */
|
||||
engineVersion: string;
|
||||
/**
|
||||
* Gates the administrative routes — listing, exporting and deleting games — and is DELIBERATELY
|
||||
* not the join secret. Every player holds that one, so gating a delete with it would let anyone
|
||||
* at the table destroy anyone else's game. This is held by whoever runs the server and nobody
|
||||
* else. When it is unset the admin routes do not exist at all (404, the same answer as any other
|
||||
* unknown path), so a server that was never given one cannot be administered by guessing.
|
||||
*/
|
||||
adminSecret?: string | undefined;
|
||||
/** Reconstructed by `index.ts`'s load-on-start. Empty maps for a fresh server. */
|
||||
initialGames: Map<string, GameSession>;
|
||||
initialLobbies: Map<string, Lobby>;
|
||||
initialSessions: Map<string, PlayerSession>;
|
||||
};
|
||||
|
||||
const MIME: Record<string, string> = {
|
||||
'.html': 'text/html; charset=utf-8',
|
||||
'.js': 'text/javascript; charset=utf-8',
|
||||
'.css': 'text/css; charset=utf-8',
|
||||
'.json': 'application/json; charset=utf-8',
|
||||
'.png': 'image/png',
|
||||
'.svg': 'image/svg+xml',
|
||||
};
|
||||
|
||||
const HEARTBEAT_MS = 20_000;
|
||||
|
||||
async function readJson(req: IncomingMessage): Promise<unknown> {
|
||||
const chunks: Buffer[] = [];
|
||||
for await (const chunk of req) chunks.push(chunk as Buffer);
|
||||
const text = Buffer.concat(chunks).toString('utf8');
|
||||
return text.trim() === '' ? {} : JSON.parse(text);
|
||||
}
|
||||
|
||||
function sendJson(res: ServerResponse, status: number, body: unknown): void {
|
||||
const text = JSON.stringify(body);
|
||||
res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Content-Length': Buffer.byteLength(text) });
|
||||
res.end(text);
|
||||
}
|
||||
|
||||
async function serveStatic(distDir: string, urlPath: string, res: ServerResponse): Promise<void> {
|
||||
const rel = urlPath === '/' ? '/index.html' : urlPath;
|
||||
// `normalize` collapses `..`, and the join is then checked to still be inside `distDir` — a request
|
||||
// for `/../../etc/passwd` must not escape the one directory this is allowed to read from.
|
||||
const full = join(distDir, normalize(rel));
|
||||
if (!full.startsWith(distDir)) {
|
||||
sendJson(res, 400, { error: 'bad path' });
|
||||
return;
|
||||
}
|
||||
try {
|
||||
const info = await stat(full);
|
||||
if (!info.isFile()) throw new Error('not a file');
|
||||
res.writeHead(200, { 'Content-Type': MIME[extname(full)] ?? 'application/octet-stream', 'Content-Length': info.size });
|
||||
createReadStream(full).pipe(res);
|
||||
} catch {
|
||||
res.writeHead(404, { 'Content-Type': 'text/plain' });
|
||||
res.end('not found');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* What a lobby SSE push carries — the whole `Lobby`, since the seat list is small and a delta
|
||||
* mechanism buys nothing at this size (`session.ts`'s `Push` deltas the BOARD, which is not this).
|
||||
*
|
||||
* `started` rides on the FINAL push of a lobby's life, sent the instant before the connection is
|
||||
* closed at `Lobby.Start` — without it, the client's only signal that the game began is the stream
|
||||
* simply ending, indistinguishable from a network hiccup that `EventSource` would otherwise retry.
|
||||
*/
|
||||
type LobbyPush = { lobby: Lobby; you: PlayerIndex; started: boolean };
|
||||
/** What `/api/lobby/preview` answers with — everything a player weighing a join needs, and nothing
|
||||
* that would spoil the game. THE SEED IS NOT IN IT: it decides every shuffle and every roll. */
|
||||
type LobbyPreview = {
|
||||
gameCode: string;
|
||||
hostName: string;
|
||||
config: GameConfig;
|
||||
players: number;
|
||||
seated: { seat: number; who: string | null; bot: boolean }[];
|
||||
};
|
||||
|
||||
export function startServer(opts: ServerOptions): void {
|
||||
const games = opts.initialGames;
|
||||
const lobbies = opts.initialLobbies;
|
||||
const sessions = opts.initialSessions;
|
||||
const gameCodes = new Map<string, string>(); // gameCode -> gameId, for /api/lobby/join
|
||||
for (const [gameId, lobby] of lobbies) gameCodes.set(lobby.gameCode, gameId);
|
||||
|
||||
// One open SSE response per (gameId, seat) for a running game, and per (gameId, token) for a
|
||||
// lobby still being seated — a second connection from the same seat/token replaces the first
|
||||
// rather than fanning out to both (no concept yet of "the same seat from two tabs").
|
||||
const gameConnections = new Map<string, Map<PlayerIndex, ServerResponse>>();
|
||||
const gameEventIds = new Map<string, Map<PlayerIndex, number>>();
|
||||
const lobbyConnections = new Map<string, Map<string, ServerResponse>>();
|
||||
/** Which seats of a game have ever held a connection in THIS process — see `presenceOfOthers`. */
|
||||
const everConnected = new Map<string, Set<PlayerIndex>>();
|
||||
|
||||
function writeSse(res: ServerResponse, id: number, data: unknown): void {
|
||||
res.write(`id: ${id}\ndata: ${JSON.stringify(data)}\n\n`);
|
||||
}
|
||||
|
||||
function nextEventId(gameId: string, seat: PlayerIndex): number {
|
||||
const ids = gameEventIds.get(gameId) ?? new Map<PlayerIndex, number>();
|
||||
const id = (ids.get(seat) ?? 0) + 1;
|
||||
ids.set(seat, id);
|
||||
gameEventIds.set(gameId, ids);
|
||||
return id;
|
||||
}
|
||||
|
||||
function broadcastGame(gameId: string, pushes: Map<PlayerIndex, Push>): void {
|
||||
const conns = gameConnections.get(gameId);
|
||||
if (!conns) return;
|
||||
for (const [seat, push] of pushes) {
|
||||
const res = conns.get(seat);
|
||||
if (res) writeSse(res, nextEventId(gameId, seat), push);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Presence is transport-layer news about a CONNECTION, never a `GameEvent` — it does not go
|
||||
* through `session.ts` at all (`lobby-and-sessions.md` §5). Sent to every OTHER currently
|
||||
* connected seat of the same game as a presence-only push (an empty board delta, no menu, no new
|
||||
* lines) rather than inventing a second SSE event type — one message shape for the client to parse.
|
||||
*/
|
||||
function broadcastPresence(gameId: string, seat: PlayerIndex, connected: boolean): void {
|
||||
const conns = gameConnections.get(gameId);
|
||||
if (!conns) return;
|
||||
for (const [other, res] of conns) {
|
||||
if (other === seat) continue;
|
||||
const push: Push = { menu: null, lines: [], presence: [{ seat, connected, seen: true }] };
|
||||
writeSse(res, nextEventId(gameId, other), push);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EVERY OTHER SEAT'S STATE, for a client that has just connected.
|
||||
*
|
||||
* `broadcastPresence` only ever reports a CHANGE, so a player arriving at a table where two people
|
||||
* had not opened the game yet was told nothing about them at all — and "is everyone here?" is the
|
||||
* question at the moment a game starts. `seen` separates a seat that was here and dropped from one
|
||||
* that has never connected; it is remembered only for as long as this process runs, so after a
|
||||
* restart every absent seat reads as "not here yet", which is the more cautious of the two.
|
||||
*/
|
||||
function presenceOfOthers(
|
||||
gameId: string,
|
||||
seat: PlayerIndex,
|
||||
session: GameSession,
|
||||
): NonNullable<Push['presence']> {
|
||||
const conns = gameConnections.get(gameId);
|
||||
const ever = everConnected.get(gameId) ?? new Set<PlayerIndex>();
|
||||
const out: NonNullable<Push['presence']> = [];
|
||||
for (let other = 0 as PlayerIndex; other < session.playerCount; other++) {
|
||||
// A bot holds no connection and never will, so reporting it would put "waiting on Bot 1 — not
|
||||
// here yet" on every screen for the whole game. Found by playing a real 3-seat game.
|
||||
if (other === seat || session.isBot(other)) continue;
|
||||
out.push({ seat: other, connected: conns?.has(other) === true, seen: ever.has(other) });
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function broadcastLobby(gameId: string): void {
|
||||
const lobby = lobbies.get(gameId);
|
||||
const conns = lobbyConnections.get(gameId);
|
||||
if (!lobby || !conns) return;
|
||||
for (const [token, res] of conns) {
|
||||
const ps = sessions.get(token);
|
||||
if (!ps) continue;
|
||||
writeSse(res, 0, { lobby, you: ps.player, started: false } satisfies LobbyPush);
|
||||
}
|
||||
}
|
||||
|
||||
async function persistLobby(lobby: Lobby): Promise<void> {
|
||||
lobbies.set(lobby.gameId, lobby);
|
||||
gameCodes.set(lobby.gameCode, lobby.gameId);
|
||||
await writeLobby(opts.dataDir, lobby);
|
||||
await upsertIndexEntry(opts.dataDir, { gameId: lobby.gameId, gameCode: lobby.gameCode, status: 'lobby' });
|
||||
}
|
||||
|
||||
async function persistSession(ps: PlayerSession): Promise<void> {
|
||||
sessions.set(ps.token, ps);
|
||||
const all = [...sessions.values()].filter((s) => s.gameId === ps.gameId);
|
||||
await writeSessions(opts.dataDir, ps.gameId, all);
|
||||
}
|
||||
|
||||
const server = createServer((req, res) => {
|
||||
void (async () => {
|
||||
const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
|
||||
|
||||
// -- Is anyone home? --------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* THE ONE ROUTE THAT EXISTS TO BE FAILED.
|
||||
*
|
||||
* The same `dist/` is served two ways: by this server, and as a plain static upload with no
|
||||
* server behind it at all (`scripts/deploy-web.ts`). The bundle is byte-identical either way
|
||||
* — one client, mode decided at runtime (D4) — so the page cannot know from its own build
|
||||
* which it is, and every other route here answers a 404 for a path it does not have, exactly
|
||||
* as a static host would. Nothing distinguished them until this did.
|
||||
*
|
||||
* Unauthenticated on purpose: it says only that a Station Master server is answering, which
|
||||
* is what the client is about to offer the player anyway. It reveals no game and no seat.
|
||||
*/
|
||||
if (url.pathname === '/api/health' && req.method === 'GET') {
|
||||
// `summary()` rather than `exportSave()`: this is polled on a timer, and the save copies
|
||||
// every intent of every game to answer a question about none of them.
|
||||
let active = 0;
|
||||
for (const g of games.values()) if (g.summary().status === 'active') active++;
|
||||
sendJson(res, 200, {
|
||||
ok: true,
|
||||
service: 'station-master',
|
||||
engineVersion: opts.engineVersion,
|
||||
games: { active, lobby: lobbies.size },
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// -- Administration: listing, exporting and deleting games ------------------------------
|
||||
|
||||
if (url.pathname === '/api/games' || url.pathname.startsWith('/api/games/')) {
|
||||
// Unset means the routes are not here — indistinguishable from any other unknown path, so
|
||||
// nothing advertises an administrative surface to someone probing for one.
|
||||
if (!opts.adminSecret) {
|
||||
await serveStatic(opts.distDir, url.pathname, res);
|
||||
return;
|
||||
}
|
||||
if (req.headers['x-admin-secret'] !== opts.adminSecret) {
|
||||
sendJson(res, 403, { error: 'bad or missing admin secret' });
|
||||
return;
|
||||
}
|
||||
|
||||
const codes = new Map((await readIndex(opts.dataDir)).map((e) => [e.gameId, e.gameCode]));
|
||||
|
||||
if (url.pathname === '/api/games' && req.method === 'GET') {
|
||||
const running = [...games.entries()].map(([gameId, g]) => ({
|
||||
gameId,
|
||||
gameCode: codes.get(gameId) ?? null,
|
||||
state: 'running' as const,
|
||||
...g.summary(),
|
||||
}));
|
||||
// A lobby has no game to summarize yet — it is reported as what it is, so an
|
||||
// administrator sees a table that never started rather than nothing at all.
|
||||
const waiting = [...lobbies.values()].map((l) => ({
|
||||
gameId: l.gameId,
|
||||
gameCode: l.gameCode,
|
||||
state: 'lobby' as const,
|
||||
playerCount: l.seats.length,
|
||||
playerNames: l.seats.map((seat) =>
|
||||
seat === null ? '(empty)' : seat.kind === 'bot' ? 'Bot' : seat.displayName,
|
||||
),
|
||||
createdAt: l.createdAt,
|
||||
}));
|
||||
sendJson(res, 200, { games: [...running, ...waiting] });
|
||||
return;
|
||||
}
|
||||
|
||||
const match = /^\/api\/games\/([^/]+)(\/save)?$/.exec(url.pathname);
|
||||
const gameId = match?.[1];
|
||||
if (!gameId) {
|
||||
sendJson(res, 404, { error: 'no such route' });
|
||||
return;
|
||||
}
|
||||
|
||||
if (match?.[2] && req.method === 'GET') {
|
||||
const session = games.get(gameId);
|
||||
if (!session) {
|
||||
sendJson(res, 404, { error: 'no such game' });
|
||||
return;
|
||||
}
|
||||
sendJson(res, 200, { gameCode: codes.get(gameId) ?? null, save: session.exportSave() });
|
||||
return;
|
||||
}
|
||||
|
||||
if (req.method === 'DELETE') {
|
||||
const session = games.get(gameId);
|
||||
const lobby = lobbies.get(gameId);
|
||||
if (!session && !lobby) {
|
||||
sendJson(res, 404, { error: 'no such game' });
|
||||
return;
|
||||
}
|
||||
// The save goes back with the deletion, so a game can never be destroyed without its
|
||||
// record being handed to whoever destroyed it — the intents ARE the game (D5), so this
|
||||
// is the whole thing, replayable later, not a summary of it.
|
||||
const save = session?.exportSave() ?? null;
|
||||
|
||||
// Everyone watching is told the game is gone before its files are, rather than being
|
||||
// left on a stream that will never push again.
|
||||
for (const [, watcher] of gameConnections.get(gameId) ?? []) watcher.end();
|
||||
gameConnections.delete(gameId);
|
||||
for (const [, watcher] of lobbyConnections.get(gameId) ?? []) watcher.end();
|
||||
lobbyConnections.delete(gameId);
|
||||
|
||||
games.delete(gameId);
|
||||
lobbies.delete(gameId);
|
||||
gameEventIds.delete(gameId);
|
||||
const code = lobby?.gameCode ?? codes.get(gameId);
|
||||
if (code) gameCodes.delete(code);
|
||||
for (const [token, ps] of [...sessions]) if (ps.gameId === gameId) sessions.delete(token);
|
||||
|
||||
await removeIndexEntry(opts.dataDir, gameId);
|
||||
await deleteGame(opts.dataDir, gameId);
|
||||
sendJson(res, 200, { ok: true, gameCode: code ?? null, save });
|
||||
return;
|
||||
}
|
||||
|
||||
sendJson(res, 405, { error: 'method not allowed' });
|
||||
return;
|
||||
}
|
||||
|
||||
// -- Lobby: creating and joining (the door — join-secret gated) --------------------------
|
||||
|
||||
if (url.pathname === '/api/lobby/create' && req.method === 'POST') {
|
||||
const body = (await readJson(req)) as {
|
||||
secret?: string;
|
||||
config?: GameConfig;
|
||||
displayName?: string;
|
||||
players?: number;
|
||||
seed?: number | null;
|
||||
};
|
||||
if (body.secret !== opts.joinSecret) {
|
||||
sendJson(res, 403, { error: 'bad or missing secret' });
|
||||
return;
|
||||
}
|
||||
if (!body.config || typeof body.displayName !== 'string' || body.displayName.trim() === '') {
|
||||
sendJson(res, 400, { error: 'expected { secret, config, displayName, players }' });
|
||||
return;
|
||||
}
|
||||
// The table size is the host's to choose and is fixed from here on, so it is validated at
|
||||
// the door rather than at Start — `createLobby` builds the seats array from it.
|
||||
const players = body.players ?? 0;
|
||||
if (!Number.isInteger(players) || !playerCountAllowed(body.config.mode, players)) {
|
||||
sendJson(res, 400, { error: 'BAD_PLAYER_COUNT' });
|
||||
return;
|
||||
}
|
||||
const gameCode = freshGameCode((code) => gameCodes.has(code));
|
||||
const seed = typeof body.seed === 'number' && Number.isFinite(body.seed) ? Math.trunc(body.seed) : null;
|
||||
const { lobby, session } = createLobby(body.config, body.displayName.trim(), gameCode, players, seed);
|
||||
await persistLobby(lobby);
|
||||
await persistSession(session);
|
||||
sendJson(res, 200, { gameId: lobby.gameId, gameCode: lobby.gameCode, token: session.token, player: session.player });
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/lobby/join' && req.method === 'POST') {
|
||||
const body = (await readJson(req)) as { secret?: string; gameCode?: string; displayName?: string };
|
||||
if (body.secret !== opts.joinSecret) {
|
||||
sendJson(res, 403, { error: 'bad or missing secret' });
|
||||
return;
|
||||
}
|
||||
if (typeof body.gameCode !== 'string' || typeof body.displayName !== 'string' || body.displayName.trim() === '') {
|
||||
sendJson(res, 400, { error: 'expected { secret, gameCode, displayName }' });
|
||||
return;
|
||||
}
|
||||
const gameId = gameCodes.get(body.gameCode.trim().toUpperCase());
|
||||
const lobby = gameId ? lobbies.get(gameId) : undefined;
|
||||
if (!lobby) {
|
||||
// A game code that already started is no longer in `lobbies` at all — same NOT_FOUND a
|
||||
// typo gets, which tells a latecomer "that game is gone" without leaking which case it was.
|
||||
sendJson(res, 404, { error: 'no open lobby with that code' });
|
||||
return;
|
||||
}
|
||||
const result = joinLobby(lobby, body.displayName.trim());
|
||||
if (!result.ok) {
|
||||
sendJson(res, 409, { error: result.code });
|
||||
return;
|
||||
}
|
||||
await persistLobby(result.lobby);
|
||||
await persistSession(result.session);
|
||||
broadcastLobby(lobby.gameId);
|
||||
sendJson(res, 200, {
|
||||
gameId: lobby.gameId,
|
||||
gameCode: lobby.gameCode,
|
||||
token: result.session.token,
|
||||
player: result.session.player,
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// -- Lobby: seating, once inside (token-authenticated) ------------------------------------
|
||||
|
||||
if (url.pathname === '/api/lobby/bot' && req.method === 'POST') {
|
||||
const body = (await readJson(req)) as { token?: string; seat?: number; filled?: boolean };
|
||||
const ps = typeof body.token === 'string' ? sessions.get(body.token) : undefined;
|
||||
const lobby = ps ? lobbies.get(ps.gameId) : undefined;
|
||||
if (!ps || !lobby) {
|
||||
sendJson(res, 404, { error: 'no such lobby' });
|
||||
return;
|
||||
}
|
||||
if (lobby.hostToken !== ps.token) {
|
||||
sendJson(res, 403, { error: 'NOT_HOST' });
|
||||
return;
|
||||
}
|
||||
if (typeof body.seat !== 'number' || typeof body.filled !== 'boolean') {
|
||||
sendJson(res, 400, { error: 'expected { token, seat, filled }' });
|
||||
return;
|
||||
}
|
||||
const updated = setBotSeat(lobby, body.seat as PlayerIndex, body.filled);
|
||||
await persistLobby(updated);
|
||||
broadcastLobby(lobby.gameId);
|
||||
sendJson(res, 200, { ok: true });
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* GIVING UP A SEAT — the player's own, or (host only) somebody else's.
|
||||
*
|
||||
* There was no door out of a lobby before this: a mis-join or a player who wandered off left a
|
||||
* chair that could not be freed, and a table that cannot start until every chair is taken.
|
||||
* The host's "remove" and a player's "Leave" are the same act from opposite ends, so they are
|
||||
* one route — `seat` names somebody else's chair and is refused to anyone but the host.
|
||||
*/
|
||||
if (url.pathname === '/api/lobby/leave' && req.method === 'POST') {
|
||||
const body = (await readJson(req)) as { token?: string; seat?: number };
|
||||
const ps = typeof body.token === 'string' ? sessions.get(body.token) : undefined;
|
||||
const lobby = ps ? lobbies.get(ps.gameId) : undefined;
|
||||
if (!ps || !lobby) {
|
||||
sendJson(res, 404, { error: 'no such lobby' });
|
||||
return;
|
||||
}
|
||||
const seat = typeof body.seat === 'number' ? (body.seat as PlayerIndex) : undefined;
|
||||
if (seat !== undefined && seat !== ps.player && lobby.hostToken !== ps.token) {
|
||||
sendJson(res, 403, { error: 'NOT_HOST' });
|
||||
return;
|
||||
}
|
||||
const result = leaveLobby(lobby, ps.token, seat);
|
||||
if (result.empty) {
|
||||
// Nobody human is left to start it. Everything about this lobby goes, including the code,
|
||||
// so it cannot be joined into a game that will never begin.
|
||||
lobbies.delete(lobby.gameId);
|
||||
gameCodes.delete(lobby.gameCode);
|
||||
for (const [, watcher] of lobbyConnections.get(lobby.gameId) ?? []) watcher.end();
|
||||
lobbyConnections.delete(lobby.gameId);
|
||||
await deleteLobby(opts.dataDir, lobby.gameId);
|
||||
// The row goes with the lobby rather than being marked: a game that never started is not a
|
||||
// game an administrator has any use for a record of.
|
||||
await removeIndexEntry(opts.dataDir, lobby.gameId);
|
||||
sendJson(res, 200, { ok: true, closed: true });
|
||||
return;
|
||||
}
|
||||
await persistLobby(result.lobby);
|
||||
broadcastLobby(lobby.gameId);
|
||||
sendJson(res, 200, { ok: true });
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* WHAT AM I ABOUT TO JOIN? Read-only, takes no seat, and gated by the same join secret the
|
||||
* door itself is.
|
||||
*
|
||||
* A player used to have to take a chair before they could see a single rule of the game they
|
||||
* were sitting down to — and until 2026-08-23 there was then no way back out of it.
|
||||
*/
|
||||
if (url.pathname === '/api/lobby/preview' && req.method === 'GET') {
|
||||
if (url.searchParams.get('secret') !== opts.joinSecret) {
|
||||
sendJson(res, 403, { error: 'bad or missing secret' });
|
||||
return;
|
||||
}
|
||||
const code = (url.searchParams.get('gameCode') ?? '').trim().toUpperCase();
|
||||
const gameId = gameCodes.get(code);
|
||||
const lobby = gameId ? lobbies.get(gameId) : undefined;
|
||||
if (!lobby) {
|
||||
sendJson(res, 404, { error: 'no open lobby with that code' });
|
||||
return;
|
||||
}
|
||||
const hostSeat = lobby.seats.find((seat) => seat?.kind === 'human' && seat.token === lobby.hostToken);
|
||||
const preview: LobbyPreview = {
|
||||
gameCode: lobby.gameCode,
|
||||
hostName: hostSeat?.kind === 'human' ? hostSeat.displayName : 'unknown',
|
||||
config: lobby.config,
|
||||
players: lobby.seats.length,
|
||||
seated: lobby.seats.map((seat, i) => ({
|
||||
seat: i,
|
||||
who: seat?.kind === 'human' ? seat.displayName : null,
|
||||
bot: seat?.kind === 'bot',
|
||||
})),
|
||||
};
|
||||
sendJson(res, 200, preview);
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/lobby/start' && req.method === 'POST') {
|
||||
const body = (await readJson(req)) as { token?: string };
|
||||
const ps = typeof body.token === 'string' ? sessions.get(body.token) : undefined;
|
||||
const lobby = ps ? lobbies.get(ps.gameId) : undefined;
|
||||
if (!ps || !lobby) {
|
||||
sendJson(res, 404, { error: 'no such lobby' });
|
||||
return;
|
||||
}
|
||||
const result = startLobby(lobby, ps.token);
|
||||
if (!result.ok) {
|
||||
sendJson(res, 409, { error: result.code });
|
||||
return;
|
||||
}
|
||||
// The host's seed if they named one; otherwise a fresh random deal.
|
||||
const session = createSession(
|
||||
lobby.seed ?? Math.floor(Math.random() * 1e9),
|
||||
lobby.config,
|
||||
result.playerNames,
|
||||
result.botSeats,
|
||||
);
|
||||
games.set(lobby.gameId, session);
|
||||
lobbies.delete(lobby.gameId);
|
||||
// Every SSE watcher on the LOBBY stream is done — the game stream is what carries the game
|
||||
// forward from here. `started: true` on one last message, THEN close, is what lets a
|
||||
// still-open lobby tab tell "the game began" apart from a network hiccup `EventSource`
|
||||
// would otherwise silently retry through.
|
||||
for (const [watcherToken, watcherRes] of lobbyConnections.get(lobby.gameId) ?? []) {
|
||||
const watcherPs = sessions.get(watcherToken);
|
||||
if (watcherPs) writeSse(watcherRes, 0, { lobby, you: watcherPs.player, started: true } satisfies LobbyPush);
|
||||
watcherRes.end();
|
||||
}
|
||||
lobbyConnections.delete(lobby.gameId);
|
||||
|
||||
await writeGame(gameDir(opts.dataDir, lobby.gameId), session.exportSave(), opts.engineVersion);
|
||||
await upsertIndexEntry(opts.dataDir, { gameId: lobby.gameId, gameCode: lobby.gameCode, status: 'active' });
|
||||
await deleteLobby(opts.dataDir, lobby.gameId);
|
||||
sendJson(res, 200, { ok: true });
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/lobby/stream' && req.method === 'GET') {
|
||||
const token = url.searchParams.get('token') ?? '';
|
||||
const ps = sessions.get(token);
|
||||
const lobby = ps ? lobbies.get(ps.gameId) : undefined;
|
||||
if (!ps || !lobby) {
|
||||
sendJson(res, 404, { error: 'no such lobby' });
|
||||
return;
|
||||
}
|
||||
res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive' });
|
||||
const conns = lobbyConnections.get(lobby.gameId) ?? new Map<string, ServerResponse>();
|
||||
conns.set(token, res);
|
||||
lobbyConnections.set(lobby.gameId, conns);
|
||||
writeSse(res, 0, { lobby, you: ps.player, started: false } satisfies LobbyPush);
|
||||
const heartbeat = setInterval(() => res.write(': ping\n\n'), HEARTBEAT_MS);
|
||||
req.on('close', () => {
|
||||
clearInterval(heartbeat);
|
||||
const live = lobbyConnections.get(lobby.gameId);
|
||||
if (live?.get(token) === res) live.delete(token);
|
||||
// `lobby-and-sessions.md` §2 — host rights pass to the earliest-joined remaining player
|
||||
// if the host's connection closes before start. `lobbies.get` again, not the captured
|
||||
// `lobby`, because it may have changed (another join, another bot toggle) since connect.
|
||||
const current = lobbies.get(lobby.gameId);
|
||||
if (current && current.hostToken === token) {
|
||||
void persistLobby(reassignHost(current, token)).then(() => broadcastLobby(lobby.gameId));
|
||||
}
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// -- The running game (token-authenticated) ------------------------------------------------
|
||||
|
||||
/**
|
||||
* IS THIS TOKEN STILL GOOD FOR ANYTHING?
|
||||
*
|
||||
* A browser remembers its session in `localStorage` and re-enters the game on the next load
|
||||
* without asking, which is what makes reconnection seamless — and what leaves it stranded
|
||||
* when the game is gone. `EventSource` cannot report a status code and retries a 404
|
||||
* silently forever, so the client needs somewhere cheap to ask a yes/no question. Two ways a
|
||||
* game legitimately disappears under a player: an engine-version bump refuses to resume it
|
||||
* (D7), and an administrator ends it (`DELETE /api/games/<id>`).
|
||||
*/
|
||||
if (url.pathname === '/api/session' && req.method === 'GET') {
|
||||
const ps = sessions.get(url.searchParams.get('token') ?? '');
|
||||
const live = ps ? games.get(ps.gameId) : undefined;
|
||||
if (!ps || !live) {
|
||||
sendJson(res, 404, { error: 'no such game' });
|
||||
return;
|
||||
}
|
||||
sendJson(res, 200, { gameId: ps.gameId, player: ps.player });
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/stream' && req.method === 'GET') {
|
||||
const token = url.searchParams.get('token') ?? '';
|
||||
const ps = sessions.get(token);
|
||||
const session = ps ? games.get(ps.gameId) : undefined;
|
||||
if (!ps || !session) {
|
||||
sendJson(res, 404, { error: 'no such game' });
|
||||
return;
|
||||
}
|
||||
const { gameId, player: seat } = ps;
|
||||
res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive' });
|
||||
const conns = gameConnections.get(gameId) ?? new Map<PlayerIndex, ServerResponse>();
|
||||
conns.set(seat, res);
|
||||
gameConnections.set(gameId, conns);
|
||||
const ever = everConnected.get(gameId) ?? new Set<PlayerIndex>();
|
||||
ever.add(seat);
|
||||
everConnected.set(gameId, ever);
|
||||
// The board, and who else is at the table — the second half used to be missing entirely.
|
||||
const first = session.connect(seat);
|
||||
first.presence = presenceOfOthers(gameId, seat, session);
|
||||
writeSse(res, nextEventId(gameId, seat), first);
|
||||
broadcastPresence(gameId, seat, true);
|
||||
// Idle for minutes at a time is the expected shape of this game (multiplayer.md §9) — a
|
||||
// silent SSE connection is exactly what a proxy in the path may reap. A comment line is not a
|
||||
// real event (EventSource ignores lines starting with `:`), so it costs the client nothing.
|
||||
const heartbeat = setInterval(() => res.write(': ping\n\n'), HEARTBEAT_MS);
|
||||
req.on('close', () => {
|
||||
clearInterval(heartbeat);
|
||||
const live = gameConnections.get(gameId);
|
||||
if (live?.get(seat) === res) live.delete(seat);
|
||||
broadcastPresence(gameId, seat, false);
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/intent' && req.method === 'POST') {
|
||||
// Token comes from the QUERY STRING, matching `/api/stream` and matching what
|
||||
// `web/session.ts`'s `RemoteSession.submit` actually sends (`fetch('/api/intent?token=…')`)
|
||||
// — the body carries only what changes per call, `{ seq, intent }`.
|
||||
const token = url.searchParams.get('token') ?? '';
|
||||
const ps = sessions.get(token);
|
||||
const session = ps ? games.get(ps.gameId) : undefined;
|
||||
if (!ps || !session) {
|
||||
sendJson(res, 404, { error: 'no such game' });
|
||||
return;
|
||||
}
|
||||
const body = (await readJson(req)) as { seq?: number; intent?: Intent };
|
||||
if (typeof body.seq !== 'number' || !body.intent) {
|
||||
sendJson(res, 400, { error: 'expected { seq, intent }' });
|
||||
return;
|
||||
}
|
||||
const result = session.intent(ps.player, body.seq, body.intent);
|
||||
if (result.accepted) {
|
||||
// Persisted BEFORE the response goes out — "accepted" should mean "durably on disk" at
|
||||
// this scale, not just "applied in memory" (§12 step 14).
|
||||
const dir = gameDir(opts.dataDir, ps.gameId);
|
||||
await writeGame(dir, session.exportSave(), opts.engineVersion);
|
||||
if (result.timing) await appendTiming(dir, result.timing);
|
||||
if (session.exportSave().status === 'finished') {
|
||||
// `upsertIndexEntry` replaces the WHOLE row for this `gameId`, so the code has to be
|
||||
// carried forward here rather than left blank — `gameCodes` is the only place still
|
||||
// holding it once a lobby's own record is gone.
|
||||
const gameCode = [...gameCodes.entries()].find(([, id]) => id === ps.gameId)?.[0] ?? '';
|
||||
await upsertIndexEntry(opts.dataDir, { gameId: ps.gameId, gameCode, status: 'finished' });
|
||||
}
|
||||
}
|
||||
sendJson(res, 200, result.accepted ? { ok: true } : { ok: false, code: result.code });
|
||||
if (result.accepted) broadcastGame(ps.gameId, result.pushes);
|
||||
return;
|
||||
}
|
||||
|
||||
await serveStatic(opts.distDir, url.pathname, res);
|
||||
})().catch((err: unknown) => {
|
||||
sendJson(res, 500, { error: err instanceof Error ? err.message : 'internal error' });
|
||||
});
|
||||
});
|
||||
|
||||
server.listen(opts.port, opts.bindAddress);
|
||||
}
|
||||
@@ -1,107 +0,0 @@
|
||||
/**
|
||||
* Process bootstrap — Phase 2 §12 step 8, extended for Phase 3 (§12 steps 14-15) load-on-start and
|
||||
* Phase 4 (§12 steps 17-20) to resume every saved game and lobby, not just one.
|
||||
*
|
||||
* Run with: node src/server/index.ts
|
||||
*
|
||||
* Env-configured, no config file — matches how the rest of this project's dev-side tooling reads
|
||||
* `process.env` directly (`scripts/build-web.ts`'s `BUILD_DIST_DIR`).
|
||||
*/
|
||||
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { dirname, join, resolve } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { startServer } from './http.ts';
|
||||
import { gameDir, loadGame, readIndex, readLobby, readSessions } from './persistence.ts';
|
||||
import { tryResumeSession } from './session.ts';
|
||||
import type { GameSession } from './session.ts';
|
||||
import type { Lobby, PlayerSession } from './lobby.ts';
|
||||
|
||||
const port = Number(process.env['PORT'] ?? 8081);
|
||||
const bindAddress = process.env['BIND_ADDRESS'] ?? '0.0.0.0';
|
||||
const joinSecret = process.env['JOIN_SECRET'];
|
||||
/**
|
||||
* Optional, unlike `JOIN_SECRET`: a server with no administrator is a perfectly good server, and
|
||||
* refusing to boot without one would break every existing deployment and every dev run. Unset
|
||||
* simply means the admin routes are not there (`http.ts`), which is the safe default — the
|
||||
* capability has to be granted, never merely left ungated.
|
||||
*/
|
||||
const adminSecret = process.env['ADMIN_SECRET'];
|
||||
const distDir = resolve(process.env['DIST_DIR'] ?? 'dist');
|
||||
const dataDir = resolve(process.env['DATA_DIR'] ?? 'data');
|
||||
|
||||
if (!joinSecret) {
|
||||
console.error('JOIN_SECRET must be set — a server-wide secret, passed out of band (D14).');
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
// `package.json`'s version IS `engineVersion` (§12 step 15) — the same reading `scripts/build-web.ts`'s
|
||||
// `buildStamp()` already does, just from `src/server/` rather than the repo root script directory.
|
||||
const root = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
|
||||
const engineVersion = (JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')) as { version: string }).version;
|
||||
|
||||
const initialGames = new Map<string, GameSession>();
|
||||
const initialLobbies = new Map<string, Lobby>();
|
||||
const initialSessions = new Map<string, PlayerSession>();
|
||||
|
||||
const index = await readIndex(dataDir);
|
||||
// Said before the loop, not after it: replaying is the reason a restart pauses before the port
|
||||
// opens, and a log that only reports each game once it is done gives no warning of how much is
|
||||
// still to come.
|
||||
const resumable = index.filter((e) => e.status !== 'finished').length;
|
||||
if (resumable > 0) console.log(`Resuming ${resumable} saved game(s)…`);
|
||||
for (const entry of index) {
|
||||
const sessions = await readSessions(dataDir, entry.gameId);
|
||||
for (const s of sessions) initialSessions.set(s.token, s);
|
||||
|
||||
if (entry.status === 'lobby') {
|
||||
const lobby = await readLobby(dataDir, entry.gameId);
|
||||
if (lobby) initialLobbies.set(entry.gameId, lobby);
|
||||
continue;
|
||||
}
|
||||
|
||||
const loaded = await loadGame(gameDir(dataDir, entry.gameId));
|
||||
if (loaded.found) {
|
||||
const resumed = tryResumeSession(loaded.saved);
|
||||
if (resumed.ok) {
|
||||
initialGames.set(entry.gameId, resumed.session);
|
||||
console.log(`Resumed ${entry.gameId} (${entry.gameCode}) — ${loaded.saved.history.length} intents replayed.`);
|
||||
} else {
|
||||
/**
|
||||
* The save does not replay under these rules, which is the only thing that has ever actually
|
||||
* mattered — and now the only thing asked. Says which move it choked on, because "some
|
||||
* version differs" was never enough to act on: the file is left untouched, so an operator who
|
||||
* wants the game back can put the previous version on and finish it.
|
||||
*/
|
||||
const f = resumed.failure;
|
||||
console.error(
|
||||
`Refusing to resume ${entry.gameId} (${entry.gameCode}): move ${f.stoppedAt + 1} of ${f.of} ` +
|
||||
`(${f.intent}) is rejected by the current rules with ${f.code}. Saved under engine ` +
|
||||
`version ${loaded.storedVersion}, this server is running ${engineVersion}. The file is ` +
|
||||
`left untouched.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
// `entry.status === 'finished'` games are not resumed into memory at all — nothing plays them
|
||||
// forward, and their files stay on disk for post-game replay (`lobby-and-sessions.md` §6).
|
||||
}
|
||||
|
||||
startServer({
|
||||
port,
|
||||
bindAddress,
|
||||
joinSecret,
|
||||
adminSecret,
|
||||
distDir,
|
||||
dataDir,
|
||||
engineVersion,
|
||||
initialGames,
|
||||
initialLobbies,
|
||||
initialSessions,
|
||||
});
|
||||
console.log(
|
||||
`Station Master multiplayer server on ${bindAddress}:${port}, serving ${distDir} — ` +
|
||||
`${initialGames.size} game(s) and ${initialLobbies.size} lobby(ies) resumed.`,
|
||||
);
|
||||
if (!adminSecret) {
|
||||
console.log('ADMIN_SECRET is unset — the /api/games administration routes are disabled.');
|
||||
}
|
||||
@@ -1,254 +0,0 @@
|
||||
/**
|
||||
* The lobby — Phase 4 of `docs/architecture/multiplayer.md` (§12 steps 17-20), fully specified in
|
||||
* `docs/architecture/lobby-and-sessions.md`.
|
||||
*
|
||||
* Pure logic, no sockets, no filesystem, no in-memory registry — same split `session.ts` already
|
||||
* draws (`http.ts` wires connections and persistence to this; `persistence.ts` is the only thing
|
||||
* that touches disk). A `Lobby` exists only BEFORE `Lobby.Start`: once the config locks and the
|
||||
* `GameSession` is built, this module is done with that game — everything after is `session.ts`.
|
||||
*
|
||||
* WHY A SEPARATE FILE FROM `session.ts`. `session.ts` is already the "running game" module and is
|
||||
* large; a lobby's concerns — seating, host rights, the join secret's door versus a game code's
|
||||
* discovery, config locking — share almost no code with running a Stage clock, and mixing them would
|
||||
* make both harder to read for no reuse gained.
|
||||
*/
|
||||
|
||||
import { randomUUID } from 'node:crypto';
|
||||
|
||||
import type { GameConfig, PlayerIndex } from '../engine/state.ts';
|
||||
|
||||
/** `lobby-and-sessions.md` §1 — names the PLAYER, not the seat. Issued once, at join, and never
|
||||
* reissued: it is what makes reconnection work, so it must outlive the connection that first used
|
||||
* it. */
|
||||
export type PlayerSession = {
|
||||
token: string;
|
||||
gameId: string;
|
||||
player: PlayerIndex;
|
||||
displayName: string;
|
||||
};
|
||||
|
||||
export type LobbySeat = { kind: 'human'; token: string; displayName: string } | { kind: 'bot' } | null;
|
||||
|
||||
/** A game that has not started. `hostToken` ends its meaning at `Lobby.Start` — nothing here
|
||||
* survives into the running game except the seat list and the locked `config`. */
|
||||
export type Lobby = {
|
||||
gameId: string;
|
||||
gameCode: string;
|
||||
hostToken: string;
|
||||
config: GameConfig;
|
||||
seats: LobbySeat[];
|
||||
/** Tokens in the order they joined — human seats only, host first — so a departed host's
|
||||
* replacement is unambiguous (`lobby-and-sessions.md` §2: "earliest-joined remaining player"). */
|
||||
joinOrder: string[];
|
||||
createdAt: number;
|
||||
/**
|
||||
* The seed the host asked for, or null for one picked at `Lobby.Start`. Chosen here rather than
|
||||
* at start because the same seed and the same settings deal the same railroad — which is only
|
||||
* useful if the person setting the game up can name it.
|
||||
*/
|
||||
seed: number | null;
|
||||
};
|
||||
|
||||
export type CreateResult = { lobby: Lobby; session: PlayerSession };
|
||||
export type JoinResult =
|
||||
| { ok: true; lobby: Lobby; session: PlayerSession }
|
||||
| { ok: false; code: 'LOBBY_FULL' | 'ALREADY_STARTED' | 'NAME_TAKEN' };
|
||||
/** `empty` when the last human has gone — the caller drops the lobby rather than leaving a table of
|
||||
* bots waiting for a host who no longer exists. */
|
||||
export type LeaveResult = { lobby: Lobby; empty: boolean };
|
||||
export type StartResult = { ok: true; playerNames: string[]; botSeats: PlayerIndex[] } | { ok: false; code: 'NOT_HOST' | 'BAD_PLAYER_COUNT' };
|
||||
|
||||
/**
|
||||
* `lobby-and-sessions.md` §2 — short and speakable, not an account name and not a UUID. A small
|
||||
* fixed word list rather than a dictionary: this is read aloud across a table or a call, not typed
|
||||
* from memory, so a handful of unambiguous railroad words serve better than a large random one.
|
||||
*/
|
||||
const CODE_WORDS = [
|
||||
'RAIL', 'YARD', 'DEPOT', 'COAL', 'MAIL', 'CABOOSE', 'SIGNAL', 'FREIGHT',
|
||||
'TRESTLE', 'HOPPER', 'TENDER', 'SIDING', 'GRADE', 'SPUR', 'WHISTLE', 'TROLLEY',
|
||||
];
|
||||
|
||||
function randomCode(): string {
|
||||
const word = CODE_WORDS[Math.floor(Math.random() * CODE_WORDS.length)]!;
|
||||
const digits = Math.floor(Math.random() * 10_000)
|
||||
.toString()
|
||||
.padStart(4, '0');
|
||||
return `${word}-${digits}`;
|
||||
}
|
||||
|
||||
/** Collision-checked against whatever codes the caller already knows about — `http.ts` holds the
|
||||
* live registry, so the check lives there rather than this module owning a set of its own. */
|
||||
export function freshGameCode(taken: (code: string) => boolean): string {
|
||||
let code = randomCode();
|
||||
while (taken(code)) code = randomCode();
|
||||
return code;
|
||||
}
|
||||
|
||||
/** `lobby-and-sessions.md` §2 — solitaire is exactly 1, competitive/coop are 2-4. Not a rules
|
||||
* limit: the engine will build a Division for any seat count. This is the lobby judgment, sized to
|
||||
* what has actually been played and tested (`test/multiplayer.test.ts` exercises 2, 3 and 4). */
|
||||
export function playerCountAllowed(mode: GameConfig['mode'], count: number): boolean {
|
||||
return mode === 'solitaire' ? count === 1 : count >= 2 && count <= 4;
|
||||
}
|
||||
|
||||
/** The creating player is the host and takes seat 0 (`lobby-and-sessions.md` §2). */
|
||||
/**
|
||||
* THE TABLE SIZE IS FIXED WHEN THE GAME IS CREATED, and `seats.length` is it.
|
||||
*
|
||||
* The host says how many are playing, so the seats array is built at full length with the host in
|
||||
* chair 0 and the rest empty. Nothing ever grows or shrinks it, which is what makes a gap
|
||||
* impossible to express rather than merely illegal — and that matters more than it looks: seats
|
||||
* used to be appended as people joined, so a bot dropped into a later chair padded the array with
|
||||
* a hole that silently blocked Start. It also removes any need to compact the seats at
|
||||
* `Lobby.Start`, and compaction would have shifted the `player` index every `PlayerSession`
|
||||
* already carries (`joinLobby` stamps it at join time, and `/api/stream` and `/api/intent` route
|
||||
* by it) — quietly handing a player somebody else's railroad.
|
||||
*
|
||||
* Knowing the count this early has one more consequence, and it is a bug fix: the config's
|
||||
* `minCombinedRevenue` is derived from the player count, and the lobby previously had to guess it
|
||||
* as 4 before anyone had sat down.
|
||||
*/
|
||||
export function createLobby(
|
||||
config: GameConfig,
|
||||
hostDisplayName: string,
|
||||
gameCode: string,
|
||||
players: number,
|
||||
seed: number | null = null,
|
||||
): CreateResult {
|
||||
const gameId = randomUUID();
|
||||
const token = randomUUID();
|
||||
const session: PlayerSession = { token, gameId, player: 0, displayName: hostDisplayName };
|
||||
const seats: LobbySeat[] = Array.from({ length: players }, (_, i) =>
|
||||
i === 0 ? { kind: 'human', token, displayName: hostDisplayName } : null,
|
||||
);
|
||||
const lobby: Lobby = {
|
||||
gameId,
|
||||
gameCode,
|
||||
hostToken: token,
|
||||
config,
|
||||
seats,
|
||||
joinOrder: [token],
|
||||
createdAt: Date.now(),
|
||||
seed,
|
||||
};
|
||||
return { lobby, session };
|
||||
}
|
||||
|
||||
/** Joins the first empty seat, or extends the seat list if every seat so far is filled and the
|
||||
* mode's cap allows one more (`lobby-and-sessions.md` §2's 2-4 is enforced at `Lobby.Start`, not
|
||||
* here — a 5th join before anyone starts is refused outright since there is no seat it could ever
|
||||
* play in, but the running count is checked against `playerCountAllowed` at every join too, so a
|
||||
* lobby can never grow the seats array past what could legally start). */
|
||||
export function joinLobby(lobby: Lobby, displayName: string): JoinResult {
|
||||
// The table was sized at creation, so joining takes an empty chair or none at all — there is no
|
||||
// longer an "append another seat" path for a late arrival to grow the game through.
|
||||
const seatIndex = lobby.seats.findIndex((s) => s === null);
|
||||
if (seatIndex < 0) return { ok: false, code: 'LOBBY_FULL' };
|
||||
|
||||
/**
|
||||
* TWO PLAYERS CANNOT SHARE A NAME (2026-08-23).
|
||||
*
|
||||
* The name is not decoration: it labels the district on the Division map, it is what the turn
|
||||
* chart means by "waiting on Jesse", and `record()` puts it in front of every line that player
|
||||
* causes. Two identical names make all three ambiguous, and there is no way to fix it once the
|
||||
* game starts — the names are locked into the session at `Lobby.Start`. Refused rather than
|
||||
* silently suffixed: a player should play under the name they chose, or be told to choose again.
|
||||
*/
|
||||
const wanted = displayName.trim().toLowerCase();
|
||||
const clash = lobby.seats.some((s) => s?.kind === 'human' && s.displayName.trim().toLowerCase() === wanted);
|
||||
if (clash) return { ok: false, code: 'NAME_TAKEN' };
|
||||
|
||||
const token = randomUUID();
|
||||
const session: PlayerSession = { token, gameId: lobby.gameId, player: seatIndex, displayName };
|
||||
const seats = [...lobby.seats];
|
||||
seats[seatIndex] = { kind: 'human', token, displayName };
|
||||
return {
|
||||
ok: true,
|
||||
lobby: { ...lobby, seats, joinOrder: [...lobby.joinOrder, token] },
|
||||
session,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* GIVING UP A SEAT — a player leaving, or the host clearing somebody out of a chair.
|
||||
*
|
||||
* There was no way out of a lobby at all before 2026-08-23: a mis-join or a player who wandered off
|
||||
* wedged the table, because Start needs every chair filled and `setBotSeat` refuses to touch an
|
||||
* occupied human seat. One function serves both, since they differ only in whose seat is named, and
|
||||
* `http.ts` is what checks that a caller naming somebody else's seat is the host.
|
||||
*
|
||||
* Host rights move exactly as they do on a dropped connection (`reassignHost`), and the caller is
|
||||
* told when the last human has gone so the lobby can be dropped rather than left orphaned.
|
||||
*/
|
||||
export function leaveLobby(lobby: Lobby, token: string, seat?: PlayerIndex): LeaveResult {
|
||||
const index =
|
||||
seat === undefined ? lobby.seats.findIndex((s) => s?.kind === 'human' && s.token === token) : seat;
|
||||
const occupant = index >= 0 ? (lobby.seats[index] ?? null) : null;
|
||||
if (index < 0 || occupant?.kind !== 'human') return { lobby, empty: false };
|
||||
|
||||
const seats = [...lobby.seats];
|
||||
seats[index] = null;
|
||||
const departing = occupant.token;
|
||||
const withoutThem: Lobby = {
|
||||
...lobby,
|
||||
seats,
|
||||
joinOrder: lobby.joinOrder.filter((t) => t !== departing),
|
||||
};
|
||||
const empty = !seats.some((s) => s?.kind === 'human');
|
||||
return { lobby: reassignHost(withoutThem, departing), empty };
|
||||
}
|
||||
|
||||
/** Host-only in effect (`http.ts` checks the caller's token against `hostToken` before calling
|
||||
* this) — marks an empty seat as bot-filled, or clears one back to empty. Never touches an occupied
|
||||
* human seat; the host removes a person by them leaving, not by overwriting their seat. */
|
||||
export function setBotSeat(lobby: Lobby, seat: PlayerIndex, filled: boolean): Lobby {
|
||||
const seats = [...lobby.seats];
|
||||
// No padding: a seat outside the table the host chose is not a seat, and inventing one is how
|
||||
// the old array grew holes in it.
|
||||
if (seat < 0 || seat >= seats.length) return lobby;
|
||||
if (filled) {
|
||||
if (seats[seat] !== null) return lobby;
|
||||
seats[seat] = { kind: 'bot' };
|
||||
} else {
|
||||
if (seats[seat]?.kind !== 'bot') return lobby;
|
||||
seats[seat] = null;
|
||||
}
|
||||
return { ...lobby, seats };
|
||||
}
|
||||
|
||||
/**
|
||||
* The host's connection closed before `Lobby.Start`. `lobby-and-sessions.md` §2: rights pass to the
|
||||
* earliest-joined remaining player — remaining means still occupying a seat, not necessarily still
|
||||
* connected, since a momentary drop should not also cost the NEXT person the host chair. Returns
|
||||
* the lobby unchanged if the departing token was not the host, or if no other human seat exists.
|
||||
*/
|
||||
export function reassignHost(lobby: Lobby, departingToken: string): Lobby {
|
||||
if (lobby.hostToken !== departingToken) return lobby;
|
||||
const stillSeated = new Set(
|
||||
lobby.seats.flatMap((s) => (s?.kind === 'human' ? [s.token] : [])),
|
||||
);
|
||||
const next = lobby.joinOrder.find((t) => t !== departingToken && stillSeated.has(t));
|
||||
return next ? { ...lobby, hostToken: next } : lobby;
|
||||
}
|
||||
|
||||
/**
|
||||
* Locks the config, checks the player count, and hands back exactly what `session.ts`'s
|
||||
* `createSession` needs — this function does not call it, so `lobby.ts` never depends on
|
||||
* `session.ts` (the dependency runs the other way: `http.ts` calls both).
|
||||
*/
|
||||
export function startLobby(lobby: Lobby, callerToken: string): StartResult {
|
||||
if (callerToken !== lobby.hostToken) return { ok: false, code: 'NOT_HOST' };
|
||||
// Every chair at the table must be taken. The size itself was validated at creation and cannot
|
||||
// have moved since, so this is only ever waiting on the last empty seat to fill.
|
||||
if (lobby.seats.some((s) => s === null) || !playerCountAllowed(lobby.config.mode, lobby.seats.length)) {
|
||||
return { ok: false, code: 'BAD_PLAYER_COUNT' };
|
||||
}
|
||||
// Seat index IS player index — no compaction, because there is nothing to compact past.
|
||||
const taken = lobby.seats as Exclude<LobbySeat, null>[];
|
||||
// Bots are numbered rather than all being called "Bot": two of them at one table are two
|
||||
// different railroads, and a map labelling both the same cannot say which is which.
|
||||
let botNumber = 0;
|
||||
const playerNames = taken.map((s) => (s.kind === 'human' ? s.displayName : `Bot ${++botNumber}`));
|
||||
const botSeats = taken.flatMap((s, i) => (s.kind === 'bot' ? [i as PlayerIndex] : []));
|
||||
return { ok: true, playerNames, botSeats };
|
||||
}
|
||||
@@ -1,183 +0,0 @@
|
||||
/**
|
||||
* Persistence — Phase 3 of `docs/architecture/multiplayer.md` (§12 steps 14-15), extended for
|
||||
* Phase 4 (§12 steps 17-20) to more than one game (`lobby-and-sessions.md` §6 specifies both
|
||||
* shapes and the reasoning behind them).
|
||||
*
|
||||
* ONE DIRECTORY PER GAME (`games/<gameId>/`), plus one top-level `index.json` naming every game so
|
||||
* `index.ts` can find and resume them all on boot without scanning the filesystem. Every write is
|
||||
* still a full-file atomic rewrite (write to `.tmp`, `rename` over the real path) rather than true
|
||||
* on-disk appending — §6 says the storage mechanism is genuinely open as long as the LOGICAL history
|
||||
* is never rewritten or reordered, which a full rewrite of an always-growing array satisfies, and at
|
||||
* the measured scale (~350 intents, a few hundred bytes per game) there is nothing to optimize yet.
|
||||
*/
|
||||
|
||||
import { mkdir, readFile, rename, rm, unlink, writeFile } from 'node:fs/promises';
|
||||
import { join } from 'node:path';
|
||||
import type { SavedGame, TurnTiming } from './session.ts';
|
||||
import type { Lobby, PlayerSession } from './lobby.ts';
|
||||
|
||||
const GAME_FILE = 'game.json';
|
||||
const TIMINGS_FILE = 'turn-timings.json';
|
||||
const LOBBY_FILE = 'lobby.json';
|
||||
const SESSIONS_FILE = 'sessions.json';
|
||||
const INDEX_FILE = 'index.json';
|
||||
|
||||
type PersistedGame = SavedGame & { engineVersion: string };
|
||||
|
||||
async function atomicWrite(path: string, text: string): Promise<void> {
|
||||
const tmp = `${path}.tmp`;
|
||||
await writeFile(tmp, text);
|
||||
await rename(tmp, path);
|
||||
}
|
||||
|
||||
export async function writeGame(dataDir: string, saved: SavedGame, engineVersion: string): Promise<void> {
|
||||
await mkdir(dataDir, { recursive: true });
|
||||
const payload: PersistedGame = { engineVersion, ...saved };
|
||||
await atomicWrite(join(dataDir, GAME_FILE), JSON.stringify(payload, null, 1));
|
||||
}
|
||||
|
||||
export type LoadResult =
|
||||
| { found: false }
|
||||
/** The version that wrote the file, for diagnostics — it is no longer what decides. */
|
||||
| { found: true; saved: SavedGame; storedVersion: string };
|
||||
|
||||
/**
|
||||
* READS THE SAVE. DOES NOT JUDGE IT.
|
||||
*
|
||||
* This used to refuse any save whose `engineVersion` was not an exact match for the running one,
|
||||
* on the reasoning that a move legal under old rules may not be legal under new ones (D7). The
|
||||
* reasoning is sound and the test was not: the stamp is the PACKAGE version, which moves for
|
||||
* reasons that have nothing to do with the rules, so four consecutive releases destroyed every
|
||||
* game in progress — one of them a release that changed only how the board is drawn.
|
||||
*
|
||||
* Whether a save still replays is a question with an exact answer, so it is now asked directly:
|
||||
* `tryResumeSession` replays the intents and reports the first one the engine refuses, if any.
|
||||
* The version is kept and reported because it is useful in a failure, but it decides nothing.
|
||||
*/
|
||||
export async function loadGame(dataDir: string): Promise<LoadResult> {
|
||||
let text: string;
|
||||
try {
|
||||
text = await readFile(join(dataDir, GAME_FILE), 'utf8');
|
||||
} catch {
|
||||
return { found: false };
|
||||
}
|
||||
const payload = JSON.parse(text) as PersistedGame;
|
||||
const { engineVersion, ...saved } = payload;
|
||||
return { found: true, saved, storedVersion: engineVersion };
|
||||
}
|
||||
|
||||
/** Appended once per closed turn span (`GameSession.intent`'s `timing` result) — read-modify-write at
|
||||
* this scale rather than real appending, same reasoning as `writeGame`. */
|
||||
export async function appendTiming(dataDir: string, timing: TurnTiming): Promise<void> {
|
||||
await mkdir(dataDir, { recursive: true });
|
||||
const path = join(dataDir, TIMINGS_FILE);
|
||||
let existing: TurnTiming[];
|
||||
try {
|
||||
existing = JSON.parse(await readFile(path, 'utf8')) as TurnTiming[];
|
||||
} catch {
|
||||
existing = [];
|
||||
}
|
||||
existing.push(timing);
|
||||
await atomicWrite(path, JSON.stringify(existing, null, 1));
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Phase 4 — more than one game
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export type GameIndexEntry = { gameId: string; gameCode: string; status: 'lobby' | 'active' | 'finished' };
|
||||
|
||||
/** Where one game's own files live. Every function below takes a `gameId` and joins it under here
|
||||
* itself; `writeGame`/`loadGame`/`appendTiming` above do not, and take a directory directly, so a
|
||||
* caller wanting one specific game's `game.json` passes `gameDir(dataDir, gameId)` to those. */
|
||||
export function gameDir(dataDir: string, gameId: string): string {
|
||||
return join(dataDir, 'games', gameId);
|
||||
}
|
||||
|
||||
export async function readIndex(dataDir: string): Promise<GameIndexEntry[]> {
|
||||
try {
|
||||
return JSON.parse(await readFile(join(dataDir, INDEX_FILE), 'utf8')) as GameIndexEntry[];
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
async function writeIndex(dataDir: string, entries: GameIndexEntry[]): Promise<void> {
|
||||
await mkdir(dataDir, { recursive: true });
|
||||
await atomicWrite(join(dataDir, INDEX_FILE), JSON.stringify(entries, null, 1));
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds or updates exactly one game's row, by `gameId` — every caller that changes one game's status
|
||||
* (created, started, finished) wants precisely this, not "replace the whole index", which would
|
||||
* silently drop every other game's row the moment two writes happened close together.
|
||||
*/
|
||||
export async function upsertIndexEntry(dataDir: string, entry: GameIndexEntry): Promise<void> {
|
||||
const entries = await readIndex(dataDir);
|
||||
const i = entries.findIndex((e) => e.gameId === entry.gameId);
|
||||
if (i >= 0) entries[i] = entry;
|
||||
else entries.push(entry);
|
||||
await writeIndex(dataDir, entries);
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a game from the index. Paired with `deleteGame` — the directory holds the game, the
|
||||
* index says the game exists, and a delete that did one without the other would either resurrect
|
||||
* it on the next boot or leave `index.json` pointing at nothing.
|
||||
*/
|
||||
export async function removeIndexEntry(dataDir: string, gameId: string): Promise<void> {
|
||||
const entries = await readIndex(dataDir);
|
||||
await writeIndex(
|
||||
dataDir,
|
||||
entries.filter((e) => e.gameId !== gameId),
|
||||
);
|
||||
}
|
||||
|
||||
/** Deletes a game's whole directory — its save, its turn timings, its sessions, its lobby file. */
|
||||
export async function deleteGame(dataDir: string, gameId: string): Promise<void> {
|
||||
await rm(gameDir(dataDir, gameId), { recursive: true, force: true });
|
||||
}
|
||||
|
||||
export async function writeLobby(dataDir: string, lobby: Lobby): Promise<void> {
|
||||
const dir = gameDir(dataDir, lobby.gameId);
|
||||
await mkdir(dir, { recursive: true });
|
||||
await atomicWrite(join(dir, LOBBY_FILE), JSON.stringify(lobby, null, 1));
|
||||
}
|
||||
|
||||
export async function readLobby(dataDir: string, gameId: string): Promise<Lobby | null> {
|
||||
try {
|
||||
return JSON.parse(await readFile(join(gameDir(dataDir, gameId), LOBBY_FILE), 'utf8')) as Lobby;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Removed once a game starts — a `Lobby` and a running `SavedGame` are mutually exclusive for one
|
||||
* `gameId`, and leaving the file behind would let a restart resurrect a lobby for a game already
|
||||
* under way. Missing already is not an error; `Lobby.Start` calls this exactly once, in the same
|
||||
* request that writes `game.json`.
|
||||
*/
|
||||
export async function deleteLobby(dataDir: string, gameId: string): Promise<void> {
|
||||
try {
|
||||
await unlink(join(gameDir(dataDir, gameId), LOBBY_FILE));
|
||||
} catch {
|
||||
// Already gone — nothing to do.
|
||||
}
|
||||
}
|
||||
|
||||
/** Session tokens for one game — `lobby-and-sessions.md` §6: persisted so a token still works after
|
||||
* a server restart, the same reason `game.json` itself is persisted. */
|
||||
export async function writeSessions(dataDir: string, gameId: string, sessions: PlayerSession[]): Promise<void> {
|
||||
const dir = gameDir(dataDir, gameId);
|
||||
await mkdir(dir, { recursive: true });
|
||||
await atomicWrite(join(dir, SESSIONS_FILE), JSON.stringify(sessions, null, 1));
|
||||
}
|
||||
|
||||
export async function readSessions(dataDir: string, gameId: string): Promise<PlayerSession[]> {
|
||||
try {
|
||||
return JSON.parse(await readFile(join(gameDir(dataDir, gameId), SESSIONS_FILE), 'utf8')) as PlayerSession[];
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
@@ -1,484 +0,0 @@
|
||||
/**
|
||||
* The game session host — Phases 2 and 3 of `docs/architecture/multiplayer.md` (§8, §12 steps 9,
|
||||
* 14-16).
|
||||
*
|
||||
* Pure logic, no sockets, no filesystem — `src/server/http.ts` is the thin wiring that calls into
|
||||
* this, and `src/server/persistence.ts` is what actually reads/writes disk. One `GameSession` per
|
||||
* in-memory game (Phase 2 is one game per process; Phase 4 generalizes to many).
|
||||
*
|
||||
* REUSES `src/web/game.ts`'s `Game`/`submit`/`drain`/`currentActor`/`actionMenu` wholesale — all pure
|
||||
* logic already, with no DOM dependency, exactly as `LocalSession` uses them client-side. Building a
|
||||
* second copy of "apply an intent, narrate it, compute the Menu" here would drift from what solitaire
|
||||
* already does and is tested against.
|
||||
*
|
||||
* ONE THING `game.ts`'s `submit` DOES NOT DO: verify who is calling it. `submit(game, intent)` reads
|
||||
* `currentActor(game)` itself and applies the intent AS that player, regardless of who asked — safe
|
||||
* for `LocalSession` (there is only ever one possible caller: the one browser). A server has more than
|
||||
* one seat submitting, so THIS file is where "is `seat` actually allowed to act right now?" has to be
|
||||
* checked, before `submit` is ever called — see `intent()` below.
|
||||
*/
|
||||
|
||||
import { check } from '../engine/apply.ts';
|
||||
import { legalActions } from '../engine/legal.ts';
|
||||
import type { Intent } from '../engine/intents.ts';
|
||||
import type { GameConfig, PlayerIndex } from '../engine/state.ts';
|
||||
import { actionMenu, currentActor, fromMultiplayerSave, isOutOfTurn, newMultiplayerGame, submit } from '../web/game.ts';
|
||||
import type { Game, Menu } from '../web/game.ts';
|
||||
import { deltaFrame } from '../sim/frame-delta.ts';
|
||||
import type { FrameDelta } from '../sim/frame-delta.ts';
|
||||
import { snapshot, seatLabel } from '../sim/view.ts';
|
||||
import type { Frame } from '../sim/view.ts';
|
||||
import { developerBot } from '../sim/bot.ts';
|
||||
|
||||
export type Push = {
|
||||
/**
|
||||
* Absent on a presence-only push (below) — there is no board delta to send when nothing about the
|
||||
* GAME changed, and computing one just to say "unchanged" would mean tracking a last-sent frame
|
||||
* for a seat that may not even be in this game's connection table (a lobby-stage notice has none).
|
||||
*/
|
||||
frame?: FrameDelta;
|
||||
/** Non-null only for the seat that may currently act — never guess otherwise (`game.ts`'s `actionMenu` guards this too, but the host must still only compute/send it for the actor). */
|
||||
menu: Menu | null;
|
||||
/** Narration since the LAST push to this specific seat, not the whole game's log. */
|
||||
lines: { text: string; tone: string }[];
|
||||
/**
|
||||
* Connection news about OTHER seats — never this push's own recipient. `lobby-and-sessions.md`
|
||||
* §5: a disconnect is server-layer news about a connection, not a `GameEvent`, so it must not go
|
||||
* through the engine or the shared narration log (which must stay replayable from a seed). Built
|
||||
* and broadcast entirely by `http.ts`, which already owns the connection table; `session.ts` never
|
||||
* sets this field itself — every `Push` `session.ts` builds carries a real `frame` and no
|
||||
* `presence`, and `http.ts`'s presence notices carry no `frame` and no `menu`.
|
||||
*
|
||||
* A LIST, since 2026-08-23: a connecting client is told about every other seat at once. It used to
|
||||
* learn of a seat only when that seat disconnected AFTER it connected, so a player arriving at a
|
||||
* table where two people had not shown up yet was told nothing at all. `seen` distinguishes "was
|
||||
* here and dropped" from "has never opened the game".
|
||||
*/
|
||||
presence?: { seat: PlayerIndex; connected: boolean; seen: boolean }[];
|
||||
/**
|
||||
* THE FOUR TRANSIENT SIGNALS (2026-08-23) — what solitaire has always drawn and multiplayer never
|
||||
* did: sound cues, the timetable slot a D12 just filled, a one-line announcement, and the card
|
||||
* that just came into this seat's hand.
|
||||
*
|
||||
* The first three are SHARED — a collision anywhere on the Division, the Stage bell, a train
|
||||
* running off the end pays everyone — so they are identical in every seat's push and drained once
|
||||
* per broadcast. `justDrawn` is not: it goes ONLY to the seat that drew it (`game.justDrawn` is
|
||||
* one field for the whole game and does not say whose). `test/redaction.test.ts` is the guard.
|
||||
*/
|
||||
cues?: string[];
|
||||
scheduled?: number | null;
|
||||
announcement?: string | null;
|
||||
justDrawn?: string | null;
|
||||
};
|
||||
|
||||
/**
|
||||
* `lobby-and-sessions.md` §5 — "wall-clock at the start of a turn, wall-clock at the intent that
|
||||
* ends it, per player per phase." Computed entirely here, never touching the engine (which has no
|
||||
* clock and must stay deterministic) and never stored inside `history` (a replay must reproduce a
|
||||
* game from decisions alone).
|
||||
*/
|
||||
export type TurnTiming = {
|
||||
player: PlayerIndex;
|
||||
phase: string;
|
||||
day: number;
|
||||
stage: number;
|
||||
startedAt: number;
|
||||
endedAt: number;
|
||||
};
|
||||
|
||||
/** Everything `persistence.ts` needs to write `game.json` and rebuild a session from it later. */
|
||||
export type SavedGame = {
|
||||
seed: number;
|
||||
config: GameConfig;
|
||||
playerNames: string[];
|
||||
history: Intent[];
|
||||
status: 'active' | 'finished';
|
||||
createdAt: number;
|
||||
/**
|
||||
* Seats `developerBot` plays for, filled at `Lobby.Start` (D8 — bots fill EMPTY seats at lobby
|
||||
* time only, never mid-game). Persisted so a bot seat is still a bot after a server restart —
|
||||
* `resumeSession` has no other way to know, and re-deriving it from `playerNames` would mean
|
||||
* guessing from a display name rather than reading a fact.
|
||||
*/
|
||||
botSeats: PlayerIndex[];
|
||||
/**
|
||||
* Wall-clock of the last accepted intent, so "has this game stalled?" survives a restart.
|
||||
*
|
||||
* Optional because it postdates the format, and defaulted to `createdAt` when absent — a game
|
||||
* whose last move is unrecorded reads as untouched since it began, which is the honest answer
|
||||
* rather than a fabricated one. Kept OUT of `history`, like the turn timings and for the same
|
||||
* reason: a replay must reproduce a game from decisions alone, and wall-clock is not a decision.
|
||||
*/
|
||||
lastMoveAt?: number;
|
||||
};
|
||||
|
||||
/** What an administrator needs to see about a game without replaying it themselves. */
|
||||
export type GameSummary = {
|
||||
playerCount: number;
|
||||
playerNames: string[];
|
||||
botSeats: PlayerIndex[];
|
||||
status: 'active' | 'finished';
|
||||
createdAt: number;
|
||||
lastMoveAt: number;
|
||||
day: number;
|
||||
stage: number;
|
||||
phase: string;
|
||||
/**
|
||||
* Whose move it is, or `null` — which is not an error state: the Mainline Phase runs itself, and
|
||||
* a finished game waits on nobody.
|
||||
*/
|
||||
waitingOn: { seat: PlayerIndex; name: string } | null;
|
||||
};
|
||||
|
||||
export type IntentResult =
|
||||
| { accepted: true; pushes: Map<PlayerIndex, Push>; timing: TurnTiming | null }
|
||||
| { accepted: false; code: string };
|
||||
|
||||
export type GameSession = {
|
||||
readonly playerCount: number;
|
||||
isBot(seat: PlayerIndex): boolean;
|
||||
/** A new SSE connection (or a reconnect) for `seat` — always a full Frame, never a delta. */
|
||||
connect(seat: PlayerIndex): Push;
|
||||
intent(seat: PlayerIndex, seq: number, i: Intent): IntentResult;
|
||||
/** Everything needed to persist this game and, later, rebuild it via `resumeSession`. */
|
||||
exportSave(): SavedGame;
|
||||
/**
|
||||
* A cheap description of where this game has got to. Deliberately does not copy `history` the
|
||||
* way `exportSave` must — the health check polls this on a timer, and an administrator listing
|
||||
* games wants the state of each, not a copy of every intent in all of them.
|
||||
*/
|
||||
summary(): GameSummary;
|
||||
};
|
||||
|
||||
type OpenSpan = { player: PlayerIndex; phase: string; day: number; stage: number; startedAt: number };
|
||||
|
||||
function buildSession(
|
||||
game: Game,
|
||||
playerNames: string[],
|
||||
createdAt: number,
|
||||
botSeats: Set<PlayerIndex>,
|
||||
lastMoveAtInit: number,
|
||||
): GameSession {
|
||||
let lastMoveAt = lastMoveAtInit;
|
||||
/** Who drew the card `game.justDrawn` names. The engine records WHICH card came into hand but not
|
||||
* whose hand it went into, and that is the whole difference between a badge and a leak. */
|
||||
let lastDraw: { seat: PlayerIndex; cardId: string } | null = null;
|
||||
const lastSeq = new Map<PlayerIndex, number>();
|
||||
const lastFrame = new Map<PlayerIndex, Frame>();
|
||||
const sentLines = new Map<PlayerIndex, number>();
|
||||
|
||||
const openSpanFor = (now: number): OpenSpan | null => {
|
||||
const actor = currentActor(game);
|
||||
if (actor === null) return null;
|
||||
return { player: actor, phase: game.state.clock.phase, day: game.state.clock.day, stage: game.state.clock.stage, startedAt: now };
|
||||
};
|
||||
let open: OpenSpan | null = openSpanFor(Date.now());
|
||||
|
||||
function frameFor(seat: PlayerIndex): Frame {
|
||||
return snapshot(game.state, game.log, null, null, null, false, seat);
|
||||
}
|
||||
|
||||
function linesSince(seat: PlayerIndex): { text: string; tone: string }[] {
|
||||
const already = sentLines.get(seat) ?? 0;
|
||||
sentLines.set(seat, game.log.length);
|
||||
return game.log.slice(already);
|
||||
}
|
||||
|
||||
function menuFor(seat: PlayerIndex): Menu | null {
|
||||
return seat === currentActor(game) ? actionMenu(game, seat) : null;
|
||||
}
|
||||
|
||||
/** What the last batch of events earned, drained from the game exactly once and then handed to
|
||||
* every seat. `null` on a (re)connect: a fresh connection is drawing a STATE, and replaying the
|
||||
* sounds of everything it missed would be a burst of noise about the past. */
|
||||
type Moment = { cues: string[]; scheduled: number | null; announcement: string | null };
|
||||
|
||||
function takeMoment(): Moment {
|
||||
const cues = game.cues.splice(0, game.cues.length);
|
||||
const scheduled = game.scheduled;
|
||||
game.scheduled = null;
|
||||
const announcement = game.announced;
|
||||
game.announced = null;
|
||||
return { cues, scheduled, announcement };
|
||||
}
|
||||
|
||||
function pushFor(seat: PlayerIndex, moment: Moment | null): Push {
|
||||
const frame = frameFor(seat);
|
||||
const delta = deltaFrame(lastFrame.get(seat) ?? null, frame);
|
||||
lastFrame.set(seat, frame);
|
||||
const push: Push = { frame: delta, menu: menuFor(seat), lines: linesSince(seat) };
|
||||
if (moment) {
|
||||
if (moment.cues.length > 0) push.cues = moment.cues;
|
||||
if (moment.scheduled !== null) push.scheduled = moment.scheduled;
|
||||
if (moment.announcement !== null) push.announcement = moment.announcement;
|
||||
}
|
||||
// The drawer's own card, and nobody else's — on a reconnect too, so the badge survives a refresh.
|
||||
if (lastDraw !== null && lastDraw.seat === seat) push.justDrawn = lastDraw.cardId;
|
||||
return push;
|
||||
}
|
||||
|
||||
function pushesForAll(): Map<PlayerIndex, Push> {
|
||||
const moment = takeMoment();
|
||||
const out = new Map<PlayerIndex, Push>();
|
||||
for (let seat = 0; seat < playerNames.length; seat++) {
|
||||
out.set(seat as PlayerIndex, pushFor(seat as PlayerIndex, moment));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* Closes the open span if the acting player, phase, Day or Stage moved since it opened, and opens
|
||||
* the next one (or none, in the automatic Mainline Phase). Returns the just-closed span, if any,
|
||||
* for the caller to persist — a "turn" here is exactly the contiguous stretch where none of those
|
||||
* four things changed, which can span several intents (draw, then play, then end) as one span.
|
||||
*/
|
||||
function settleTiming(): TurnTiming | null {
|
||||
const now = Date.now();
|
||||
const next = openSpanFor(now);
|
||||
const same =
|
||||
open !== null &&
|
||||
next !== null &&
|
||||
open.player === next.player &&
|
||||
open.phase === next.phase &&
|
||||
open.day === next.day &&
|
||||
open.stage === next.stage;
|
||||
if (same) return null;
|
||||
const closed: TurnTiming | null = open === null ? null : { ...open, endedAt: now };
|
||||
open = next;
|
||||
return closed;
|
||||
}
|
||||
|
||||
/**
|
||||
* PLAY EVERY BOT SEAT FORWARD until a human is due, or the game ends.
|
||||
*
|
||||
* `developerBot` (D8, `lobby-and-sessions.md` §2) fills EMPTY seats at lobby time only — it never
|
||||
* takes over for a disconnected human, so this loop only ever touches seats `botSeats` named at
|
||||
* `Lobby.Start`. Uses `submit` directly rather than the public `intent()` path: a bot is not a
|
||||
* client with a `seq` to dedupe against, and its choice is by construction always legal (`check`
|
||||
* would only ever confirm what `legalActions` already promised).
|
||||
*
|
||||
* Intermediate bot-turn spans are swept through `settleTiming()` but their result is discarded —
|
||||
* `lobby-and-sessions.md` §5's turn clock exists to learn how long HUMANS take, and a bot decides
|
||||
* in zero wall-clock time by definition. Called once at construction (a resume could land exactly
|
||||
* on a bot's turn) and once after every accepted human intent.
|
||||
*/
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — the bots' half of a unanimous vote.
|
||||
*
|
||||
* "Bots will not disagree with the human. Humans get to vote first. If all humans vote yes, then
|
||||
* bots vote yes too. If a human votes no, it's not unanimous, it ends right then. If only bots are
|
||||
* playing, they never vote to extend" (Jesse, 2026-08-28).
|
||||
*
|
||||
* Which makes a bot's vote a formality rather than a policy decision, performed once the humans
|
||||
* have already settled it, so that the unanimity the engine checks is a real unanimity rather than
|
||||
* a special case carved into the rules for absent players.
|
||||
*
|
||||
* THE ALL-BOT TABLE IS THE CASE TO GET RIGHT, and getting it wrong hung the game. `driveBots`
|
||||
* cannot reach the vote — it loops on `currentActor`, which is null the moment the game stops —
|
||||
* so if this returns early with no humans to follow, nobody votes at all and a bot-only game sits
|
||||
* on the question for ever. It happened: an all-bot session never reached `finished`. With nobody
|
||||
* to follow, the bots' own answer stands, and it is no.
|
||||
*/
|
||||
function driveBotVotes(): void {
|
||||
if (game.state.status !== 'awaitingExtension') return;
|
||||
const humans = [...Array(playerNames.length).keys()].filter((p) => !botSeats.has(p));
|
||||
// A human who has voted `false` has already ended the game, so reaching here with humans still
|
||||
// outstanding means the table is genuinely waiting on a person. Bots wait with it.
|
||||
if (humans.length > 0 && !humans.every((p) => game.state.extensionVotes[p] === true)) return;
|
||||
const agree = humans.length > 0;
|
||||
for (const seat of botSeats) {
|
||||
if (game.state.extensionVotes[seat] === null) {
|
||||
submit(game, { type: 'game.extend', player: seat, agree }, seat);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Bots play, bots vote, and an agreed extension puts them back to playing — so the two drivers
|
||||
* alternate rather than running once each. Bounded because every pass must consume something: a
|
||||
* turn, or a vote that cannot be cast twice.
|
||||
*/
|
||||
function driveBotTurns(): void {
|
||||
for (let pass = 0; pass < 1_000; pass++) {
|
||||
const before = game.history.length;
|
||||
driveBots();
|
||||
driveBotVotes();
|
||||
if (game.history.length === before) return;
|
||||
}
|
||||
throw new Error('driveBotTurns: probable infinite loop');
|
||||
}
|
||||
|
||||
function driveBots(): void {
|
||||
let guard = 0;
|
||||
for (;;) {
|
||||
const actor = currentActor(game);
|
||||
if (actor === null || !botSeats.has(actor)) return;
|
||||
if (++guard > 10_000) throw new Error(`driveBots: probable infinite loop at seat ${actor}`);
|
||||
const options = legalActions(game.state, actor);
|
||||
if (options.length === 0) return;
|
||||
const choice = developerBot.choose(game.state, actor, options);
|
||||
const drawnBefore = game.justDrawn;
|
||||
const ok = submit(game, choice);
|
||||
if (game.justDrawn !== drawnBefore && game.justDrawn !== null) {
|
||||
lastDraw = { seat: actor, cardId: game.justDrawn };
|
||||
}
|
||||
/* c8 ignore next -- `options` came from `legalActions`, so `choice` is always legal. */
|
||||
if (!ok) throw new Error(`driveBots: developerBot chose an illegal action for seat ${actor}`);
|
||||
settleTiming();
|
||||
}
|
||||
}
|
||||
driveBotTurns();
|
||||
// Whatever the opening bot turns earned belongs to a game nobody was connected to yet — dropped
|
||||
// here rather than fired at the first client to arrive. (It also stops `game.cues` growing without
|
||||
// bound on a server, which nothing was draining before this.)
|
||||
takeMoment();
|
||||
|
||||
return {
|
||||
playerCount: playerNames.length,
|
||||
isBot: (seat) => botSeats.has(seat),
|
||||
|
||||
connect(seat) {
|
||||
// A (re)connect always starts from a clean slate — no cache to trust across a lost connection
|
||||
// (or a server restart, Phase 3) — so the honest thing is a full Frame, not a delta.
|
||||
lastFrame.delete(seat);
|
||||
return pushFor(seat, null);
|
||||
},
|
||||
|
||||
intent(seat, seq, i) {
|
||||
// Idempotent resend (protocol.md §5): a repeat of an ALREADY-APPLIED seq is a no-op success,
|
||||
// with no pushes to re-broadcast. A repeat after a REJECTION is not remembered here — it was
|
||||
// never applied, so it is worth trying again (see the `lastSeq.set` below: only on success).
|
||||
if (lastSeq.get(seat) === seq) return { accepted: true, pushes: new Map(), timing: null };
|
||||
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — the vote is the one intent with no actor to be.
|
||||
*
|
||||
* `currentActor` is null once the timetable has run out, so this guard would refuse every
|
||||
* vote with NOT_YOUR_TURN. Every seat may vote, and `check` is still the authority on whether
|
||||
* this particular seat may vote right now (it has voted already; the game is not waiting on a
|
||||
* vote at all), so skipping the turn test here gives nothing away.
|
||||
*/
|
||||
if (!isOutOfTurn(i) && seat !== currentActor(game)) {
|
||||
return { accepted: false, code: 'NOT_YOUR_TURN' };
|
||||
}
|
||||
|
||||
// Checked directly, rather than via `submit`'s boolean, for two reasons: `submit` writes a
|
||||
// "that is not allowed" line into the SHARED `game.log` on rejection, which would otherwise
|
||||
// broadcast one seat's illegal attempt to the whole table on their next push (rejection
|
||||
// feedback is private, to the submitter only); and calling `check` first means an intent
|
||||
// already known to be illegal never touches the engine at all.
|
||||
const code = check(game.state, seat, i);
|
||||
if (code) return { accepted: false, code };
|
||||
|
||||
const drawnBefore = game.justDrawn;
|
||||
const applied = submit(game, i, isOutOfTurn(i) ? seat : null);
|
||||
if (game.justDrawn !== drawnBefore && game.justDrawn !== null) {
|
||||
lastDraw = { seat, cardId: game.justDrawn };
|
||||
}
|
||||
/* c8 ignore next -- `check` above already proved this intent is legal; `submit` cannot then refuse it. */
|
||||
if (!applied) return { accepted: false, code: 'REJECTED' };
|
||||
|
||||
lastSeq.set(seat, seq);
|
||||
lastMoveAt = Date.now();
|
||||
const timing = settleTiming();
|
||||
// Any bot due to act now plays out entirely before this push goes back — the delta mechanism
|
||||
// diffs against whatever was last sent, so it captures the bots' moves along with the human's
|
||||
// in one push regardless of how many turns that took. Votes included, since Gitea#11: a human
|
||||
// agreeing to another Day is exactly the move the bots are waiting on to agree themselves.
|
||||
driveBotTurns();
|
||||
return { accepted: true, pushes: pushesForAll(), timing };
|
||||
},
|
||||
|
||||
exportSave() {
|
||||
return {
|
||||
seed: game.seed,
|
||||
config: game.state.config,
|
||||
playerNames: [...playerNames],
|
||||
history: [...game.history],
|
||||
// `awaitingExtension` is a game waiting on its table, not a game that is over — so it maps
|
||||
// to 'active' and `server/index.ts` resumes it on a restart like any other (Gitea#11).
|
||||
status: game.state.status === 'finished' ? 'finished' : 'active',
|
||||
createdAt,
|
||||
botSeats: [...botSeats],
|
||||
lastMoveAt,
|
||||
};
|
||||
},
|
||||
|
||||
summary() {
|
||||
const actor = currentActor(game);
|
||||
return {
|
||||
playerCount: playerNames.length,
|
||||
playerNames: [...playerNames],
|
||||
botSeats: [...botSeats],
|
||||
// `awaitingExtension` is a game waiting on its table, not a game that is over — so it maps
|
||||
// to 'active' and `server/index.ts` resumes it on a restart like any other (Gitea#11).
|
||||
status: game.state.status === 'finished' ? 'finished' : 'active',
|
||||
createdAt,
|
||||
lastMoveAt,
|
||||
day: game.state.clock.day,
|
||||
stage: game.state.clock.stage,
|
||||
phase: game.state.clock.phase,
|
||||
waitingOn: actor === null ? null : { seat: actor, name: playerNames[actor] ?? `Seat ${seatLabel(actor)}` },
|
||||
};
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function createSession(
|
||||
seed: number,
|
||||
config: GameConfig,
|
||||
playerNames: string[],
|
||||
botSeats: PlayerIndex[] = [],
|
||||
): GameSession {
|
||||
const now = Date.now();
|
||||
return buildSession(newMultiplayerGame(seed, config, playerNames), playerNames, now, new Set(botSeats), now);
|
||||
}
|
||||
|
||||
/**
|
||||
* Phase 3 — rebuild a session from a persisted `SavedGame` (`persistence.ts`). The engine-version
|
||||
* check happens before this is ever called; by the time `saved.history` reaches here it is already
|
||||
* known to have been recorded under the currently-running rules.
|
||||
*/
|
||||
/**
|
||||
* A resume that could not complete, and exactly where it gave up. `index.ts` turns this into the
|
||||
* refusal it logs, so the operator is told which move the current rules will not accept rather
|
||||
* than only that some version string differs.
|
||||
*/
|
||||
export type ResumeFailure = { stoppedAt: number; of: number; intent: string; code: string };
|
||||
|
||||
export function tryResumeSession(saved: SavedGame): { ok: true; session: GameSession } | { ok: false; failure: ResumeFailure } {
|
||||
const { game, stopped } = fromMultiplayerSave(saved.seed, saved.config, saved.playerNames, saved.history);
|
||||
if (stopped) {
|
||||
return {
|
||||
ok: false,
|
||||
failure: { stoppedAt: stopped.index, of: saved.history.length, intent: stopped.intent.type, code: stopped.code },
|
||||
};
|
||||
}
|
||||
return { ok: true, session: build(game, saved) };
|
||||
}
|
||||
|
||||
/**
|
||||
* Throws on a save the current rules will not replay. Kept for callers that have already
|
||||
* established the save is good — the server boots through `tryResumeSession`, which answers
|
||||
* instead of throwing.
|
||||
*/
|
||||
export function resumeSession(saved: SavedGame): GameSession {
|
||||
const r = tryResumeSession(saved);
|
||||
if (!r.ok) {
|
||||
throw new Error(
|
||||
`save does not replay under the current rules: intent ${r.failure.stoppedAt + 1} of ` +
|
||||
`${r.failure.of} (${r.failure.intent}) was rejected with ${r.failure.code}`,
|
||||
);
|
||||
}
|
||||
return r.session;
|
||||
}
|
||||
|
||||
function build(game: Game, saved: SavedGame): GameSession {
|
||||
return buildSession(
|
||||
game,
|
||||
saved.playerNames,
|
||||
saved.createdAt,
|
||||
new Set(saved.botSeats),
|
||||
saved.lastMoveAt ?? saved.createdAt,
|
||||
);
|
||||
}
|
||||
+159
-332
@@ -28,23 +28,7 @@ export type BoardTrain = { label: string; consist: string[] };
|
||||
* The Division as a dispatcher would see it: one continuous line per running track, sections
|
||||
* separated by thin seams, capacity legible because the lines can be counted.
|
||||
*/
|
||||
/**
|
||||
* Who is at the table, so an Office can be labelled with its owner rather than only its tier.
|
||||
*
|
||||
* Passed in rather than read off the nodes because a `DivisionView` knows its seat and nothing
|
||||
* about people — the roster lives on the `Frame`, keyed by player, and `seat` is what joins them.
|
||||
* Optional so the standalone replay (`replay.ts`, which serialises this function by `toString()`)
|
||||
* keeps working unchanged.
|
||||
*/
|
||||
export type DivisionRoster = {
|
||||
players: { index: number; seat: number; name: string }[];
|
||||
/** The player whose move it is, or null in an automatic phase. A PLAYER index, not a seat. */
|
||||
actor: number | null;
|
||||
/** The player this map is being drawn for. */
|
||||
viewer: number;
|
||||
};
|
||||
|
||||
export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | null): string {
|
||||
export function divisionSvg(nodes: DivisionView[]): string {
|
||||
/**
|
||||
* THE WHOLE DIVISION, west to east, as one continuous route.
|
||||
*
|
||||
@@ -65,30 +49,7 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
|
||||
* anything outside its own body.
|
||||
*/
|
||||
const CW = { dp: 118, ml: 152, run: 78 };
|
||||
/**
|
||||
* 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 CH = 58;
|
||||
const GAP = 6;
|
||||
/**
|
||||
* ONE FIXED SLOT PER A/D TRACK, so the Office Running Track cell is drawn wide enough to hold
|
||||
@@ -136,14 +97,6 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
|
||||
tip: string;
|
||||
/** Which SEAT's district this cell belongs to, or null for Mainline and Division Points. */
|
||||
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;
|
||||
@@ -151,8 +104,11 @@ 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 });
|
||||
};
|
||||
|
||||
@@ -160,99 +116,50 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
|
||||
if (n.kind === 'office') {
|
||||
const cap = n.capacity;
|
||||
const ad = n.trains.flat();
|
||||
/**
|
||||
* THE NAME IS THE HEADLINE, the tier is the detail.
|
||||
*
|
||||
* "Where does Bob sit?" is the question this map could not answer: an Office was labelled
|
||||
* with its tier, which every player's Office also has, so four districts read the same. The
|
||||
* owner's name takes the headline and the tier moves down beside the A/D count, because the
|
||||
* name is what is being looked for and the tier is what is being referred to once found.
|
||||
*/
|
||||
const seatOwner =
|
||||
roster && n.seat !== null ? (roster.players.find((p) => p.seat === n.seat) ?? null) : null;
|
||||
const owner = seatOwner
|
||||
? {
|
||||
name: seatOwner.name,
|
||||
isTurn: roster!.actor === seatOwner.index,
|
||||
isYou: roster!.viewer === seatOwner.index,
|
||||
}
|
||||
: null;
|
||||
|
||||
/**
|
||||
* 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);
|
||||
for (const rc of n.running ?? []) {
|
||||
const isOffice = rc.kind === 'office';
|
||||
push({
|
||||
kind: 'run',
|
||||
label: rc.label,
|
||||
sub: isOffice ? (cap === null ? '' : `A/D ${ad.length}/${cap}`) : '',
|
||||
/**
|
||||
* 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: `${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,
|
||||
});
|
||||
}
|
||||
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,
|
||||
});
|
||||
// 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 = [];
|
||||
continue;
|
||||
}
|
||||
const dp = n.kind === 'dp';
|
||||
/**
|
||||
* A train in the Interchange's yard is drawn on the card but counted against nothing.
|
||||
*
|
||||
* It is not on the running line — that is the whole distinction §7 rests on — so it cannot take
|
||||
* the card's capacity. It still has to be SEEN: an Extra made up here would otherwise be a train
|
||||
* the player just placed that appears nowhere on the map.
|
||||
*/
|
||||
const inYard = n.yard ?? [];
|
||||
const onRoad = n.trains.flat();
|
||||
const free = n.capacity === null ? '' : `${Math.max(0, n.capacity - onRoad.length)} of ${n.capacity} free`;
|
||||
push({
|
||||
kind: dp ? 'dp' : 'ml',
|
||||
label: n.label,
|
||||
sub: n.capacity === null
|
||||
? 'no limit — trains queue'
|
||||
: [free, inYard.length > 0 ? `${inYard.length} in the yard` : ''].filter(Boolean).join(' · '),
|
||||
trains: [...onRoad, ...inYard],
|
||||
sub: n.capacity === null ? 'no limit — trains queue' : `${Math.max(0, n.capacity - n.trains.flat().length)} of ${n.capacity} free`,
|
||||
trains: n.trains.flat(),
|
||||
cap: n.capacity,
|
||||
tip: dp
|
||||
? 'A Division Point — the end of the line. Trains both enter and leave the Division here (odd numbers run west, even run east), and queue without limit'
|
||||
: `${n.label} — Mainline${n.gradeUp ? `, climbs ${n.gradeUp === 'east' ? 'east' : 'west'}` : ''}${n.modifiers.length ? ` · ${n.modifiers.join(' · ')}` : ''}` +
|
||||
(inYard.length > 0
|
||||
? `\n\n${inYard.length} train${inYard.length === 1 ? '' : 's'} standing in the yard, not on the running line — waiting to highball onto this card`
|
||||
: '') +
|
||||
// What the card actually DOES. The name alone left Hilly and Uncontrolled Siding as
|
||||
// words with no gameplay attached — reported exactly that way.
|
||||
(n.what ? `\n\n${n.what}` : ''),
|
||||
@@ -262,31 +169,58 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
|
||||
w: dp ? CW.dp : CW.ml,
|
||||
});
|
||||
}
|
||||
if (side.length > 0) sides.push(side);
|
||||
|
||||
/**
|
||||
* 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;
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// -- draw -------------------------------------------------------------------------------------
|
||||
const rail = (x1: number, y: number, x2: number): string => {
|
||||
@@ -301,29 +235,20 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
|
||||
return o;
|
||||
};
|
||||
|
||||
/**
|
||||
* 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 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">`;
|
||||
|
||||
// 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
|
||||
@@ -331,30 +256,39 @@ 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]!;
|
||||
out += rail(a.x + a.w, a.y + RAIL_Y, b.x);
|
||||
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}"/>`;
|
||||
}
|
||||
}
|
||||
|
||||
cells.forEach((c) => {
|
||||
const full = c.cap !== null && c.trains.length >= c.cap;
|
||||
out += `<g class="bs-dcell bs-d${c.kind}${full ? ' bs-full' : ''}" data-tip="${esc(c.tip)}">`;
|
||||
out += `<rect x="${c.x}" y="${c.y}" width="${c.w}" height="${CH}" rx="5"/>`;
|
||||
/**
|
||||
* WHOSE IS IT, IS IT THEIR MOVE, AND IS IT MINE — answered by colour and one suffix rather
|
||||
* than by a legend. Amber is the same "it is happening here" the action panel uses; "(you)"
|
||||
* is spelled out because a colour alone cannot say which of four railroads is the reader's,
|
||||
* and that is the first thing anybody wants to know at a table they just sat down at.
|
||||
*/
|
||||
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 + RAIL_Y, c.x + c.w - 6);
|
||||
out += `<text class="bs-name" x="${c.x + 7}" y="${c.y + 14}">${esc(c.label)}</text>`;
|
||||
out += rail(c.x + 6, c.y + 32, 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. 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.
|
||||
// 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.
|
||||
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 + RAIL_Y - 14}" x2="${c.x + 6 + RW * r}" y2="${c.y + RAIL_Y + 10}"/>`;
|
||||
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}"/>`;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -369,25 +303,36 @@ 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.
|
||||
*/
|
||||
/**
|
||||
* 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 => {
|
||||
c.trains.forEach((t, k) => {
|
||||
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`
|
||||
? ` \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)'
|
||||
: '';
|
||||
out += `<g class="bs-train" data-tip="${esc(t.label)} \u2014 carrying ${esc(cars.join(', ') || 'no cars')}${
|
||||
cars.length ? ` (${loaded} loaded)` : ''
|
||||
@@ -396,61 +341,15 @@ 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="${ty}" width="${w}" height="19" rx="3"/>` +
|
||||
`<text class="bs-tlab" x="${tx}" y="${ty + 13}" text-anchor="middle">${esc(label)}</text>`;
|
||||
`<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>`;
|
||||
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, 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.
|
||||
// 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.
|
||||
const first = cells[0];
|
||||
const last = cells[cells.length - 1];
|
||||
/**
|
||||
@@ -575,65 +474,6 @@ export function officeSvg(
|
||||
return out;
|
||||
};
|
||||
|
||||
/**
|
||||
* A 45° LEG, drawn as a smooth curve rather than two straight segments meeting at a hard corner.
|
||||
*
|
||||
* It is an EASEMENT, not an arbitrary curve: tangent to horizontal at `p0` (the east or west edge),
|
||||
* so an abutting straight card's through-rail still reads as one unbroken line, and tangent to
|
||||
* exactly 45° at `p3` (the north or south edge), so two stacked curves still read as one continuous
|
||||
* diagonal and the edge-crossing angle the matching rule depends on is unchanged. `p1`/`p2` are
|
||||
* cubic-Bezier control points chosen to hit those two tangents — see the call site.
|
||||
*
|
||||
* Sampled as a short polyline rather than left as one SVG path command, because the two parallel
|
||||
* rails and the tie marks all need points evenly spaced ALONG THE CURVE with the local tangent at
|
||||
* each one — `rail()`'s straight-line version does the same sampling, just on a line.
|
||||
*/
|
||||
const curvedRail = (
|
||||
p0: { x: number; y: number },
|
||||
p1: { x: number; y: number },
|
||||
p2: { x: number; y: number },
|
||||
p3: { x: number; y: number },
|
||||
): string => {
|
||||
const at = (t: number): { x: number; y: number } => {
|
||||
const u = 1 - t;
|
||||
return {
|
||||
x: u * u * u * p0.x + 3 * u * u * t * p1.x + 3 * u * t * t * p2.x + t * t * t * p3.x,
|
||||
y: u * u * u * p0.y + 3 * u * u * t * p1.y + 3 * u * t * t * p2.y + t * t * t * p3.y,
|
||||
};
|
||||
};
|
||||
const tangentAt = (t: number): { x: number; y: number } => {
|
||||
const u = 1 - t;
|
||||
return {
|
||||
x: 3 * u * u * (p1.x - p0.x) + 6 * u * t * (p2.x - p1.x) + 3 * t * t * (p3.x - p2.x),
|
||||
y: 3 * u * u * (p1.y - p0.y) + 6 * u * t * (p2.y - p1.y) + 3 * t * t * (p3.y - p2.y),
|
||||
};
|
||||
};
|
||||
const N = 24;
|
||||
const left: string[] = [];
|
||||
const right: string[] = [];
|
||||
let ties = '';
|
||||
for (let i = 0; i <= N; i++) {
|
||||
const t = i / N;
|
||||
const pt = at(t);
|
||||
const tan = tangentAt(t);
|
||||
const tlen = Math.hypot(tan.x, tan.y) || 1;
|
||||
const nx = (-tan.y / tlen) * 2.5;
|
||||
const ny = (tan.x / tlen) * 2.5;
|
||||
left.push(`${pt.x + nx} ${pt.y + ny}`);
|
||||
right.push(`${pt.x - nx} ${pt.y - ny}`);
|
||||
// Every third sample — the same rough 9px spacing `rail()` uses for a straight run of similar
|
||||
// length, not tied to `N` itself.
|
||||
if (i % 3 === 0) {
|
||||
ties += `<line class="bs-tie" x1="${pt.x + nx * 1.8}" y1="${pt.y + ny * 1.8}" x2="${pt.x - nx * 1.8}" y2="${pt.y - ny * 1.8}"/>`;
|
||||
}
|
||||
}
|
||||
return (
|
||||
`<path class="bs-rail" fill="none" d="M${left.join(' L')}"/>` +
|
||||
`<path class="bs-rail" fill="none" d="M${right.join(' L')}"/>` +
|
||||
ties
|
||||
);
|
||||
};
|
||||
|
||||
// Where each port meets the card edge. East and west sit at the rail height — the card's middle —
|
||||
// so a straight run stays straight across the whole row; north and south are centred on the edge.
|
||||
const port = (p: string): { x: number; y: number } => {
|
||||
@@ -694,23 +534,19 @@ export function officeSvg(
|
||||
out += rail(port(from).x, port(from).y, port(to).x, port(to).y);
|
||||
} else {
|
||||
/**
|
||||
* A 45° LEG — drawn as a smooth curve (v0.5.0) that still passes through the same FROG the
|
||||
* old two-segment version bent at, so the underlying geometry (and the `frog` position used
|
||||
* elsewhere for the actual joining/matching rules) is unchanged; only the picture is.
|
||||
* A 45° LEG, drawn as the card prints it: along the centre line from the east or west edge
|
||||
* to the FROG, then out at exactly 45° through the middle of the north or south edge.
|
||||
*
|
||||
* The frog is `H/2` from the centre because a 45° run climbing half the card's height
|
||||
* travels half its height sideways. The control points sit halfway from each endpoint to the
|
||||
* frog, which is what gives the curve a horizontal tangent at the e/w edge (matching an
|
||||
* abutting straight card's through-rail) and an exact 45° tangent at the n/s edge (matching
|
||||
* the card above or below) — see `curvedRail`.
|
||||
* travels half its height sideways. This used to be a fixed elbow at (W/2, RAIL+(H-RAIL)/2)
|
||||
* — below the rail on the assumption everything diverged downward — which drew a leg
|
||||
* reaching north as a hook that dropped past the rail and came back up, and drew nothing at
|
||||
* any angle the matching rule cares about.
|
||||
*/
|
||||
const side = vertical === from ? to : from;
|
||||
const frog = { x: W / 2 + (side === 'e' ? H / 2 : -H / 2), y: RAIL };
|
||||
const start = port(side);
|
||||
const edge = port(vertical);
|
||||
const c1 = { x: start.x + 0.5 * (frog.x - start.x), y: start.y };
|
||||
const c2 = { x: edge.x + 0.5 * (frog.x - edge.x), y: edge.y + 0.5 * (frog.y - edge.y) };
|
||||
out += curvedRail(start, c1, c2, edge);
|
||||
out += rail(port(side).x, port(side).y, frog.x, frog.y) + rail(frog.x, frog.y, edge.x, edge.y);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1191,15 +1027,6 @@ export const BOARD_CSS = `
|
||||
.bs-cn{fill:#e6e9ee;font:600 11px ui-monospace,monospace}
|
||||
.bs-coord{fill:#5f6b7a;font:9px ui-monospace,monospace}
|
||||
.bs-name{fill:#e6e9ee;font:600 11px ui-monospace,monospace}
|
||||
.bs-name.bs-you{fill:#5aa9e6}
|
||||
/* Their move — wins over .bs-you when both apply, because whose turn it is changes every few
|
||||
seconds and which railroad is yours never does.
|
||||
|
||||
NO WEIGHT BUMP. This was 700 and the name came out fuzzy to the point of being unreadable: the
|
||||
base is already 600, so at 11px a monospace face has to be synthesised the rest of the way, and
|
||||
the extra ink lands as blur rather than as weight. Amber against #e6e9ee is the distinction; it
|
||||
does not need help. */
|
||||
.bs-name.bs-turn{fill:#f0b64a}
|
||||
.bs-cap{fill:#8b94a3;font:10px ui-monospace,monospace}
|
||||
.bs-cap.bs-full{fill:#e0a060;font-weight:600}
|
||||
.bs-grade{fill:#e08060;font:10px ui-monospace,monospace}
|
||||
|
||||
+17
-73
@@ -35,7 +35,7 @@ import type { Intent } from '../engine/intents.ts';
|
||||
import { legalActions } from '../engine/legal.ts';
|
||||
import { connectionsFor, exitsFrom, facilityVariants, hasPort, joins, neighbour, opposite, variantsFor } from '../engine/track.ts';
|
||||
import type { Port } from '../engine/track.ts';
|
||||
import { actingPlayer, coordKey, turnOf } from '../engine/state.ts';
|
||||
import { coordKey, turnOf } from '../engine/state.ts';
|
||||
import type { Facility, GameState, GridCoord, OfficeArea, PlayerIndex, RollingStock, TrackCard } from '../engine/state.ts';
|
||||
|
||||
export type BotPolicy = {
|
||||
@@ -138,39 +138,13 @@ export function makeDeveloperBot(tweaks: BotTweaks): BotPolicy {
|
||||
|
||||
choose(s, player, options) {
|
||||
lastReason = 'no specific reason — first legal option';
|
||||
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — a bot never asks for another Day.
|
||||
*
|
||||
* "If only bots are playing, they never vote to extend" (Jesse, 2026-08-28), which is what keeps
|
||||
* the balance harness and every bot-only game ending at the timetable it was dealt with. It also
|
||||
* makes this the SAFE DEFAULT everywhere else: a bot's agreement in a game with humans in it is
|
||||
* decided by `server/session.ts`, which votes on the bots' behalf only once every human has
|
||||
* already said yes, and never reaches this policy at all.
|
||||
*/
|
||||
const extend = options.find((i) => i.type === 'game.extend' && i.agree === false);
|
||||
if (extend) return because('a bot plays the timetable it was dealt and no more', extend);
|
||||
|
||||
const clearance = ruleOnClearance(options);
|
||||
if (clearance) return because('the Superintendent must rule on a following train', clearance);
|
||||
|
||||
/**
|
||||
* §11 (Gitea#5) — the bot keeps its trains at the Train Order Office.
|
||||
*
|
||||
* A deliberate policy, not an oversight, and the cautious half of a real choice: the Yard Office
|
||||
* frees an A/D track, which is worth something on a busy district, but the lead into it may be
|
||||
* fouled and the bot does not read its own yard well enough to tell (`TODO.md`, Bot
|
||||
* Performance — it cannot spot a car at a stub industry either). Declining is always safe, and
|
||||
* it keeps the balance harness comparable with every measurement taken before this rule existed.
|
||||
* Worth revisiting when the bot can judge the lead.
|
||||
*/
|
||||
const yardOffice = options.find((i) => i.type === 'mainline.yardOffice' && i.take === false);
|
||||
if (yardOffice) return because('the bot does not judge the lead into a yard, so it stays at the Office', yardOffice);
|
||||
if (clearance) return because('the Superintendent must rule on a following train (§8.1)', clearance);
|
||||
|
||||
// Red Flags come before anything else — protection is only worth playing at the moment the
|
||||
// collision is actually pending, and that moment passes.
|
||||
const flags = worthFlagging(s, options);
|
||||
if (flags) return because('the engine says this arrival collides, and we hold a Red Flag — now or never', flags);
|
||||
if (flags) return because('a train of ours is stopped on a Mainline card with another train on it — Red Flags now or not at all', flags);
|
||||
|
||||
// --- Load/Unload: spend every worker, then end. Each is a point, or a step toward one.
|
||||
//
|
||||
@@ -1043,20 +1017,19 @@ function facilityWantsAt(
|
||||
}
|
||||
|
||||
/**
|
||||
* §Q, RED FLAGS (Gitea#19) — spent only at the moment of danger.
|
||||
*
|
||||
* The card was redefined: it plants a directional flag on your own Limits rather than protecting a
|
||||
* stopped train out on the Mainline, so the old heuristic ("is a train of ours sharing a Mainline
|
||||
* card") no longer describes anything the card does.
|
||||
*
|
||||
* The bot now flags ONLY through the out-of-phase prompt, which the engine raises exactly when an
|
||||
* arrival would collide (`redFlagStop`). That is a better policy than the old one and a much
|
||||
* simpler one: the engine has already established the danger, so there is nothing for the bot to
|
||||
* judge. It never plants a flag speculatively — it cannot tell whether it wants time to switch, and
|
||||
* a flag spent early is a flag not there when a train is actually bearing down.
|
||||
* Red Flags — "any time". Worth spending only when a train of ours is stopped out on the Mainline
|
||||
* with another train on the same card, which is the situation that becomes a rear-ender.
|
||||
*/
|
||||
function worthFlagging(_s: GameState, options: Intent[]): Intent | null {
|
||||
return options.find((i) => i.type === 'mainline.redFlag' && i.flag === true) ?? null;
|
||||
function worthFlagging(s: GameState, options: Intent[]): Intent | null {
|
||||
for (const i of options) {
|
||||
if (i.type !== 'maneuver.redFlags') continue;
|
||||
const tray = s.trays.get(i.trayId);
|
||||
if (!tray || tray.position.at !== 'mainline') continue;
|
||||
const node = s.division.nodes[tray.position.index];
|
||||
if (node?.kind !== 'mainline') continue;
|
||||
if (node.transits.length > 1) return i;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/** A one-line account of which Load/Unload action was taken, and why it ranked first. */
|
||||
@@ -1888,37 +1861,8 @@ export function playGame(
|
||||
tally(pumpFn(s));
|
||||
if (s.status === 'finished') break;
|
||||
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — a simulated game plays the timetable it was dealt.
|
||||
*
|
||||
* DECIDED BY THE DRIVER, not by the policy, and that distinction is the whole point. A bot that
|
||||
* is merely handed the two votes among its legal options will sometimes take another Day —
|
||||
* `randomBot` does so half the time — and since the table can go on granting Days for ever, the
|
||||
* game then runs until `maxTurns`. That is not a hypothetical: it turned `test/sim.test.ts` from
|
||||
* under a second into an unbounded hang, because every seeded game in the harness suddenly played
|
||||
* fifty thousand turns instead of two hundred.
|
||||
*
|
||||
* The harness exists to measure games of a configured length against a configured floor, so
|
||||
* "would you like more Days?" has one answer here whatever the policy. `developerBot` declines on
|
||||
* its own account too, which is what the server relies on when a table is all bots; this is the
|
||||
* guarantee that holds for every OTHER policy, including ones not written yet.
|
||||
*/
|
||||
if (s.status === 'awaitingExtension') {
|
||||
const voter = s.extensionVotes.findIndex((v) => v === null);
|
||||
if (voter < 0) break;
|
||||
const decline: Intent = { type: 'game.extend', player: voter, agree: false };
|
||||
intents.push(decline.type);
|
||||
history.push(decline);
|
||||
const declined = applyIntent(s, voter, decline);
|
||||
// A broken invariant, not a game ending early: the status says a vote is pending and `voter` is
|
||||
// a seat that has not cast one. Thrown rather than broken out of, matching the illegal-action
|
||||
// check below — silently returning a short game is how a dead replay looks like a real one.
|
||||
if (!declined.ok) throw new Error(`the extension vote was refused with ${declined.code}`);
|
||||
tally(declined.events);
|
||||
continue;
|
||||
}
|
||||
|
||||
const actor = actingPlayer(s);
|
||||
const actor =
|
||||
s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
|
||||
if (actor === null) break;
|
||||
|
||||
const options = legalActions(s, actor);
|
||||
|
||||
+11
-23
@@ -31,12 +31,6 @@
|
||||
|
||||
import { pump } from '../engine/advance.ts';
|
||||
import { createGame } from '../engine/setup.ts';
|
||||
import {
|
||||
DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
collectiveRevenueFloor,
|
||||
lengthProfile,
|
||||
} from '../engine/content.ts';
|
||||
import type { GameLength } from '../engine/content.ts';
|
||||
import type { GameConfig, GameMode } from '../engine/state.ts';
|
||||
import type { BotPolicy, BotTweaks } from './bot.ts';
|
||||
@@ -62,23 +56,17 @@ export type PairedResult = {
|
||||
variantStats: GameStats[];
|
||||
};
|
||||
|
||||
// Always one bot (`runOne` below), so the revenue floor is `collectiveRevenueFloor(1, days)`.
|
||||
const SOLO = (length: GameLength, mode: GameMode): GameConfig => {
|
||||
const days = lengthProfile(length).days;
|
||||
return {
|
||||
mode,
|
||||
days,
|
||||
minCombinedRevenue: collectiveRevenueFloor(1, days),
|
||||
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
};
|
||||
};
|
||||
const SOLO = (length: GameLength, mode: GameMode): GameConfig => ({
|
||||
mode,
|
||||
victory: 'highestAfterDays',
|
||||
length,
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
});
|
||||
|
||||
/**
|
||||
* One game, one seed, one policy.
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
/**
|
||||
* Live per-seat Frame delta — Phase 2 of `docs/architecture/multiplayer.md`.
|
||||
*
|
||||
* `src/sim/replay.ts`'s `compress()` looked like the thing to reuse here (D2/D3's "2.9 KB per push
|
||||
* with the board omitted when unchanged" cites it) but it solves a different problem: it interns
|
||||
* card/description strings across a WHOLE recorded array of frames, which only pays off when
|
||||
* bundling many frames into one replay file. A live server pushes one frame at a time and has
|
||||
* nothing to intern against. The part that genuinely carries over is much smaller — a one-step-back
|
||||
* "null if unchanged since the last thing sent to THIS seat" check on the three fields that make up
|
||||
* almost all of a Frame's size: `cells`, `facilities`, `division` (`replay.ts`'s own `keys` array).
|
||||
*
|
||||
* Node-free by design, unlike `replay.ts` (which imports `node:fs`) — both the server and a browser
|
||||
* `RemoteSession` import this file directly.
|
||||
*/
|
||||
|
||||
import type { CellView, DivisionView, FacilityView, Frame } from './view.ts';
|
||||
|
||||
/** A `Frame` with the three board-shaped fields replaced by `null` where unchanged since `previous`. */
|
||||
export type FrameDelta = Omit<Frame, 'cells' | 'facilities' | 'division'> & {
|
||||
cells: CellView[] | null;
|
||||
facilities: FacilityView[] | null;
|
||||
division: DivisionView[] | null;
|
||||
};
|
||||
|
||||
const BOARD_KEYS = ['cells', 'facilities', 'division'] as const;
|
||||
|
||||
/**
|
||||
* `previous` is the last Frame actually sent to THIS seat, or `null` for a first connect / a
|
||||
* reconnect after a gap — Phase 2 has no persistence to replay a gap against (Phase 3), so a
|
||||
* reconnect always gets a full Frame here rather than a delta.
|
||||
*/
|
||||
export function deltaFrame(previous: Frame | null, next: Frame): FrameDelta {
|
||||
const out = { ...next } as unknown as FrameDelta;
|
||||
for (const key of BOARD_KEYS) {
|
||||
const unchanged = previous !== null && JSON.stringify(previous[key]) === JSON.stringify(next[key]);
|
||||
(out as Record<string, unknown>)[key] = unchanged ? null : next[key];
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** The receiving side: merges a delta back onto the last full Frame this seat actually has. */
|
||||
export function applyDelta(previous: Frame | null, delta: FrameDelta): Frame {
|
||||
const out = { ...delta } as unknown as Frame;
|
||||
for (const key of BOARD_KEYS) {
|
||||
if (delta[key] === null) {
|
||||
if (previous === null) {
|
||||
throw new Error(`deltaFrame said "${key}" is unchanged, but there is no previous Frame to merge onto`);
|
||||
}
|
||||
(out as Record<string, unknown>)[key] = previous[key];
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
+7
-15
@@ -12,12 +12,7 @@
|
||||
*/
|
||||
|
||||
import { pump } from '../engine/advance.ts';
|
||||
import {
|
||||
DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
collectiveRevenueFloor,
|
||||
lengthProfile,
|
||||
} from '../engine/content.ts';
|
||||
import { collectiveRevenueFloor, lengthProfile } from '../engine/content.ts';
|
||||
import { createGame } from '../engine/setup.ts';
|
||||
import type { GameLength } from '../engine/content.ts';
|
||||
import type { GameConfig, GameMode } from '../engine/state.ts';
|
||||
@@ -65,17 +60,14 @@ function statsOf(xs: number[]): Stats {
|
||||
};
|
||||
}
|
||||
|
||||
function configFor(mode: GameMode, length: GameLength, players: number): GameConfig {
|
||||
const days = lengthProfile(length).days;
|
||||
function configFor(mode: GameMode, length: GameLength): GameConfig {
|
||||
return {
|
||||
mode,
|
||||
days,
|
||||
minCombinedRevenue: collectiveRevenueFloor(players, days),
|
||||
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
pvpCardsAllowed: false,
|
||||
victory: 'highestAfterDays',
|
||||
length,
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -91,7 +83,7 @@ export function simulate(opts: SimOptions): SimReport {
|
||||
const s = createGame({
|
||||
id: `sim-${i}`,
|
||||
seed,
|
||||
config: configFor(opts.mode, opts.length, opts.players.length),
|
||||
config: configFor(opts.mode, opts.length),
|
||||
playerNames: opts.players,
|
||||
});
|
||||
// The probe watches the game as it is played: the funnel gates are conditions at a moment, not
|
||||
@@ -162,7 +154,7 @@ export function formatReport(r: SimReport, length: GameLength, players: number):
|
||||
|
||||
// The provisional numbers this exists to test.
|
||||
out.push('\n against the provisional targets:');
|
||||
out.push(` ${profile.days} Days`);
|
||||
out.push(` target ${profile.target} over ${profile.days} Days`);
|
||||
out.push(
|
||||
` predicted ~5-6 revenue/player/Day steady state; observed mean ` +
|
||||
`${r.revenuePerPlayerPerDay.mean.toFixed(1)}`,
|
||||
|
||||
+21
-187
@@ -18,7 +18,7 @@
|
||||
import { MAX_CONSIST } from '../engine/content.ts';
|
||||
import { adTrackCount, coordKey, seatOf, turnOf } from '../engine/state.ts';
|
||||
import type { GameState, GridCoord, PlayerIndex, RollingStock, SeatIndex, TrayId } from '../engine/state.ts';
|
||||
import { areaOf, canAdvanceLoad, canBoard, canDetrain, canStartLoad, facilityCarType, facilityCarTypes, laborersLeft, movesFor, passengerRefusal, portersLeft } from '../engine/apply.ts';
|
||||
import { areaOf, canAdvanceLoad, canStartLoad, facilityCarType, facilityCarTypes, laborersLeft, movesFor, portersLeft } from '../engine/apply.ts';
|
||||
import type { GameEvent } from '../engine/events.ts';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -103,11 +103,6 @@ export type NarrateContext = {
|
||||
* game, phrased in internal identifiers.
|
||||
*/
|
||||
trainName?: (trayId: TrayId) => string;
|
||||
/**
|
||||
* Resolves a player index to their display name. Optional like the rest: an engine test narrating
|
||||
* events has no roster, and "Player 2" is a truthful fallback rather than a broken one.
|
||||
*/
|
||||
playerName?: (player: PlayerIndex) => string;
|
||||
};
|
||||
|
||||
export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
@@ -118,15 +113,6 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
// -- clock
|
||||
case 'stageBegan':
|
||||
return { tone: 'clock', text: `── Day ${e.day}, Stage ${e.stage} — ${clockTime(e.stage)} ──` };
|
||||
case 'seatsRotated':
|
||||
// Named players rather than seat numbers: the rule is that everyone MOVED, and a list of
|
||||
// indices does not say who is now next to whom.
|
||||
return {
|
||||
tone: 'clock',
|
||||
text: `Employee Rotation — everyone moves one chair left. West to East: ${e.seating
|
||||
.map((p) => ctx.playerName?.(p) ?? `Player ${p + 1}`)
|
||||
.join(' → ')}`,
|
||||
};
|
||||
case 'phaseBegan':
|
||||
// Its own tone, not `quiet`. A phase marker sat in the same grey as the events inside it, so
|
||||
// the log read as one undifferentiated column and you could not see where a phase began.
|
||||
@@ -218,19 +204,10 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
? `Realignment: Mainline card ${e.node} converted to ${e.became}`
|
||||
: `Played ${e.key} on Mainline card ${e.node}`,
|
||||
};
|
||||
case 'redFlagSpent':
|
||||
return {
|
||||
tone: 'good',
|
||||
text: `RED FLAG — Train ${e.trainNumber} stopped short of the ${e.side === 'east' ? 'Eastern' : 'Western'} Limits. The flag comes down with it.`,
|
||||
};
|
||||
case 'redFlagRuled':
|
||||
return e.flag
|
||||
? { tone: 'plain', text: `Player ${e.player} flagged the approaching train` }
|
||||
: { tone: 'plain', text: `Player ${e.player} waved the train through` };
|
||||
case 'redFlagsSet':
|
||||
return {
|
||||
tone: 'good',
|
||||
text: `RED FLAGS set out on the ${e.side === 'east' ? 'Eastern' : 'Western'} Limits — the next train from that way is held short`,
|
||||
text: `Red Flags set out to protect train ${e.trayId} on Mainline card ${e.node} — an approaching train must stop`,
|
||||
};
|
||||
case 'flyingSwitch':
|
||||
return {
|
||||
@@ -276,33 +253,16 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
case 'secondSectionOrdered':
|
||||
return {
|
||||
tone: 'bad',
|
||||
text: `SECOND SECTION ordered on Train ${e.trainNumber} — an identical train will run right behind it, which forces the Superintendent to rule on a following train`,
|
||||
text: `SECOND SECTION ordered on Train ${e.trainNumber} — an identical train will run right behind it, which forces the Superintendent to rule on a following train (§8.1)`,
|
||||
};
|
||||
/**
|
||||
* WHERE THE PLAYER PUT IT, not where its number would have sent it.
|
||||
*
|
||||
* An Extra's direction comes from its start now (§7, Jesse's ruling), so the line that used to
|
||||
* explain the number's parity would be explaining a rule that no longer applies to this train.
|
||||
*/
|
||||
case 'extraStarted': {
|
||||
const where =
|
||||
e.at.kind === 'divisionPoint'
|
||||
? `the ${e.at.side === 'west' ? 'Western' : 'Eastern'} Division Point`
|
||||
: e.at.kind === 'mainline'
|
||||
? "the Interchange's yard"
|
||||
: `the Control Point in seat ${e.at.seat}`;
|
||||
const why =
|
||||
e.at.kind === 'divisionPoint'
|
||||
? 'the end it runs away from — an Extra may start at either, and the end chooses the run'
|
||||
: e.at.kind === 'mainline'
|
||||
? 'made up off the running line, so it highballs onto the Mainline once the Subdivision ' +
|
||||
'is clear and may be held in the yard until it is'
|
||||
: 'an Extra may begin at any Office above a Whistle Post, and the player chooses the run';
|
||||
case 'extraStarted':
|
||||
return {
|
||||
tone: 'good',
|
||||
text: `EXTRA X${e.trainNumber} started at ${where}, running ${e.direction} — ${why}`,
|
||||
text:
|
||||
e.atSeat === null
|
||||
? `EXTRA X${e.trainNumber} started at the ${e.trainNumber % 2 === 0 ? 'Western' : 'Eastern'} Division Point, running ${e.trainNumber % 2 === 0 ? 'east' : 'west'} — odd numbers run west and even run east (§2.3), so its number chose the end`
|
||||
: `EXTRA X${e.trainNumber} started at the Control Point in seat ${e.atSeat}, running ${e.trainNumber % 2 === 0 ? 'east' : 'west'} — an Extra may begin at any Office above a Whistle Post instead of at a Division Point`,
|
||||
};
|
||||
}
|
||||
case 'trainMadeUp':
|
||||
return {
|
||||
tone: 'good',
|
||||
@@ -391,7 +351,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
return {
|
||||
tone: 'good',
|
||||
text: bumped
|
||||
? `Train ${e.trainNumber} SCHEDULED at Stage ${e.slot + 1} — rolled ${e.roll}, but Stage ${e.roll} was already taken, so it moved down the column to the next free Stage`
|
||||
? `Train ${e.trainNumber} SCHEDULED at Stage ${e.slot + 1} — rolled ${e.roll}, but Stage ${e.roll} was already taken, so it moved down the column to the next free Stage (§7)`
|
||||
: `Train ${e.trainNumber} SCHEDULED to depart at Stage ${e.slot + 1} (rolled ${e.roll}) — it will run at this time EVERY Day from now on`,
|
||||
};
|
||||
}
|
||||
@@ -409,9 +369,9 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
// player the score had changed and nothing else.
|
||||
const why =
|
||||
e.reason === 'no free A/D track'
|
||||
? `it arrived at ${e.where} with every A/D track already occupied — there was nowhere to put it`
|
||||
? `it arrived at ${e.where} with every A/D track already occupied — there was nowhere to put it (§8.3)`
|
||||
: e.reason === 'cars fouling the Running Track'
|
||||
? `it ran into cars left standing on ${e.where} between the Limits and the Office`
|
||||
? `it ran into cars left standing on ${e.where} between the Limits and the Office (§8.3)`
|
||||
: e.reason;
|
||||
const wrecked = e.trains
|
||||
.map((t) => `${t.label} (${t.consist.length ? carsLabel(t.consist) : 'no cars'})`)
|
||||
@@ -420,7 +380,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
tone: 'bad',
|
||||
text:
|
||||
`COLLISION — ${wrecked} destroyed: ${why}. Engines and cabooses go back to the Division ` +
|
||||
`Yard, all other cars to the Classification Yard. A Timetabled train card returns ` +
|
||||
`Yard, all other cars to the Classification Yard (§10). A Timetabled train card returns ` +
|
||||
`to its slot and runs again next Day; an Extra is gone for good.`,
|
||||
};
|
||||
}
|
||||
@@ -429,7 +389,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
return {
|
||||
tone: 'bad',
|
||||
text:
|
||||
`SUPERINTENDENT MUST RULE: ${train(e.trainId)} wants to enter the Mainline card ` +
|
||||
`SUPERINTENDENT MUST RULE (§8.1): ${train(e.trainId)} wants to enter the Mainline card ` +
|
||||
`that ${train(e.occupiedBy)} is still crossing. Allow it and ${train(e.trainId)} may run ` +
|
||||
`into the back of ${train(e.occupiedBy)} — a collision costs 5 Revenue. Hold it and it ` +
|
||||
`waits where it is, losing time but safe.`,
|
||||
@@ -449,13 +409,13 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
return {
|
||||
tone: 'good',
|
||||
where: e.at,
|
||||
text: `Porter boarded passengers at ${at(e.at)} — one coach per Porter per Stage`,
|
||||
text: `Porter boarded passengers at ${at(e.at)} — one coach per Porter per Stage (§9.2)`,
|
||||
};
|
||||
case 'passengersDetrained':
|
||||
return {
|
||||
tone: 'good',
|
||||
where: e.at,
|
||||
text: `Porter de-trained passengers at ${at(e.at)} — one coach per Porter per Stage`,
|
||||
text: `Porter de-trained passengers at ${at(e.at)} — one coach per Porter per Stage (§9.2)`,
|
||||
};
|
||||
|
||||
// -- freight pipeline
|
||||
@@ -497,22 +457,6 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
|
||||
: { tone: 'good', text: `+${e.delta} Revenue (now ${e.total}) — ${e.reason}` };
|
||||
case 'phaseEnded':
|
||||
return { tone: 'quiet', text: `Player ${e.player} finished ${phaseLabel(e.phase)}` };
|
||||
|
||||
// -- §3.3, extended play (Gitea#11)
|
||||
case 'extensionVoted':
|
||||
return e.agree
|
||||
? { tone: 'plain', text: `Player ${e.player} would play one more Day` }
|
||||
: { tone: 'plain', text: `Player ${e.player} called time — the game ends here` };
|
||||
case 'dayExtended':
|
||||
return { tone: 'clock', text: `── The table plays on: Day ${e.day} is added to the timetable ──` };
|
||||
case 'playConcluded':
|
||||
return { tone: 'clock', text: '── The railroad is put to bed. Final results stand. ──' };
|
||||
|
||||
// -- §11, the Yard Office (Gitea#5)
|
||||
case 'yardOfficeRuled':
|
||||
return e.take
|
||||
? { tone: 'plain', text: `Player ${e.player} sent ${train(e.trainId)} into the Yard Office` }
|
||||
: { tone: 'plain', text: `Player ${e.player} kept ${train(e.trainId)} at the Train Order Office` };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -549,124 +493,14 @@ export type Impediment = { where: string; why: string; severity: 'stuck' | 'wait
|
||||
* This is the panel that should answer the standing questions: whether facilities jam, whether
|
||||
* trains are held for want of a crew, whether the Office is about to cause a collision.
|
||||
*/
|
||||
/** `coordKey`'s inverse — the grid is keyed by string and the engine predicates take coordinates. */
|
||||
function uncoordKey(key: string): GridCoord {
|
||||
const [row, col] = key.split(',').map(Number);
|
||||
return { row: row ?? 0, col: col ?? 0 };
|
||||
}
|
||||
|
||||
/**
|
||||
* One of `passengerRefusal`'s codes, in words a player can act on.
|
||||
*
|
||||
* `NO_EMPTY_COACH_IN_YARD` gets the longest answer because it is the one that looks like a broken
|
||||
* game: the Division Yard is visibly full of cars, and the single type that has run out is the one
|
||||
* §9.2 needs. Where the missing coaches ARE, and the condition that brings them back, is the whole
|
||||
* of what the player needs to know — §2.2 returns the Classification Yard only when the Division
|
||||
* Yard is bare, so a yard with fifty freight cars in it will not refill for a long time.
|
||||
*/
|
||||
function passengerReason(
|
||||
s: GameState,
|
||||
player: PlayerIndex,
|
||||
at: GridCoord,
|
||||
dir: 'board' | 'detrain',
|
||||
): string {
|
||||
const code = passengerRefusal(s, player, at, dir);
|
||||
switch (code) {
|
||||
case 'NO_TRAIN_AT_OFFICE':
|
||||
return dir === 'board'
|
||||
? 'passengers waiting, no train at the platform to take them'
|
||||
: 'no train at the platform';
|
||||
case 'NOT_A_TERMINAL':
|
||||
return 'the only train here stops at Terminals only — Porters may not work it at this Office';
|
||||
case 'NO_PASSENGER_WORK':
|
||||
return 'the only train here is one its card bars Porters from working';
|
||||
case 'NO_EMPTY_COACH':
|
||||
return 'passengers waiting, but every coach on the train is already full';
|
||||
case 'INBOUND_BOX_FULL':
|
||||
return 'arrivals aboard, but the red Unloading slots are all occupied';
|
||||
case 'LOADED_IN_THIS_DISTRICT':
|
||||
return 'the loaded coaches all boarded here — passengers must be carried to another Office ' +
|
||||
'Area before they can alight';
|
||||
case 'NO_EMPTY_COACH_IN_YARD': {
|
||||
const stuck = s.yards.classificationYard.filter((c) => c.type === 'coach').length;
|
||||
const total = s.yards.divisionYard.length;
|
||||
return (
|
||||
'arrivals aboard, but §9.2 needs a white empty coach from the Division Yard to swap in and ' +
|
||||
`there is none left${stuck > 0 ? ` — ${stuck} ${stuck === 1 ? 'coach is' : 'coaches are'} in the Classification Yard` : ''}. ` +
|
||||
`Classification returns only when the Division Yard is bare, and it still holds ${total} cars.`
|
||||
);
|
||||
}
|
||||
default:
|
||||
return `Porters cannot work here (${code})`;
|
||||
}
|
||||
}
|
||||
|
||||
export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[] {
|
||||
const out: Impediment[] = [];
|
||||
const area = areaOf(s, player);
|
||||
|
||||
for (const [key, card] of area.grid) {
|
||||
const f = card.facility;
|
||||
if (!f) continue;
|
||||
/**
|
||||
* A Freight Facility names itself off its own card; a Passenger Facility does NOT — it rides on
|
||||
* the `office` card, so `geometry.kind` is `'office'` and it fell through to the literal
|
||||
* "facility". Every passenger impediment therefore read `facility 0,0`, next to a freight row
|
||||
* saying `mineTipple 1,-3`. The Office Area's tier is the name it should carry, and there is
|
||||
* exactly one Office per Area, so `area.tier` is that card's own.
|
||||
*/
|
||||
const name =
|
||||
card.geometry.kind === 'facility'
|
||||
? card.geometry.facility
|
||||
: card.geometry.kind === 'office'
|
||||
? area.tier
|
||||
: 'facility';
|
||||
|
||||
/**
|
||||
* WHY THE PORTERS ARE STANDING THERE (Gitea#2).
|
||||
*
|
||||
* "Note that the sparrow (with two loaded coaches) pulled into the station. There are two
|
||||
* passengers on the platform. Four porters. My thought was to unload two and load two. I never
|
||||
* get the chance to load the last two."
|
||||
*
|
||||
* The engine was right — §9.2 needs a white coach out of the Division Yard to de-train into,
|
||||
* §2.2 returns the Classification Yard only when the Division Yard is BARE, and the Division
|
||||
* Yard was one empty coach short with eight more sitting in Classification unable to come back.
|
||||
* Jesse's ruling is that the shortage stays: "it is possible to run out — that's part of the
|
||||
* strategy." What was missing was any way to SEE it. A Porter action that cannot be taken is
|
||||
* simply absent from the menu, and this panel — the one that answers "why is nothing moving?" —
|
||||
* covered freight facilities only, so the platform had nothing to say for itself at all.
|
||||
*
|
||||
* The reason comes from `passengerRefusal`, the engine's own, so what is on screen is the rule
|
||||
* that actually refused rather than a second guess at it.
|
||||
*/
|
||||
if (f.kind === 'passenger') {
|
||||
if (portersLeft(f) > 0) {
|
||||
const coord = uncoordKey(key);
|
||||
// Passengers standing on the platform with nothing carrying them away.
|
||||
if (f.outboundBox.some((c) => c.type === 'coach' && c.loaded) && !canBoard(s, player, coord)) {
|
||||
out.push({
|
||||
where: `${name} ${key}`,
|
||||
why: passengerReason(s, player, coord, 'board'),
|
||||
severity: 'waiting',
|
||||
});
|
||||
}
|
||||
// A coach full of arrivals that cannot be emptied.
|
||||
const arriving = area.adOccupancy.some((id) =>
|
||||
s.trays.get(id)?.consist.some((c) => c.type === 'coach' && c.loaded && c.origin !== seatOf(s, player)),
|
||||
);
|
||||
if (arriving && !canDetrain(s, player, coord)) {
|
||||
out.push({
|
||||
where: `${name} ${key}`,
|
||||
why: passengerReason(s, player, coord, 'detrain'),
|
||||
severity: 'stuck',
|
||||
});
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (f.kind !== 'freight') continue;
|
||||
if (!f || f.kind !== 'freight') continue;
|
||||
const name = card.geometry.kind === 'facility' ? card.geometry.facility : 'facility';
|
||||
const want = facilityCarType(f);
|
||||
|
||||
// A load that cannot move, with Laborers standing by, is the worst state a facility reaches:
|
||||
@@ -697,7 +531,7 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
|
||||
why: blockedByBox
|
||||
? 'green box has a load but MEN is occupied'
|
||||
: `a load is staged but no empty ${want} is spotted on this industry's track — it stays ` +
|
||||
'in the green box until a crew sets one out here',
|
||||
'in the green box until a crew sets one out here (§9.3)',
|
||||
severity: blockedByBox ? 'waiting' : 'stuck',
|
||||
});
|
||||
}
|
||||
@@ -718,7 +552,7 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
|
||||
why: spotted
|
||||
? 'green box empty — nothing to load (needs a Freight Agent action)'
|
||||
: `green box empty — the Freight Agent can stage a load now, but no empty ${want} is ` +
|
||||
'spotted here, so a crew must set one out before Laborers can work it',
|
||||
'spotted here, so a crew must set one out before Laborers can work it (§9.3)',
|
||||
severity: 'waiting',
|
||||
});
|
||||
}
|
||||
@@ -803,7 +637,7 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
|
||||
|
||||
if (pf.porters < 1) {
|
||||
say(
|
||||
'this Office has NO Porters — a Whistle Post is not a Passenger Facility and cannot ' +
|
||||
'this Office has NO Porters — a Whistle Post is not a Passenger Facility (§9) and cannot ' +
|
||||
'work passengers at all. Upgrade it to a Depot or better.',
|
||||
'stuck',
|
||||
);
|
||||
@@ -826,7 +660,7 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
|
||||
);
|
||||
}
|
||||
if (loadedOnTrain && !s.yards.divisionYard.some((c) => c.type === 'coach' && !c.loaded)) {
|
||||
say('no EMPTY coach in the Division Yard to swap into the train — one is required');
|
||||
say('no EMPTY coach in the Division Yard to swap into the train (§9.2 requires one)');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+9
-27
@@ -21,20 +21,12 @@ import { writeFileSync } from 'node:fs';
|
||||
import { advance } from '../engine/advance.ts';
|
||||
import { applyIntent, areaOf, facilityCarType, laborersLeft, portersLeft } from '../engine/apply.ts';
|
||||
import type { GameLength } from '../engine/content.ts';
|
||||
import {
|
||||
DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
MAINLINE_PROFILES,
|
||||
collectiveRevenueFloor,
|
||||
lengthProfile,
|
||||
officeProfile,
|
||||
} from '../engine/content.ts';
|
||||
import { MAINLINE_PROFILES, lengthProfile, officeProfile } from '../engine/content.ts';
|
||||
import type { GameEvent } from '../engine/events.ts';
|
||||
import type { Intent } from '../engine/intents.ts';
|
||||
import { legalActions } from '../engine/legal.ts';
|
||||
import { createGame } from '../engine/setup.ts';
|
||||
import type { Facility, GameConfig, GameState } from '../engine/state.ts';
|
||||
import { actingPlayer } from '../engine/state.ts';
|
||||
import { developerBot, lastChoiceReason } from './bot.ts';
|
||||
import { carLabel, cuesFor, idleNote, isVisible, narrate } from './narrate.ts';
|
||||
// The view-model lives in its own module so the browser build can import it without dragging in
|
||||
@@ -59,16 +51,13 @@ import { playCue } from '../web/sound.ts';
|
||||
export type Recording = { seed: number; length: GameLength; frames: Frame[]; outcome: string };
|
||||
|
||||
export function record(seed: number, length: GameLength, maxSteps = 100_000): Recording {
|
||||
const days = lengthProfile(length).days;
|
||||
const config: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days,
|
||||
minCombinedRevenue: collectiveRevenueFloor(1, days),
|
||||
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
pvpCardsAllowed: false,
|
||||
victory: 'highestAfterDays',
|
||||
length,
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -136,7 +125,7 @@ export function record(seed: number, length: GameLength, maxSteps = 100_000): Re
|
||||
if (s.status === 'finished') break;
|
||||
if (!r.needsInput) continue;
|
||||
|
||||
const actor = actingPlayer(s);
|
||||
const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
|
||||
if (actor === null) break;
|
||||
const options = legalActions(s, actor);
|
||||
if (options.length === 0) break;
|
||||
@@ -274,7 +263,7 @@ export function rehydrateCells(
|
||||
}
|
||||
|
||||
export function renderHtml(rec: Recording): string {
|
||||
const profile = lengthProfile(rec.length);
|
||||
const target = lengthProfile(rec.length);
|
||||
return `<!doctype html>
|
||||
<html lang="en"><head><meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1">
|
||||
@@ -371,7 +360,7 @@ kbd{background:#2a3038;border:1px solid var(--line);border-radius:3px;padding:0
|
||||
</style></head><body>
|
||||
|
||||
<header>
|
||||
<h1>Station Master — replay · seed ${rec.seed} · ${rec.length} (${profile.days} Days) · ${esc(rec.outcome)}</h1>
|
||||
<h1>Station Master — replay · seed ${rec.seed} · ${rec.length} (target ${target.target} over ${target.days} Days) · ${esc(rec.outcome)}</h1>
|
||||
<div class="bar">
|
||||
<span class="dim">fedora <span id="super">—</span></span>
|
||||
<span>revenue <b class="big" id="rev">0</b></span>
|
||||
@@ -493,11 +482,7 @@ function boxes(items, cap, cls) {
|
||||
|
||||
function render() {
|
||||
const f = FRAMES[i];
|
||||
$('turnchart').innerHTML = turnChartHtml(
|
||||
f,
|
||||
f.actor === null ? null : 'Player ' + (f.actor + 1),
|
||||
f.players.length > 1 ? 'Player ' + (f.superintendent + 1) : null,
|
||||
);
|
||||
$('turnchart').innerHTML = turnChartHtml(f, f.actor === null ? null : 'Player ' + (f.actor + 1));
|
||||
$('super').textContent = 'P' + f.superintendent;
|
||||
$('rev').textContent = f.revenue;
|
||||
$('rev').className = 'big ' + (f.revenue < 0 ? 't-bad' : f.revenue > 0 ? 't-good' : '');
|
||||
@@ -517,10 +502,7 @@ function render() {
|
||||
|
||||
const CELLS = cellsAt(i), FACS = carry(i, 'facilities'), DIV = carry(i, 'division');
|
||||
|
||||
// players, actor and viewer are not among the delta'd keys (see compress), so they ride whole on
|
||||
// every frame and the replay names the districts exactly as the live page does. No backticks in
|
||||
// this comment: it is inside the generated-page template literal, which they would terminate.
|
||||
$('division').innerHTML = divisionSvg(DIV, { players: f.players, actor: f.actor, viewer: f.viewer });
|
||||
$('division').innerHTML = divisionSvg(DIV);
|
||||
// The same office renderer the playable app uses, so replay and game draw one board.
|
||||
$('grid').innerHTML = officeSvg(CELLS, f.runningRow, [], [], f.limits);
|
||||
|
||||
|
||||
@@ -52,21 +52,6 @@ export type PlayedGame = {
|
||||
export function playForReplay(seed: number, policy: BotPolicy, maxTurns = 50_000): PlayedGame {
|
||||
const game = newGame(seed);
|
||||
for (let t = 0; t < maxTurns; t++) {
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — a recorded replay is a game played to its end.
|
||||
*
|
||||
* The timetable running out leaves the game on "play one more Day?", where `currentActor` is
|
||||
* null and this loop would otherwise stop — recording a file that replays to a question nobody
|
||||
* answered rather than to a finished game. A recording bot plays the timetable it was dealt, the
|
||||
* same rule `playGame` follows, so it declines and the file ends where a real game would.
|
||||
*/
|
||||
if (game.state.status === 'awaitingExtension') {
|
||||
const voter = game.state.extensionVotes.findIndex((v) => v === null);
|
||||
if (voter < 0) break;
|
||||
if (!submit(game, { type: 'game.extend', player: voter, agree: false }, voter)) break;
|
||||
continue;
|
||||
}
|
||||
|
||||
const actor = currentActor(game);
|
||||
if (actor === null) break;
|
||||
const options = legalActions(game.state, actor);
|
||||
|
||||
+2
-27
@@ -27,18 +27,7 @@ export type TurnChartFrame = {
|
||||
* The first three are the rules text; Cargo and Supervisor Shift are written from what the engine
|
||||
* does, since the recovered sheet does not spell them out.
|
||||
*/
|
||||
/**
|
||||
* `superName` is the player holding the Fedora, or null for a table where saying so is noise — one
|
||||
* seat, where it is always you.
|
||||
*
|
||||
* REPORTED BY JESSE 2026-08-23, from a two-player game on StartOS: seat 1 played a train card and
|
||||
* seat 2 was asked to build the train, "what's the rule for WHICH player builds a train?" The engine
|
||||
* was right — §7 makes up a consist "starting with the Superintendent and working left" — but the
|
||||
* board did not name the Superintendent ANYWHERE, so the question could not be answered from the
|
||||
* screen. `Frame` has carried `superintendent` all along and the standalone replay printed it; the
|
||||
* live game never did.
|
||||
*/
|
||||
export function turnChartHtml(f: TurnChartFrame, actorName: string | null, superName: string | null = null): string {
|
||||
export function turnChartHtml(f: TurnChartFrame, actorName: string | null): string {
|
||||
const PHASES: { key: string; label: string; tip: string; icon: string }[] = [
|
||||
{
|
||||
key: 'localOps',
|
||||
@@ -50,10 +39,7 @@ export function turnChartHtml(f: TurnChartFrame, actorName: string | null, super
|
||||
{
|
||||
key: 'newTrain',
|
||||
label: 'New Train',
|
||||
// Says WHO builds, which is the question this phase actually raises at a table: the round
|
||||
// starts with the Superintendent and works left, one car each, repeating (§7, Gap 9) — not
|
||||
// with whoever played the card. An Extra is the exception: its player loads it as they choose.
|
||||
tip: 'Timetabled trains for this Stage are built: starting with the Superintendent and working left, each player adds ONE car, going round again until the consist is full or the Division Yard has nothing suitable. New timetabled trains are rolled onto the timetable. Held trains are built. An Extra is loaded by the player who played it.',
|
||||
tip: 'Timetabled trains for this Stage are built. New timetabled trains are randomly placed on the timetable. Held trains are built. Extra trains are built.',
|
||||
// a locomotive being made up
|
||||
icon: '<rect class="ic" x="2" y="6" width="9" height="7" rx="1"/><path class="ic" d="M11 9h4v4h-4"/><circle class="icf" cx="5" cy="15" r="1.5"/><circle class="icf" cx="13" cy="15" r="1.5"/>',
|
||||
},
|
||||
@@ -95,18 +81,12 @@ export function turnChartHtml(f: TurnChartFrame, actorName: string | null, super
|
||||
|
||||
// An automatic phase is waiting on nobody, and saying so is more use than a blank.
|
||||
const who = actorName ?? 'nobody — the Division is running itself';
|
||||
const fedora =
|
||||
superName === null
|
||||
? ''
|
||||
: `<div class="tc-super" data-tip="The Superintendent holds the Fedora. Every third Stage — 3, 6, 9 and 12 — it passes one seat to the left. The office rules on whether a following train may depart, and every round that goes round the table starts here: the New Train make-up round, and the acting order within a phase." tabindex="0">` +
|
||||
`<span aria-hidden="true">🎩</span> Superintendent <b>${esc(superName)}</b></div>`;
|
||||
|
||||
return (
|
||||
`<div class="tc-when"><b>Day ${f.day}</b><span>Stage ${f.stage} of 12</span>` +
|
||||
`<span class="dim">${esc(f.clock)}</span></div>` +
|
||||
`<div class="tc-now">phase <b>${esc(f.phase)}</b></div>` +
|
||||
`<div class="tc-who">waiting on <b>${esc(who)}</b></div>` +
|
||||
fedora +
|
||||
`<ol class="tc-phases">${chips}</ol>`
|
||||
);
|
||||
}
|
||||
@@ -132,11 +112,6 @@ export const TURNCHART_CSS = `
|
||||
.tc-who{display:flex;align-items:center;gap:6px;font-size:12px;color:#8b94a3}
|
||||
.tc-who b{color:#b98cf0;background:rgba(150,110,230,.16);border:1px solid #8b6ad0;
|
||||
border-radius:11px;padding:1px 9px;font-size:12px}
|
||||
/* WHO HOLDS THE FEDORA. Violet like the rest of the chart — this is "where you are" news, not
|
||||
something to press — but unfilled, so the eye still lands on "waiting on" first: that is the one
|
||||
that changes every turn, while this changes four times a Day. */
|
||||
.tc-super{display:flex;align-items:center;gap:6px;font-size:12px;color:#8b94a3;cursor:help}
|
||||
.tc-super b{color:#cbb6f2;border:1px solid #6b5a94;border-radius:11px;padding:1px 9px;font-size:12px}
|
||||
ol.tc-phases{display:flex;gap:6px;list-style:none;margin:0;padding:0;flex-wrap:wrap}
|
||||
.tc-phase{display:flex;align-items:center;gap:6px;border:1px solid #2c333d;border-radius:14px;
|
||||
padding:3px 10px 3px 7px;font-size:11px;color:#8b94a3;background:#1a1f26;cursor:help}
|
||||
|
||||
+44
-259
@@ -10,7 +10,6 @@
|
||||
* drift into two different pictures of the same board.
|
||||
*/
|
||||
|
||||
import { regionOfTransit } from '../engine/advance.ts';
|
||||
import {
|
||||
areaAtSeat,
|
||||
areaOf,
|
||||
@@ -19,20 +18,18 @@ import {
|
||||
laborersLeft,
|
||||
movesFor,
|
||||
ownCutFor,
|
||||
keepReason,
|
||||
portersLeft,
|
||||
resolveExtraStart,
|
||||
selectDestination,
|
||||
} from '../engine/apply.ts';
|
||||
import {
|
||||
ACTION_CARDS,
|
||||
ENHANCEMENT_CARDS,
|
||||
HAND_LIMIT,
|
||||
MAINLINE_MODIFIER_CARDS,
|
||||
MAINLINE_PROFILES,
|
||||
MANEUVER_CARDS,
|
||||
MODIFIER_PROFILES,
|
||||
REALIGNMENTS,
|
||||
REGIONS_PER_MAINLINE_CARD,
|
||||
OFFICE_ORDER,
|
||||
SPACE_USE_CARDS,
|
||||
enhancementRule,
|
||||
@@ -40,13 +37,14 @@ import {
|
||||
industryProfile,
|
||||
mainlineProfile,
|
||||
modifierProfile,
|
||||
lengthProfile,
|
||||
officeProfile,
|
||||
trainProfile,
|
||||
houseRules,
|
||||
mainlineDescription,
|
||||
} from '../engine/content.ts';
|
||||
import type { Intent } from '../engine/intents.ts';
|
||||
import type { Facility, GameConfig, GameState, PlayerIndex, SeatIndex, TrackCard, TurnoutOrientation } from '../engine/state.ts';
|
||||
import type { Facility, GameState, PlayerIndex, SeatIndex, TrackCard, TurnoutOrientation } from '../engine/state.ts';
|
||||
import { carsOn, playerAtSeat, railFacingOf, seatOf, turnOf } from '../engine/state.ts';
|
||||
import type { Hand, HouseRules, TrackGeometry } from '../engine/content.ts';
|
||||
import type { Port } from '../engine/track.ts';
|
||||
@@ -277,22 +275,6 @@ export type RunningCardView = {
|
||||
trains: TrainChip[];
|
||||
};
|
||||
|
||||
/**
|
||||
* A seat as a PERSON counts them, from 1.
|
||||
*
|
||||
* Seats are zero-based everywhere inside — `PlayerIndex`, `seating`, the seats array, every route
|
||||
* — and that must not change, since it is what indexes into all of them. But nobody sitting down
|
||||
* at a table calls their chair "seat 0", so the number on screen is the one they would say out
|
||||
* loud. Every user-facing seat goes through here, so the two conventions cannot drift apart.
|
||||
*
|
||||
* It lives here rather than in `web/game.ts` because the page may not import values from that
|
||||
* module — they are the local engine by another name, and `test/session.test.ts` fails the build
|
||||
* for it. This is presentation, which is what `view.ts` is for.
|
||||
*/
|
||||
export function seatLabel(seat: number): number {
|
||||
return seat + 1;
|
||||
}
|
||||
|
||||
export type DivisionView = {
|
||||
kind: string;
|
||||
label: string;
|
||||
@@ -325,14 +307,6 @@ export type DivisionView = {
|
||||
/** Office nodes only: whose district this is. */
|
||||
/** Which SEAT's district this is — a position on the Division, not a player. */
|
||||
seat?: number;
|
||||
/**
|
||||
* Interchange only: trains standing in its yard, not out on the running line (state.ts).
|
||||
*
|
||||
* Separate from `trains` for the same reason `switching` is separate from an Office's A/D list —
|
||||
* they are not occupying the thing whose capacity is being counted. An Extra made up here has to
|
||||
* be VISIBLE, though, or the player who placed it has a train that exists nowhere on the map.
|
||||
*/
|
||||
yard?: TrainChip[];
|
||||
/**
|
||||
* Office nodes only: crews working BELOW the Running Track.
|
||||
*
|
||||
@@ -374,48 +348,8 @@ export type Frame = {
|
||||
* must be able to answer. Resolved, never partial, so nobody downstream re-applies defaults.
|
||||
*/
|
||||
houseRules: HouseRules;
|
||||
/**
|
||||
* WHICH GAME THIS IS — the mode it is scored under and Appendix B's three switches.
|
||||
*
|
||||
* Added 2026-08-23 with the game types (`web/presets.ts`). Everything else needed to name a game
|
||||
* "Co-op" or "Cutthroat" was already here; `mode` and `optionalRules` were the two missing pieces,
|
||||
* so a remote client could see the dials but not what they added up to — and a Cutthroat game
|
||||
* looked exactly like a Co-op one from the board.
|
||||
*/
|
||||
mode: GameConfig['mode'];
|
||||
optionalRules: GameConfig['optionalRules'];
|
||||
/**
|
||||
* The victory-condition dials this game was configured with (`GameConfig`, `state.ts`), plus the
|
||||
* running collision counts — same reasoning as `houseRules`: a remote client holds no `GameState`
|
||||
* and needs to show live progress ("2 of 3 collisions today") without guessing a default. `0` on
|
||||
* any `max*`/`minCombinedRevenue` field means that check is off.
|
||||
*/
|
||||
days: number;
|
||||
minCombinedRevenue: number;
|
||||
maxCollisionsPerDay: number;
|
||||
maxCollisionsTotal: number;
|
||||
collisionsToday: number;
|
||||
collisionsTotal: number;
|
||||
status: GameState['status'];
|
||||
outcome: GameState['outcome'];
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11). `days` above stays the ORIGINAL timetable — it is what the
|
||||
* official result was decided at — so the Day the game now runs to is `days + extraDays`.
|
||||
*/
|
||||
extraDays: number;
|
||||
/** Per PLAYER, while `status` is `awaitingExtension`. `null` is a seat that has not voted. */
|
||||
extensionVotes: (boolean | null)[];
|
||||
/** The official result, frozen when the original timetable ran out. Null until then. */
|
||||
official: GameState['official'];
|
||||
/**
|
||||
* Gitea#16 — everything interesting that has happened, folded from the event stream.
|
||||
*
|
||||
* Aggregate counts only, which is why it can ride the Frame at all: `test/redaction.test.ts`
|
||||
* proves a Frame carries no other seat's secrets, and a count of trains is nobody's secret. Being
|
||||
* here rather than on a side channel is what gets the results screen the same numbers in
|
||||
* multiplayer as in solitaire, from one implementation.
|
||||
*/
|
||||
tally: GameState['tally'];
|
||||
/**
|
||||
* Every PLAYER's public standing — names and Revenue. "The race is the game" (protocol.md §4).
|
||||
*
|
||||
@@ -424,32 +358,8 @@ export type Frame = {
|
||||
* player order once §4.4's D12 decided who sits where.
|
||||
*/
|
||||
players: { index: number; seat: number; name: string; revenue: number; hand: number }[];
|
||||
/**
|
||||
* WHO THIS FRAME WAS BUILT FOR.
|
||||
*
|
||||
* Every private thing on a Frame is already scoped to one player — the hand, the Office Area,
|
||||
* `revenue`, `option`, `movesLeft` — but nothing said which player that was, so a page rendering
|
||||
* it could show a railroad without being able to say whose it is. Harmless in solitaire, where
|
||||
* there is only one; the first thing you want to know at a four-player table.
|
||||
*/
|
||||
viewer: number;
|
||||
/** The viewer's position in the west-to-east chain, which is not their player index (§4.4). */
|
||||
viewerSeat: number;
|
||||
/**
|
||||
* §4.4's opening D12 per player, and the roll that chose the Superintendent — kept so a client
|
||||
* can show the chain being formed rather than only its result (`lobby-and-sessions.md` §4).
|
||||
* Indexed by player, like `s.players`, not by seat.
|
||||
*/
|
||||
openingRolls: { division: number[]; superintendent: number[] };
|
||||
/** How many cards the VIEWER holds. Other players' counts are in `players`. */
|
||||
handCount: number;
|
||||
/**
|
||||
* True when the VIEWER's hand is over §6.2's limit and their turn cannot end until it is played
|
||||
* down. Duplicates `game.ts`'s `overHandLimit(game, seat)` at the engine-data level rather than
|
||||
* importing the web layer here — a `RemoteSession` (Phase 2) has no `GameState` to compute this
|
||||
* from, only a `Frame`, so it has to already be resolved on the wire.
|
||||
*/
|
||||
overHandLimit: boolean;
|
||||
lines: { text: string; tone: string }[];
|
||||
where: { row: number; col: number } | null;
|
||||
/** Origin of a Move, so the crew's journey is visible rather than a chip teleporting. */
|
||||
@@ -507,25 +417,6 @@ export type Frame = {
|
||||
hand: string[];
|
||||
/** What each hand card does, in the same order — names alone are not a playable hand. */
|
||||
handWhat: string[];
|
||||
/**
|
||||
* Whether each hand card may be DISCARDED, in the same order.
|
||||
*
|
||||
* The player has to be told which cards those are, not merely find that a button is missing —
|
||||
* that silence is the whole of the Gitea#2 complaint, where a blocked platform left the board with
|
||||
* nothing to click and no reason. Named for the rule rather than for trains, since it answers the
|
||||
* question the panel is asking.
|
||||
*/
|
||||
handDiscardable: boolean[];
|
||||
/**
|
||||
* WHY a card may not be discarded, in the same order; `null` where it may.
|
||||
*
|
||||
* Carried rather than written on the page because §6.2 now fails for two different reasons
|
||||
* (Gitea#9): an Extra is never discardable, and a Timetabled train is not discardable only when
|
||||
* the `discardTimetabled` house rule is off. A panel that hard-codes one sentence tells half the
|
||||
* players the wrong thing, and a panel that reconstructs the rule is a second implementation of
|
||||
* it. `keepReason` is the engine's own, so the card says the rule that actually refused.
|
||||
*/
|
||||
handKeepWhy: (string | null)[];
|
||||
deck: number;
|
||||
/** The face-up card on top of each Department pile — the only one that may be drawn. */
|
||||
departments: string[];
|
||||
@@ -984,29 +875,14 @@ export function describeIntent(s: GameState, i: Intent): string {
|
||||
return `board passengers at ${at(i.at)}${onto(s, i.trayId, ' onto ')}`;
|
||||
case 'porter.detrain':
|
||||
return `detrain passengers at ${at(i.at)}${onto(s, i.trayId, ' from ')}`;
|
||||
/**
|
||||
* NAME THE PLACE AND THE DIRECTION, because the player is choosing both.
|
||||
*
|
||||
* This used to explain why the Extra had no choice — "it runs west, so that is the end it
|
||||
* starts from". It has one now (§7, Jesse's ruling), and every candidate is on screen at once,
|
||||
* so each label has to be distinguishable from its three or four siblings at a glance.
|
||||
*/
|
||||
case 'newTrain.startExtra': {
|
||||
const where = resolveExtraStart(s, s.clock.currentActor ?? 0, i);
|
||||
if (typeof where === 'string') return `start Extra X${i.trainNumber}`;
|
||||
const { direction } = where;
|
||||
if (where.at.kind === 'divisionPoint') {
|
||||
const end = where.at.side === 'west' ? 'Western' : 'Eastern';
|
||||
return `start Extra X${i.trainNumber} at the ${end} Division Point — it runs ${direction} from there`;
|
||||
const runs = i.trainNumber % 2 === 0 ? 'east' : 'west';
|
||||
if (i.atSeat === null) {
|
||||
const end = i.trainNumber % 2 === 0 ? 'Western' : 'Eastern';
|
||||
return `start Extra X${i.trainNumber} at the ${end} Division Point — it runs ${runs}, so that is the end it starts from`;
|
||||
}
|
||||
if (where.at.kind === 'mainline') {
|
||||
return (
|
||||
`start Extra X${i.trainNumber} ${direction}bound in the Interchange — it is made up in the ` +
|
||||
'yard and highballs onto the Mainline once the Subdivision is clear'
|
||||
);
|
||||
}
|
||||
const tier = officeProfile(areaAtSeat(s, where.at.seat).tier).name;
|
||||
return `start Extra X${i.trainNumber} ${direction}bound at the ${tier} in seat ${where.at.seat} — a Control Point, so it may begin its run there`;
|
||||
const tier = officeProfile(areaAtSeat(s, i.atSeat).tier).name;
|
||||
return `start Extra X${i.trainNumber} at the ${tier} in seat ${i.atSeat} — a Control Point, so it may begin its ${runs}bound run there instead`;
|
||||
}
|
||||
|
||||
case 'newTrain.placeCar':
|
||||
@@ -1043,41 +919,15 @@ export function describeIntent(s: GameState, i: Intent): string {
|
||||
return `${cardName(s, i.cardId)} on ${shortWhere} — ${where}${effect ? `; ${effect}` : ''}`;
|
||||
}
|
||||
case 'maneuver.redFlags':
|
||||
return (
|
||||
`FLAG ${i.side === 'east' ? 'EAST' : 'WEST'} — hold the next ${i.side === 'east' ? 'westbound' : 'eastbound'} ` +
|
||||
'train short of your Limits, so you can finish switching'
|
||||
);
|
||||
// §Q, the out-of-phase play (Gitea#19) — "COLLISION RISK! FLAG AGAINST T2?"
|
||||
case 'mainline.redFlag':
|
||||
return i.flag
|
||||
? 'FLAG IT — stop the train short of your Limits, spending a Red Flags card'
|
||||
: 'wave it through — let it come in';
|
||||
/**
|
||||
* §11, the Yard Office (Gitea#5). The offer interrupts the Mainline Phase, so the label has to
|
||||
* carry the whole question — there is no surrounding context on screen to lean on, and the
|
||||
* player is being asked about a train they were not otherwise thinking about.
|
||||
*/
|
||||
case 'mainline.yardOffice':
|
||||
return i.take
|
||||
? 'take the YARD OFFICE — straight into the yard, leaving the Train Order Office free'
|
||||
: 'keep it at the Train Order Office — the ordinary arrival, onto an A/D track';
|
||||
// §3.3, extended play (Gitea#11). The results screen draws its own buttons, but a bot reads its
|
||||
// options through this list like any other, and the label is what the history says it chose.
|
||||
case 'game.extend':
|
||||
return i.agree
|
||||
? 'play one more Day — the result already recorded still stands'
|
||||
: 'end the game here';
|
||||
return `set Red Flags to protect ${trainName(s, i.trayId)} — an approaching train must stop short`;
|
||||
case 'maneuver.flyingSwitch':
|
||||
return `Flying Switch ${i.count} car(s) into ${at(i.to)}`;
|
||||
case 'mainline.clearance': {
|
||||
// The §8.1 ruling is the sharpest decision in the game and read "grant clearance" — no hint
|
||||
// that granting it risks a rear-ender, or that refusing merely costs time.
|
||||
// Narrowed to the clearance question: `pendingDecision` is a union since Gitea#5, and only
|
||||
// this member names a train ahead.
|
||||
const pending = s.clock.pendingDecision;
|
||||
const clearance = pending?.kind === 'clearance' ? pending : null;
|
||||
const who = clearance ? trainName(s, clearance.train) : 'the train';
|
||||
const ahead = clearance ? trainName(s, clearance.occupiedBy) : 'the train ahead';
|
||||
const who = pending ? trainName(s, pending.train) : 'the train';
|
||||
const ahead = pending ? trainName(s, pending.occupiedBy) : 'the train ahead';
|
||||
// NOT "risks a collision, −5". A rear-end on a Mainline card is described by §10 and is what
|
||||
// ABS Signals exists to prevent, but no such collision is implemented — granting clearance is
|
||||
// currently free. Saying otherwise invents a consequence the engine will never deliver.
|
||||
@@ -1117,30 +967,7 @@ export function describeIntent(s: GameState, i: Intent): string {
|
||||
case 'redFlag.play':
|
||||
return 'play your red flag';
|
||||
case 'maneuver.redFlags':
|
||||
return (
|
||||
`FLAG ${i.side === 'east' ? 'EAST' : 'WEST'} — hold the next ${i.side === 'east' ? 'westbound' : 'eastbound'} ` +
|
||||
'train short of your Limits, so you can finish switching'
|
||||
);
|
||||
// §Q, the out-of-phase play (Gitea#19) — "COLLISION RISK! FLAG AGAINST T2?"
|
||||
case 'mainline.redFlag':
|
||||
return i.flag
|
||||
? 'FLAG IT — stop the train short of your Limits, spending a Red Flags card'
|
||||
: 'wave it through — let it come in';
|
||||
/**
|
||||
* §11, the Yard Office (Gitea#5). The offer interrupts the Mainline Phase, so the label has to
|
||||
* carry the whole question — there is no surrounding context on screen to lean on, and the
|
||||
* player is being asked about a train they were not otherwise thinking about.
|
||||
*/
|
||||
case 'mainline.yardOffice':
|
||||
return i.take
|
||||
? 'take the YARD OFFICE — straight into the yard, leaving the Train Order Office free'
|
||||
: 'keep it at the Train Order Office — the ordinary arrival, onto an A/D track';
|
||||
// §3.3, extended play (Gitea#11). The results screen draws its own buttons, but a bot reads its
|
||||
// options through this list like any other, and the label is what the history says it chose.
|
||||
case 'game.extend':
|
||||
return i.agree
|
||||
? 'play one more Day — the result already recorded still stands'
|
||||
: 'end the game here';
|
||||
return `set Red Flags to protect ${trainName(s, i.trayId)} — an approaching train must stop short`;
|
||||
default: {
|
||||
// Every Intent now has a sentence, so `i` narrows to never here. Keeping the assignment makes
|
||||
// that a COMPILE error the day someone adds an intent without describing it — the playable UI
|
||||
@@ -1232,27 +1059,36 @@ 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 = n.card === 'heavyGrade';
|
||||
const isGrade = MAINLINE_PROFILES.find((m) => m.kind === n.card)?.speed.kind === 'grade';
|
||||
/**
|
||||
* WHERE ON THE CARD — now simply what the card says.
|
||||
* WHERE ON THE CARD, from what the crossing already cost.
|
||||
*
|
||||
* 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.
|
||||
* §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:
|
||||
*
|
||||
* 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.
|
||||
* 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.
|
||||
*/
|
||||
// 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);
|
||||
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));
|
||||
};
|
||||
return {
|
||||
kind: 'ml',
|
||||
label: name,
|
||||
regions: mainlineProfile(n.card).regions,
|
||||
regions: REGIONS_PER_MAINLINE_CARD,
|
||||
trains: [n.transits.map((t) => {
|
||||
const chip = trainChip(s, t.tray);
|
||||
return {
|
||||
@@ -1271,9 +1107,6 @@ export function snapshot(
|
||||
};
|
||||
})],
|
||||
capacity: MAINLINE_PROFILES.find((m) => m.kind === n.card)?.trainsMayPass ? 2 : 1,
|
||||
// Drawn at the start of the card: the yard is beside the rail, and this is the end the
|
||||
// train will pull out of. It counts against nothing — see `yard` on DivisionView.
|
||||
yard: (n.holding ?? []).map((id) => ({ ...trainChip(s, id), region: 0 })),
|
||||
modifiers: [
|
||||
...(n.modifiers ?? []).map(prettyKey),
|
||||
...(n.absSignals ? ['ABS Signals'] : []),
|
||||
@@ -1362,8 +1195,6 @@ export function snapshot(
|
||||
*/
|
||||
hand: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => cardName(s, id)),
|
||||
handWhat: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => cardDescription(s, id)),
|
||||
handDiscardable: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => keepReason(s, id) === null),
|
||||
handKeepWhy: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => keepReason(s, id)),
|
||||
deck: s.decks.homeOffice.length,
|
||||
departments: s.decks.departments.map((pile) => {
|
||||
const top = pile[pile.length - 1];
|
||||
@@ -1392,20 +1223,8 @@ export function snapshot(
|
||||
wasted,
|
||||
option: turnOf(s, viewer).option,
|
||||
houseRules: houseRules(s.config),
|
||||
mode: s.config.mode,
|
||||
optionalRules: s.config.optionalRules,
|
||||
days: s.config.days,
|
||||
minCombinedRevenue: s.config.minCombinedRevenue,
|
||||
maxCollisionsPerDay: s.config.maxCollisionsPerDay,
|
||||
maxCollisionsTotal: s.config.maxCollisionsTotal,
|
||||
collisionsToday: s.collisionsToday,
|
||||
collisionsTotal: s.collisionsTotal,
|
||||
status: s.status,
|
||||
outcome: s.outcome,
|
||||
extraDays: s.extraDays,
|
||||
extensionVotes: [...s.extensionVotes],
|
||||
official: s.official,
|
||||
tally: s.tally,
|
||||
players: s.players.map((p) => ({
|
||||
index: p.index,
|
||||
seat: seatOf(s, p.index),
|
||||
@@ -1413,15 +1232,7 @@ export function snapshot(
|
||||
revenue: p.revenue,
|
||||
hand: (s.decks.hands.get(p.index) ?? []).length,
|
||||
})),
|
||||
viewer,
|
||||
viewerSeat,
|
||||
openingRolls: {
|
||||
division: [...s.openingRolls.division],
|
||||
superintendent: [...s.openingRolls.superintendent],
|
||||
},
|
||||
handCount: (s.decks.hands.get(viewer) ?? []).length,
|
||||
overHandLimit:
|
||||
(s.decks.hands.get(viewer) ?? []).length > (s.decks.redFlags.get(viewer) ? HAND_LIMIT + 1 : HAND_LIMIT),
|
||||
objective: objectiveOf(s, viewer),
|
||||
runningRow: area.runningRow,
|
||||
limits: { west: area.limitsWest.col, east: area.limitsEast.col },
|
||||
@@ -1648,9 +1459,7 @@ export function trainRules(t: {
|
||||
}
|
||||
if (p.rules.noPassengerWork) parts.push('NO PASSENGER WORK — Porters may not board or detrain it');
|
||||
if (p.rules.dropOnly) parts.push('MAY DROP BUT NOT PICK UP — it cannot couple anything');
|
||||
if (p.rules.pickUpEmptiesOnly) {
|
||||
parts.push('EMPTIES ONLY — it may not couple a loaded car. A caboose is not a load.');
|
||||
}
|
||||
if (p.rules.pickUpEmptiesOnly) parts.push('EMPTIES ONLY — it may not couple a loaded car');
|
||||
if (p.rules.stopThenExpedite) {
|
||||
parts.push('STOPS ONCE FOR SPEECHES, then runs expedited from its next Office onward');
|
||||
}
|
||||
@@ -1840,45 +1649,21 @@ const SIMPLE_CARDS = [
|
||||
...ACTION_CARDS,
|
||||
];
|
||||
|
||||
/**
|
||||
* The goal, and whether the VIEWER's score is keeping up with the clock.
|
||||
*
|
||||
* `target` is `config.minCombinedRevenue` now (2026-08-20) — the floor below which everyone loses,
|
||||
* not a per-player win threshold; `days` and `daysLeft` come off `config.days`. Paced against the
|
||||
* VIEWER's own Revenue, same as before: exact for solitaire (the viewer IS the whole table), an
|
||||
* approximation for competitive/coop until Phase 2 gives the objective panel a combined-progress
|
||||
* view of its own. `0` means no floor is configured — nothing to pace against.
|
||||
*/
|
||||
/** The goal, and whether the VIEWER's score is keeping up with the clock. */
|
||||
function objectiveOf(s: GameState, viewer: PlayerIndex): Frame['objective'] {
|
||||
const { minCombinedRevenue: target } = s.config;
|
||||
/**
|
||||
* PACED AGAINST THE TIMETABLE ACTUALLY BEING PLAYED, extensions included (Gitea#11).
|
||||
*
|
||||
* `config.days` alone would say "the last Day is over" through every extended Day, and pace an
|
||||
* eight-Day game against five — both of which the status line used to do the moment play carried
|
||||
* on past the end. The official result is still decided at `config.days`; that is `checkVictory`'s
|
||||
* business, and nothing here feeds it.
|
||||
*/
|
||||
const days = s.config.days + s.extraDays;
|
||||
const profile = lengthProfile(s.config.length);
|
||||
const revenue = s.players[viewer]?.revenue ?? 0;
|
||||
const daysLeft = Math.max(0, days - s.clock.day + 1);
|
||||
const elapsed = days - daysLeft + 1;
|
||||
if (target <= 0) {
|
||||
const note =
|
||||
daysLeft === 0
|
||||
? 'the last Day is over'
|
||||
: `${revenue} · ${daysLeft} Day${daysLeft === 1 ? '' : 's'} left · no minimum this game`;
|
||||
return { target: 0, days, daysLeft, onPace: true, note };
|
||||
}
|
||||
const daysLeft = Math.max(0, profile.days - s.clock.day + 1);
|
||||
const elapsed = profile.days - daysLeft + 1;
|
||||
// Straight-line pace: by the end of Day N you want N/days of the target.
|
||||
const expected = (target * elapsed) / days;
|
||||
const expected = (profile.target * elapsed) / profile.days;
|
||||
const onPace = revenue >= expected;
|
||||
const note =
|
||||
daysLeft === 0
|
||||
? 'the last Day is over'
|
||||
: `${revenue} of ${target} · ${daysLeft} Day${daysLeft === 1 ? '' : 's'} left · ` +
|
||||
: `${revenue} of ${profile.target} · ${daysLeft} Day${daysLeft === 1 ? '' : 's'} left · ` +
|
||||
(onPace ? 'on pace' : `behind pace (about ${Math.ceil(expected)} by now)`);
|
||||
return { target, days, daysLeft, onPace, note };
|
||||
return { target: profile.target, days: profile.days, daysLeft, onPace, note };
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
+15
-216
@@ -30,7 +30,6 @@ import type { Intent } from '../engine/intents.ts';
|
||||
import { legalActions } from '../engine/legal.ts';
|
||||
import { createGame } from '../engine/setup.ts';
|
||||
import type { CardId, GameConfig, GameState, PlayerIndex } from '../engine/state.ts';
|
||||
import { actingPlayer } from '../engine/state.ts';
|
||||
import { playerAtSeat } from '../engine/state.ts';
|
||||
import { cuesFor, narrate } from '../sim/narrate.ts';
|
||||
// Import from the view module, NOT replay.ts — replay.ts writes files and reads process.argv,
|
||||
@@ -45,13 +44,9 @@ import {
|
||||
variantLabel,
|
||||
} from '../sim/view.ts';
|
||||
import {
|
||||
DEFAULT_DAYS,
|
||||
DEFAULT_HOUSE_RULES,
|
||||
DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
HAND_LIMIT,
|
||||
LEGACY_HOUSE_RULES,
|
||||
collectiveRevenueFloor,
|
||||
houseRules,
|
||||
mainlineProfile,
|
||||
trainProfile,
|
||||
@@ -62,21 +57,13 @@ import { connectionsFor, joins, neighbour, variantsFor } from '../engine/track.t
|
||||
import { areaOf, destinationsFor, selectDestination, trainNeedingCars } from '../engine/apply.ts';
|
||||
import type { Frame } from '../sim/view.ts';
|
||||
|
||||
/**
|
||||
* The canonical "what does a fresh solitaire game look like" config — also what the New Game
|
||||
* dialog's solitaire defaults are drawn from (`main.ts`). One player, so `minCombinedRevenue` uses
|
||||
* `collectiveRevenueFloor(1, DEFAULT_DAYS)` — the same formula multiplayer configs use, just at
|
||||
* player count 1.
|
||||
*/
|
||||
export const SOLO_CONFIG: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: DEFAULT_DAYS,
|
||||
minCombinedRevenue: collectiveRevenueFloor(1, DEFAULT_DAYS),
|
||||
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
pvpCardsAllowed: false,
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -85,64 +72,9 @@ export const SOLO_CONFIG: GameConfig = {
|
||||
houseRules: DEFAULT_HOUSE_RULES,
|
||||
};
|
||||
|
||||
/**
|
||||
* The lobby's (`lobby.ts`) starting point for a Competitive or Co-op `Lobby.Create` — same formula
|
||||
* `SOLO_CONFIG` uses, at a nominal player count. `minCombinedRevenue` is necessarily a guess at
|
||||
* create time: nobody is seated yet, so there is no real headcount to size it against. It stays a
|
||||
* guess rather than being fixed up at `Lobby.Start`, matching what the New Game dialog already told
|
||||
* players before there was a lobby at all ("assumes a 4-player table until there's a lobby to ask
|
||||
* who's actually seated") — Phase 5 or a follow-up can revisit sizing it to the seats actually
|
||||
* filled once that is worth the complexity.
|
||||
*/
|
||||
export function defaultMultiplayerConfig(mode: 'competitive' | 'coop', players = 4): GameConfig {
|
||||
return {
|
||||
mode,
|
||||
days: DEFAULT_DAYS,
|
||||
minCombinedRevenue: collectiveRevenueFloor(players, DEFAULT_DAYS),
|
||||
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
pvpCardsAllowed: mode === 'competitive',
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
houseRules: DEFAULT_HOUSE_RULES,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Everything the New Game dialog can set for a solitaire game — the opening deal and the three
|
||||
* revenue rates (`houseRules`, unchanged), plus the four victory-condition dials added 2026-08-20.
|
||||
* Solitaire's `pvpCardsAllowed` is not here: it is forced off (`SOLO_CONFIG`), never a player choice.
|
||||
*/
|
||||
export type NewGameOptions = {
|
||||
houseRules?: HouseRuleOverrides;
|
||||
days?: number;
|
||||
minCombinedRevenue?: number;
|
||||
maxCollisionsPerDay?: number;
|
||||
maxCollisionsTotal?: number;
|
||||
/**
|
||||
* Appendix B's three, added 2026-08-23 when the New Game dialog gained them.
|
||||
*
|
||||
* The lobby has offered these since v0.6.0 and the solitaire dialog could not, which meant a
|
||||
* solitaire game could never be played under Employee Rotation or the Emergency Toolbox at all.
|
||||
* Partial like `houseRules`: a caller names only what it is setting.
|
||||
*/
|
||||
optionalRules?: Partial<GameConfig['optionalRules']>;
|
||||
};
|
||||
|
||||
/** The same config with the New Game dialog's answers in it. */
|
||||
export function configWith(opts: NewGameOptions): GameConfig {
|
||||
return {
|
||||
...SOLO_CONFIG,
|
||||
days: opts.days ?? SOLO_CONFIG.days,
|
||||
minCombinedRevenue: opts.minCombinedRevenue ?? SOLO_CONFIG.minCombinedRevenue,
|
||||
maxCollisionsPerDay: opts.maxCollisionsPerDay ?? SOLO_CONFIG.maxCollisionsPerDay,
|
||||
maxCollisionsTotal: opts.maxCollisionsTotal ?? SOLO_CONFIG.maxCollisionsTotal,
|
||||
optionalRules: { ...SOLO_CONFIG.optionalRules, ...(opts.optionalRules ?? {}) },
|
||||
houseRules: houseRules(opts.houseRules ? { houseRules: opts.houseRules } : {}),
|
||||
};
|
||||
export function configWith(rules: HouseRuleOverrides): GameConfig {
|
||||
return { ...SOLO_CONFIG, houseRules: houseRules({ houseRules: rules }) };
|
||||
}
|
||||
|
||||
/** A group of legal actions of one kind, ready to put on screen. */
|
||||
@@ -267,7 +199,6 @@ export type Game = {
|
||||
/** How each intent kind is introduced in the action list, in the order they should appear. */
|
||||
const GROUP_ORDER: readonly { prefix: string; title: string }[] = [
|
||||
{ prefix: 'mainline.clearance', title: 'Superintendent — rule on this train' },
|
||||
{ prefix: 'mainline.yardOffice', title: 'Where does this train arrive?' },
|
||||
{ prefix: 'localOps.choose', title: 'Local Operations — choose ONE' },
|
||||
{ prefix: 'switch.', title: 'Switching' },
|
||||
// Specific before general: `startsWith` means a bare `draw.` would swallow all three, and the
|
||||
@@ -306,23 +237,6 @@ export function newGame(seed: number, config: GameConfig = SOLO_CONFIG): Game {
|
||||
return game;
|
||||
}
|
||||
|
||||
/**
|
||||
* `newGame`'s multi-player sibling — the server session host (Phase 2) needs a `Game` wrapper for
|
||||
* more than one seat, and `newGame` hardcodes `[SOLO_PLAYER]`. Kept as a separate function rather
|
||||
* than a shared parametrized helper: `newGame` is exercised by every solitaire test and save, and
|
||||
* reordering its log-then-drain sequence to share code with this risks nothing for a marginal DRY
|
||||
* gain. `submit`/`drain`/`actionMenu`/`currentActor` all work on either unchanged, since none of them
|
||||
* know or care how many players a `Game` has.
|
||||
*/
|
||||
export function newMultiplayerGame(seed: number, config: GameConfig, playerNames: string[]): Game {
|
||||
const state = createGame({ id: `mp-${seed}`, seed, config, playerNames });
|
||||
const game: Game = { state, seed, history: [], log: [], mustPlayCard: false, cues: [], scheduled: null, justDrawn: null, announced: null };
|
||||
game.log.push({ text: 'Game Begins', tone: 'start' });
|
||||
game.log.push({ text: `${config.mode} · ${playerNames.length} players · seed ${seed}`, tone: 'quiet' });
|
||||
drain(game);
|
||||
return game;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run the engine forward until it needs a decision.
|
||||
*
|
||||
@@ -336,9 +250,9 @@ export function drain(game: Game): void {
|
||||
/** Whose turn it is, or null if the game is over or waiting on nothing. */
|
||||
export function currentActor(game: Game): PlayerIndex | null {
|
||||
if (game.state.status !== 'active') return null;
|
||||
// `actingPlayer` (state.ts) knows which player each kind of interruption goes to — the
|
||||
// Superintendent for a §8.1 clearance, the district's owner for a Yard Office offer.
|
||||
return actingPlayer(game.state);
|
||||
return game.state.clock.pendingDecision !== null
|
||||
? game.state.clock.superintendent
|
||||
: game.state.clock.currentActor;
|
||||
}
|
||||
|
||||
/** Every legal action right now, grouped for display. Empty when there is nothing to decide. */
|
||||
@@ -467,26 +381,13 @@ export function actionGroups(game: Game): { options: Intent[]; groups: ActionGro
|
||||
*/
|
||||
if (prefix === 'mainline.clearance') {
|
||||
const pending = game.state.clock.pendingDecision;
|
||||
if (pending?.kind === 'clearance') {
|
||||
if (pending) {
|
||||
headed =
|
||||
`Superintendent — may ${trainName(game.state, pending.train)} follow ` +
|
||||
`${trainName(game.state, pending.occupiedBy)} onto the same Mainline card?`;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* §11 (Gitea#5) — the Yard Office offer interrupts the Mainline Phase, so it arrives with no
|
||||
* context around it: the player was not thinking about this train a moment ago.
|
||||
*/
|
||||
if (prefix === 'mainline.yardOffice') {
|
||||
const pending = game.state.clock.pendingDecision;
|
||||
if (pending?.kind === 'yardOffice') {
|
||||
headed =
|
||||
`${trainName(game.state, pending.train)} is arriving with no coaches — ` +
|
||||
'take it into the Yard Office, or hold it at the Train Order Office?';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A PENDING EXTRA IS ITS OWN QUESTION, and its own heading.
|
||||
*
|
||||
@@ -629,16 +530,7 @@ export type Menu = {
|
||||
|
||||
/** The action list as the page shows it: direct actions, plus subject-then-location for the rest. */
|
||||
export function actionMenu(game: Game, seat: PlayerIndex = 0): Menu {
|
||||
/**
|
||||
* SEAT-SAFETY. `actionGroups`/`legalActions` answer for `currentActor(game)`, not for `seat` — there
|
||||
* is exactly one acting player at a time, so a Menu built for anyone else must show no actions at
|
||||
* all, only their own hand (found the hard way: calling this for a non-acting seat used to hand
|
||||
* back the ACTOR's legal moves paired with the WRONG seat's cards). Emptying `options`/`groups` here
|
||||
* degrades every downstream computation (`direct`, `placeable`, `makeUp`) to empty for free — the
|
||||
* hand section below still reads `seat`'s own cards correctly either way.
|
||||
*/
|
||||
const isActor = seat === currentActor(game);
|
||||
const { options, groups } = isActor ? actionGroups(game) : { options: [] as Intent[], groups: [] as ActionGroup[] };
|
||||
const { options, groups } = actionGroups(game);
|
||||
const direct: ActionGroup[] = [];
|
||||
const placeableByTitle = new Map<string, Map<string, Placeable>>();
|
||||
|
||||
@@ -1029,42 +921,9 @@ export function overHandLimit(game: Game, seat: PlayerIndex = 0): boolean {
|
||||
return hand.length > limit;
|
||||
}
|
||||
|
||||
/**
|
||||
* Intents any seat may send regardless of whose turn it is — and, for `game.extend`, regardless of
|
||||
* whether the game is still running at all (§3.3, Gitea#11).
|
||||
*
|
||||
* `currentActor` is null once the timetable has run out, which is correct for everything else and
|
||||
* exactly wrong for the vote on playing another Day. Rather than teach `currentActor` about a state
|
||||
* where EVERY seat may act at once — which it has no way to express — callers name the seat.
|
||||
*/
|
||||
export function isOutOfTurn(intent: Intent): intent is Extract<Intent, { type: 'game.extend' }> {
|
||||
return intent.type === 'game.extend';
|
||||
}
|
||||
|
||||
/**
|
||||
* WHO ACTED, when replaying a saved history.
|
||||
*
|
||||
* A save is a flat `Intent[]` with no seat written beside each move, so a replay normally derives
|
||||
* the actor from the turn order — the same order the live game went round in, reproduced exactly.
|
||||
* That breaks for exactly one intent: the extension vote, which every seat may cast in any order,
|
||||
* and which `currentActor` answers `null` for because the game has stopped. Replaying such a save
|
||||
* used to fail outright with `NO_ACTOR`, which is to say an extended game could not be resumed at
|
||||
* all — found by `test/server/session.test.ts`'s resume test, and the reason `game.extend` carries
|
||||
* its voter (`intents.ts`).
|
||||
*/
|
||||
function replayActor(game: Game, intent: Intent): PlayerIndex | null {
|
||||
return isOutOfTurn(intent) ? intent.player : currentActor(game);
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit an action. Returns false and changes nothing if the engine rejects it.
|
||||
*
|
||||
* `as` names the seat for an out-of-turn intent (see `isOutOfTurn`). It cannot be used to smuggle an
|
||||
* ordinary move past the turn order: `check` is still the authority and still asks `isActor`, so a
|
||||
* named seat that is not the actor is refused exactly as it would have been.
|
||||
*/
|
||||
export function submit(game: Game, intent: Intent, as: PlayerIndex | null = null): boolean {
|
||||
const actor = as ?? currentActor(game);
|
||||
/** Submit an action. Returns false and changes nothing if the engine rejects it. */
|
||||
export function submit(game: Game, intent: Intent): boolean {
|
||||
const actor = currentActor(game);
|
||||
if (actor === null) return false;
|
||||
|
||||
const result = applyIntent(game.state, actor, intent);
|
||||
@@ -1193,15 +1052,10 @@ function configFor(save: Save, config: GameConfig): GameConfig {
|
||||
*
|
||||
* Returns null when there is nothing to undo, so the caller can leave the button disabled.
|
||||
*/
|
||||
export function undo(game: Game, config: GameConfig = game.state.config): Game | null {
|
||||
export function undo(game: Game, config: GameConfig = SOLO_CONFIG): Game | null {
|
||||
if (game.history.length === 0) return null;
|
||||
// `toSave` first, so the rules this game was dealt under come with it. Rebuilding the save by hand
|
||||
// here dropped them, and undo re-dealt the game under the defaults instead of its own settings.
|
||||
//
|
||||
// THE VICTORY DIALS COME FROM THE GAME ITSELF for the same reason (2026-08-23). `Save` carries only
|
||||
// the house rules, so defaulting this parameter to `SOLO_CONFIG` meant undoing a game dealt over
|
||||
// eight Days replayed it as a five-Day game — the length, the Revenue floor and both collision
|
||||
// caps all quietly reverting to the defaults.
|
||||
return fromSave({ ...toSave(game), history: game.history.slice(0, -1) }, config);
|
||||
}
|
||||
|
||||
@@ -1215,7 +1069,7 @@ export function undo(game: Game, config: GameConfig = game.state.config): Game |
|
||||
export function fromSave(save: Save, config: GameConfig = SOLO_CONFIG): Game {
|
||||
const game = newGame(save.seed, configFor(save, config));
|
||||
for (const intent of save.history) {
|
||||
const actor = replayActor(game, intent);
|
||||
const actor = currentActor(game);
|
||||
if (actor === null) break;
|
||||
const result = applyIntent(game.state, actor, intent);
|
||||
if (!result.ok) break;
|
||||
@@ -1225,58 +1079,3 @@ export function fromSave(save: Save, config: GameConfig = SOLO_CONFIG): Game {
|
||||
}
|
||||
return game;
|
||||
}
|
||||
|
||||
/**
|
||||
* `fromSave`'s multi-player sibling — Phase 3 (`docs/architecture/multiplayer.md`): "a mid-game
|
||||
* server restart is a replay rather than a recovery" (`lobby-and-sessions.md` §6). Built on
|
||||
* `newMultiplayerGame` instead of `newGame` since a saved multiplayer game did not deal to
|
||||
* `[SOLO_PLAYER]`. The engine-version check belongs to the caller (`src/server/persistence.ts`) —
|
||||
* this function only ever reconstructs from history that is already known to have been recorded
|
||||
* under the currently-running rules.
|
||||
*
|
||||
* UNLIKE `fromSave`'s loop, this passes `actor` to `record()` (matching `submit`'s own call,
|
||||
* `game.ts` above) — found while testing Phase 3's resume path: without it, every replayed line loses
|
||||
* its "Player X" attribution and reads as anonymous "Chose to..." narration, which `record`'s own
|
||||
* comment calls "unreadable the moment there is more than one seat" — exactly the multiplayer case a
|
||||
* resumed game hits every time. `fromSave` has the same gap (it predates multiplayer and nothing ever
|
||||
* compares its output against a LIVE-played log, so it has gone unnoticed — `undo`'s rebuilt game is
|
||||
* itself `fromSave`-built, so `test/web.test.ts`'s replay-fidelity test only ever compares one
|
||||
* unattributed replay against another). Flagged in `TODO.md` rather than fixed there in this pass —
|
||||
* out of scope for Phase 3 and used far more widely, so worth its own careful look rather than a
|
||||
* touch-in-passing.
|
||||
*/
|
||||
/**
|
||||
* Why the intent a replay stopped at is reported rather than swallowed.
|
||||
*
|
||||
* The loop below has always stopped at the first intent the engine will not accept, and used to do
|
||||
* it in silence — which is the one outcome nobody can afford to guess at, because the result is a
|
||||
* game that looks fine and is short of where it should be. That silence was survivable only
|
||||
* because `loadGame` refused any save whose engine version was not an exact match, so a replay
|
||||
* that could fail was never attempted. Refusing on the version is a proxy question, though, and it
|
||||
* answered "no" for four releases running that changed no rules at all — so the real question gets
|
||||
* asked instead, and its answer has to be legible.
|
||||
*/
|
||||
export type ReplayStop = { index: number; intent: Intent; code: string };
|
||||
|
||||
export function fromMultiplayerSave(
|
||||
seed: number,
|
||||
config: GameConfig,
|
||||
playerNames: string[],
|
||||
history: Intent[],
|
||||
): { game: Game; stopped: ReplayStop | null } {
|
||||
const game = newMultiplayerGame(seed, config, playerNames);
|
||||
for (const [index, intent] of history.entries()) {
|
||||
const actor = replayActor(game, intent);
|
||||
if (actor === null) {
|
||||
return { game, stopped: { index, intent, code: 'NO_ACTOR' } };
|
||||
}
|
||||
const result = applyIntent(game.state, actor, intent);
|
||||
if (!result.ok) {
|
||||
return { game, stopped: { index, intent, code: result.code } };
|
||||
}
|
||||
game.history.push(intent);
|
||||
record(game, result.events, actor);
|
||||
drain(game);
|
||||
}
|
||||
return { game, stopped: null };
|
||||
}
|
||||
|
||||
+9
-11
@@ -29,8 +29,6 @@ a.door:hover{border-color:#4d6fa8;background:#1f2733;transform:translateY(-1px)}
|
||||
.door p{margin:0;color:var(--dim);font-size:13px;line-height:1.5}
|
||||
.door .go{display:inline-block;margin-top:11px;font-size:12px;color:#5aa9e6}
|
||||
.door.disabled .go{color:var(--dim)}
|
||||
a.door.disabled{pointer-events:none}
|
||||
a.door.disabled:hover{border-color:var(--line);background:var(--panel);transform:none}
|
||||
.lightbox{position:fixed;inset:0;background:rgba(8,10,13,.92);display:flex;
|
||||
align-items:center;justify-content:center;padding:32px;z-index:10;cursor:zoom-out}
|
||||
.lightbox[hidden]{display:none}
|
||||
@@ -71,21 +69,21 @@ footer{margin-top:26px;color:var(--dim);font-size:11px;display:flex;gap:18px;fle
|
||||
</div>
|
||||
|
||||
<div class="doors">
|
||||
<a class="door" id="door-multiplayer" href="./play.html?lobby">
|
||||
<div class="door disabled">
|
||||
<h2>Play multiplayer</h2>
|
||||
<p id="door-multiplayer-blurb">Play with your friends across the internet. You each run your
|
||||
own office area within the entire division. You can play a normal game, or choose co-op or
|
||||
cutthroat.</p>
|
||||
<span class="go" id="door-multiplayer-go">Set up a game →</span>
|
||||
</a>
|
||||
<p>Play with your friends across the internet. You each run your own office area within the
|
||||
entire division. You can play a normal game, or choose co-op or cutthroat. This requires
|
||||
a Station Master server to be running.</p>
|
||||
<span class="go">Coming soon</span>
|
||||
</div>
|
||||
|
||||
<a class="door" href="./play.html">
|
||||
<h2>Play solitaire</h2>
|
||||
<p>Play by yourself and run the entire division for five full days. Clear the Revenue floor of
|
||||
15 by the end or the game is a loss. Your game data is saved in your browser — if you close the tab and reopen this site
|
||||
<p>Play by yourself and run the entire division for five full days. Your goal is 20 Revenue.
|
||||
Your game data is saved in your browser — if you close the tab and reopen this site
|
||||
without clearing your cache, your game is preserved and you can continue automatically.
|
||||
During the game you can also explicitly save your progress for later replay.</p>
|
||||
<span class="go">Set up a game →</span>
|
||||
<span class="go">Start a game →</span>
|
||||
</a>
|
||||
|
||||
<a class="door" href="./replays.html">
|
||||
|
||||
@@ -1,634 +0,0 @@
|
||||
/**
|
||||
* The lobby screen — Phase 4 of `docs/architecture/multiplayer.md` (§12 steps 17-20), rebuilt
|
||||
* 2026-08-23 (Jesse's cleanup pass).
|
||||
*
|
||||
* Everything in `#lobby` (`play.html`) is owned here: the join-secret gate, the two doors (join a
|
||||
* game, create one), the read-only preview a player reads BEFORE taking a seat, and the seating
|
||||
* screen up to `Lobby.Start`.
|
||||
*
|
||||
* WHAT CHANGED, and why each one was worth changing:
|
||||
* - JOINING CAME FIRST. It used to be a heading below the whole create form — fifteen fields a
|
||||
* player who was handed a code has no use for.
|
||||
* - A SEAT SURVIVES A RELOAD. The token was held in a closure and only written to `localStorage`
|
||||
* at `Lobby.Start`, so a refresh before the host started orphaned the chair: the player could
|
||||
* not get back and the seat could not be freed. `onSeated` hands it to `main.ts` immediately.
|
||||
* - THERE IS A WAY OUT. `/api/lobby/leave` frees a seat, so a mis-join or a player who wanders off
|
||||
* no longer wedges a table that cannot start until every chair is taken.
|
||||
* - THE STREAM CAN FAIL OUT LOUD. `onmessage` was the only handler; a dropped connection left the
|
||||
* seating screen frozen and silent.
|
||||
* - THE RULES ARE VISIBLE TO EVERYONE, not just the host who typed them.
|
||||
*
|
||||
* MIRRORS SERVER TYPES RATHER THAN IMPORTING THEM, same choice `web/session.ts` already made for
|
||||
* `Push`: this file must never depend on anything under `src/server/`, even at the type level, since
|
||||
* it ships to the browser and the server does not.
|
||||
*/
|
||||
|
||||
import type { GameConfig, PlayerIndex } from '../engine/state.ts';
|
||||
import {
|
||||
closestPreset,
|
||||
configFromSettings,
|
||||
gameTypeLabel,
|
||||
preset,
|
||||
presetSettings,
|
||||
} from './presets.ts';
|
||||
import type { GameType, PresetName } from './presets.ts';
|
||||
import { rulesListHtml, settingsForm } from './settings-form.ts';
|
||||
import { seatLabel } from '../sim/view.ts';
|
||||
|
||||
export type LobbyReady = { token: string; gameId: string; seat: PlayerIndex; gameCode: string };
|
||||
|
||||
/** What the page must do with a seat this screen takes or gives up. `main.ts` owns the storage; this
|
||||
* module owns the moments. */
|
||||
export type LobbyHandlers = {
|
||||
/** The game has begun — tear this screen down and build a `RemoteSession`. Called at most once. */
|
||||
onReady: (r: LobbyReady) => void;
|
||||
/** A seat is now held. Called before the game starts, so a reload can come back to it. */
|
||||
onSeated: (s: { token: string; gameId: string; gameCode: string }) => void;
|
||||
/** The seat is gone — left, removed, or the lobby closed under us. Forget the stored record. */
|
||||
onLeft: (gameId?: string) => void;
|
||||
/** Every game this browser still holds a seat in — the page owns the storage, this screen only
|
||||
* draws it. */
|
||||
known?: () => { gameId: string; gameCode: string; stage: 'lobby' | 'game' }[];
|
||||
/** Re-enter one of them. */
|
||||
rejoin?: (gameId: string) => void;
|
||||
/** Give one up for good: the token is the only proof of identity, so this cannot be undone. */
|
||||
forget?: (gameId: string) => void;
|
||||
};
|
||||
|
||||
type LobbySeat = { kind: 'human'; token: string; displayName: string } | { kind: 'bot' } | null;
|
||||
type Lobby = {
|
||||
gameId: string;
|
||||
gameCode: string;
|
||||
hostToken: string;
|
||||
config: GameConfig;
|
||||
seats: LobbySeat[];
|
||||
joinOrder: string[];
|
||||
createdAt: number;
|
||||
};
|
||||
type LobbyPush = { lobby: Lobby; you: PlayerIndex; started: boolean };
|
||||
type Preview = {
|
||||
gameCode: string;
|
||||
hostName: string;
|
||||
config: GameConfig;
|
||||
players: number;
|
||||
seated: { seat: number; who: string | null; bot: boolean }[];
|
||||
};
|
||||
|
||||
/** Per-origin, same reasoning `lobby-and-sessions.md` §1 gives for the session token itself — a
|
||||
* secret typed at one address means nothing at another. */
|
||||
const SECRET_KEY = 'stationmaster-joinsecret';
|
||||
/** The name is not a credential; it is remembered for the same reason the secret is — nobody should
|
||||
* retype what they typed last time. */
|
||||
const NAME_KEY = 'stationmaster-displayname';
|
||||
|
||||
const $ = <T extends HTMLElement = HTMLElement>(id: string): T => document.getElementById(id) as T;
|
||||
const has = (id: string): boolean => document.getElementById(id) !== null;
|
||||
|
||||
/**
|
||||
* A server code turned into a sentence.
|
||||
*
|
||||
* `LOBBY_FULL` and `BAD_PLAYER_COUNT` used to be printed at the player exactly as the server said
|
||||
* them. The codes are the server's vocabulary, not the table's.
|
||||
*/
|
||||
function explain(code: unknown, fallback: string): string {
|
||||
const messages: Record<string, string> = {
|
||||
LOBBY_FULL: 'That table is already full — every chair is taken.',
|
||||
ALREADY_STARTED: 'That game has already started.',
|
||||
BAD_PLAYER_COUNT: 'That table size cannot start a game — 2 to 4 players.',
|
||||
NOT_HOST: 'Only the host can do that.',
|
||||
NAME_TAKEN: 'Somebody at that table is already using that name — pick another.',
|
||||
'bad or missing secret': 'That join secret was not accepted by this server.',
|
||||
// What a lobby answers once it has become a GAME — most often seen by a host pressing Start
|
||||
// twice, and by a tab left open on a lobby that started somewhere else.
|
||||
'no such lobby': 'That game is no longer waiting to start — it has either begun or been closed.',
|
||||
'no open lobby with that code': 'No game is waiting under that code. Check it, or ask for a new one — a game that has already started cannot be joined.',
|
||||
};
|
||||
const key = typeof code === 'string' ? code : '';
|
||||
return messages[key] ?? (key !== '' ? key : fallback);
|
||||
}
|
||||
|
||||
async function postJson(path: string, body: unknown): Promise<{ status: number; body: Record<string, unknown> }> {
|
||||
const res = await fetch(path, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify(body),
|
||||
});
|
||||
return { status: res.status, body: (await res.json()) as Record<string, unknown> };
|
||||
}
|
||||
|
||||
async function getJson(path: string): Promise<{ status: number; body: Record<string, unknown> }> {
|
||||
const res = await fetch(path);
|
||||
return { status: res.status, body: (await res.json().catch(() => ({}))) as Record<string, unknown> };
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows `#lobby` and drives it. `resume` re-enters the seating screen for a browser that already
|
||||
* holds a seat (a reload before the host started) rather than starting at the doors.
|
||||
*/
|
||||
export function runLobby(handlers: LobbyHandlers, resume?: { token: string; gameId: string; gameCode: string }): void {
|
||||
// Nothing below exists on a page that is not `play.html` — and `main.ts` is imported by tests that
|
||||
// stub only part of the DOM. Bail rather than throwing through the module's caller.
|
||||
if (!has('lobby') || !has('lb-choice-section')) return;
|
||||
$('lobby').hidden = false;
|
||||
|
||||
const form = settingsForm('lb-');
|
||||
let source: EventSource | null = null;
|
||||
let done = false;
|
||||
|
||||
/**
|
||||
* THE GAMES THIS BROWSER IS ALREADY IN.
|
||||
*
|
||||
* Rejoining is what the stored token is FOR, and until now the only thing that ever used one was a
|
||||
* bare page load — so a player who left a game, or who joined a second, had no way to get back to
|
||||
* the first. Drawn from the page's own storage (`main.ts`), never from this module.
|
||||
*/
|
||||
function renderKnown(): void {
|
||||
if (!has('lb-known')) return;
|
||||
const games = handlers.known?.() ?? [];
|
||||
$('lb-known').hidden = games.length === 0;
|
||||
if (games.length === 0) return;
|
||||
$('lb-known-list').innerHTML = games
|
||||
.map(
|
||||
(g) =>
|
||||
`<div class="lb-known-row"><span class="code">${escapeHtml(g.gameCode || g.gameId.slice(0, 8))}</span>` +
|
||||
`<span class="dim">${g.stage === 'lobby' ? 'waiting to start' : 'in play'}</span>` +
|
||||
`<button class="lb-rejoin" data-game="${escapeHtml(g.gameId)}">Rejoin</button>` +
|
||||
`<button class="lb-forget ghost" data-game="${escapeHtml(g.gameId)}">Forget</button></div>`,
|
||||
)
|
||||
.join('');
|
||||
for (const btn of Array.from($('lb-known-list').querySelectorAll<HTMLButtonElement>('.lb-rejoin'))) {
|
||||
btn.onclick = () => handlers.rejoin?.(btn.dataset['game'] ?? '');
|
||||
}
|
||||
for (const btn of Array.from($('lb-known-list').querySelectorAll<HTMLButtonElement>('.lb-forget'))) {
|
||||
btn.onclick = () => {
|
||||
// Confirmed, because it is not recoverable from this browser: the token IS the identity
|
||||
// (`lobby-and-sessions.md` §1), and nothing else on this server will accept a claim to that
|
||||
// seat.
|
||||
const code = btn.previousElementSibling?.previousElementSibling?.textContent ?? 'that game';
|
||||
if (!confirm(`Forget ${code}? This browser will not be able to rejoin it — your seat stays in the game, and only whoever runs the server could let you back in.`)) return;
|
||||
handlers.forget?.(btn.dataset['game'] ?? '');
|
||||
renderKnown();
|
||||
};
|
||||
}
|
||||
}
|
||||
renderKnown();
|
||||
|
||||
// -- the join secret ------------------------------------------------------------------------
|
||||
|
||||
function showSecret(saved: boolean): void {
|
||||
$('lb-secret-saved').hidden = !saved;
|
||||
$('lb-secret-ask').hidden = saved;
|
||||
}
|
||||
const storedSecret = localStorage.getItem(SECRET_KEY) ?? '';
|
||||
$<HTMLInputElement>('lb-secret').value = storedSecret;
|
||||
showSecret(storedSecret !== '');
|
||||
$<HTMLButtonElement>('lb-secret-change').onclick = () => showSecret(false);
|
||||
|
||||
function secret(): string {
|
||||
const value = $<HTMLInputElement>('lb-secret').value;
|
||||
localStorage.setItem(SECRET_KEY, value);
|
||||
return value;
|
||||
}
|
||||
|
||||
/** A rejected secret re-opens the field it is about — the error used to appear a screen away from
|
||||
* the box that caused it. */
|
||||
function secretRejected(status: number): boolean {
|
||||
if (status !== 403) return false;
|
||||
showSecret(false);
|
||||
$<HTMLInputElement>('lb-secret').focus();
|
||||
return true;
|
||||
}
|
||||
|
||||
// -- display name ---------------------------------------------------------------------------
|
||||
|
||||
const nameField = $<HTMLInputElement>('lb-name');
|
||||
nameField.value = localStorage.getItem(NAME_KEY) ?? '';
|
||||
function displayName(): string {
|
||||
const value = nameField.value.trim();
|
||||
if (value !== '') localStorage.setItem(NAME_KEY, value);
|
||||
return value;
|
||||
}
|
||||
|
||||
// -- the two doors --------------------------------------------------------------------------
|
||||
|
||||
function door(which: 'join' | 'create'): void {
|
||||
$('lb-join-panel').hidden = which !== 'join';
|
||||
$('lb-create-panel').hidden = which !== 'create';
|
||||
$('lb-door-join').classList.toggle('active', which === 'join');
|
||||
$('lb-door-create').classList.toggle('active', which === 'create');
|
||||
}
|
||||
$<HTMLButtonElement>('lb-door-join').onclick = () => door('join');
|
||||
$<HTMLButtonElement>('lb-door-create').onclick = () => door('create');
|
||||
|
||||
// -- the create form ------------------------------------------------------------------------
|
||||
|
||||
/** The named type the form is currently measured against — and, for a Custom game, the type it is
|
||||
* scored as. Custom is only ever reached FROM one of these, so there is always an answer. */
|
||||
let base: PresetName = 'coop';
|
||||
let type: GameType = 'coop';
|
||||
/** Once the host types a Revenue floor it is theirs; players and days stop re-deriving it. */
|
||||
let floorTyped = false;
|
||||
|
||||
const players = (): number => Number($<HTMLSelectElement>('lb-players').value) || 4;
|
||||
const days = (): number => {
|
||||
const raw = Number($<HTMLInputElement>('lb-days').value);
|
||||
return Number.isFinite(raw) && raw >= 1 ? Math.round(raw) : 5;
|
||||
};
|
||||
|
||||
function typeRadios(): HTMLInputElement[] {
|
||||
return Array.from(document.querySelectorAll<HTMLInputElement>('input[name="lb-type"]'));
|
||||
}
|
||||
|
||||
/** Reset every rule to a named type. Seed, players and days are parameters, and are left alone. */
|
||||
function selectPreset(name: PresetName): void {
|
||||
base = name;
|
||||
type = name;
|
||||
floorTyped = false;
|
||||
const values = presetSettings(name, players(), days());
|
||||
form.write(values, values);
|
||||
form.setEmployeeRotationAvailable(true);
|
||||
refresh();
|
||||
}
|
||||
|
||||
function refresh(): void {
|
||||
const differing = form.mark(base, players(), days());
|
||||
if (differing.length > 0) type = 'custom';
|
||||
else if (type === 'custom') type = base;
|
||||
for (const r of typeRadios()) r.checked = r.value === type;
|
||||
|
||||
const scoring = preset(base).scoring;
|
||||
const note = $('lb-type-note');
|
||||
if (type === 'custom') {
|
||||
note.textContent =
|
||||
`${gameTypeLabel('custom', scoring)} · ${differing.length} ` +
|
||||
`${differing.length === 1 ? 'setting differs' : 'settings differ'} from ${preset(base).label}.`;
|
||||
note.className = 'ng-note changed-note';
|
||||
// A Custom game is nobody's default: open the block that says how it differs.
|
||||
$<HTMLDetailsElement>('lb-settings').open = true;
|
||||
} else {
|
||||
note.textContent = preset(type as PresetName).blurb;
|
||||
note.className = 'ng-note';
|
||||
}
|
||||
}
|
||||
|
||||
for (const r of typeRadios()) {
|
||||
// Solitaire is on this screen so the two screens read as one list, but there is nothing here to
|
||||
// deal it with — the New Game dialog is where a solitaire game comes from.
|
||||
if (r.value === 'solitaire') markUnavailable(r, 'dealt with the New game button, not here');
|
||||
r.onchange = () => {
|
||||
if (!r.checked) return;
|
||||
if (r.value === 'custom') {
|
||||
// Clicking Custom keeps everything as it stands, and keeps the scoring of the type it came
|
||||
// from (Jesse, 2026-08-23) — it is only ever reached from one of the named types.
|
||||
type = 'custom';
|
||||
refresh();
|
||||
return;
|
||||
}
|
||||
selectPreset(r.value as PresetName);
|
||||
};
|
||||
}
|
||||
|
||||
form.onEdit((key) => {
|
||||
// The floor is derived until somebody sets it; ticking the condition off counts as setting it.
|
||||
if (key === 'minCombinedRevenue') floorTyped = true;
|
||||
type = 'custom';
|
||||
refresh();
|
||||
});
|
||||
|
||||
/** Players and days are parameters, not settings: they re-derive the floor and never make a game
|
||||
* Custom by themselves. */
|
||||
function paramsChanged(): void {
|
||||
if (!floorTyped) {
|
||||
const values = form.read();
|
||||
const want = presetSettings(base, players(), days());
|
||||
form.write({ ...values, minCombinedRevenue: want.minCombinedRevenue }, want);
|
||||
}
|
||||
refresh();
|
||||
}
|
||||
$<HTMLSelectElement>('lb-players').onchange = paramsChanged;
|
||||
$<HTMLInputElement>('lb-days').oninput = paramsChanged;
|
||||
|
||||
selectPreset('coop');
|
||||
door('join');
|
||||
|
||||
// -- creating -------------------------------------------------------------------------------
|
||||
|
||||
$<HTMLButtonElement>('lb-create').onclick = () => {
|
||||
const name = displayName();
|
||||
if (name === '') {
|
||||
$('lb-create-err').textContent = 'Enter a display name first.';
|
||||
return;
|
||||
}
|
||||
const asked = $<HTMLInputElement>('lb-seed').value.trim();
|
||||
// Blank or unparseable both mean "surprise me", which is what leaving the box alone asks for.
|
||||
const seed = asked === '' || !Number.isFinite(Number(asked)) ? null : Math.trunc(Number(asked));
|
||||
const config = configFromSettings(form.read(), preset(base).scoring, days(), preset(base).pvpCards);
|
||||
|
||||
$('lb-create-err').textContent = '';
|
||||
void postJson('/api/lobby/create', {
|
||||
secret: secret(),
|
||||
config,
|
||||
displayName: name,
|
||||
players: players(),
|
||||
seed,
|
||||
}).then(({ status, body }) => {
|
||||
if (status !== 200) {
|
||||
secretRejected(status);
|
||||
$('lb-create-err').textContent = explain(body['error'], 'Could not create the game.');
|
||||
return;
|
||||
}
|
||||
enterSeating(body['gameId'] as string, body['token'] as string, body['gameCode'] as string);
|
||||
});
|
||||
};
|
||||
|
||||
// -- joining --------------------------------------------------------------------------------
|
||||
|
||||
let previewed: Preview | null = null;
|
||||
|
||||
function showPreview(p: Preview): void {
|
||||
previewed = p;
|
||||
$('lb-preview').hidden = false;
|
||||
$('lb-preview-code').textContent = p.gameCode;
|
||||
const near = closestPreset(p.config, p.players, p.config.days);
|
||||
const label = gameTypeLabel(
|
||||
near.differing.length === 0 ? near.name : 'custom',
|
||||
p.config.mode,
|
||||
);
|
||||
$('lb-preview-type').textContent =
|
||||
near.differing.length === 0
|
||||
? label
|
||||
: `${label} · ${near.differing.length} ${near.differing.length === 1 ? 'setting differs' : 'settings differ'} from ${preset(near.name).label}`;
|
||||
const taken = p.seated.filter((s) => s.who !== null || s.bot).length;
|
||||
const names = p.seated
|
||||
.map((s) => (s.bot ? 'a bot' : (s.who ?? 'empty')))
|
||||
.join(', ');
|
||||
$('lb-preview-who').textContent = `Host: ${p.hostName} · ${taken} of ${p.players} seats taken — ${names}`;
|
||||
$('lb-preview-rules').innerHTML = rulesListHtml(p.config, p.players, p.config.days);
|
||||
}
|
||||
|
||||
$<HTMLButtonElement>('lb-look').onclick = () => {
|
||||
const code = $<HTMLInputElement>('lb-code').value.trim().toUpperCase();
|
||||
$('lb-preview').hidden = true;
|
||||
if (code === '') {
|
||||
$('lb-join-err').textContent = 'Enter the game code you were given.';
|
||||
return;
|
||||
}
|
||||
$('lb-join-err').textContent = '';
|
||||
void getJson(
|
||||
`/api/lobby/preview?gameCode=${encodeURIComponent(code)}&secret=${encodeURIComponent(secret())}`,
|
||||
).then(({ status, body }) => {
|
||||
if (status !== 200) {
|
||||
secretRejected(status);
|
||||
$('lb-join-err').textContent = explain(body['error'], 'Could not look up that game.');
|
||||
return;
|
||||
}
|
||||
showPreview(body as unknown as Preview);
|
||||
});
|
||||
};
|
||||
|
||||
$<HTMLButtonElement>('lb-join').onclick = () => {
|
||||
const name = displayName();
|
||||
const code = previewed?.gameCode ?? $<HTMLInputElement>('lb-code').value.trim().toUpperCase();
|
||||
if (name === '') {
|
||||
$('lb-join-err').textContent = 'Enter a display name first.';
|
||||
return;
|
||||
}
|
||||
$('lb-join-err').textContent = '';
|
||||
void postJson('/api/lobby/join', { secret: secret(), gameCode: code, displayName: name }).then(
|
||||
({ status, body }) => {
|
||||
if (status !== 200) {
|
||||
secretRejected(status);
|
||||
$('lb-join-err').textContent = explain(body['error'], 'Could not join that game.');
|
||||
return;
|
||||
}
|
||||
enterSeating(body['gameId'] as string, body['token'] as string, code);
|
||||
},
|
||||
);
|
||||
};
|
||||
|
||||
// -- seating --------------------------------------------------------------------------------
|
||||
|
||||
function renderSeating(lobby: Lobby, you: PlayerIndex, token: string): void {
|
||||
$('lb-gamecode').textContent = lobby.gameCode;
|
||||
const isHost = lobby.hostToken === token;
|
||||
|
||||
let html = '';
|
||||
// Bots are numbered here exactly as `startLobby` numbers them at the moment the game starts, so
|
||||
// the table you set up is the table that appears on the board.
|
||||
let botNumber = 0;
|
||||
for (let seat = 0; seat < lobby.seats.length; seat++) {
|
||||
const occupant = lobby.seats[seat] ?? null;
|
||||
const isYou = occupant?.kind === 'human' && occupant.token === token;
|
||||
const isSeatHost = occupant?.kind === 'human' && occupant.token === lobby.hostToken;
|
||||
if (occupant?.kind === 'bot') botNumber++;
|
||||
const who =
|
||||
occupant === null
|
||||
? '<span class="dim">— waiting —</span>'
|
||||
: occupant.kind === 'bot'
|
||||
? `Bot ${botNumber}`
|
||||
: `${escapeHtml(occupant.displayName)}${isYou ? ' (you)' : ''}${isSeatHost ? ' — host' : ''}`;
|
||||
let action = '';
|
||||
if (isHost) {
|
||||
if (occupant === null) action = `<button class="lb-bot-add" data-seat="${seat}">+ bot</button>`;
|
||||
else if (occupant.kind === 'bot') action = `<button class="lb-bot-remove" data-seat="${seat}">remove bot</button>`;
|
||||
else if (!isYou) action = `<button class="lb-kick" data-seat="${seat}">remove</button>`;
|
||||
}
|
||||
html += `<div class="lb-seat"><span class="dim">Seat ${seatLabel(seat)}</span><span class="who">${who}</span>${action}</div>`;
|
||||
}
|
||||
$('lb-seats').innerHTML = html;
|
||||
|
||||
/**
|
||||
* The code is the whole invitation, so it has to leave this screen by some route other than
|
||||
* being read off it and retyped. Two buttons because they are two different acts: the CODE is
|
||||
* what you read aloud on a call and works at whatever address each player reaches the box by;
|
||||
* the LINK is what you paste into a chat, and only works for someone who can reach this address.
|
||||
* Neither carries the join secret — that is the door key, and it travels out of band.
|
||||
*
|
||||
* `navigator.clipboard` is unavailable on an insecure origin and can be refused outright, so a
|
||||
* failure says the code is there to be selected rather than silently doing nothing.
|
||||
*/
|
||||
const say = (m: string): void => {
|
||||
$('lb-copied').textContent = m;
|
||||
setTimeout(() => ($('lb-copied').textContent = ''), 4000);
|
||||
};
|
||||
const copy = (text: string, ok: string): void => {
|
||||
void navigator.clipboard
|
||||
?.writeText(text)
|
||||
.then(() => say(ok))
|
||||
.catch(() => say('Could not copy — select the code above instead.'));
|
||||
};
|
||||
$<HTMLButtonElement>('lb-copy').onclick = () => copy(lobby.gameCode, 'Code copied.');
|
||||
$<HTMLButtonElement>('lb-copylink').onclick = () =>
|
||||
copy(
|
||||
`${location.origin}${location.pathname}?lobby&code=${encodeURIComponent(lobby.gameCode)}`,
|
||||
'Invite link copied — the join secret is not in it.',
|
||||
);
|
||||
|
||||
for (const btn of Array.from($('lb-seats').querySelectorAll<HTMLButtonElement>('.lb-bot-add'))) {
|
||||
btn.onclick = () => void postJson('/api/lobby/bot', { token, seat: Number(btn.dataset['seat']), filled: true });
|
||||
}
|
||||
for (const btn of Array.from($('lb-seats').querySelectorAll<HTMLButtonElement>('.lb-bot-remove'))) {
|
||||
btn.onclick = () => void postJson('/api/lobby/bot', { token, seat: Number(btn.dataset['seat']), filled: false });
|
||||
}
|
||||
for (const btn of Array.from($('lb-seats').querySelectorAll<HTMLButtonElement>('.lb-kick'))) {
|
||||
btn.onclick = () => {
|
||||
void postJson('/api/lobby/leave', { token, seat: Number(btn.dataset['seat']) }).then(({ status, body }) => {
|
||||
if (status !== 200) $('lb-start-note').textContent = explain(body['error'], 'Could not clear that seat.');
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
// What everyone at the table is about to play — the host chose it, and until now nobody else
|
||||
// could see any of it.
|
||||
const near = closestPreset(lobby.config, lobby.seats.length, lobby.config.days);
|
||||
const label = gameTypeLabel(near.differing.length === 0 ? near.name : 'custom', lobby.config.mode);
|
||||
$('lb-seating-type').textContent =
|
||||
near.differing.length === 0
|
||||
? label
|
||||
: `${label} · ${near.differing.length} ${near.differing.length === 1 ? 'setting differs' : 'settings differ'} from ${preset(near.name).label}`;
|
||||
$('lb-seating-rules').innerHTML = rulesListHtml(lobby.config, lobby.seats.length, lobby.config.days);
|
||||
|
||||
const waiting = lobby.seats.filter((s) => s === null).length;
|
||||
const startBtn = $<HTMLButtonElement>('lb-start');
|
||||
startBtn.hidden = !isHost;
|
||||
startBtn.disabled = waiting > 0;
|
||||
startBtn.textContent = 'Start game';
|
||||
$('lb-start-note').textContent = '';
|
||||
const waitNote = $('lb-stream-note');
|
||||
if (waitNote.dataset['reason'] !== 'stream') {
|
||||
waitNote.hidden = waiting === 0 && isHost;
|
||||
waitNote.textContent = isHost
|
||||
? waiting === 0
|
||||
? ''
|
||||
: `Waiting on ${waiting} more ${waiting === 1 ? 'player' : 'players'} — add a bot to any empty chair to start now.`
|
||||
: 'Waiting for the host to start the game.';
|
||||
waitNote.hidden = waitNote.textContent === '';
|
||||
}
|
||||
startBtn.onclick = () => {
|
||||
// No busy state used to mean a second press posted a second start, whose 409 landed on screen
|
||||
// as a raw code.
|
||||
startBtn.disabled = true;
|
||||
startBtn.textContent = 'Starting…';
|
||||
void postJson('/api/lobby/start', { token }).then(({ status, body }) => {
|
||||
if (status !== 200) {
|
||||
startBtn.disabled = false;
|
||||
startBtn.textContent = 'Start game';
|
||||
$('lb-start-note').textContent = explain(body['error'], 'Could not start the game.');
|
||||
}
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
function streamNote(message: string): void {
|
||||
const el = $('lb-stream-note');
|
||||
el.dataset['reason'] = message === '' ? '' : 'stream';
|
||||
el.textContent = message;
|
||||
el.hidden = message === '';
|
||||
}
|
||||
|
||||
function enterSeating(gameId: string, token: string, gameCode: string): void {
|
||||
handlers.onSeated({ token, gameId, gameCode });
|
||||
$('lb-choice-section').hidden = true;
|
||||
$('lb-seating-section').hidden = false;
|
||||
|
||||
$<HTMLButtonElement>('lb-leave').onclick = () => {
|
||||
void postJson('/api/lobby/leave', { token }).then(() => {
|
||||
source?.close();
|
||||
handlers.onLeft(gameId);
|
||||
$('lb-seating-section').hidden = true;
|
||||
$('lb-choice-section').hidden = false;
|
||||
renderKnown();
|
||||
notice('');
|
||||
});
|
||||
};
|
||||
|
||||
source = new EventSource(`/api/lobby/stream?token=${encodeURIComponent(token)}`);
|
||||
source.onmessage = (ev: MessageEvent<string>) => {
|
||||
streamNote('');
|
||||
const push = JSON.parse(ev.data) as LobbyPush;
|
||||
if (push.started) {
|
||||
source?.close();
|
||||
if (done) return;
|
||||
done = true;
|
||||
handlers.onReady({ token, gameId, seat: push.you, gameCode: push.lobby.gameCode });
|
||||
return;
|
||||
}
|
||||
renderSeating(push.lobby, push.you, token);
|
||||
};
|
||||
|
||||
/**
|
||||
* A DEAD LOBBY AND A BLIP LOOK IDENTICAL HERE, so ask — the same shape `session.ts` already uses
|
||||
* for the game stream, which the lobby never got.
|
||||
*
|
||||
* Three answers matter. The game may have STARTED while we were disconnected (the `started` push
|
||||
* is sent once and then the connection closes, so a drop at the wrong moment loses it) —
|
||||
* `/api/session` knows, and we go straight in. The lobby may still be there, in which case
|
||||
* `EventSource` is already retrying and the note is all that is needed. Or it is gone, and
|
||||
* sitting on a frozen seating screen is the one thing that must not happen.
|
||||
*/
|
||||
source.onerror = () => {
|
||||
if (done) return;
|
||||
streamNote('Connection lost — retrying. You can leave and rejoin if this does not clear.');
|
||||
void getJson(`/api/session?token=${encodeURIComponent(token)}`).then(({ status, body }) => {
|
||||
if (done) return;
|
||||
if (status === 200) {
|
||||
done = true;
|
||||
source?.close();
|
||||
handlers.onReady({ token, gameId, seat: body['player'] as PlayerIndex, gameCode });
|
||||
return;
|
||||
}
|
||||
void getJson(
|
||||
`/api/lobby/preview?gameCode=${encodeURIComponent(gameCode)}&secret=${encodeURIComponent(secret())}`,
|
||||
).then(({ status: lobbyStatus }) => {
|
||||
if (done || lobbyStatus === 200) return;
|
||||
source?.close();
|
||||
handlers.onLeft(gameId);
|
||||
$('lb-seating-section').hidden = true;
|
||||
$('lb-choice-section').hidden = false;
|
||||
renderKnown();
|
||||
streamNote('');
|
||||
notice('That game is no longer waiting on this server — it was ended, or the last player left.');
|
||||
});
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
if (resume) enterSeating(resume.gameId, resume.token, resume.gameCode);
|
||||
}
|
||||
|
||||
/** The lobby-wide message slot: why you are looking at this screen, when it was not your own click. */
|
||||
export function notice(message: string): void {
|
||||
const el = document.getElementById('lb-notice');
|
||||
if (!el) return;
|
||||
el.textContent = message;
|
||||
el.hidden = message === '';
|
||||
}
|
||||
|
||||
/** Prefills the code from an invite link and opens the join door on it. */
|
||||
export function prefillCode(code: string): void {
|
||||
const field = document.getElementById('lb-code') as HTMLInputElement | null;
|
||||
if (field) field.value = code.toUpperCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* A CHOICE THAT CANNOT BE TAKEN HAS TO SAY SO.
|
||||
*
|
||||
* Reported by Jesse 2026-08-23: "solitaire is disabled, but really hard to tell." A bare `disabled`
|
||||
* on a radio leaves the whole row at full strength — the dot simply refuses the click, which reads
|
||||
* as a broken control rather than an unavailable one. Dims the row and says why, once.
|
||||
*/
|
||||
function markUnavailable(radio: HTMLInputElement, why: string): void {
|
||||
radio.disabled = true;
|
||||
const row = radio.closest('label');
|
||||
if (!row) return;
|
||||
row.classList.add('disabled');
|
||||
if (row.querySelector('.lb-why')) return;
|
||||
const note = document.createElement('span');
|
||||
note.className = 'lb-why';
|
||||
note.textContent = ` — ${why}`;
|
||||
row.querySelector('span')?.appendChild(note);
|
||||
}
|
||||
|
||||
function escapeHtml(s: string): string {
|
||||
return s.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"');
|
||||
}
|
||||
+105
-1197
File diff suppressed because it is too large
Load Diff
+2
-367
@@ -31,18 +31,8 @@ export function cardRow(name: string, why: string, playable: boolean | null): st
|
||||
}
|
||||
|
||||
export function handHtml(f: Frame, canPlay: (boolean | null)[] = []): string {
|
||||
// §6.2 — say so on the card itself. A player who cannot discard a train needs to read that on the
|
||||
// train, not deduce it from a button that is not there. The sentence comes off the Frame
|
||||
// (`handKeepWhy`) rather than being written here, because since Gitea#9 there are two of them and
|
||||
// which one applies depends on the card AND the game's rules.
|
||||
return f.hand.length
|
||||
? f.hand
|
||||
.map((h, i) => {
|
||||
const what = f.handWhat[i] ?? '';
|
||||
const held = f.handKeepWhy[i];
|
||||
return cardRow(h, held ? [what, held].filter(Boolean).join(' · ') : what, canPlay[i] ?? null);
|
||||
})
|
||||
.join('')
|
||||
? f.hand.map((h, i) => cardRow(h, f.handWhat[i] ?? '', canPlay[i] ?? null)).join('')
|
||||
: '<span class="dim">empty</span>';
|
||||
}
|
||||
|
||||
@@ -153,337 +143,6 @@ export function timetableHtml(f: Frame, justSet: number | null): string {
|
||||
return `<div class="tt">${slots}</div>`;
|
||||
}
|
||||
|
||||
/**
|
||||
* THE DAY THAT JUST ENDED — the body of the dialog `main.ts` puts up at every Day rollover.
|
||||
*
|
||||
* Reported as Gitea#10: "as the game rolls off the end of the day, you get a dialog saying such.
|
||||
* Hard to keep track of time." The clock was on screen the whole time, but a Day turns over inside
|
||||
* the automatic phases — between one click and the next — and neither the phase banner (2.6s) nor
|
||||
* the announcement flash (4.2s) survives long enough to be noticed by someone reading the board.
|
||||
* A modal is the point: it stops, and it waits to be dismissed.
|
||||
*
|
||||
* It is written from the FRAME AFTER the rollover, so `f.day` is the Day about to start and the one
|
||||
* that ended is the Day before it. Standings are in Revenue order rather than seat order: the
|
||||
* question at the end of a Day is who is ahead.
|
||||
*/
|
||||
export function dayEndHtml(f: Frame): string {
|
||||
const ended = f.day - 1;
|
||||
const left = f.days + f.extraDays - ended;
|
||||
|
||||
const ahead =
|
||||
left <= 0
|
||||
? '<p>That was the last Day on the timetable.</p>'
|
||||
: `<p><b>Day ${f.day} of ${f.days + f.extraDays}</b> begins now — ${left} ${left === 1 ? 'Day' : 'Days'} left to run.</p>`;
|
||||
|
||||
return (
|
||||
`<h3 class="dayend-h">Day ${ended} has ended</h3>` +
|
||||
ahead +
|
||||
standingsHtml(f) +
|
||||
targetHtml(f) +
|
||||
collisionsHtml(f)
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Shared between the Day-end dialog and the end-of-game results screen.
|
||||
//
|
||||
// Gitea#16 asked for the results screen and Gitea#10's dialog had already assembled most of it. The
|
||||
// three blocks below are the overlap, factored out rather than written twice: the two screens report
|
||||
// the same numbers about the same game, and the one thing they must never do is disagree.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Every player in Revenue order, the viewer marked.
|
||||
*
|
||||
* `winner` rings the player the OFFICIAL result named, which is not always the player at the top:
|
||||
* in an extended game the standings keep moving after the result is settled, and showing the leader
|
||||
* without saying who actually won would be the screen contradicting itself.
|
||||
*/
|
||||
function standingsHtml(f: Frame, winner: number | null = null): string {
|
||||
const rows = [...f.players]
|
||||
.sort((a, b) => b.revenue - a.revenue || a.seat - b.seat)
|
||||
.map((p) => {
|
||||
const marks =
|
||||
(p.index === f.viewer ? ' <span class="dim">(you)</span>' : '') +
|
||||
(p.index === winner ? ' <span class="wins">— winner</span>' : '');
|
||||
return (
|
||||
`<tr${p.index === f.viewer ? ' class="you"' : ''}><td>${esc(p.name)}${marks}</td>` +
|
||||
`<td class="num">${p.revenue}</td></tr>`
|
||||
);
|
||||
})
|
||||
.join('');
|
||||
return `<table class="dayend-t"><tbody>${rows}</tbody></table>`;
|
||||
}
|
||||
|
||||
/**
|
||||
* The target is a COMBINED floor in every mode that sets one, so it is reported against the whole
|
||||
* table's Revenue rather than the viewer's — showing one player's score against a four-player
|
||||
* target reads as a hopeless position when the table may be comfortably ahead.
|
||||
*/
|
||||
function targetHtml(f: Frame): string {
|
||||
if (f.minCombinedRevenue <= 0) return '';
|
||||
const combined = f.players.reduce((n, p) => n + p.revenue, 0);
|
||||
const met = combined >= f.minCombinedRevenue;
|
||||
return (
|
||||
`<p>Combined Revenue <b>${combined}</b> against a target of <b>${f.minCombinedRevenue}</b>` +
|
||||
`${met ? ' — cleared.' : ' — short.'}</p>`
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Only when the game is actually scored on collisions.
|
||||
*
|
||||
* Two conditions, both of them `advance.ts`'s own: `0` on a dial turns that check off, and the
|
||||
* checks run in COMPETITIVE AND CO-OP ONLY (§3.4). A solitaire game carries the default dials on
|
||||
* its config and enforces neither, so reporting a collision budget there would put a rule on
|
||||
* screen that this game does not have.
|
||||
*/
|
||||
function collisionsHtml(f: Frame): string {
|
||||
const scoredOnCollisions =
|
||||
(f.mode === 'competitive' || f.mode === 'coop') &&
|
||||
(f.maxCollisionsTotal > 0 || f.maxCollisionsPerDay > 0);
|
||||
return scoredOnCollisions
|
||||
? `<p>Collisions: <b>${f.collisionsToday}</b> today, <b>${f.collisionsTotal}</b> in all.</p>`
|
||||
: '';
|
||||
}
|
||||
|
||||
/**
|
||||
* WHY THE GAME ENDED, as a sentence (Gitea#16).
|
||||
*
|
||||
* The page used to interpolate `outcome.reason` straight into the DOM, so a player who finished a
|
||||
* game read the words `GAME OVER — revenueFloor`: an internal enum value, printed at the one moment
|
||||
* the game has the player's whole attention. Each reason gets a sentence that says what actually
|
||||
* happened, with this game's own numbers in it.
|
||||
*/
|
||||
function reasonSentence(f: Frame, o: NonNullable<Frame['outcome']>, day: number): string {
|
||||
const combined = f.players.reduce((n, p) => n + p.revenue, 0);
|
||||
switch (o.reason) {
|
||||
case 'daysElapsed':
|
||||
return `Day ${day} was the last on the timetable, and it ran out.`;
|
||||
case 'revenueFloor':
|
||||
return (
|
||||
`The Division closed short: <b>${combined}</b> Revenue between everyone, against a floor of ` +
|
||||
`<b>${f.minCombinedRevenue}</b>. §3.3 — miss the floor and the whole table loses, whoever ` +
|
||||
`earned the most.`
|
||||
);
|
||||
case 'collisionFloor':
|
||||
return (
|
||||
`Too many collisions — <b>${f.collisionsToday}</b> in one Day and <b>${f.collisionsTotal}</b> ` +
|
||||
`in all, against limits of ${f.maxCollisionsPerDay || '—'} and ${f.maxCollisionsTotal || '—'}. ` +
|
||||
`§3.4 — the railroad was declared unsafe and the game was stopped.`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/** The rules this game was actually dealt under — Gitea#16's "what the rules of the game were". */
|
||||
function rulesHtml(f: Frame): string {
|
||||
const mode =
|
||||
f.mode === 'coop' ? 'Co-op — the table scores together' :
|
||||
f.mode === 'competitive' ? 'Competitive — highest Revenue wins' :
|
||||
'Solitaire';
|
||||
const optional = [
|
||||
f.optionalRules.employeeRotation ? 'Employee Rotation' : null,
|
||||
f.optionalRules.reducedVisibility ? 'Reduced Visibility' : null,
|
||||
f.optionalRules.emergencyToolbox ? 'Emergency Toolbox' : null,
|
||||
].filter((x): x is string => x !== null);
|
||||
const r = f.houseRules.revenue;
|
||||
|
||||
const rows: [string, string][] = [
|
||||
['Scoring', mode],
|
||||
['Timetable', f.extraDays > 0
|
||||
? `${f.days} Days, extended by ${f.extraDays} more`
|
||||
: `${f.days} Day${f.days === 1 ? '' : 's'}`],
|
||||
['Revenue floor', f.minCombinedRevenue > 0 ? `${f.minCombinedRevenue} combined` : 'none'],
|
||||
['Collision limits', f.maxCollisionsPerDay > 0 || f.maxCollisionsTotal > 0
|
||||
? `${f.maxCollisionsPerDay || '—'} per Day, ${f.maxCollisionsTotal || '—'} in all`
|
||||
: 'not scored'],
|
||||
['Pay rates', `${r.freightPerLoad} per load, ${r.passengerPerCoach} per coach, ${r.trainPerTransit} per transit`],
|
||||
['Extras start', f.houseRules.extraStart === 'divisionPointsOnly' ? 'Division Points and the Interchange'
|
||||
: f.houseRules.extraStart === 'ownOffice' ? 'those, plus your own Control Point'
|
||||
: 'those, plus any Control Point'],
|
||||
['Timetabled trains', f.houseRules.discardTimetabled ? 'may be discarded' : 'are never discarded'],
|
||||
['Optional rules', optional.length ? optional.join(', ') : 'none'],
|
||||
];
|
||||
|
||||
return `<h4 class="res-h">The rules in play</h4>${factTable(rows)}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* A two-column table of plain-text facts.
|
||||
*
|
||||
* BOTH HALVES ESCAPED, exactly once, which is the only reason this is a shared helper rather than a
|
||||
* template repeated twice. The rows it is given today are numbers and fixed phrases, but they are
|
||||
* assembled from the Frame — and the day somebody adds a row carrying a player's name, or a facility
|
||||
* label, the escaping has to already be here rather than be remembered.
|
||||
*/
|
||||
function factTable(rows: [string, string][]): string {
|
||||
return (
|
||||
'<table class="res-t"><tbody>' +
|
||||
rows.map(([k, v]) => `<tr><td>${esc(k)}</td><td>${esc(v)}</td></tr>`).join('') +
|
||||
'</tbody></table>'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* THE RAILROAD — what actually happened out there, from `GameState.tally` (Gitea#16).
|
||||
*
|
||||
* Rows that would read zero for a reason (no passenger work in a game that had none, no collisions
|
||||
* in a clean one) are dropped rather than printed as `0`: a screen of zeroes reads as a bug, and the
|
||||
* absence of a line is the same information more quietly. A zero that is genuinely interesting —
|
||||
* trains through the Division — stays.
|
||||
*/
|
||||
function tallyHtml(t: Frame['tally']): string {
|
||||
const rows: [string, string][] = [['Trains through the Division', String(t.trainsCompleted)]];
|
||||
|
||||
if (t.trainsCompleted > 0) {
|
||||
rows.push([
|
||||
'Of those, worked en route',
|
||||
`${t.trainsCompletedWithWork} of ${t.trainsCompleted}` +
|
||||
(t.trainsCompletedWithWork === t.trainsCompleted ? ' — every one' : ''),
|
||||
]);
|
||||
}
|
||||
const push = (label: string, n: number, detail = ''): void => {
|
||||
if (n > 0) rows.push([label, `${n}${detail}`]);
|
||||
};
|
||||
push('Loads made up', t.loadsCompleted);
|
||||
push('Loads broken', t.unloadsCompleted);
|
||||
push('Loads still in the pipeline', t.loadsStarted - t.loadsCompleted);
|
||||
push('Passengers boarded', t.passengersBoarded);
|
||||
push('Passengers detrained', t.passengersDetrained);
|
||||
push('Cars coupled', t.carsCoupled);
|
||||
push('Cars set out', t.carsDropped);
|
||||
push('Extras run', t.extrasStarted);
|
||||
push('Second sections ordered', t.secondSections);
|
||||
push('Flying switches', t.flyingSwitches);
|
||||
push('Offices upgraded', t.officeUpgrades);
|
||||
push('Facilities unjammed', t.facilitiesUnjammed);
|
||||
push('Trains held', t.trainsHeld);
|
||||
push('Trains diverted', t.trainsDiverted);
|
||||
push('Expedite faults', t.expediteFaults);
|
||||
push('Dispatch bonuses used', t.dispatchBonusesUsed);
|
||||
if (t.clearancesRequested > 0) {
|
||||
rows.push(['Clearances', `${t.clearancesAllowed} allowed of ${t.clearancesRequested} asked`]);
|
||||
}
|
||||
if (t.trainsDestroyed > 0) {
|
||||
rows.push([
|
||||
'Trains destroyed',
|
||||
`${t.trainsDestroyed}, taking ${t.carsDestroyed} car${t.carsDestroyed === 1 ? '' : 's'} with them`,
|
||||
]);
|
||||
}
|
||||
// §X18 only — the one card in the deck that pays a train for standing still. Reported as what it
|
||||
// is rather than as "the longest an engine sat on a siding", which the engine cannot answer (see
|
||||
// `Tally.circusStops`).
|
||||
if (t.circusStops.length > 0) {
|
||||
rows.push([
|
||||
'Circus set-ups',
|
||||
t.circusStops.map((c) => `Train ${c.trainNumber} at ${c.where}`).join(', '),
|
||||
]);
|
||||
}
|
||||
push('Cards drawn', t.cardsDrawn);
|
||||
push('Cards played', t.cardsPlayed);
|
||||
|
||||
return `<h4 class="res-h">The railroad</h4>${factTable(rows)}`;
|
||||
}
|
||||
|
||||
/** Per-player work, for a table that wants to know who did what rather than only who won. */
|
||||
function perPlayerHtml(f: Frame): string {
|
||||
const t = f.tally;
|
||||
if (f.players.length < 2) return '';
|
||||
const head =
|
||||
'<tr><th></th><th class="num">Rev</th><th class="num">Loads</th><th class="num">Unloads</th>' +
|
||||
'<th class="num">Pass.</th><th class="num">Cards</th><th class="num">Crashes</th></tr>';
|
||||
const rows = [...f.players]
|
||||
.sort((a, b) => b.revenue - a.revenue || a.seat - b.seat)
|
||||
.map((p) => {
|
||||
const q = t.byPlayer[p.index];
|
||||
if (!q) return '';
|
||||
return (
|
||||
`<tr${p.index === f.viewer ? ' class="you"' : ''}><td>${esc(p.name)}</td>` +
|
||||
`<td class="num">${p.revenue}</td><td class="num">${q.loads}</td>` +
|
||||
`<td class="num">${q.unloads}</td>` +
|
||||
`<td class="num">${q.passengersBoarded + q.passengersDetrained}</td>` +
|
||||
`<td class="num">${q.cardsPlayed}</td><td class="num">${q.collisions}</td></tr>`
|
||||
);
|
||||
})
|
||||
.join('');
|
||||
return `<h4 class="res-h">Who did what</h4><table class="res-t res-wide"><tbody>${head}${rows}</tbody></table>`;
|
||||
}
|
||||
|
||||
/**
|
||||
* THE END-OF-GAME RESULTS SCREEN — Gitea#16, first pass.
|
||||
*
|
||||
* Everything the Frame already knew plus everything the event tally counted, in the order a player
|
||||
* asks for it: what happened, who won, by how much, under what rules, and then what the railroad
|
||||
* actually did all game. Badges and the "what would make this exciting" brainstorm are the second
|
||||
* pass the issue asks for and are deliberately not here.
|
||||
*
|
||||
* THE OFFICIAL RESULT IS THE ONE AT THE TOP, always. In an extended game (Gitea#11) the standings go
|
||||
* on moving after the winner is settled, so this screen reports the frozen result first and puts
|
||||
* everything that happened afterwards in its own section, marked as informational. "In a five-day
|
||||
* game, even if it's extended to eight or nine days, the winner and the official answer is the
|
||||
* winner at the end of five days" (Jesse, 2026-08-28).
|
||||
*/
|
||||
export function resultsHtml(f: Frame): string {
|
||||
// `official` is written by the engine the moment any game ends, so it is present on every finished
|
||||
// game. The fallback keeps this rendering something sane for a Frame that predates it — a replay
|
||||
// of a save recorded before this release, which the replay viewer will happily hand us.
|
||||
const report = f.official;
|
||||
const o = report?.outcome ?? f.outcome;
|
||||
if (!o) return '<p class="dim">This game has not ended.</p>';
|
||||
|
||||
const officialDay = report?.day ?? f.days;
|
||||
const winnerName =
|
||||
o.winner === null ? null : (f.players.find((p) => p.index === o.winner)?.name ?? null);
|
||||
|
||||
const headline =
|
||||
o.result === 'loss'
|
||||
? 'The Division failed'
|
||||
: winnerName === null
|
||||
? 'The Division ran'
|
||||
: `${esc(winnerName)} takes the Division`;
|
||||
|
||||
/**
|
||||
* The result is reported against the standings AS THEY WERE at the official ending, not as they
|
||||
* are now — in an extended game those are different numbers, and the winner has to be shown
|
||||
* winning. `revenues` is frozen alongside the outcome for exactly this.
|
||||
*/
|
||||
const frozen = report
|
||||
? { ...f, players: f.players.map((p) => ({ ...p, revenue: report.revenues[p.index] ?? p.revenue })) }
|
||||
: f;
|
||||
|
||||
const result =
|
||||
o.result === 'loss'
|
||||
? '<p>Nobody wins this one.</p>'
|
||||
: o.winner === null
|
||||
? '<p>The table clears it together — a Co-op game has no individual winner.</p>'
|
||||
: `<p><b>${esc(winnerName ?? '')}</b> finishes ahead on Revenue.</p>`;
|
||||
|
||||
const extended =
|
||||
f.extraDays > 0
|
||||
? '<h4 class="res-h">After the timetable</h4>' +
|
||||
`<p>The table played on for ${f.extraDays} more Day${f.extraDays === 1 ? '' : 's'}, ` +
|
||||
`through Day ${f.days + f.extraDays}. None of it changed the result above — it is recorded ` +
|
||||
'here because it happened.</p>' +
|
||||
standingsHtml(f) +
|
||||
targetHtml(f) +
|
||||
collisionsHtml(f) +
|
||||
tallyHtml(f.tally)
|
||||
: '';
|
||||
|
||||
return (
|
||||
`<h3 class="dayend-h res-${o.result}">${headline}</h3>` +
|
||||
`<p>${reasonSentence(frozen, o, officialDay)}</p>` +
|
||||
result +
|
||||
standingsHtml(frozen, o.winner) +
|
||||
targetHtml(frozen) +
|
||||
collisionsHtml(frozen) +
|
||||
perPlayerHtml(frozen) +
|
||||
rulesHtml(f) +
|
||||
tallyHtml(report?.tally ?? f.tally) +
|
||||
extended
|
||||
);
|
||||
}
|
||||
|
||||
export function blockedHtml(f: Frame): string {
|
||||
return f.blocked.length === 0
|
||||
? '<li class="dim">nothing blocked</li>'
|
||||
@@ -622,7 +281,7 @@ export function facilitiesHtml(f: Frame): string {
|
||||
: '') +
|
||||
`<div class="fstat ${x.jammed ? 'bad' : x.canFinish ? 'good' : 'idle'}" data-tip="${
|
||||
x.jammed
|
||||
? 'A load is sitting on MEN|AT|WORK with no spotted car to receive it. That locks the industry track, which blocks the very car that would clear it.'
|
||||
? 'A load is sitting on MEN|AT|WORK with no spotted car to receive it. That locks the industry track, which blocks the very car that would clear it (§9.3).'
|
||||
: x.canFinish
|
||||
? 'A matching empty car is spotted on this industry\'s track, so a load worked here can come off onto it.'
|
||||
: 'No matching car is spotted. Starting a load here would park it on WORK and jam the facility.'
|
||||
@@ -738,28 +397,4 @@ ul.blocked{margin:0;padding-left:18px}
|
||||
.fstat.good{background:rgba(40,140,60,.28)}
|
||||
.fstat.bad{background:rgba(190,50,50,.38);font-weight:700}
|
||||
.fstat.idle{opacity:.6}
|
||||
/* THE DAY-END DIALOG (Gitea#10). The dialog chrome is play.html's; these are its contents, here
|
||||
because dayEndHtml is here — a panel and its styling stay together. */
|
||||
.dayend-h{font-size:15px;text-transform:none;letter-spacing:0;color:#e6e9ee;margin:0 0 8px}
|
||||
.dayend-t{border-collapse:collapse;margin:9px 0;min-width:210px}
|
||||
.dayend-t td{padding:3px 12px 3px 0;border-top:1px solid #2c333d}
|
||||
.dayend-t tr:first-child td{border-top:0}
|
||||
.dayend-t .num{text-align:right;font-variant-numeric:tabular-nums;font-weight:700;padding-right:0}
|
||||
.dayend-t .you td{color:#8fd6a0}
|
||||
.dayend-t .wins{color:#e8c56a;font-weight:700}
|
||||
|
||||
/* END-OF-GAME RESULTS (Gitea#16). Same family as the Day-end dialog above, which is the point —
|
||||
the two screens share their standings/target/collision blocks and should look like each other. */
|
||||
.res-h{font-size:12px;text-transform:uppercase;letter-spacing:.08em;color:#8b95a3;
|
||||
margin:16px 0 6px;border-top:1px solid #2c333d;padding-top:10px}
|
||||
.res-win{color:#8fd6a0}
|
||||
.res-loss{color:#d98f8f}
|
||||
.res-t{border-collapse:collapse;margin:4px 0;width:100%}
|
||||
.res-t td,.res-t th{padding:3px 12px 3px 0;border-top:1px solid #232a33;vertical-align:top}
|
||||
.res-t tr:first-child td{border-top:0}
|
||||
.res-t td:first-child{color:#8b95a3;white-space:nowrap}
|
||||
.res-t th{color:#6d7783;font-weight:600;font-size:11px;text-transform:uppercase;letter-spacing:.05em}
|
||||
.res-t .num{text-align:right;font-variant-numeric:tabular-nums}
|
||||
.res-wide td:first-child{color:#e6e9ee}
|
||||
.res-t .you td{color:#8fd6a0}
|
||||
`;
|
||||
|
||||
+21
-783
@@ -33,16 +33,6 @@ header button:hover{border-color:#4d6fa8}
|
||||
stops inviting the press. */
|
||||
header button:disabled{opacity:.45;cursor:not-allowed;border-color:#2c333d}
|
||||
header button:disabled:hover{border-color:#2c333d}
|
||||
.zoom{display:inline-flex;align-items:center;gap:4px}
|
||||
.zoom button{padding:3px 9px;line-height:1}
|
||||
.lb-invite{display:flex;align-items:center;gap:12px;flex-wrap:wrap;margin:0 0 10px;
|
||||
background:#1e242c;border:1px solid var(--line);border-radius:7px;padding:10px 12px}
|
||||
.lb-invite-label{font-size:11px;color:var(--dim)}
|
||||
.lb-invite-code{font-size:22px;font-weight:700;letter-spacing:.08em;color:#f2e6cf}
|
||||
#lb-settings{margin:10px 0;border:1px solid var(--line);border-radius:7px;padding:8px 12px;background:#171c23}
|
||||
#lb-settings summary{cursor:pointer;font-size:13px;color:#9fb6d8}
|
||||
#lb-settings h3{font-size:12px;margin:12px 0 4px;color:#9fb6d8}
|
||||
.zoom #zoomlabel{font-size:11px;color:var(--dim);min-width:32px;text-align:center;display:inline-block}
|
||||
.build{margin-left:auto;font-size:10px;opacity:.55;white-space:nowrap}
|
||||
.home{color:inherit;text-decoration:none;border-bottom:1px dotted #5f6b7a}
|
||||
.home:hover{color:#5aa9e6}
|
||||
@@ -80,29 +70,6 @@ main{display:grid;grid-template-columns:minmax(0,1fr) 400px;gap:14px;padding:14p
|
||||
@media(max-width:1100px){main{grid-template-columns:1fr}}
|
||||
section{background:var(--panel);border:1px solid var(--line);border-radius:7px;
|
||||
padding:10px 12px;margin-bottom:12px}
|
||||
#lobby,#solitairesetup{max-width:1040px;margin:0 auto;padding:14px}
|
||||
/* The create form is two short lists, not one long one: what game this is on the left, what its
|
||||
rules are on the right. Collapses to one column where there is no room for two. */
|
||||
.lb-two{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1.1fr);gap:22px;align-items:start}
|
||||
@media(max-width:860px){.lb-two{grid-template-columns:1fr;gap:0}}
|
||||
.lb-col{min-width:0}
|
||||
.lb-span{grid-column:1/-1;min-width:0}
|
||||
/* The rules in as many columns as the width allows — one in the New Game dialog, which is narrow. */
|
||||
.set-groups{display:grid;grid-template-columns:repeat(auto-fit,minmax(290px,1fr));gap:0 26px;align-items:start}
|
||||
.set-group{min-width:0;break-inside:avoid}
|
||||
.set-group h3:first-child{margin-top:4px}
|
||||
/* A DISABLED CHOICE HAS TO LOOK DISABLED. Reported by Jesse: Solitaire is not selectable in the
|
||||
lobby and nothing on it said so — a radio that silently refuses reads as a broken radio. */
|
||||
.ng-radio.disabled{opacity:.45;cursor:not-allowed}
|
||||
.ng-radio.disabled:hover{background:none}
|
||||
.lb-why{color:#e0b060;font-size:11px}
|
||||
#lobby h2,#solitairesetup h2{margin-top:0}
|
||||
#lobby h3,#solitairesetup h3{margin-bottom:2px}
|
||||
.lb-seat{display:flex;align-items:center;gap:8px;padding:5px 0;border-bottom:1px solid var(--line)}
|
||||
.lb-seat:last-child{border-bottom:none}
|
||||
.lb-seat .who{flex:1}
|
||||
#presence{color:#e0b060;font-size:12px;padding:0 14px;empty-cells:hide}
|
||||
#presence:empty{display:none}
|
||||
/* division strip */
|
||||
#division{display:flex;gap:7px;overflow-x:auto;padding-bottom:4px}
|
||||
.node{border:1px solid var(--line);border-radius:6px;padding:6px 9px;min-width:112px;flex:0 0 auto}
|
||||
@@ -187,12 +154,6 @@ button.act.crew.on{border-color:var(--now);background:rgba(185,140,240,.18);colo
|
||||
button{background:#2a3038;color:var(--fg);border:1px solid var(--line);border-radius:5px;
|
||||
padding:5px 9px;margin:2px 3px 2px 0;cursor:pointer;font:inherit;font-size:12px;text-align:left}
|
||||
button:hover{background:#39424e;border-color:#4d6fa8}
|
||||
/* GENERIC, and it was not. `header button:disabled` and `#actions button:disabled` were the only
|
||||
disabled styles on the page, so a disabled button anywhere else — #lb-start being the one that
|
||||
mattered — kept its normal face AND still lit up under the cursor from the rule above. It was
|
||||
advertising a click it would refuse. */
|
||||
button:disabled{opacity:.45;cursor:not-allowed}
|
||||
button:disabled:hover{background:#2a3038;border-color:var(--line)}
|
||||
#actions button{background:#2b3444;border:2px solid #c8912f;box-shadow:0 0 0 1px rgba(200,145,47,.18);
|
||||
color:#f2e6cf;font-weight:600}
|
||||
#actions button:hover{background:#3a4a63;border-color:#f0b64a;box-shadow:0 0 0 3px rgba(240,182,74,.20)}
|
||||
@@ -222,14 +183,6 @@ h3.actions-hd{font-size:13px;text-transform:none;letter-spacing:.01em;color:#cfe
|
||||
.over{padding:9px;border-radius:5px;font-weight:700;margin-bottom:8px}
|
||||
.over.win{background:rgba(40,140,60,.35)}
|
||||
.over.loss{background:rgba(160,60,60,.3)}
|
||||
/* THE EXTENSION VOTE (Gitea#11) — unanimous, so who has not answered yet is the useful half. */
|
||||
.vote-tally{display:flex;flex-wrap:wrap;gap:4px 12px;margin:0 0 9px;font-size:12px}
|
||||
.vote.yes{color:#8fd6a0}
|
||||
.vote.no{color:#d98f8f}
|
||||
.vote.wait{color:var(--dim)}
|
||||
/* Wider than the New Game dialog: the results carry a seven-column per-player table (Gitea#16). */
|
||||
#resultsdlg{max-width:640px}
|
||||
#resultsdlg table{max-width:100%}
|
||||
/* cards, log, blocked */
|
||||
.card.gone{opacity:.35;text-decoration:line-through}
|
||||
.subj{display:block;width:100%;margin:2px 0}
|
||||
@@ -250,528 +203,10 @@ h3.actions-hd{font-size:13px;text-transform:none;letter-spacing:.01em;color:#cfe
|
||||
ul.blocked{list-style:none;margin:0;padding:0;font-size:12px}
|
||||
ul.blocked li{padding:2px 0}
|
||||
.sev-warn{color:#e0b060}.sev-stop{color:#e58080}
|
||||
/* THE RULES BLOCK, shared by the lobby and the New Game dialog (`settings-form.ts`).
|
||||
`.changed` is the one signal that says "this game is not the type it claims" — amber, the palette's
|
||||
attention colour, never red: a changed rule is a choice, not an error. */
|
||||
.set-row{padding:3px 0}
|
||||
.set-row.changed{border-left:3px solid #e0b060;padding-left:9px;margin-left:-12px;
|
||||
background:rgba(224,176,96,.08);border-radius:0 4px 4px 0}
|
||||
.set-hint{display:block;font-size:11px;color:var(--dim);margin:2px 0 0}
|
||||
/* The line under the type radios when a game is no longer the type it started as. */
|
||||
.changed-note{color:#e0b060}
|
||||
.set-row.changed .set-hint{color:#e0b060}
|
||||
.set-row.unavailable{opacity:.5}
|
||||
.ng-gate{display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding:3px 0}
|
||||
.ng-gate input[type=checkbox]{flex:none}
|
||||
.gate-num{width:82px}
|
||||
.ng-gate input:disabled{opacity:.45}
|
||||
.lb-params{display:flex;gap:14px;flex-wrap:wrap;align-items:end;margin:8px 0}
|
||||
.lb-params .ng-num{flex:1 1 150px}
|
||||
/* An error a player must not scroll past. The grey `.dim` line this replaced was routinely missed —
|
||||
it looked like the note above it. Red is the palette's `.sev-stop`. */
|
||||
.lb-error{color:#e58080;font-size:14px;font-weight:600;margin:8px 0;padding:8px 11px;
|
||||
border-left:3px solid #e58080;background:rgba(229,128,128,.12);border-radius:0 5px 5px 0;
|
||||
empty-cells:hide}
|
||||
.lb-error:empty{display:none}
|
||||
.lb-warn{color:#e0b060;font-size:13px;margin:8px 0}
|
||||
.lb-doors{display:flex;gap:9px;margin:14px 0 12px}
|
||||
.lb-door{flex:1;background:#222831;color:var(--fg);border:1px solid var(--line);border-radius:7px;
|
||||
padding:9px 12px;cursor:pointer;font:inherit;font-size:14px}
|
||||
.lb-door:hover{border-color:#4d6fa8}
|
||||
.lb-door.active{background:#2f3a4b;border-color:#6f8fc8;color:#cfe0f5;font-weight:600}
|
||||
.lb-saved{display:flex;align-items:center;gap:10px}
|
||||
.lb-known-row{display:flex;align-items:center;gap:10px;padding:6px 0;border-bottom:1px solid var(--line)}
|
||||
.lb-known-row:last-child{border-bottom:none}
|
||||
.lb-known-row .code{font-weight:700;letter-spacing:.06em;color:#f2e6cf;flex:1}
|
||||
.lb-type{font-size:15px;font-weight:600;color:#cfe0f5;margin:2px 0 8px}
|
||||
.lb-preview-head{background:#1e242c;border:1px solid var(--line);border-radius:7px;padding:10px 12px;margin:0 0 10px}
|
||||
/* The read-only rule set — what a joining player reads before sitting down, and what the seating
|
||||
screen keeps showing afterwards. Generated, never a form: nobody but the host may change these. */
|
||||
.rules-list{border:1px solid var(--line);border-radius:7px;background:#171c23;padding:4px 12px;margin:0 0 12px}
|
||||
.rules-list dl{display:grid;grid-template-columns:minmax(140px,auto) 1fr;gap:2px 14px;margin:8px 0}
|
||||
.rules-list dt{color:var(--dim);font-size:12px}
|
||||
.rules-list dd{margin:0;font-size:13px}
|
||||
.rules-list dd.changed{color:#e0b060}
|
||||
.rules-list h4{font-size:11px;text-transform:uppercase;letter-spacing:.07em;color:var(--dim);margin:10px 0 0}
|
||||
/* THE HANDOFF. Between the host pressing Start and the first Frame arriving there is nothing to
|
||||
draw — and a blank board is what a broken game looks like too. */
|
||||
#handoff{position:fixed;inset:0;z-index:20;display:none;align-items:center;justify-content:center;
|
||||
background:rgba(18,21,26,.94);text-align:center;padding:20px}
|
||||
#handoff.shown{display:flex}
|
||||
#handoff .hand-inner{max-width:460px}
|
||||
#handoff h2{font-size:15px;text-transform:none;letter-spacing:.01em;color:#cfe0f5}
|
||||
#handoff .hand-note{color:var(--dim);font-size:13px;margin-top:8px}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<!-- THE LOBBY (Phase 4) — shown instead of the game UI whenever there is no game yet to play: no
|
||||
stored session token, or a token whose game hasn't started. `lobby.ts` owns everything in here;
|
||||
`main.ts` only decides whether THIS div or `#gameui` below is the one currently visible.
|
||||
`#newgamedlg` at the very end of the body is solitaire-only, and asks the same questions through
|
||||
the same shared module (`settings-form.ts`) — the two blocks are generated from one template. -->
|
||||
<div id="lobby" hidden>
|
||||
<header><b><a href="./index.html" class="home">Station Master</a></b> — <span class="dim">Multiplayer</span></header>
|
||||
|
||||
<!-- Whatever brought the player here when it was not their own click: a game that was ended under
|
||||
them, or a lobby that closed. Never a field-level error — those sit with their fields. -->
|
||||
<p class="lb-error" id="lb-notice" role="alert" hidden></p>
|
||||
|
||||
<section id="lb-secret-section">
|
||||
<h2>Join secret</h2>
|
||||
<!-- Saved: one line, not a password field asking to be filled in again. `lobby.ts` swaps these
|
||||
two, and re-opens the ask automatically when the server answers 403. -->
|
||||
<div id="lb-secret-saved" class="lb-saved" hidden>
|
||||
<span class="dim">Join secret · saved in this browser</span>
|
||||
<button id="lb-secret-change" class="ghost" type="button">Change</button>
|
||||
</div>
|
||||
<div id="lb-secret-ask">
|
||||
<p class="ng-note">Whoever is running this server gave you a secret out of band (a chat message, not a public page). It is kept in this browser only, never shown back, and sent with every lobby request.</p>
|
||||
<label class="ng-num"><span>Join secret</span><input id="lb-secret" type="password" autocomplete="off"></label>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<!-- EVERY GAME THIS BROWSER IS IN. `localStorage` used to hold exactly ONE multiplayer session, so
|
||||
joining a second silently overwrote the first and locked that seat out for good. Keyed by game
|
||||
now, and this is where they are picked between — and forgotten deliberately rather than by
|
||||
accident. -->
|
||||
<section id="lb-known" hidden>
|
||||
<h2>Games you are in</h2>
|
||||
<p class="ng-note">This browser holds a seat in these. Rejoining needs the token kept here, so
|
||||
<b>Forget</b> is the one thing that cannot be undone from this screen.</p>
|
||||
<div id="lb-known-list"></div>
|
||||
</section>
|
||||
|
||||
<section id="lb-choice-section">
|
||||
<label class="ng-num"><span>Your display name</span><input id="lb-name" type="text" autocomplete="off" maxlength="40"></label>
|
||||
|
||||
<!-- TWO DOORS, one panel at a time. Joining used to be a heading at the BOTTOM of the create
|
||||
form: someone sent a code had to scroll past fifteen fields they had no use for. -->
|
||||
<div class="lb-doors">
|
||||
<button id="lb-door-join" class="lb-door active" type="button">Join a game</button>
|
||||
<button id="lb-door-create" class="lb-door" type="button">Create a game</button>
|
||||
</div>
|
||||
|
||||
<section id="lb-join-panel">
|
||||
<h2>Join a game</h2>
|
||||
<p class="ng-note">Ask whoever created the game for its code. You will see the whole rule set
|
||||
before you take a seat.</p>
|
||||
<label class="ng-num"><span>Game code</span><input id="lb-code" type="text" autocomplete="off" placeholder="RAIL-1234"></label>
|
||||
<button id="lb-look" type="button">Look up game</button>
|
||||
<p class="lb-error" id="lb-join-err" role="alert"></p>
|
||||
|
||||
<!-- Filled by `/api/lobby/preview` — the config, who is seated, and nothing else. The SEED is
|
||||
never in that response: it decides every shuffle in the game. -->
|
||||
<div id="lb-preview" hidden>
|
||||
<h3>Before you sit down</h3>
|
||||
<div class="lb-preview-head">
|
||||
<div class="lb-invite-code" id="lb-preview-code"></div>
|
||||
<div id="lb-preview-type" class="lb-type"></div>
|
||||
<div id="lb-preview-who" class="dim"></div>
|
||||
</div>
|
||||
<div id="lb-preview-rules" class="rules-list"></div>
|
||||
<button id="lb-join" type="button">Join this game</button>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<section id="lb-create-panel" hidden>
|
||||
<h2>Create a new game</h2>
|
||||
<p class="ng-note">You become the host — you choose the game type and, once everyone is seated, start the game. 2 to 4 players.</p>
|
||||
|
||||
<!-- TWO COLUMNS WHERE THERE IS ROOM. One 640px-wide column made this form a very long scroll
|
||||
for what is really two short lists: what game this is, and what its rules are. -->
|
||||
<div class="lb-two">
|
||||
<div class="lb-col">
|
||||
|
||||
<!-- THE PARAMETERS, above the type. Changing one of these does NOT make the game Custom: the
|
||||
types are formulas in the table size and the length, so the Revenue floor re-derives and
|
||||
"Co-op, 3 players, 8 days" is still Co-op. -->
|
||||
<div class="lb-params">
|
||||
<label class="ng-num"><span>Seed</span>
|
||||
<input id="lb-seed" type="text" inputmode="numeric" autocomplete="off" placeholder="blank for a random seed"></label>
|
||||
<label class="ng-num"><span>Players at the table</span>
|
||||
<select id="lb-players">
|
||||
<option value="2">2</option>
|
||||
<option value="3">3</option>
|
||||
<option value="4" selected>4</option>
|
||||
</select></label>
|
||||
<label class="ng-num"><span>Days</span>
|
||||
<input id="lb-days" type="number" min="1" max="20" step="1" value="5"></label>
|
||||
</div>
|
||||
<p class="ng-note">The same seed and the same settings always deal the same railroad, so a game
|
||||
can be shared, compared or replayed. Leave it blank for a random one.</p>
|
||||
<!-- WITH THE TABLE SIZE IT IS ABOUT, not below the rules block — reported by Jesse, who found
|
||||
it separated from the control it explains by fifteen settings. -->
|
||||
<p class="ng-note">Every chair has to be taken before the game can start — by a person or by a
|
||||
bot. Pick the size of the table now; it cannot change once the game is created.</p>
|
||||
</div>
|
||||
|
||||
<div class="lb-col">
|
||||
<h3>Game type</h3>
|
||||
<div class="set-row" id="lb-type-row">
|
||||
<label class="ng-radio"><input type="radio" name="lb-type" value="solitaire">
|
||||
<span><b>Solitaire</b><br><span class="dim">One railroad, one player. The whole Division is yours to run.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="lb-type" value="coop" checked>
|
||||
<span><b>Co-op</b><br><span class="dim">Everyone’s Revenue is one table score. You win together or lose together.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="lb-type" value="competitive">
|
||||
<span><b>Competitive</b><br><span class="dim">Highest Revenue wins — unless the table misses its combined minimum, and then everyone loses.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="lb-type" value="cutthroat">
|
||||
<span><b>Cutthroat</b><br><span class="dim">Highest Revenue wins, and nothing is shared — the only way everyone loses is three collisions in one Day.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="lb-type" value="custom">
|
||||
<span><b>Custom</b><br><span class="dim">Whatever you set below. Selected for you the moment you change a rule; it is scored as the type you started from.</span></span></label>
|
||||
</div>
|
||||
|
||||
<p class="ng-note" id="lb-type-note"></p>
|
||||
</div>
|
||||
|
||||
<!-- FULL WIDTH WHEN IT OPENS. Reported by Jesse: opened inside the right-hand column it made a
|
||||
very long scroll with the left column standing empty beside it. It is a grid child of its
|
||||
own now, spanning both, and its five groups flow into as many columns as fit. -->
|
||||
<details id="lb-settings" class="lb-span">
|
||||
<summary>Game settings</summary>
|
||||
<p class="ng-note">Every rule the game type sets, and every one of them yours to change.
|
||||
Changing any of them selects <b>Custom</b>, which keeps the scoring of the type you
|
||||
started from; clicking a type again resets all of them back to it. They are fixed when the
|
||||
game is created and cannot be changed once it starts.</p>
|
||||
<div class="set-groups">
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Starting hand</h3>
|
||||
<p class="ng-note">What each player is dealt before the first turn. The hand limit is three
|
||||
either way — deal six and the first turn is spent choosing which of them to keep.</p>
|
||||
<div class="set-row" id="lb-hand-row">
|
||||
<label class="ng-radio"><input type="radio" name="lb-hand" value="threeRandom">
|
||||
<span><b>Three random cards</b><br><span class="dim">The original rule. At the hand limit already, and no guarantee of track.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="lb-hand" value="sixRandom" checked>
|
||||
<span><b>Six random cards</b><br><span class="dim">Twice the choice, still no guaranteed track — the first turn is a discard.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="lb-hand" value="threeTrackThreeOther">
|
||||
<span><b>Three random track and three random non-track cards</b><br><span class="dim">Dealt from two piles, so the district you can build is dealt rather than waited for.</span></span></label>
|
||||
<span class="set-hint" id="lb-hand-hint"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Where an Extra may start</h3>
|
||||
<p class="ng-note">The player who plays an Extra Train card chooses where its Crew Tray goes,
|
||||
and the place decides which way it runs — a Division Point sends it away from itself; in the
|
||||
middle of the railroad the player picks east or west. The Division Points and the Interchange
|
||||
belong to nobody and are always available. Starting one inside a district is the part that
|
||||
favours a seat, so it is set here. An Office must be a Control Point whatever this says: a
|
||||
Whistle Post never qualifies.</p>
|
||||
<div class="set-row" id="lb-extra-row">
|
||||
<label class="ng-radio"><input type="radio" name="lb-extra" value="divisionPointsOnly">
|
||||
<span><b>Division Points and the Interchange only</b><br><span class="dim">The strictest reading. Every Extra begins on shared ground.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="lb-extra" value="ownOffice">
|
||||
<span><b>Also the playing player’s own Control Point</b><br><span class="dim">You may start one at home, but not in somebody else’s district.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="lb-extra" value="anyOffice">
|
||||
<span><b>Also any player’s Control Point</b><br><span class="dim">The most permissive — an Extra may be planted in another player’s district.</span></span></label>
|
||||
<span class="set-hint" id="lb-extra-hint"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Revenue</h3>
|
||||
<p class="ng-note">What each piece of work pays, 0 to 5. A coach pays when it is boarded and
|
||||
again when it is detrained; a load pays when it is made up and again when it is broken. Zero
|
||||
switches an economy off so the others can be read.</p>
|
||||
<div class="set-row" id="lb-passenger-row">
|
||||
<label class="ng-num"><span>Passenger revenue per coach</span>
|
||||
<input id="lb-passenger" type="number" min="0" max="5" step="1" value="1"></label>
|
||||
<span class="set-hint" id="lb-passenger-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="lb-freight-row">
|
||||
<label class="ng-num"><span>Freight revenue per load</span>
|
||||
<input id="lb-freight" type="number" min="0" max="5" step="1" value="1"></label>
|
||||
<span class="set-hint" id="lb-freight-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="lb-transit-row">
|
||||
<label class="ng-num"><span>Train revenue per transit</span>
|
||||
<input id="lb-transit" type="number" min="0" max="5" step="1" value="0"></label>
|
||||
<span class="set-hint" id="lb-transit-hint"></span>
|
||||
</div>
|
||||
<p class="ng-note">A transit pays every player, once, when a train runs off the end of the
|
||||
Division — the one thing nobody has to work for.</p>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Victory conditions</h3>
|
||||
<p class="ng-note">The ways this game can end badly. Each one is switched on or off in its own
|
||||
right; how long the game runs is set above, with the table size.</p>
|
||||
<div class="set-row" id="lb-minrev-row">
|
||||
<label class="ng-gate"><input type="checkbox" id="lb-minrev-on" checked>
|
||||
<span>Everyone loses if combined Revenue at the end is under</span>
|
||||
<input id="lb-minrev" type="number" min="0" step="1" class="gate-num"></label>
|
||||
<span class="set-hint" id="lb-minrev-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="lb-colday-row">
|
||||
<label class="ng-gate"><input type="checkbox" id="lb-colday-on" checked>
|
||||
<span>The game ends and everyone loses if collisions in one Day reach</span>
|
||||
<input id="lb-colday" type="number" min="0" step="1" class="gate-num"></label>
|
||||
<span class="set-hint" id="lb-colday-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="lb-coltotal-row">
|
||||
<label class="ng-gate"><input type="checkbox" id="lb-coltotal-on" checked>
|
||||
<span>The game ends and everyone loses after this many collisions in the whole game</span>
|
||||
<input id="lb-coltotal" type="number" min="0" step="1" class="gate-num"></label>
|
||||
<span class="set-hint" id="lb-coltotal-hint"></span>
|
||||
</div>
|
||||
<p class="ng-note">The opponent-directed cards — Derail, Watertower, Hobo Jungle and the
|
||||
nineteen others, along with the seven that answer them — are not implemented yet, so no game
|
||||
type deals them whatever else is set here.</p>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Optional rules</h3>
|
||||
<p class="ng-note">Off in every game type; each one changes how the game plays.</p>
|
||||
<div class="set-row" id="lb-visibility-row">
|
||||
<label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
|
||||
night Stages (1–3 and 11–12)</span>
|
||||
<input id="lb-visibility" type="checkbox"></label>
|
||||
<span class="set-hint" id="lb-visibility-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="lb-rotation-row">
|
||||
<label class="ng-num"><span>Employee Rotation — at the end of each Day everyone moves one
|
||||
chair left and takes over the next station up the line. Your Revenue and the Fedora go with
|
||||
you; the district stays where it is</span>
|
||||
<input id="lb-rotation" type="checkbox"></label>
|
||||
<span class="set-hint" id="lb-rotation-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="lb-toolbox-row">
|
||||
<label class="ng-num"><span>Emergency Toolbox — everyone starts holding a Red Flag, so a hand
|
||||
of four; play or discard down to three on the first turn</span>
|
||||
<input id="lb-toolbox" type="checkbox"></label>
|
||||
<span class="set-hint" id="lb-toolbox-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="lb-tossloco-row">
|
||||
<label class="ng-num"><span>A Timetabled train may be discarded — toss it face-up to a
|
||||
Department slot, where a rival may pick it up. Turn this off and a train card can only ever
|
||||
be played onto the timetable. An Extra is never discardable either way</span>
|
||||
<input id="lb-tossloco" type="checkbox"></label>
|
||||
<span class="set-hint" id="lb-tossloco-hint"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
</div>
|
||||
</details>
|
||||
|
||||
<div class="lb-span">
|
||||
<button id="lb-create" type="button">Create game</button>
|
||||
<p class="lb-error" id="lb-create-err" role="alert"></p>
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
</section>
|
||||
|
||||
<!-- Shown once created or joined, in place of the choice above, until the host starts the game. -->
|
||||
<section id="lb-seating-section" hidden>
|
||||
<h2>Seating</h2>
|
||||
<div class="lb-invite">
|
||||
<div>
|
||||
<div class="lb-invite-label">Send this to your players</div>
|
||||
<div class="lb-invite-code" id="lb-gamecode"></div>
|
||||
</div>
|
||||
<button id="lb-copy" class="ghost" type="button">Copy code</button>
|
||||
<button id="lb-copylink" class="ghost" type="button">Copy invite link</button>
|
||||
<span class="ng-note" id="lb-copied"></span>
|
||||
</div>
|
||||
<p class="ng-note">They enter the code under <b>Join a game</b>, along with the same join secret
|
||||
you used — the link carries the code, never the secret.</p>
|
||||
<p class="ng-note">The host may fill an empty seat with a bot or clear an occupied one, and
|
||||
starts the game once every seat is either a player or a bot. <b>These chairs are not the
|
||||
running order</b> — who sits where along the Division is decided by a D12 roll when the game
|
||||
starts, and the map shows the result.</p>
|
||||
<div id="lb-seats"></div>
|
||||
<p class="lb-warn" id="lb-stream-note" role="status" hidden></p>
|
||||
<button id="lb-start" disabled>Start game</button>
|
||||
<button id="lb-leave" class="ghost" type="button">Leave</button>
|
||||
<p class="lb-error" id="lb-start-note" role="alert"></p>
|
||||
|
||||
<h3>The game you are in</h3>
|
||||
<div id="lb-seating-type" class="lb-type"></div>
|
||||
<div id="lb-seating-rules" class="rules-list"></div>
|
||||
</section>
|
||||
</div>
|
||||
|
||||
<!-- ===================================================================
|
||||
SOLITAIRE SETUP — the same question multiplayer already asks first,
|
||||
now asked here too (Jesse, 2026-08-29): a genuinely fresh visit deals
|
||||
nothing until this screen's own Deal button is pressed. A saved game,
|
||||
an explicit `?seed=`, or a URL already carrying a Deal's answers (any
|
||||
of the shared block's fields — `hand` names the one always written)
|
||||
all skip straight past this screen, exactly as `?lobby` already skips
|
||||
past it into the lobby: those are not "no plan yet", they are a
|
||||
choice already made, elsewhere.
|
||||
|
||||
THE SAME BLOCK THE DIALOG AND THE LOBBY USE, same shared module
|
||||
(`settings-form.ts`), same order — three screens are one design now
|
||||
instead of two. Only Solitaire can be dealt from here, so the other
|
||||
four types are shown exactly as the in-game dialog shows them: present,
|
||||
disabled, with a note pointing at the Multiplayer door instead.
|
||||
==================================================================== -->
|
||||
<div id="solitairesetup" hidden>
|
||||
<header><b><a href="./index.html" class="home">Station Master</a></b> — <span class="dim">Solitaire</span></header>
|
||||
|
||||
<section>
|
||||
<h2>New solitaire game</h2>
|
||||
<p class="ng-note">One railroad, one player, five full days by default — everything below is
|
||||
yours to change before you deal. Clearing the Revenue floor wins; falling short loses.</p>
|
||||
|
||||
<div class="lb-params">
|
||||
<label class="ng-num"><span>Seed</span>
|
||||
<input id="ss-seed" type="text" inputmode="numeric" autocomplete="off" placeholder="blank for a random seed"></label>
|
||||
<label class="ng-num"><span>Days</span>
|
||||
<input id="ss-days" type="number" min="1" max="20" step="1" value="5"></label>
|
||||
</div>
|
||||
<p class="ng-note">The same seed and the same settings always deal the same railroad, so a game
|
||||
can be shared, compared or replayed. Leave it blank for a random one.</p>
|
||||
|
||||
<h3>Game type</h3>
|
||||
<div class="set-row" id="ss-type-row">
|
||||
<label class="ng-radio"><input type="radio" name="ss-type" value="solitaire" checked>
|
||||
<span><b>Solitaire</b><br><span class="dim">One railroad, one player. The whole Division is yours to run.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ss-type" value="coop">
|
||||
<span><b>Co-op</b><br><span class="dim">Everyone’s Revenue is one table score. You win together or lose together.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ss-type" value="competitive">
|
||||
<span><b>Competitive</b><br><span class="dim">Highest Revenue wins — unless the table misses its combined minimum, and then everyone loses.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ss-type" value="cutthroat">
|
||||
<span><b>Cutthroat</b><br><span class="dim">Highest Revenue wins, and nothing is shared — the only way everyone loses is three collisions in one Day.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ss-type" value="custom">
|
||||
<span><b>Custom</b><br><span class="dim">Whatever you set below. Selected for you the moment you change a rule; it is scored as the type you started from.</span></span></label>
|
||||
</div>
|
||||
|
||||
<p class="ng-note" id="ss-type-note"></p>
|
||||
|
||||
<details id="ss-settings" open>
|
||||
<summary>Game settings</summary>
|
||||
<p class="ng-note">Every rule the game type sets, and every one of them yours to change.
|
||||
Changing any of them selects <b>Custom</b>; clicking a type again resets all of them back
|
||||
to it.</p>
|
||||
<div class="set-groups">
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Starting hand</h3>
|
||||
<p class="ng-note">What you are dealt before the first turn. The hand limit is three either
|
||||
way — deal six and the first turn is spent choosing which of them to keep.</p>
|
||||
<div class="set-row" id="ss-hand-row">
|
||||
<label class="ng-radio"><input type="radio" name="ss-hand" value="threeRandom">
|
||||
<span><b>Three random cards</b><br><span class="dim">The original rule. At the hand limit already, and no guarantee of track.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ss-hand" value="sixRandom" checked>
|
||||
<span><b>Six random cards</b><br><span class="dim">Twice the choice, still no guaranteed track — the first turn is a discard.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ss-hand" value="threeTrackThreeOther">
|
||||
<span><b>Three random track and three random non-track cards</b><br><span class="dim">Dealt from two piles, so the district you can build is dealt rather than waited for.</span></span></label>
|
||||
<span class="set-hint" id="ss-hand-hint"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Where an Extra may start</h3>
|
||||
<p class="ng-note">The player who plays an Extra Train card chooses where its Crew Tray goes,
|
||||
and the place decides which way it runs — a Division Point sends it away from itself; in the
|
||||
middle of the railroad the player picks east or west. The Division Points and the Interchange
|
||||
belong to nobody and are always available. Starting one inside a district is the part that
|
||||
favours a seat, so it is set here. An Office must be a Control Point whatever this says: a
|
||||
Whistle Post never qualifies.</p>
|
||||
<div class="set-row" id="ss-extra-row">
|
||||
<label class="ng-radio"><input type="radio" name="ss-extra" value="divisionPointsOnly">
|
||||
<span><b>Division Points and the Interchange only</b><br><span class="dim">The strictest reading. Every Extra begins on shared ground.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ss-extra" value="ownOffice">
|
||||
<span><b>Also the playing player’s own Control Point</b><br><span class="dim">You may start one at home, but not in somebody else’s district.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ss-extra" value="anyOffice">
|
||||
<span><b>Also any player’s Control Point</b><br><span class="dim">The most permissive — an Extra may be planted in another player’s district.</span></span></label>
|
||||
<span class="set-hint" id="ss-extra-hint"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Revenue</h3>
|
||||
<p class="ng-note">What each piece of work pays, 0 to 5. A coach pays when it is boarded and
|
||||
again when it is detrained; a load pays when it is made up and again when it is broken. Zero
|
||||
switches an economy off so the others can be read.</p>
|
||||
<div class="set-row" id="ss-passenger-row">
|
||||
<label class="ng-num"><span>Passenger revenue per coach</span>
|
||||
<input id="ss-passenger" type="number" min="0" max="5" step="1" value="1"></label>
|
||||
<span class="set-hint" id="ss-passenger-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ss-freight-row">
|
||||
<label class="ng-num"><span>Freight revenue per load</span>
|
||||
<input id="ss-freight" type="number" min="0" max="5" step="1" value="1"></label>
|
||||
<span class="set-hint" id="ss-freight-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ss-transit-row">
|
||||
<label class="ng-num"><span>Train revenue per transit</span>
|
||||
<input id="ss-transit" type="number" min="0" max="5" step="1" value="0"></label>
|
||||
<span class="set-hint" id="ss-transit-hint"></span>
|
||||
</div>
|
||||
<p class="ng-note">A transit pays every player, once, when a train runs off the end of the
|
||||
Division — the one thing nobody has to work for.</p>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Victory conditions</h3>
|
||||
<p class="ng-note">The ways this game can end badly. How long it runs is set above, in Days.</p>
|
||||
<div class="set-row" id="ss-minrev-row">
|
||||
<label class="ng-gate"><input type="checkbox" id="ss-minrev-on" checked>
|
||||
<span>You lose if Revenue at the end is under</span>
|
||||
<input id="ss-minrev" type="number" min="0" step="1" class="gate-num"></label>
|
||||
<span class="set-hint" id="ss-minrev-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ss-colday-row">
|
||||
<label class="ng-gate"><input type="checkbox" id="ss-colday-on" checked>
|
||||
<span>The game ends in a loss if collisions in one Day reach</span>
|
||||
<input id="ss-colday" type="number" min="0" step="1" class="gate-num"></label>
|
||||
<span class="set-hint" id="ss-colday-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ss-coltotal-row">
|
||||
<label class="ng-gate"><input type="checkbox" id="ss-coltotal-on" checked>
|
||||
<span>The game ends in a loss after this many collisions in the whole game</span>
|
||||
<input id="ss-coltotal" type="number" min="0" step="1" class="gate-num"></label>
|
||||
<span class="set-hint" id="ss-coltotal-hint"></span>
|
||||
</div>
|
||||
<p class="ng-note">The opponent-directed cards — Derail, Watertower, Hobo Jungle and the
|
||||
nineteen others, along with the seven that answer them — are not implemented yet, so no game
|
||||
type deals them whatever else is set here.</p>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Optional rules</h3>
|
||||
<p class="ng-note">Off in every game type; each one changes how the game plays.</p>
|
||||
<div class="set-row" id="ss-visibility-row">
|
||||
<label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
|
||||
night Stages (1–3 and 11–12)</span>
|
||||
<input id="ss-visibility" type="checkbox"></label>
|
||||
<span class="set-hint" id="ss-visibility-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ss-rotation-row">
|
||||
<label class="ng-num"><span>Employee Rotation — meaningless at a table of one, shown here so
|
||||
this screen and the lobby read as one list</span>
|
||||
<input id="ss-rotation" type="checkbox" disabled></label>
|
||||
<span class="set-hint" id="ss-rotation-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ss-toolbox-row">
|
||||
<label class="ng-num"><span>Emergency Toolbox — start holding a Red Flag, so a hand of four;
|
||||
play or discard down to three on the first turn</span>
|
||||
<input id="ss-toolbox" type="checkbox"></label>
|
||||
<span class="set-hint" id="ss-toolbox-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ss-tossloco-row">
|
||||
<label class="ng-num"><span>A Timetabled train may be discarded — toss it face-up to a
|
||||
Department slot. Turn this off and a train card can only ever be played onto the timetable.
|
||||
An Extra is never discardable either way</span>
|
||||
<input id="ss-tossloco" type="checkbox"></label>
|
||||
<span class="set-hint" id="ss-tossloco-hint"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
</div>
|
||||
</details>
|
||||
|
||||
<menu class="ng-buttons">
|
||||
<button id="ss-deal" type="button">Deal</button>
|
||||
</menu>
|
||||
</section>
|
||||
</div>
|
||||
|
||||
<div id="gameui" hidden>
|
||||
<div class="topbar">
|
||||
<header>
|
||||
<b><a href="./index.html" class="home">Station Master</a></b>
|
||||
@@ -780,36 +215,15 @@ ul.blocked li{padding:2px 0}
|
||||
engine's guess at what your score ought to be were noise on the one line that must not wrap. -->
|
||||
<span id="objective" class="pace">—</span>
|
||||
<span class="dim">seed <span id="seed">—</span></span>
|
||||
<!-- THE GAME CODE SURVIVES THE LOBBY. It used to end at `Lobby.Start` — the code was never carried
|
||||
into `LobbyReady` — so a seated player could not say which game they were in, could not match
|
||||
it against the administrator's Games in Progress list, and could not pass it to a latecomer.
|
||||
Empty (and collapsed) in solitaire, where there is no code. -->
|
||||
<span class="dim" id="gamecode" title="The code this game was created under. The administrator's Games in Progress list uses it, and it is how you say which game you mean."></span>
|
||||
<!-- Co-op, Competitive, Cutthroat or Custom, derived from the config the Frame carries
|
||||
(`presets.ts`). A Cutthroat game used to look exactly like a Co-op one from the board. -->
|
||||
<span class="dim" id="gametype" title=""></span>
|
||||
<!-- WHICH RULES THIS GAME IS BEING PLAYED UNDER. The settings are chosen when the game is dealt
|
||||
and then never mentioned again, which makes a playtest note ("scored 4") unreadable a week
|
||||
later: at 0 revenue per transit that is a different game from the same seed at 5. Short enough
|
||||
to keep the header on one line; the tooltip spells it out. -->
|
||||
<span class="dim" id="houserules" title="">—</span>
|
||||
<button id="sound" title="Whistle at the end of each Stage, the crossing bell at the end of each Day, and the conductor when a train is built. Currently synthesised, not recorded.">🔇 muted</button>
|
||||
<!-- BOARD ZOOM. Applies to the Division map and the Office Area grid alike — both already scroll
|
||||
horizontally (`#division`, `#grid`) when they run wide, so this only ever needs to resize the
|
||||
rendered SVG's own pixel dimensions; the existing scrollbar keeps doing the panning. -->
|
||||
<span class="zoom" title="Zoom the Division map and your Office Area. Both already scroll — this only changes their size.">
|
||||
<button id="zoomout" aria-label="Zoom out">−</button><span id="zoomlabel">100%</span><button id="zoomin" aria-label="Zoom in">+</button>
|
||||
</span>
|
||||
<button id="undo" title="Take the last action back. The save is the seed plus the moves made, so this replays the game without the last one — as far back as you like.">Undo</button>
|
||||
<button id="savefile" title="Download this game as a save file you can replay or share">Save replay</button>
|
||||
<button id="newgame" title="Deal a fresh game. You choose the seed, the opening hand and what the three economies pay. Undo steps back one action at a time; this throws the whole game away, so download the replay first if you want to keep it.">New game</button>
|
||||
<button id="multiplayer" title="Create or join a Competitive or Co-op game on this server, with other players.">Multiplayer</button>
|
||||
<!-- LEAVING A RUNNING GAME. Reported by Jesse 2026-08-23: "if I'm a player in the middle of the
|
||||
game and I need to leave, how do I leave the game, clear the token from my browser so I can
|
||||
play a different game later?" There was no way at all — the page rejoined the same game on
|
||||
every load and nothing let go of it. This keeps your seat — the table waits for you — and
|
||||
your token, and puts you back at the lobby, which lists every game this browser is in. -->
|
||||
<button id="leavegame" hidden title="Go back to the lobby. Your seat is kept and the game waits for you — the lobby lists it under Games you are in, so you can come back or hand the browser to a different game.">Leave game</button>
|
||||
<a class="home" href="./replays.html" style="font-size:12px">replays</a>
|
||||
<span class="dim build" title="what is actually deployed">__BUILD__</span>
|
||||
</header>
|
||||
@@ -824,15 +238,10 @@ ul.blocked li{padding:2px 0}
|
||||
what you miss when the automatic phases run between two clicks. -->
|
||||
<div id="phasenote"></div>
|
||||
<div id="announce"></div>
|
||||
<!-- `lobby-and-sessions.md` §5 — a disconnect keeps the seat and the game simply waits; this is
|
||||
what says WHY, instead of the table watching nothing happen with no explanation. Empty and
|
||||
collapsed whenever everyone connected is still connected — a `LocalSession` never fills it. -->
|
||||
<div id="presence"></div>
|
||||
|
||||
<main>
|
||||
<div>
|
||||
<section><h2>The Division — west to east</h2><div id="division"></div>
|
||||
<p class="ng-note" id="seating-chain"></p></section>
|
||||
<section><h2>The Division — west to east</h2><div id="division"></div></section>
|
||||
<section id="district">
|
||||
<h2>Your Office Area
|
||||
<span class="dim" style="text-transform:none;letter-spacing:0">— hover any card for the full explanation</span>
|
||||
@@ -896,211 +305,40 @@ ul.blocked li{padding:2px 0}
|
||||
complete, sensible game. The settings ride in the URL alongside the seed, because a seed alone
|
||||
no longer names a game: `?seed=430` with a different opening hand is a different railroad.
|
||||
==================================================================== -->
|
||||
</div><!-- /gameui -->
|
||||
|
||||
<dialog id="newgamedlg" aria-labelledby="ng-title">
|
||||
<form method="dialog" id="newgameform">
|
||||
<h2 class="big" id="ng-title">New game</h2>
|
||||
|
||||
<!-- THE SAME BLOCK THE LOBBY USES, same shared module, same order — the two screens are one
|
||||
design. Only Solitaire can be dealt here; the multiplayer types are shown disabled rather
|
||||
than hidden, so what this screen offers and what the lobby offers read as one list. -->
|
||||
<div class="lb-params">
|
||||
<label class="ng-num"><span>Seed</span>
|
||||
<input id="ng-seed" type="text" inputmode="numeric" autocomplete="off" placeholder="blank for a random seed"></label>
|
||||
<label class="ng-num"><span>Days</span>
|
||||
<input id="ng-days" type="number" min="1" max="20" step="1" value="5"></label>
|
||||
</div>
|
||||
<p class="ng-note">The same seed and the same settings always deal the same railroad, so a game
|
||||
can be shared, compared or replayed. Leave it blank for a random one.</p>
|
||||
<h3>Seed</h3>
|
||||
<p class="ng-note">The same seed and the same settings always deal the same railroad, so a game can be shared, compared or replayed. Leave it blank for a random one.</p>
|
||||
<input id="ng-seed" type="text" inputmode="numeric" autocomplete="off" placeholder="blank for a random seed">
|
||||
|
||||
<h3>Game type</h3>
|
||||
<div class="set-row" id="ng-type-row">
|
||||
<label class="ng-radio"><input type="radio" name="ng-type" value="solitaire">
|
||||
<span><b>Solitaire</b><br><span class="dim">One railroad, one player. The whole Division is yours to run.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-type" value="coop" checked>
|
||||
<span><b>Co-op</b><br><span class="dim">Everyone’s Revenue is one table score. You win together or lose together.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-type" value="competitive">
|
||||
<span><b>Competitive</b><br><span class="dim">Highest Revenue wins — unless the table misses its combined minimum, and then everyone loses.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-type" value="cutthroat">
|
||||
<span><b>Cutthroat</b><br><span class="dim">Highest Revenue wins, and nothing is shared — the only way everyone loses is three collisions in one Day.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-type" value="custom">
|
||||
<span><b>Custom</b><br><span class="dim">Whatever you set below. Selected for you the moment you change a rule; it is scored as the type you started from.</span></span></label>
|
||||
</div>
|
||||
<h3>Starting hand</h3>
|
||||
<p class="ng-note">What each player is dealt before the first turn. The hand limit is three either way — deal six and the first turn is spent choosing which of them to keep.</p>
|
||||
<label class="ng-radio"><input type="radio" name="ng-hand" value="threeRandom" checked>
|
||||
<span><b>Three random cards</b><br><span class="dim">The original rule. At the hand limit already, and no guarantee of track.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-hand" value="sixRandom">
|
||||
<span><b>Six random cards</b><br><span class="dim">Twice the choice, still no guaranteed track — the first turn is a discard.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-hand" value="threeTrackThreeOther">
|
||||
<span><b>Three random track and three random non-track cards</b><br><span class="dim">Dealt from two piles, so the district you can build is dealt rather than waited for.</span></span></label>
|
||||
|
||||
<p class="ng-note" id="ng-type-note"></p>
|
||||
|
||||
<details id="ng-settings" open>
|
||||
<summary>Game settings</summary>
|
||||
<p class="ng-note">Every rule the game type sets, and every one of them yours to change.
|
||||
Changing any of them selects <b>Custom</b>; clicking a type again resets all of them back
|
||||
to it.</p>
|
||||
<div class="set-groups">
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Starting hand</h3>
|
||||
<p class="ng-note">What each player is dealt before the first turn. The hand limit is three
|
||||
either way — deal six and the first turn is spent choosing which of them to keep.</p>
|
||||
<div class="set-row" id="ng-hand-row">
|
||||
<label class="ng-radio"><input type="radio" name="ng-hand" value="threeRandom">
|
||||
<span><b>Three random cards</b><br><span class="dim">The original rule. At the hand limit already, and no guarantee of track.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-hand" value="sixRandom" checked>
|
||||
<span><b>Six random cards</b><br><span class="dim">Twice the choice, still no guaranteed track — the first turn is a discard.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-hand" value="threeTrackThreeOther">
|
||||
<span><b>Three random track and three random non-track cards</b><br><span class="dim">Dealt from two piles, so the district you can build is dealt rather than waited for.</span></span></label>
|
||||
<span class="set-hint" id="ng-hand-hint"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Where an Extra may start</h3>
|
||||
<p class="ng-note">The player who plays an Extra Train card chooses where its Crew Tray goes,
|
||||
and the place decides which way it runs — a Division Point sends it away from itself; in the
|
||||
middle of the railroad the player picks east or west. The Division Points and the Interchange
|
||||
belong to nobody and are always available. Starting one inside a district is the part that
|
||||
favours a seat, so it is set here. An Office must be a Control Point whatever this says: a
|
||||
Whistle Post never qualifies.</p>
|
||||
<div class="set-row" id="ng-extra-row">
|
||||
<label class="ng-radio"><input type="radio" name="ng-extra" value="divisionPointsOnly">
|
||||
<span><b>Division Points and the Interchange only</b><br><span class="dim">The strictest reading. Every Extra begins on shared ground.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-extra" value="ownOffice">
|
||||
<span><b>Also the playing player’s own Control Point</b><br><span class="dim">You may start one at home, but not in somebody else’s district.</span></span></label>
|
||||
<label class="ng-radio"><input type="radio" name="ng-extra" value="anyOffice">
|
||||
<span><b>Also any player’s Control Point</b><br><span class="dim">The most permissive — an Extra may be planted in another player’s district.</span></span></label>
|
||||
<span class="set-hint" id="ng-extra-hint"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Revenue</h3>
|
||||
<p class="ng-note">What each piece of work pays, 0 to 5. A coach pays when it is boarded and
|
||||
again when it is detrained; a load pays when it is made up and again when it is broken. Zero
|
||||
switches an economy off so the others can be read.</p>
|
||||
<div class="set-row" id="ng-passenger-row">
|
||||
<label class="ng-num"><span>Passenger revenue per coach</span>
|
||||
<input id="ng-passenger" type="number" min="0" max="5" step="1" value="1"></label>
|
||||
<span class="set-hint" id="ng-passenger-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ng-freight-row">
|
||||
<label class="ng-num"><span>Freight revenue per load</span>
|
||||
<input id="ng-freight" type="number" min="0" max="5" step="1" value="1"></label>
|
||||
<span class="set-hint" id="ng-freight-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ng-transit-row">
|
||||
<label class="ng-num"><span>Train revenue per transit</span>
|
||||
<input id="ng-transit" type="number" min="0" max="5" step="1" value="0"></label>
|
||||
<span class="set-hint" id="ng-transit-hint"></span>
|
||||
</div>
|
||||
<p class="ng-note">A transit pays every player, once, when a train runs off the end of the
|
||||
Division — the one thing nobody has to work for.</p>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Victory conditions</h3>
|
||||
<p class="ng-note">The ways this game can end badly. Each one is switched on or off in its own
|
||||
right; how long the game runs is set above, with the table size.</p>
|
||||
<div class="set-row" id="ng-minrev-row">
|
||||
<label class="ng-gate"><input type="checkbox" id="ng-minrev-on" checked>
|
||||
<span>Everyone loses if combined Revenue at the end is under</span>
|
||||
<input id="ng-minrev" type="number" min="0" step="1" class="gate-num"></label>
|
||||
<span class="set-hint" id="ng-minrev-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ng-colday-row">
|
||||
<label class="ng-gate"><input type="checkbox" id="ng-colday-on" checked>
|
||||
<span>The game ends and everyone loses if collisions in one Day reach</span>
|
||||
<input id="ng-colday" type="number" min="0" step="1" class="gate-num"></label>
|
||||
<span class="set-hint" id="ng-colday-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ng-coltotal-row">
|
||||
<label class="ng-gate"><input type="checkbox" id="ng-coltotal-on" checked>
|
||||
<span>The game ends and everyone loses after this many collisions in the whole game</span>
|
||||
<input id="ng-coltotal" type="number" min="0" step="1" class="gate-num"></label>
|
||||
<span class="set-hint" id="ng-coltotal-hint"></span>
|
||||
</div>
|
||||
<p class="ng-note">The opponent-directed cards — Derail, Watertower, Hobo Jungle and the
|
||||
nineteen others, along with the seven that answer them — are not implemented yet, so no game
|
||||
type deals them whatever else is set here.</p>
|
||||
</div>
|
||||
|
||||
<div class="set-group">
|
||||
<h3>Optional rules</h3>
|
||||
<p class="ng-note">Off in every game type; each one changes how the game plays.</p>
|
||||
<div class="set-row" id="ng-visibility-row">
|
||||
<label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
|
||||
night Stages (1–3 and 11–12)</span>
|
||||
<input id="ng-visibility" type="checkbox"></label>
|
||||
<span class="set-hint" id="ng-visibility-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ng-rotation-row">
|
||||
<label class="ng-num"><span>Employee Rotation — at the end of each Day everyone moves one
|
||||
chair left and takes over the next station up the line. Your Revenue and the Fedora go with
|
||||
you; the district stays where it is</span>
|
||||
<input id="ng-rotation" type="checkbox"></label>
|
||||
<span class="set-hint" id="ng-rotation-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ng-toolbox-row">
|
||||
<label class="ng-num"><span>Emergency Toolbox — everyone starts holding a Red Flag, so a hand
|
||||
of four; play or discard down to three on the first turn</span>
|
||||
<input id="ng-toolbox" type="checkbox"></label>
|
||||
<span class="set-hint" id="ng-toolbox-hint"></span>
|
||||
</div>
|
||||
<div class="set-row" id="ng-tossloco-row">
|
||||
<label class="ng-num"><span>A Timetabled train may be discarded — toss it face-up to a
|
||||
Department slot, where a rival may pick it up. Turn this off and a train card can only ever
|
||||
be played onto the timetable. An Extra is never discardable either way</span>
|
||||
<input id="ng-tossloco" type="checkbox"></label>
|
||||
<span class="set-hint" id="ng-tossloco-hint"></span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
</div>
|
||||
</details>
|
||||
<h3>Revenue</h3>
|
||||
<p class="ng-note">What each piece of work pays, 0 to 5. A coach pays when it is boarded and again when it is detrained; a load pays when it is made up and again when it is broken. Zero switches an economy off so the others can be read.</p>
|
||||
<label class="ng-num"><span>Passenger revenue per coach</span>
|
||||
<input id="ng-passenger" type="number" min="0" max="5" step="1" value="1"></label>
|
||||
<label class="ng-num"><span>Freight revenue per load</span>
|
||||
<input id="ng-freight" type="number" min="0" max="5" step="1" value="1"></label>
|
||||
<label class="ng-num"><span>Train revenue per transit</span>
|
||||
<input id="ng-transit" type="number" min="0" max="5" step="1" value="0"></label>
|
||||
<p class="ng-note">A transit pays every player, once, when a train runs off the end of the Division — the one thing nobody has to work for. It defaults to 0 for that reason.</p>
|
||||
|
||||
<menu class="ng-buttons">
|
||||
<span class="ng-note" id="ng-multiplayer-note" style="margin:0 auto 0 0">Use the <b>Multiplayer</b> button instead — it creates or joins a game on this server.</span>
|
||||
<button value="cancel" id="ng-cancel" type="submit" formnovalidate>Cancel</button>
|
||||
<button value="deal" id="ng-deal" type="submit">Deal</button>
|
||||
</menu>
|
||||
</form>
|
||||
</dialog>
|
||||
|
||||
<!-- THE DAY ROLLING OVER (Gitea#10). A Day turns inside the automatic phases, so it happens
|
||||
between one click and the next; the phase banner and the announcement flash both fade before
|
||||
someone reading the board notices them. A modal stops and waits, which is the whole request:
|
||||
"hard to keep track of time". Filled by `dayEndHtml` and opened from `render()`. -->
|
||||
<dialog id="dayenddlg" aria-labelledby="de-title">
|
||||
<form method="dialog">
|
||||
<div id="dayendbody"></div>
|
||||
<menu class="ng-buttons">
|
||||
<button value="ok" id="de-ok" type="submit">Carry on</button>
|
||||
</menu>
|
||||
</form>
|
||||
</dialog>
|
||||
|
||||
<!-- THE END-OF-GAME RESULTS (Gitea#16). Filled by `resultsHtml` and opened from `renderEnding`,
|
||||
which puts it up once per ending unasked and leaves a button to reopen it. Reopenable matters:
|
||||
Gitea#11 lets a table play past the end, and continuing must not cost you the results screen. -->
|
||||
<dialog id="resultsdlg" aria-labelledby="rs-title">
|
||||
<form method="dialog">
|
||||
<div id="resultsbody"></div>
|
||||
<menu class="ng-buttons">
|
||||
<button value="ok" id="rs-ok" type="submit">Close</button>
|
||||
</menu>
|
||||
</form>
|
||||
</dialog>
|
||||
|
||||
<!-- THE HANDOFF, between `Lobby.Start` and the first Frame.
|
||||
`beginRemote` used to write "… connecting to the game" into `#presence` — the DISCONNECT banner,
|
||||
whose job is `⚠ waiting on Alice`. It worked only because the first render overwrote it, and it
|
||||
had nothing to say when the first push never came. This is its own state: it opens on the way
|
||||
into a game, holds a deliberate beat so the game visibly begins, and closes on the first Frame. -->
|
||||
<div id="handoff">
|
||||
<div class="hand-inner">
|
||||
<h2 id="handoff-title">Dealing the railroad…</h2>
|
||||
<div id="handoff-note" class="hand-note"></div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script type="module" src="./web/main.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -1,365 +0,0 @@
|
||||
/**
|
||||
* THE FOUR GAME TYPES, and what "Custom" means.
|
||||
*
|
||||
* Jesse's design, 2026-08-23. A game type is not a mode and not a ruleset — it is a NAMED SET OF
|
||||
* DEFAULTS that the host may then edit. Editing any of them selects `custom`, which keeps the
|
||||
* values and inherits the scoring of the type it was edited away from; clicking a named type again
|
||||
* resets every rule back to it.
|
||||
*
|
||||
* WHY THIS FILE EXISTS RATHER THAN A CONSTANT IN EACH SCREEN. The lobby (`lobby.ts`) and the
|
||||
* solitaire New Game dialog (`main.ts`) ask the same questions, and they had already drifted apart
|
||||
* before this was written: the dialog had "where an Extra may start" and no optional rules, the
|
||||
* lobby had the optional rules and no Extra rule — so a multiplayer game silently played the most
|
||||
* permissive Extra rule and nobody was ever asked. One description of the defaults, imported by
|
||||
* both, is what stops that happening a third time.
|
||||
*
|
||||
* PARAMETERS ARE NOT SETTINGS. Seed, player count and Day count sit ABOVE the type radios on both
|
||||
* screens and never select `custom`: the presets are formulas in players and days, so "Co-op, 3
|
||||
* players, 8 days" is still Co-op and its Revenue floor re-derives. Everything below the radios is
|
||||
* a rule, and changing one is what makes a game Custom.
|
||||
*/
|
||||
|
||||
import {
|
||||
DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
collectiveRevenueFloor,
|
||||
houseRules,
|
||||
} from '../engine/content.ts';
|
||||
import type { ExtraStartRule, RevenueRules, StartingHand } from '../engine/content.ts';
|
||||
import type { GameConfig, GameMode } from '../engine/state.ts';
|
||||
|
||||
export type PresetName = 'solitaire' | 'coop' | 'competitive' | 'cutthroat';
|
||||
/** What the radio group answers: one of the four named types, or the state of having edited one. */
|
||||
export type GameType = PresetName | 'custom';
|
||||
|
||||
/**
|
||||
* Every rule a game type sets, flattened to one value per control.
|
||||
*
|
||||
* Flat rather than shaped like `GameConfig` because this is what the FORM compares against: each key
|
||||
* is one field on screen, so "which fields differ from the preset" is a key-by-key comparison rather
|
||||
* than a walk through nested objects. `configFromSettings` puts the shape back.
|
||||
*/
|
||||
export type Settings = {
|
||||
startingHand: StartingHand;
|
||||
extraStart: ExtraStartRule;
|
||||
passengerPerCoach: number;
|
||||
freightPerLoad: number;
|
||||
trainPerTransit: number;
|
||||
/** 0 means the condition is off — the engine's convention (`state.ts`). The form draws a checkbox. */
|
||||
minCombinedRevenue: number;
|
||||
maxCollisionsPerDay: number;
|
||||
maxCollisionsTotal: number;
|
||||
reducedVisibility: boolean;
|
||||
employeeRotation: boolean;
|
||||
emergencyToolbox: boolean;
|
||||
/** §6.2 (Gitea#9) — may a Timetabled train be thrown away? An Extra never may, whatever this says. */
|
||||
discardTimetabled: boolean;
|
||||
};
|
||||
|
||||
export const SETTING_KEYS: readonly (keyof Settings)[] = [
|
||||
'startingHand',
|
||||
'extraStart',
|
||||
'passengerPerCoach',
|
||||
'freightPerLoad',
|
||||
'trainPerTransit',
|
||||
'minCombinedRevenue',
|
||||
'maxCollisionsPerDay',
|
||||
'maxCollisionsTotal',
|
||||
'reducedVisibility',
|
||||
'employeeRotation',
|
||||
'emergencyToolbox',
|
||||
'discardTimetabled',
|
||||
];
|
||||
|
||||
export type Preset = {
|
||||
name: PresetName;
|
||||
label: string;
|
||||
/** One line under the radio, saying what winning and losing mean in this type. */
|
||||
blurb: string;
|
||||
/** The engine mode this type is scored under — what a `custom` game inherits. */
|
||||
scoring: GameMode;
|
||||
/**
|
||||
* Whether the 22 opponent-directed cards would be dealt, once they exist. Not a form control any
|
||||
* more: it is a property of the type (`TODO.md` — the cards are unbuilt, so `buildDeck` holds them
|
||||
* out regardless, and a checkbox that cannot do anything is worse than a sentence saying so).
|
||||
*/
|
||||
pvpCards: boolean;
|
||||
/**
|
||||
* The Revenue floor this type asks for, as a function of the table and the length. Co-op keeps the
|
||||
* engine's own `collectiveRevenueFloor` (3 per player per Day); Competitive asks two thirds of it,
|
||||
* because a table racing each other is not also pulling in one direction; Cutthroat asks nothing.
|
||||
*/
|
||||
revenueFloor: (players: number, days: number) => number;
|
||||
rules: Omit<Settings, 'minCombinedRevenue'>;
|
||||
};
|
||||
|
||||
const NO_OPTIONAL_RULES = {
|
||||
reducedVisibility: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
/**
|
||||
* ON in every type (Gitea#9). Jesse's ruling is the rule now, and the setting exists so a table
|
||||
* can put Gitea#6's pressure back rather than so a type can choose for them — the reasoning is
|
||||
* about how long a game runs, which is a dial the table already sets for itself.
|
||||
*/
|
||||
discardTimetabled: true,
|
||||
} as const;
|
||||
|
||||
/** Every type deals six now (Jesse, 2026-08-23) — the hand limit is three, so the first turn is a
|
||||
* discard whichever three you keep. Solitaire moved with the rest so the two screens agree. */
|
||||
const SIX: StartingHand = 'sixRandom';
|
||||
|
||||
export const PRESETS: readonly Preset[] = [
|
||||
{
|
||||
name: 'solitaire',
|
||||
label: 'Solitaire',
|
||||
blurb: 'One railroad, one player. The whole Division is yours to run.',
|
||||
scoring: 'solitaire',
|
||||
pvpCards: false,
|
||||
revenueFloor: (players, days) => collectiveRevenueFloor(players, days),
|
||||
rules: {
|
||||
startingHand: SIX,
|
||||
// Nobody else's district exists, so "any Control Point" and "your own" are the same rule.
|
||||
extraStart: 'anyOffice',
|
||||
passengerPerCoach: 1,
|
||||
freightPerLoad: 1,
|
||||
trainPerTransit: 0,
|
||||
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
...NO_OPTIONAL_RULES,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'coop',
|
||||
label: 'Co-op',
|
||||
blurb: 'Everyone’s Revenue is one table score. You win together or lose together.',
|
||||
scoring: 'coop',
|
||||
// Never, even once the cards are built: there is no opponent to point them at when the table is
|
||||
// one side.
|
||||
pvpCards: false,
|
||||
revenueFloor: (players, days) => collectiveRevenueFloor(players, days),
|
||||
rules: {
|
||||
startingHand: SIX,
|
||||
extraStart: 'ownOffice',
|
||||
passengerPerCoach: 1,
|
||||
freightPerLoad: 1,
|
||||
// The one economy that pays every player at once, for work nobody had to do — which is the
|
||||
// co-operative one, so it is the type that switches it on.
|
||||
trainPerTransit: 1,
|
||||
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
...NO_OPTIONAL_RULES,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'competitive',
|
||||
label: 'Competitive',
|
||||
blurb: 'Highest Revenue wins — unless the table misses its combined minimum, and then everyone loses.',
|
||||
scoring: 'competitive',
|
||||
pvpCards: true,
|
||||
revenueFloor: (players, days) => 2 * players * days,
|
||||
rules: {
|
||||
startingHand: SIX,
|
||||
extraStart: 'ownOffice',
|
||||
passengerPerCoach: 1,
|
||||
freightPerLoad: 1,
|
||||
trainPerTransit: 0,
|
||||
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
|
||||
...NO_OPTIONAL_RULES,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'cutthroat',
|
||||
label: 'Cutthroat',
|
||||
blurb: 'Highest Revenue wins, and nothing is shared — the only way everyone loses is three collisions in one Day.',
|
||||
scoring: 'competitive',
|
||||
pvpCards: true,
|
||||
// Off. Cutthroat has no collective obligation of any kind.
|
||||
revenueFloor: () => 0,
|
||||
rules: {
|
||||
startingHand: SIX,
|
||||
// The one type that lets you plant an Extra in somebody else's district.
|
||||
extraStart: 'anyOffice',
|
||||
passengerPerCoach: 1,
|
||||
freightPerLoad: 1,
|
||||
trainPerTransit: 0,
|
||||
maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
|
||||
// Off, with the per-Day check left standing: a table can bleed collisions all game, but three
|
||||
// in one Day still ends it.
|
||||
maxCollisionsTotal: 0,
|
||||
...NO_OPTIONAL_RULES,
|
||||
},
|
||||
},
|
||||
];
|
||||
|
||||
export function preset(name: PresetName): Preset {
|
||||
const found = PRESETS.find((p) => p.name === name);
|
||||
if (!found) throw new Error(`no such preset: ${name}`);
|
||||
return found;
|
||||
}
|
||||
|
||||
/** Every rule a named type sets, at the table size and length the form currently shows. */
|
||||
export function presetSettings(name: PresetName, players: number, days: number): Settings {
|
||||
const p = preset(name);
|
||||
return { ...p.rules, minCombinedRevenue: p.revenueFloor(players, days) };
|
||||
}
|
||||
|
||||
/** The settings a config is actually carrying — the other half of every comparison below. */
|
||||
export function settingsOf(config: GameConfig): Settings {
|
||||
const rules = houseRules(config);
|
||||
return {
|
||||
startingHand: rules.startingHand,
|
||||
extraStart: rules.extraStart,
|
||||
passengerPerCoach: rules.revenue.passengerPerCoach,
|
||||
freightPerLoad: rules.revenue.freightPerLoad,
|
||||
trainPerTransit: rules.revenue.trainPerTransit,
|
||||
minCombinedRevenue: config.minCombinedRevenue,
|
||||
maxCollisionsPerDay: config.maxCollisionsPerDay,
|
||||
maxCollisionsTotal: config.maxCollisionsTotal,
|
||||
reducedVisibility: config.optionalRules.reducedVisibility,
|
||||
employeeRotation: config.optionalRules.employeeRotation,
|
||||
emergencyToolbox: config.optionalRules.emergencyToolbox,
|
||||
discardTimetabled: rules.discardTimetabled,
|
||||
};
|
||||
}
|
||||
|
||||
/** Which controls differ from a named type — what the form paints amber and counts in its summary. */
|
||||
export function differencesFrom(
|
||||
name: PresetName,
|
||||
settings: Settings,
|
||||
players: number,
|
||||
days: number,
|
||||
): (keyof Settings)[] {
|
||||
const want = presetSettings(name, players, days);
|
||||
return SETTING_KEYS.filter((k) => settings[k] !== want[k]);
|
||||
}
|
||||
|
||||
/**
|
||||
* WHICH TYPE IS THIS, derived rather than stored.
|
||||
*
|
||||
* Nothing writes a type name into `GameConfig` — a saved game is its numbers, and a name in the save
|
||||
* would be one more thing that can disagree with them. So the screens ask this instead, which means
|
||||
* a hand-tuned game that happens to match Competitive exactly reads as Competitive, and that is the
|
||||
* honest answer: it IS one.
|
||||
*
|
||||
* `mode` is part of the comparison, so a Co-op game whose dials happen to equal Competitive's is
|
||||
* still not Competitive.
|
||||
*/
|
||||
export function presetOf(config: GameConfig, players: number, days: number): GameType {
|
||||
const settings = settingsOf(config);
|
||||
const match = PRESETS.find(
|
||||
(p) => p.scoring === config.mode && differencesFrom(p.name, settings, players, days).length === 0,
|
||||
);
|
||||
return match?.name ?? 'custom';
|
||||
}
|
||||
|
||||
/**
|
||||
* A `Frame`'s copy of the config, as a `GameConfig` the functions above can read.
|
||||
*
|
||||
* The page has a Frame, never a `GameState` — a remote client holds no game — and the Frame carries
|
||||
* every field these comparisons need. Structurally typed rather than importing `Frame` so this
|
||||
* module stays free of `sim/view.ts`.
|
||||
*/
|
||||
export function configFromFrame(f: {
|
||||
mode: GameMode;
|
||||
days: number;
|
||||
minCombinedRevenue: number;
|
||||
maxCollisionsPerDay: number;
|
||||
maxCollisionsTotal: number;
|
||||
optionalRules: GameConfig['optionalRules'];
|
||||
houseRules: { startingHand: StartingHand; extraStart: ExtraStartRule; revenue: RevenueRules; discardTimetabled: boolean };
|
||||
}): GameConfig {
|
||||
return {
|
||||
mode: f.mode,
|
||||
days: f.days,
|
||||
minCombinedRevenue: f.minCombinedRevenue,
|
||||
maxCollisionsPerDay: f.maxCollisionsPerDay,
|
||||
maxCollisionsTotal: f.maxCollisionsTotal,
|
||||
// Never shown from a Frame — the cards are unbuilt, and the type carries the answer.
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: f.optionalRules,
|
||||
houseRules: {
|
||||
startingHand: f.houseRules.startingHand,
|
||||
extraStart: f.houseRules.extraStart,
|
||||
// Carried like the rest: this path describes SOMEONE ELSE'S game to a joiner, so a setting
|
||||
// dropped here shows them a rule the table is not playing (§6.2, Gitea#9).
|
||||
discardTimetabled: f.houseRules.discardTimetabled,
|
||||
revenue: f.houseRules.revenue,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* The named type a config is NEAREST to, for a screen that has to describe someone else's game.
|
||||
*
|
||||
* The create form always knows which type was clicked, so it compares against that. A join preview
|
||||
* and the seating screen do not — they are handed a finished config and nothing else — and "Custom"
|
||||
* on its own tells a player nothing about what they are joining. Comparing against the same-scoring
|
||||
* type with the fewest differences answers the question they actually have: how far from a normal
|
||||
* game is this, and which normal game?
|
||||
*/
|
||||
export function closestPreset(
|
||||
config: GameConfig,
|
||||
players: number,
|
||||
days: number,
|
||||
): { name: PresetName; differing: (keyof Settings)[] } {
|
||||
const settings = settingsOf(config);
|
||||
const candidates = PRESETS.filter((p) => p.scoring === config.mode);
|
||||
const scored = (candidates.length > 0 ? candidates : PRESETS).map((p) => ({
|
||||
name: p.name,
|
||||
differing: differencesFrom(p.name, settings, players, days),
|
||||
}));
|
||||
return scored.reduce((best, c) => (c.differing.length < best.differing.length ? c : best));
|
||||
}
|
||||
|
||||
/**
|
||||
* The label a screen shows for the current state of the form — including what a Custom game is being
|
||||
* scored as, which is the one thing a player cannot see from the dials.
|
||||
*/
|
||||
export function gameTypeLabel(type: GameType, scoring: GameMode): string {
|
||||
if (type !== 'custom') return preset(type).label;
|
||||
const named = PRESETS.find((p) => p.scoring === scoring && p.name !== 'cutthroat');
|
||||
return `Custom — scored as ${named?.label ?? scoring}`;
|
||||
}
|
||||
|
||||
/** Assembles the config a form's answers describe. `players` reaches the caller separately: it sizes
|
||||
* the lobby's seat array rather than being part of the rules. */
|
||||
export function configFromSettings(
|
||||
settings: Settings,
|
||||
scoring: GameMode,
|
||||
days: number,
|
||||
pvpCards: boolean,
|
||||
): GameConfig {
|
||||
return {
|
||||
mode: scoring,
|
||||
days,
|
||||
minCombinedRevenue: settings.minCombinedRevenue,
|
||||
maxCollisionsPerDay: settings.maxCollisionsPerDay,
|
||||
maxCollisionsTotal: settings.maxCollisionsTotal,
|
||||
// Inert until the cards are built (`setup.ts`'s `buildDeck` ANDs it with `cardsImplemented`),
|
||||
// and no longer a control on any screen — it is a property of the game type.
|
||||
pvpCardsAllowed: pvpCards,
|
||||
optionalRules: {
|
||||
reducedVisibility: settings.reducedVisibility,
|
||||
employeeRotation: settings.employeeRotation,
|
||||
emergencyToolbox: settings.emergencyToolbox,
|
||||
},
|
||||
houseRules: {
|
||||
startingHand: settings.startingHand,
|
||||
extraStart: settings.extraStart,
|
||||
discardTimetabled: settings.discardTimetabled,
|
||||
revenue: {
|
||||
passengerPerCoach: settings.passengerPerCoach,
|
||||
freightPerLoad: settings.freightPerLoad,
|
||||
trainPerTransit: settings.trainPerTransit,
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/** The whole config a named type produces, with nothing edited. */
|
||||
export function configFromPreset(name: PresetName, players: number, days: number): GameConfig {
|
||||
const p = preset(name);
|
||||
return configFromSettings(presetSettings(name, players, days), p.scoring, days, p.pvpCards);
|
||||
}
|
||||
+2
-6
@@ -26,7 +26,6 @@ import { createGame } from '../engine/setup.ts';
|
||||
import { snapshot } from '../sim/view.ts';
|
||||
import type { Intent } from '../engine/intents.ts';
|
||||
import { SOLO_CONFIG } from './game.ts';
|
||||
import { actingPlayer } from '../engine/state.ts';
|
||||
|
||||
type Save = { seed: number; history: Intent[] };
|
||||
type Entry = { file: string; title: string; note?: string; seed?: number };
|
||||
@@ -70,7 +69,7 @@ function rebuild(save: Save): { steps: Step[]; stoppedEarly: boolean } {
|
||||
push(pump(s));
|
||||
let stoppedEarly = false;
|
||||
for (const intent of save.history) {
|
||||
const actor = actingPlayer(s);
|
||||
const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
|
||||
if (actor === null || s.status !== 'active') break;
|
||||
const r = applyIntent(s, actor, intent);
|
||||
if (!r.ok) {
|
||||
@@ -118,10 +117,7 @@ function show(i: number): void {
|
||||
// A replay carries the seat names in the frame's own lines rather than a player table, so the
|
||||
// solitaire seat is named directly; a multi-player replay reports the index it has.
|
||||
const actorName = f.actor === null ? null : `Player ${f.actor + 1}`;
|
||||
// A replay of a multi-player game gets the Fedora too — it is the answer to "why is it asking
|
||||
// THEM", which a replay raises exactly as a live game does.
|
||||
const superName = f.players.length > 1 ? `Player ${f.superintendent + 1}` : null;
|
||||
$('turnchart').innerHTML = turnChartHtml(f, actorName, superName);
|
||||
$('turnchart').innerHTML = turnChartHtml(f, actorName);
|
||||
$('vrev').textContent = String(f.revenue);
|
||||
$('vpos').textContent = `${at} / ${steps.length - 1}`;
|
||||
($('vscrub') as HTMLInputElement).value = String(at);
|
||||
|
||||
+10
-214
@@ -18,16 +18,14 @@
|
||||
import type { Intent } from '../engine/intents.ts';
|
||||
import type { Frame } from '../sim/view.ts';
|
||||
import type { PlayerIndex } from '../engine/state.ts';
|
||||
import { applyDelta } from '../sim/frame-delta.ts';
|
||||
import type { FrameDelta } from '../sim/frame-delta.ts';
|
||||
import type { Game, Menu, NewGameOptions, Save } from './game.ts';
|
||||
import type { HouseRuleOverrides } from '../engine/content.ts';
|
||||
import type { Game, Menu, Save } from './game.ts';
|
||||
import {
|
||||
actionMenu,
|
||||
configWith,
|
||||
currentActor,
|
||||
fromSave,
|
||||
handPlayable,
|
||||
isOutOfTurn,
|
||||
newGame,
|
||||
overHandLimit,
|
||||
submit,
|
||||
@@ -94,29 +92,6 @@ export type Session = {
|
||||
takeAnnouncement(): string | null;
|
||||
/** The card most recently drawn into this seat's hand. Persists until another draw replaces it. */
|
||||
justDrawn(): string | null;
|
||||
/**
|
||||
* Which OTHER seats are currently connected, as last reported by the server — always empty for a
|
||||
* `LocalSession` (there is nobody else to track). `lobby-and-sessions.md` §5: a disconnect keeps
|
||||
* the seat and waits; this is what lets the page say why, instead of going quiet with no
|
||||
* explanation. Reflects the last presence push for each seat the server has ever mentioned, not
|
||||
* only the ones currently disconnected — a seat that reconnects updates its own entry rather than
|
||||
* disappearing.
|
||||
*
|
||||
* `seen` is what separates the two absences the page must not conflate: a seat that has connected
|
||||
* at some point and dropped, against one that has never opened the game at all. The server now
|
||||
* reports every other seat on connect (2026-08-23), so this is answerable at the moment a game
|
||||
* starts — which is exactly when "is everyone here?" is the question.
|
||||
*/
|
||||
presence(): { seat: PlayerIndex; connected: boolean; seen: boolean }[];
|
||||
/**
|
||||
* Stop listening, for good.
|
||||
*
|
||||
* Only a remote session has anything to close, and only one caller needs it: a player LEAVING a
|
||||
* running game (2026-08-23). Without it the page went back to the lobby with its `EventSource`
|
||||
* still open, so the server — and therefore every other seat — went on reporting them as present
|
||||
* at a table they had walked away from.
|
||||
*/
|
||||
close?(): void;
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -140,14 +115,14 @@ export type LocalSession = Session & {
|
||||
* `Game` is mutated in place by `submit`, so the wrapper keeps a mutable reference rather than
|
||||
* copying — `undo` and `restore` replace the whole game, which is why `game` is a getter.
|
||||
*
|
||||
* It takes `NewGameOptions` rather than a whole `GameConfig` because DEALING is the only thing on the
|
||||
* far side of this that the page is allowed to decide. A config carries the mode and the optional
|
||||
* rules — table settings a lobby owns — and handing main.ts a `GameConfig` to build meant importing
|
||||
* the engine's own defaults into the page, which is the boundary `session.test.ts` guards. The seed,
|
||||
* the house rules and the victory-condition dials are what a player picks when they press New game.
|
||||
* It takes `rules` rather than a whole `GameConfig` because DEALING is the only thing on the far
|
||||
* side of this that the page is allowed to decide. A config carries the mode, the victory condition
|
||||
* and the optional rules — table settings a lobby owns — and handing main.ts a `GameConfig` to build
|
||||
* meant importing the engine's own defaults into the page, which is the boundary `session.test.ts`
|
||||
* guards. The seed and the house rules are the two things a player picks when they press New game.
|
||||
*/
|
||||
export function createLocalSession(seed: number, options?: NewGameOptions): LocalSession {
|
||||
let game: Game = options ? newGame(seed, configWith(options)) : newGame(seed);
|
||||
export function createLocalSession(seed: number, rules?: HouseRuleOverrides): LocalSession {
|
||||
let game: Game = rules ? newGame(seed, configWith(rules)) : newGame(seed);
|
||||
const listeners = new Set<() => void>();
|
||||
const changed = (): void => {
|
||||
for (const fn of [...listeners]) fn();
|
||||
@@ -164,9 +139,7 @@ export function createLocalSession(seed: number, options?: NewGameOptions): Loca
|
||||
overHandLimit: () => overHandLimit(game),
|
||||
handPlayable: () => handPlayable(game),
|
||||
submit: async (intent: Intent) => {
|
||||
// Seat 0 is the solitaire player, and the extension vote (Gitea#11) is the one intent that
|
||||
// arrives when `currentActor` is null — so it has to name its seat. See `isOutOfTurn`.
|
||||
const ok = submit(game, intent, isOutOfTurn(intent) ? 0 : null);
|
||||
const ok = submit(game, intent);
|
||||
if (ok) changed();
|
||||
return ok;
|
||||
},
|
||||
@@ -189,7 +162,6 @@ export function createLocalSession(seed: number, options?: NewGameOptions): Loca
|
||||
return text;
|
||||
},
|
||||
justDrawn: () => game.justDrawn,
|
||||
presence: () => [],
|
||||
|
||||
seed: () => game.seed,
|
||||
save: () => toSave(game),
|
||||
@@ -215,179 +187,3 @@ export function createLocalSession(seed: number, options?: NewGameOptions): Loca
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/** The push envelope `src/server/session.ts` sends over SSE — mirrored here rather than imported,
|
||||
* so this file never depends on anything under `src/server/` even at the type level. */
|
||||
type Push = {
|
||||
frame?: FrameDelta;
|
||||
menu: Menu | null;
|
||||
lines: { text: string; tone: string }[];
|
||||
/** One entry for a change; every other seat at once on the connect push. */
|
||||
presence?: { seat: PlayerIndex; connected: boolean; seen: boolean }[];
|
||||
/**
|
||||
* THE FOUR TRANSIENT SIGNALS, added 2026-08-23.
|
||||
*
|
||||
* A remote session used to return nothing for any of them, so multiplayer had no sound at all, no
|
||||
* timetable flash when the D12 filled a slot, no announcement when a completed run paid the table,
|
||||
* and no highlight on the card you had just drawn — four things solitaire has had all along, and
|
||||
* most of why a multiplayer game felt inert.
|
||||
*
|
||||
* `cues` and `announcement` are SHARED events (a collision anywhere, the Stage bell, a train
|
||||
* leaving the Division) and reach every seat; `justDrawn` is the recipient's own card and nobody
|
||||
* else's — `test/redaction.test.ts` covers exactly that.
|
||||
*/
|
||||
cues?: string[];
|
||||
scheduled?: number | null;
|
||||
announcement?: string | null;
|
||||
justDrawn?: string | null;
|
||||
};
|
||||
|
||||
/**
|
||||
* A session backed by a server (Phase 2, extended Phase 4). Holds no authoritative state — no deck
|
||||
* order, no other seat's hand — only the last `Frame`/`Menu` a push actually told it. `capabilities`
|
||||
* are all `false`: undo would have to un-see what other players already saw, a local save is
|
||||
* meaningless when the server is the store, and dealing a new game is the lobby's job.
|
||||
*
|
||||
* `token` is `lobby-and-sessions.md` §1's session token, issued at `Lobby.Create`/`Lobby.Join` and
|
||||
* stored by the caller (`main.ts`, in `localStorage`) — it alone proves identity to `/api/stream`
|
||||
* and `/api/intent`, so this function no longer takes a join secret at all; that gate belongs to
|
||||
* the lobby endpoints only. `seat` still has to be passed in rather than learned from a push,
|
||||
* because the very FIRST thing this session needs — `seat()` — has to answer before any push has
|
||||
* necessarily arrived; the caller already knows it from the join/create/start response.
|
||||
*
|
||||
* Construction is synchronous (the `Session` interface has no async surface), but the first real
|
||||
* `Frame` only exists once the SSE connection's first push arrives — `main.ts` accounts for this by
|
||||
* not rendering until `subscribe`'s callback fires at least once for a session whose `capabilities`
|
||||
* are all `false` (a `LocalSession` always has data the instant it is constructed; this does not).
|
||||
*/
|
||||
export function createRemoteSession(
|
||||
token: string,
|
||||
seat: PlayerIndex,
|
||||
/**
|
||||
* Called once when this session's game is established to be gone for good, so the page can stop
|
||||
* waiting for it. Without this the only symptom is a blank screen: `EventSource` retries a 404
|
||||
* forever and reports nothing, and `frame` never becomes non-null.
|
||||
*/
|
||||
onGone?: () => void,
|
||||
): Session {
|
||||
let frame: Frame | null = null;
|
||||
let menu: Menu | null = null;
|
||||
let lines: { text: string; tone: string }[] = [];
|
||||
const presence = new Map<PlayerIndex, { connected: boolean; seen: boolean }>();
|
||||
let cues: string[] = [];
|
||||
let scheduled: number | null = null;
|
||||
let announcement: string | null = null;
|
||||
let justDrawnCard: string | null = null;
|
||||
let nextSeq = 1;
|
||||
const listeners = new Set<() => void>();
|
||||
const changed = (): void => {
|
||||
for (const fn of [...listeners]) fn();
|
||||
};
|
||||
|
||||
const qs = `token=${encodeURIComponent(token)}`;
|
||||
const source = new EventSource(`/api/stream?${qs}`);
|
||||
|
||||
/**
|
||||
* A DROPPED CONNECTION AND A DEAD GAME LOOK IDENTICAL HERE, so ask before giving up.
|
||||
*
|
||||
* `EventSource` fires `error` for both a transient blip — which it recovers from by itself, and
|
||||
* which is the expected shape of a game that sits idle for minutes (multiplayer.md §9) — and a
|
||||
* 404 it will nonetheless retry forever. It exposes no status code either way. `/api/session` is
|
||||
* the cheap question that separates them: only a definite 404 closes the stream and reports the
|
||||
* game gone, so a flaky network still self-heals.
|
||||
*/
|
||||
let reportedGone = false;
|
||||
source.onerror = () => {
|
||||
if (reportedGone) return;
|
||||
void fetch(`/api/session?${qs}`)
|
||||
.then((r) => {
|
||||
if (r.status !== 404 || reportedGone) return;
|
||||
reportedGone = true;
|
||||
source.close();
|
||||
onGone?.();
|
||||
})
|
||||
.catch(() => {
|
||||
// The probe itself failed, so this says nothing about the game — leave the retry running.
|
||||
});
|
||||
};
|
||||
source.onmessage = (ev: MessageEvent<string>) => {
|
||||
const push = JSON.parse(ev.data) as Push;
|
||||
// A presence-only push (no `frame`) carries `menu: null` too, but that is not news about this
|
||||
// seat's turn — only a push that actually came from the game (always carries a real `frame`,
|
||||
// per `session.ts`'s `Push`) updates the board or the menu.
|
||||
if (push.frame) {
|
||||
frame = applyDelta(frame, push.frame);
|
||||
menu = push.menu;
|
||||
}
|
||||
lines = [...lines, ...push.lines];
|
||||
for (const p of push.presence ?? []) presence.set(p.seat, { connected: p.connected, seen: p.seen });
|
||||
// Accumulated rather than replaced: two pushes can arrive between two renders, and a cue that
|
||||
// was earned is a cue that should be heard.
|
||||
if (push.cues) cues = [...cues, ...push.cues];
|
||||
if (push.scheduled !== undefined && push.scheduled !== null) scheduled = push.scheduled;
|
||||
if (push.announcement !== undefined && push.announcement !== null) announcement = push.announcement;
|
||||
// Persists until another draw replaces it, matching the local session's own `justDrawn`.
|
||||
if (push.justDrawn !== undefined) justDrawnCard = push.justDrawn;
|
||||
changed();
|
||||
};
|
||||
|
||||
const need = (): Frame => {
|
||||
if (frame === null) throw new Error('RemoteSession.view() called before the first Frame arrived');
|
||||
return frame;
|
||||
};
|
||||
|
||||
return {
|
||||
view: need,
|
||||
menu: () => menu ?? { options: [], direct: [], placeable: [], hand: [], makeUp: null },
|
||||
seat: () => seat,
|
||||
actor: () => need().actor,
|
||||
overHandLimit: () => need().overHandLimit,
|
||||
handPlayable: () => (menu?.hand ?? []).map((h) => h.playNow !== null),
|
||||
async submit(intent: Intent): Promise<boolean> {
|
||||
const seq = nextSeq++;
|
||||
const res = await fetch(`/api/intent?${qs}`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ seq, intent }),
|
||||
});
|
||||
const result = (await res.json()) as { ok: boolean; code?: string };
|
||||
// The visible update arrives via the SSE push (broadcast to every seat, including this one),
|
||||
// not from this response — this only reports whether the rules accepted it.
|
||||
return result.ok;
|
||||
},
|
||||
subscribe(fn: () => void) {
|
||||
listeners.add(fn);
|
||||
return () => listeners.delete(fn);
|
||||
},
|
||||
capabilities: { undo: false, saveLocal: false, newGame: false },
|
||||
|
||||
lines: () => lines,
|
||||
// Draining, exactly as the local session's are: each of these marks a moment, so it plays once
|
||||
// and is gone by the next render rather than re-firing on every redraw.
|
||||
takeCues: () => {
|
||||
const out = cues;
|
||||
cues = [];
|
||||
return out;
|
||||
},
|
||||
takeScheduled: () => {
|
||||
const out = scheduled;
|
||||
scheduled = null;
|
||||
return out;
|
||||
},
|
||||
takeAnnouncement: () => {
|
||||
const out = announcement;
|
||||
announcement = null;
|
||||
return out;
|
||||
},
|
||||
justDrawn: () => justDrawnCard,
|
||||
presence: () => [...presence].map(([seat, p]) => ({ seat, connected: p.connected, seen: p.seen })),
|
||||
close() {
|
||||
// `reportedGone` first: closing the stream fires `onerror`, and this is a deliberate exit, not
|
||||
// a game that vanished — `onGone` must not be called and land the page in "that game is no
|
||||
// longer on this server".
|
||||
reportedGone = true;
|
||||
source.close();
|
||||
listeners.clear();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,358 +0,0 @@
|
||||
/**
|
||||
* THE RULES BLOCK, driven identically on both screens.
|
||||
*
|
||||
* The lobby (`lobby.ts`) and the solitaire New Game dialog (`main.ts`) ask the same twelve questions.
|
||||
* They used to ask them in two hand-written copies and had already drifted — the dialog had "where
|
||||
* an Extra may start" and no optional rules, the lobby the reverse — so this module owns reading,
|
||||
* writing, comparing and annotating the block, and each screen supplies only the id prefix its
|
||||
* markup uses (`lb-` or `ng-`).
|
||||
*
|
||||
* THE MARKUP ITSELF STAYS STATIC IN `play.html`, deliberately. Generating it here would be less
|
||||
* duplication, but `test/web.test.ts` drives the emitted bundle against a hand-built DOM stub with
|
||||
* no HTML parser in it (there is no jsdom in this project, and adding one to test a form is a poor
|
||||
* trade), and the ids in that stub come from scanning the real `play.html`. A test in the same suite
|
||||
* asserts both screens carry every key below, which is the drift guard the shared markup would have
|
||||
* been.
|
||||
*/
|
||||
|
||||
import { REVENUE_MAX, REVENUE_MIN } from '../engine/content.ts';
|
||||
import type { ExtraStartRule, StartingHand } from '../engine/content.ts';
|
||||
import { closestPreset, differencesFrom, presetOf, presetSettings, settingsOf } from './presets.ts';
|
||||
import type { PresetName, Settings } from './presets.ts';
|
||||
import type { GameConfig } from '../engine/state.ts';
|
||||
|
||||
/**
|
||||
* How each rule is asked on screen.
|
||||
*
|
||||
* `gated` is the pair introduced 2026-08-23: a checkbox that says whether the condition applies at
|
||||
* all, plus the number it applies at. The engine's convention is that `0` switches these off, which
|
||||
* is exact but unreadable — a Cutthroat game showed two zeroes and left the player to know the
|
||||
* convention. Unchecked still WRITES 0, so nothing under this changed.
|
||||
*/
|
||||
type Field =
|
||||
| { key: keyof Settings; kind: 'radio'; id: string }
|
||||
| { key: keyof Settings; kind: 'number'; id: string }
|
||||
| { key: keyof Settings; kind: 'checkbox'; id: string }
|
||||
| { key: keyof Settings; kind: 'gated'; id: string };
|
||||
|
||||
export const FIELDS: readonly Field[] = [
|
||||
{ key: 'startingHand', kind: 'radio', id: 'hand' },
|
||||
{ key: 'extraStart', kind: 'radio', id: 'extra' },
|
||||
{ key: 'passengerPerCoach', kind: 'number', id: 'passenger' },
|
||||
{ key: 'freightPerLoad', kind: 'number', id: 'freight' },
|
||||
{ key: 'trainPerTransit', kind: 'number', id: 'transit' },
|
||||
{ key: 'minCombinedRevenue', kind: 'gated', id: 'minrev' },
|
||||
{ key: 'maxCollisionsPerDay', kind: 'gated', id: 'colday' },
|
||||
{ key: 'maxCollisionsTotal', kind: 'gated', id: 'coltotal' },
|
||||
{ key: 'reducedVisibility', kind: 'checkbox', id: 'visibility' },
|
||||
{ key: 'employeeRotation', kind: 'checkbox', id: 'rotation' },
|
||||
{ key: 'emergencyToolbox', kind: 'checkbox', id: 'toolbox' },
|
||||
{ key: 'discardTimetabled', kind: 'checkbox', id: 'tossloco' },
|
||||
];
|
||||
|
||||
/**
|
||||
* What `play.html` must contain for a screen to be able to ask all twelve questions — the exact
|
||||
* attribute text, so `test/web.test.ts` can assert it against the built page.
|
||||
*
|
||||
* THIS IS THE DRIFT GUARD. The two blocks are generated from one template today; this is what says
|
||||
* so tomorrow, when someone edits one of them by hand.
|
||||
*/
|
||||
export function fieldSelectors(prefix: string): string[] {
|
||||
const out: string[] = [];
|
||||
for (const f of FIELDS) {
|
||||
// A radio group is addressed by NAME — there is no one element carrying the field's id.
|
||||
out.push(f.kind === 'radio' ? `name="${prefix}${f.id}"` : `id="${prefix}${f.id}"`);
|
||||
if (f.kind === 'gated') out.push(`id="${prefix}${f.id}-on"`);
|
||||
out.push(`id="${prefix}${f.id}-row"`, `id="${prefix}${f.id}-hint"`);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** The label each field goes under in the read-only view below. */
|
||||
const FIELD_LABELS: Record<keyof Settings, string> = {
|
||||
startingHand: 'Starting hand',
|
||||
extraStart: 'An Extra may start at',
|
||||
discardTimetabled: 'A Timetabled train may be discarded',
|
||||
passengerPerCoach: 'Passenger per coach',
|
||||
freightPerLoad: 'Freight per load',
|
||||
trainPerTransit: 'Train per transit',
|
||||
minCombinedRevenue: 'Combined Revenue floor',
|
||||
maxCollisionsPerDay: 'Collisions in one Day',
|
||||
maxCollisionsTotal: 'Collisions in the game',
|
||||
reducedVisibility: 'Reduced Visibility',
|
||||
employeeRotation: 'Employee Rotation',
|
||||
emergencyToolbox: 'Emergency Toolbox',
|
||||
};
|
||||
|
||||
const esc = (s: string): string =>
|
||||
s.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"');
|
||||
|
||||
/**
|
||||
* THE WHOLE RULE SET, READ-ONLY — what a player weighing a join reads before taking a seat, and what
|
||||
* the seating screen keeps showing afterwards.
|
||||
*
|
||||
* Generated rather than a fourth copy of the form: nobody may change these, so form controls would
|
||||
* be a lie, and a `<dl>` says "this is what you are joining" in a third of the space. Fields that
|
||||
* differ from the nearest named type are amber here for the same reason they are amber in the form —
|
||||
* a non-standard game should never be a surprise.
|
||||
*/
|
||||
export function rulesListHtml(config: GameConfig, players: number, days: number): string {
|
||||
const settings = settingsOf(config);
|
||||
const type = presetOf(config, players, days);
|
||||
const near = closestPreset(config, players, days);
|
||||
const differing = type === 'custom' ? near.differing : [];
|
||||
|
||||
const rows = (keys: (keyof Settings)[]): string =>
|
||||
keys
|
||||
.map((k) => {
|
||||
const changed = differing.includes(k) ? ' class="changed"' : '';
|
||||
return `<dt>${esc(FIELD_LABELS[k])}</dt><dd${changed}>${esc(describe(k, settings[k]))}</dd>`;
|
||||
})
|
||||
.join('');
|
||||
|
||||
const head =
|
||||
`<dl><dt>Players</dt><dd>${players}</dd><dt>Days</dt><dd>${days}</dd>` +
|
||||
`<dt>Opponent-directed cards</dt><dd>not implemented yet</dd></dl>`;
|
||||
|
||||
return (
|
||||
head +
|
||||
`<h4>Opening</h4><dl>${rows(['startingHand', 'extraStart'])}</dl>` +
|
||||
`<h4>Train cards</h4><dl>${rows(['discardTimetabled'])}</dl>` +
|
||||
`<h4>Revenue</h4><dl>${rows(['passengerPerCoach', 'freightPerLoad', 'trainPerTransit'])}</dl>` +
|
||||
`<h4>Victory conditions</h4><dl>${rows(['minCombinedRevenue', 'maxCollisionsPerDay', 'maxCollisionsTotal'])}</dl>` +
|
||||
`<h4>Optional rules</h4><dl>${rows(['reducedVisibility', 'employeeRotation', 'emergencyToolbox'])}</dl>`
|
||||
);
|
||||
}
|
||||
|
||||
/** What a value looks like beside its label — "Co-op default: 75", "Co-op default: six random cards". */
|
||||
function describe(key: keyof Settings, value: Settings[keyof Settings]): string {
|
||||
if (typeof value === 'boolean') return value ? 'on' : 'off';
|
||||
if (key === 'startingHand') {
|
||||
const words: Record<StartingHand, string> = {
|
||||
threeRandom: 'three random',
|
||||
sixRandom: 'six random',
|
||||
threeTrackThreeOther: 'three track and three other',
|
||||
};
|
||||
return words[value as StartingHand];
|
||||
}
|
||||
if (key === 'extraStart') {
|
||||
const words: Record<ExtraStartRule, string> = {
|
||||
divisionPointsOnly: 'Division Points only',
|
||||
ownOffice: 'your own Control Point',
|
||||
anyOffice: 'any Control Point',
|
||||
};
|
||||
return words[value as ExtraStartRule];
|
||||
}
|
||||
// A victory condition at 0 is not "0" on screen, it is a condition that does not apply.
|
||||
if (value === 0 && (key === 'minCombinedRevenue' || key === 'maxCollisionsPerDay' || key === 'maxCollisionsTotal')) {
|
||||
return 'off';
|
||||
}
|
||||
return String(value);
|
||||
}
|
||||
|
||||
export type SettingsForm = {
|
||||
read(): Settings;
|
||||
/** `suggestions` fills the placeholder of a switched-off condition, so ticking it back on has a
|
||||
* number to offer rather than an empty box. */
|
||||
write(values: Settings, suggestions: Settings): void;
|
||||
/**
|
||||
* Paint the block against a named type: every field that differs goes amber and every field gets
|
||||
* its "<Type> default: x" hint. Returns what differs, for the summary line the screen draws.
|
||||
*/
|
||||
mark(name: PresetName, players: number, days: number): (keyof Settings)[];
|
||||
/** Custom with no named baseline to compare against — clears the paint rather than lying. */
|
||||
clearMarks(): void;
|
||||
/** Called whenever the player changes any rule; the screen answers by selecting Custom. */
|
||||
onEdit(fn: (key: keyof Settings) => void): void;
|
||||
/** Read-only for the join preview and the seating screen: shown in full, changeable by nobody. */
|
||||
setEditable(on: boolean): void;
|
||||
/** Employee Rotation is meaningless at one player — disabled with a note rather than hidden, so
|
||||
* the two screens still read the same. */
|
||||
setEmployeeRotationAvailable(on: boolean): void;
|
||||
};
|
||||
|
||||
const $ = <T extends HTMLElement = HTMLElement>(id: string): T | null =>
|
||||
document.getElementById(id) as T | null;
|
||||
|
||||
export function settingsForm(prefix: string): SettingsForm {
|
||||
const el = <T extends HTMLElement = HTMLElement>(id: string): T | null => $<T>(`${prefix}${id}`);
|
||||
const radios = (name: string): HTMLInputElement[] =>
|
||||
Array.from(document.querySelectorAll<HTMLInputElement>(`input[name="${prefix}${name}"]`));
|
||||
const checkedRadio = (name: string): string | null =>
|
||||
radios(name).find((r) => r.checked)?.value ?? null;
|
||||
|
||||
let editHandler: ((key: keyof Settings) => void) | null = null;
|
||||
let editable = true;
|
||||
|
||||
function num(id: string, fallback: number): number {
|
||||
const raw = el<HTMLInputElement>(id)?.value ?? '';
|
||||
return raw.trim() === '' || !Number.isFinite(Number(raw)) ? fallback : Math.round(Number(raw));
|
||||
}
|
||||
|
||||
function readGated(id: string): number {
|
||||
// Unchecked IS zero — the engine's "off". The number in the box is kept so re-ticking restores it.
|
||||
if (el<HTMLInputElement>(`${id}-on`)?.checked !== true) return 0;
|
||||
return Math.max(0, num(id, 0));
|
||||
}
|
||||
|
||||
function read(): Settings {
|
||||
return {
|
||||
startingHand: (checkedRadio('hand') ?? 'sixRandom') as StartingHand,
|
||||
extraStart: (checkedRadio('extra') ?? 'anyOffice') as ExtraStartRule,
|
||||
passengerPerCoach: clampRevenue(num('passenger', 1)),
|
||||
freightPerLoad: clampRevenue(num('freight', 1)),
|
||||
trainPerTransit: clampRevenue(num('transit', 0)),
|
||||
minCombinedRevenue: readGated('minrev'),
|
||||
maxCollisionsPerDay: readGated('colday'),
|
||||
maxCollisionsTotal: readGated('coltotal'),
|
||||
reducedVisibility: el<HTMLInputElement>('visibility')?.checked === true,
|
||||
employeeRotation: el<HTMLInputElement>('rotation')?.checked === true,
|
||||
emergencyToolbox: el<HTMLInputElement>('toolbox')?.checked === true,
|
||||
discardTimetabled: el<HTMLInputElement>('tossloco')?.checked === true,
|
||||
};
|
||||
}
|
||||
|
||||
function write(values: Settings, suggestions: Settings): void {
|
||||
for (const r of radios('hand')) r.checked = r.value === values.startingHand;
|
||||
for (const r of radios('extra')) r.checked = r.value === values.extraStart;
|
||||
setNumber('passenger', values.passengerPerCoach);
|
||||
setNumber('freight', values.freightPerLoad);
|
||||
setNumber('transit', values.trainPerTransit);
|
||||
writeGated('minrev', values.minCombinedRevenue, suggestions.minCombinedRevenue);
|
||||
writeGated('colday', values.maxCollisionsPerDay, suggestions.maxCollisionsPerDay);
|
||||
writeGated('coltotal', values.maxCollisionsTotal, suggestions.maxCollisionsTotal);
|
||||
setChecked('visibility', values.reducedVisibility);
|
||||
setChecked('rotation', values.employeeRotation);
|
||||
setChecked('toolbox', values.emergencyToolbox);
|
||||
setChecked('tossloco', values.discardTimetabled);
|
||||
}
|
||||
|
||||
function setNumber(id: string, value: number): void {
|
||||
const input = el<HTMLInputElement>(id);
|
||||
if (input) input.value = String(value);
|
||||
}
|
||||
|
||||
function setChecked(id: string, on: boolean): void {
|
||||
const input = el<HTMLInputElement>(id);
|
||||
if (input) input.checked = on;
|
||||
}
|
||||
|
||||
function writeGated(id: string, value: number, suggestion: number): void {
|
||||
const box = el<HTMLInputElement>(`${id}-on`);
|
||||
const input = el<HTMLInputElement>(id);
|
||||
if (box) box.checked = value > 0;
|
||||
if (input) {
|
||||
// A switched-off condition shows an empty box with the suggestion as its placeholder, rather
|
||||
// than a `0` the player has to decode.
|
||||
input.value = value > 0 ? String(value) : '';
|
||||
input.placeholder = String(suggestion);
|
||||
input.disabled = !editable || value === 0;
|
||||
}
|
||||
}
|
||||
|
||||
function mark(name: PresetName, players: number, days: number): (keyof Settings)[] {
|
||||
const want = presetSettings(name, players, days);
|
||||
const differing = differencesFrom(name, read(), players, days);
|
||||
const label = presetLabelOf(name);
|
||||
for (const f of FIELDS) {
|
||||
const row = el(`${f.id}-row`);
|
||||
const hint = el(`${f.id}-hint`);
|
||||
const off = differing.includes(f.key);
|
||||
row?.classList.toggle('changed', off);
|
||||
if (hint) hint.textContent = `${label} default: ${describe(f.key, want[f.key])}`;
|
||||
}
|
||||
return differing;
|
||||
}
|
||||
|
||||
function clearMarks(): void {
|
||||
for (const f of FIELDS) {
|
||||
el(`${f.id}-row`)?.classList.remove('changed');
|
||||
const hint = el(`${f.id}-hint`);
|
||||
if (hint) hint.textContent = '';
|
||||
}
|
||||
}
|
||||
|
||||
function setEditable(on: boolean): void {
|
||||
editable = on;
|
||||
for (const f of FIELDS) {
|
||||
if (f.kind === 'radio') {
|
||||
for (const r of radios(f.id)) r.disabled = !on;
|
||||
continue;
|
||||
}
|
||||
const input = el<HTMLInputElement>(f.id);
|
||||
if (input) {
|
||||
// A gated number stays disabled when its own condition is off, whatever the block's state.
|
||||
const gatedOff = f.kind === 'gated' && el<HTMLInputElement>(`${f.id}-on`)?.checked !== true;
|
||||
input.disabled = !on || gatedOff;
|
||||
}
|
||||
if (f.kind === 'gated') {
|
||||
const box = el<HTMLInputElement>(`${f.id}-on`);
|
||||
if (box) box.disabled = !on;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function setEmployeeRotationAvailable(on: boolean): void {
|
||||
const input = el<HTMLInputElement>('rotation');
|
||||
if (input) {
|
||||
input.disabled = !on || !editable;
|
||||
if (!on) input.checked = false;
|
||||
}
|
||||
el('rotation-row')?.classList.toggle('unavailable', !on);
|
||||
}
|
||||
|
||||
/** One change handler for every control — the screens all answer it the same way (select Custom). */
|
||||
for (const f of FIELDS) {
|
||||
const fire = (): void => editHandler?.(f.key);
|
||||
if (f.kind === 'radio') {
|
||||
for (const r of radios(f.id)) r.onchange = fire;
|
||||
continue;
|
||||
}
|
||||
const input = el<HTMLInputElement>(f.id);
|
||||
if (input) {
|
||||
input.oninput = fire;
|
||||
input.onchange = fire;
|
||||
}
|
||||
if (f.kind === 'gated') {
|
||||
const box = el<HTMLInputElement>(`${f.id}-on`);
|
||||
if (box) {
|
||||
box.onchange = () => {
|
||||
const number = el<HTMLInputElement>(f.id);
|
||||
if (number) {
|
||||
number.disabled = !box.checked || !editable;
|
||||
// Ticking a condition back on with an empty box takes the suggestion showing in it,
|
||||
// so "on" never means "on, at zero".
|
||||
if (box.checked && number.value.trim() === '') number.value = number.placeholder;
|
||||
}
|
||||
fire();
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
read,
|
||||
write,
|
||||
mark,
|
||||
clearMarks,
|
||||
onEdit: (fn) => void (editHandler = fn),
|
||||
setEditable,
|
||||
setEmployeeRotationAvailable,
|
||||
};
|
||||
}
|
||||
|
||||
function clampRevenue(n: number): number {
|
||||
return Math.max(REVENUE_MIN, Math.min(REVENUE_MAX, n));
|
||||
}
|
||||
|
||||
/** Kept local rather than imported from `presets.ts`'s `preset()`, which would drag the whole table
|
||||
* in for one word — and this is the only place a hint needs it. */
|
||||
function presetLabelOf(name: PresetName): string {
|
||||
const labels: Record<PresetName, string> = {
|
||||
solitaire: 'Solitaire',
|
||||
coop: 'Co-op',
|
||||
competitive: 'Competitive',
|
||||
cutthroat: 'Cutthroat',
|
||||
};
|
||||
return labels[name];
|
||||
}
|
||||
@@ -26,46 +26,3 @@ if (heroImage && lightbox) {
|
||||
if (e instanceof KeyboardEvent && e.key === 'Escape') close();
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Is a Station Master server actually behind this page?
|
||||
*
|
||||
* The same `dist/` ships two ways — served by `src/server/`, or uploaded as flat files with no
|
||||
* server at all (`scripts/deploy-web.ts`) — and the bundle is identical in both, so the only
|
||||
* honest way to answer is to ask. `/api/health` is the one route that exists to be failed.
|
||||
*
|
||||
* THE DOOR STARTS OPEN AND ONLY EVER CLOSES. Getting this wrong in the "no server" direction is
|
||||
* the bug this whole change exists to fix: a disabled door is invisible and leaves a player who
|
||||
* DOES have a server with no way in, and nothing on screen to explain it. Getting it wrong the
|
||||
* other way costs a click and a lobby that says it cannot reach a server — which is legible, and
|
||||
* recoverable. So a slow or flaky probe leaves the door alone; only a definite answer closes it.
|
||||
*/
|
||||
const mpDoor = document.getElementById('door-multiplayer');
|
||||
if (mpDoor) {
|
||||
const close = (): void => {
|
||||
mpDoor.classList.add('disabled');
|
||||
mpDoor.removeAttribute('href');
|
||||
const go = document.getElementById('door-multiplayer-go');
|
||||
if (go) go.textContent = 'Requires a Station Master server';
|
||||
const blurb = document.getElementById('door-multiplayer-blurb');
|
||||
if (blurb) {
|
||||
blurb.textContent =
|
||||
'Play with your friends across the internet, each running your own office area within the ' +
|
||||
'entire division. This copy of the game is a plain website with no server behind it, so ' +
|
||||
'there is nowhere to host a table — multiplayer needs a Station Master server.';
|
||||
}
|
||||
};
|
||||
|
||||
// Relative, never absolute: the page must work at whatever address it is reached by, and the
|
||||
// server is always the origin that served it (D16).
|
||||
void fetch('./api/health')
|
||||
.then((r) => (r.ok ? (r.json() as Promise<unknown>) : null))
|
||||
.then((body) => {
|
||||
// A static host that answers unknown paths with 200 and its own index page would sail past
|
||||
// an `r.ok` check, so the body has to name itself before the door is believed.
|
||||
const named =
|
||||
typeof body === 'object' && body !== null && (body as { service?: unknown }).service === 'station-master';
|
||||
if (!named) close();
|
||||
})
|
||||
.catch(() => close());
|
||||
}
|
||||
|
||||
+83
-610
@@ -8,23 +8,21 @@ import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import { advance, pump } from '../src/engine/advance.ts';
|
||||
import { applyIntent, areaOf, check, isBeingMadeUp } from '../src/engine/apply.ts';
|
||||
import { EXPEDITE_FAULT_PENALTY, HAND_LIMIT, MAX_CONSIST, STAGES_PER_DAY, TOTAL_ROLLING_STOCK } from '../src/engine/content.ts';
|
||||
import { applyIntent, areaOf, check } from '../src/engine/apply.ts';
|
||||
import { EXPEDITE_FAULT_PENALTY, HAND_LIMIT, STAGES_PER_DAY, lengthProfile, TOTAL_ROLLING_STOCK } from '../src/engine/content.ts';
|
||||
import { legalActions } from '../src/engine/legal.ts';
|
||||
import { createGame } from '../src/engine/setup.ts';
|
||||
import { developerBot } from '../src/sim/bot.ts';
|
||||
import type { CrewTray, DivisionNode, GameConfig, GameState } from '../src/engine/state.ts';
|
||||
import { coordKey, railFacingOf } from '../src/engine/state.ts';
|
||||
import type { CrewTray, GameConfig, GameState } from '../src/engine/state.ts';
|
||||
import { railFacingOf } from '../src/engine/state.ts';
|
||||
|
||||
const baseConfig = (over: Partial<GameConfig> = {}): GameConfig => ({
|
||||
mode: 'solitaire',
|
||||
days: 3,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
victory: 'highestAfterDays',
|
||||
length: 'short',
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -66,21 +64,6 @@ function playToCompletion(s: GameState, seed = 1, maxTurns = 20_000): PlayStats
|
||||
tally(pump(s));
|
||||
if (s.status === 'finished') break;
|
||||
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY (Gitea#11) — this harness plays the timetable it was dealt.
|
||||
*
|
||||
* It picks at random among legal options, and one of the two options here is "play another
|
||||
* Day" — so left alone it would extend the game forever and terminate only on `maxTurns`. That
|
||||
* is not a bug in the feature: a game genuinely does not end now until somebody says stop, and
|
||||
* `developerBot` says stop for exactly this reason. Said explicitly here rather than folded
|
||||
* into the random pick, because "how does this loop terminate" deserves an answer in the loop.
|
||||
*/
|
||||
if (s.status === 'awaitingExtension') {
|
||||
const r = applyIntent(s, 0, { type: 'game.extend', player: 0, agree: false });
|
||||
assert.ok(r.ok, 'a solitaire player could not decline an extension');
|
||||
break;
|
||||
}
|
||||
|
||||
const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
|
||||
if (actor === null) break;
|
||||
|
||||
@@ -344,75 +327,6 @@ describe('collisions are automatic (Gap 2)', () => {
|
||||
assert.ok(!s.trays.has(id), 'the train is removed');
|
||||
});
|
||||
|
||||
it('does not collide when a coach is legally parked at the Office (v0.5.0 §A.4 exception)', () => {
|
||||
// A coach may now be set out at the Office (§A.4's carve-out). It must not become a hazard to
|
||||
// the next train in — that would punish exactly the thing the rule was written to allow.
|
||||
const s = game();
|
||||
const area = s.officeAreas.get(0)!;
|
||||
area.adOccupancy = []; // an A/D track is free — only the fouling check is under test
|
||||
const officeCard = area.grid.get(coordKey(area.officeCoord))!;
|
||||
officeCard.standing = [{ type: 'coach', loaded: false }];
|
||||
|
||||
const id = 'inbound';
|
||||
s.trays.set(id, {
|
||||
id,
|
||||
trainNumber: 2,
|
||||
trainIsExtra: false,
|
||||
engineAt: 0,
|
||||
consist: [{ type: 'coach', loaded: true }],
|
||||
direction: 'east',
|
||||
position: { at: 'mainline', index: 1 },
|
||||
movesUsed: 0,
|
||||
});
|
||||
const ml = s.division.nodes[1];
|
||||
if (ml?.kind === 'mainline') {
|
||||
ml.card = 'plains';
|
||||
ml.transits.push({ tray: id, stagesRemaining: 1, stagesTotal: 1, direction: 'east' });
|
||||
}
|
||||
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
advance(s);
|
||||
|
||||
assert.equal(s.collisionsToday, 0, 'a legally parked coach is not a hazard to the next arrival');
|
||||
assert.ok(s.trays.has(id), 'the train is not written off');
|
||||
});
|
||||
|
||||
it('still collides when a non-coach car is left fouling the Office track', () => {
|
||||
// Reachable only by poking state directly — `canDropCarsAt` already refuses every non-coach
|
||||
// drop at the Office, so this backstops the collision check itself, not a state a legal game
|
||||
// can reach.
|
||||
const s = game();
|
||||
const area = s.officeAreas.get(0)!;
|
||||
area.adOccupancy = [];
|
||||
const officeCard = area.grid.get(coordKey(area.officeCoord))!;
|
||||
officeCard.standing = [{ type: 'boxcar', loaded: false }];
|
||||
|
||||
const id = 'inbound';
|
||||
s.trays.set(id, {
|
||||
id,
|
||||
trainNumber: 2,
|
||||
trainIsExtra: false,
|
||||
engineAt: 0,
|
||||
consist: [{ type: 'coach', loaded: true }],
|
||||
direction: 'east',
|
||||
position: { at: 'mainline', index: 1 },
|
||||
movesUsed: 0,
|
||||
});
|
||||
const ml = s.division.nodes[1];
|
||||
if (ml?.kind === 'mainline') {
|
||||
ml.card = 'plains';
|
||||
ml.transits.push({ tray: id, stagesRemaining: 1, stagesTotal: 1, direction: 'east' });
|
||||
}
|
||||
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
advance(s);
|
||||
|
||||
assert.equal(s.collisionsToday, 1);
|
||||
assert.ok(!s.trays.has(id), 'the train is removed');
|
||||
});
|
||||
|
||||
it('returns cabooses to the Division Yard and other stock to Classification (Gap 2c)', () => {
|
||||
const s = game();
|
||||
s.officeAreas.get(0)!.adOccupancy = ['blocker'];
|
||||
@@ -495,7 +409,7 @@ describe('the Superintendent clearance interrupt (§8.1)', () => {
|
||||
assert.equal(r.needsInput, true, 'the phase must stop and ask');
|
||||
assert.notEqual(s.clock.pendingDecision, null);
|
||||
assert.equal(s.clock.pendingDecision!.train, 'behind');
|
||||
assert.equal((s.clock.pendingDecision as { occupiedBy: string }).occupiedBy, 'ahead');
|
||||
assert.equal(s.clock.pendingDecision!.occupiedBy, 'ahead');
|
||||
});
|
||||
|
||||
it('does not ask when the train ahead is coming the other way — that is an absolute bar', () => {
|
||||
@@ -541,7 +455,7 @@ describe('the Superintendent clearance interrupt (§8.1)', () => {
|
||||
it('clears the decision once the Superintendent rules', () => {
|
||||
const s = game();
|
||||
s.clock.phase = 'mainline';
|
||||
s.clock.pendingDecision = { kind: 'clearance', train: 'a', occupiedBy: 'b' };
|
||||
s.clock.pendingDecision = { train: 'a', occupiedBy: 'b' };
|
||||
const r = applyIntent(s, 0, { type: 'mainline.clearance', allow: false });
|
||||
assert.ok(r.ok);
|
||||
assert.equal(s.clock.pendingDecision, null);
|
||||
@@ -550,119 +464,39 @@ describe('the Superintendent clearance interrupt (§8.1)', () => {
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('victory conditions (§3, Gap 10e) — unified 2026-08-20', () => {
|
||||
it('loses a timed Solitaire game that misses minCombinedRevenue', () => {
|
||||
// minCombinedRevenue doubles as a MINIMUM in Solitaire: below it you lose regardless of score.
|
||||
const s = game(1, { minCombinedRevenue: 10 });
|
||||
s.clock.day = s.config.days + 1;
|
||||
describe('victory conditions (§3, Gap 10e)', () => {
|
||||
it('loses a timed Solitaire game that misses the target', () => {
|
||||
// The target doubles as a MINIMUM in Solitaire: below it you lose regardless of score.
|
||||
const s = game(1);
|
||||
s.clock.day = lengthProfile('short').days + 1;
|
||||
s.clock.stage = STAGES_PER_DAY;
|
||||
s.clock.phase = 'shiftChange';
|
||||
s.players[0]!.revenue = 0;
|
||||
advance(s);
|
||||
// PAUSES rather than finishes since Gitea#11: a days-based ending offers another Day, and the
|
||||
// result is recorded either way. `official` is the frozen answer; `status` is only where play
|
||||
// has got to. The two collision tests at the foot of this block are the contrast.
|
||||
assert.equal(s.status, 'awaitingExtension');
|
||||
assert.equal(s.outcome!.result, 'loss');
|
||||
assert.equal(s.outcome!.reason, 'revenueFloor');
|
||||
assert.equal(s.official!.outcome.reason, 'revenueFloor');
|
||||
});
|
||||
|
||||
it('wins a timed Solitaire game that clears minCombinedRevenue', () => {
|
||||
const s = game(1, { minCombinedRevenue: 10 });
|
||||
s.clock.day = s.config.days + 1;
|
||||
s.clock.stage = STAGES_PER_DAY;
|
||||
s.clock.phase = 'shiftChange';
|
||||
s.players[0]!.revenue = 10;
|
||||
advance(s);
|
||||
assert.equal(s.status, 'awaitingExtension');
|
||||
assert.equal(s.outcome!.result, 'win');
|
||||
});
|
||||
|
||||
it('minCombinedRevenue = 0 disables the floor — any score wins once days run out', () => {
|
||||
const s = game(1, { minCombinedRevenue: 0 });
|
||||
s.clock.day = s.config.days + 1;
|
||||
s.clock.stage = STAGES_PER_DAY;
|
||||
s.clock.phase = 'shiftChange';
|
||||
s.players[0]!.revenue = 0;
|
||||
advance(s);
|
||||
assert.equal(s.status, 'awaitingExtension');
|
||||
assert.equal(s.outcome!.result, 'win');
|
||||
});
|
||||
|
||||
it('everyone loses in Competitive when the TABLE misses minCombinedRevenue, whoever scored best', () => {
|
||||
const s = createGame({
|
||||
id: 'g', seed: 2, config: baseConfig({ mode: 'competitive', minCombinedRevenue: 20 }),
|
||||
playerNames: ['A', 'B'],
|
||||
});
|
||||
s.clock.day = s.config.days + 1;
|
||||
s.clock.stage = STAGES_PER_DAY;
|
||||
s.clock.phase = 'shiftChange';
|
||||
s.players[0]!.revenue = 5; // best individual score...
|
||||
s.players[1]!.revenue = 3; // ...but combined (8) still misses the floor (20).
|
||||
advance(s);
|
||||
assert.equal(s.status, 'awaitingExtension');
|
||||
assert.equal(s.status, 'finished');
|
||||
assert.equal(s.outcome!.result, 'loss');
|
||||
assert.equal(s.outcome!.reason, 'revenueFloor');
|
||||
});
|
||||
|
||||
it('Co-op wins as one table score (summed Revenue), winner stays null', () => {
|
||||
const s = createGame({
|
||||
id: 'g', seed: 3, config: baseConfig({ mode: 'coop', minCombinedRevenue: 10 }),
|
||||
playerNames: ['A', 'B'],
|
||||
});
|
||||
s.clock.day = s.config.days + 1;
|
||||
it('wins a timed Solitaire game that clears the target', () => {
|
||||
const s = game(1);
|
||||
s.clock.day = lengthProfile('short').days + 1;
|
||||
s.clock.stage = STAGES_PER_DAY;
|
||||
s.clock.phase = 'shiftChange';
|
||||
s.players[0]!.revenue = 4;
|
||||
s.players[1]!.revenue = 6; // combined 10 clears the floor, neither alone would.
|
||||
s.players[0]!.revenue = lengthProfile('short').target;
|
||||
advance(s);
|
||||
assert.equal(s.status, 'awaitingExtension');
|
||||
assert.equal(s.status, 'finished');
|
||||
assert.equal(s.outcome!.result, 'win');
|
||||
assert.equal(s.outcome!.winner, null, 'Co-op names an individual winner instead of a shared one');
|
||||
});
|
||||
|
||||
it('ends immediately, mid-Stage, when collisions reach maxCollisionsPerDay', () => {
|
||||
// Competitive/coop only, and immediate — not gated on the day boundary the way the revenue
|
||||
// floor is. Stage 1, well short of STAGES_PER_DAY, proves it fires mid-day.
|
||||
const s = game(1, { mode: 'competitive', maxCollisionsPerDay: 2 });
|
||||
s.collisionsToday = 2;
|
||||
s.clock.stage = 1;
|
||||
it('ends a first-to-target game the moment the target is reached', () => {
|
||||
const s = game(1, { victory: 'firstToTarget' });
|
||||
s.players[0]!.revenue = lengthProfile('short').target;
|
||||
s.clock.stage = STAGES_PER_DAY;
|
||||
s.clock.phase = 'shiftChange';
|
||||
advance(s);
|
||||
assert.equal(s.status, 'finished');
|
||||
assert.equal(s.outcome!.result, 'loss');
|
||||
assert.equal(s.outcome!.reason, 'collisionFloor');
|
||||
});
|
||||
|
||||
it('ends immediately when the running total reaches maxCollisionsTotal, even under the per-day cap', () => {
|
||||
const s = game(1, { mode: 'coop', maxCollisionsPerDay: 0, maxCollisionsTotal: 3 });
|
||||
s.collisionsTotal = 3;
|
||||
s.clock.stage = 1;
|
||||
s.clock.phase = 'shiftChange';
|
||||
advance(s);
|
||||
assert.equal(s.status, 'finished');
|
||||
assert.equal(s.outcome!.reason, 'collisionFloor');
|
||||
});
|
||||
|
||||
it('maxCollisionsPerDay = 0 and maxCollisionsTotal = 0 disable the collision floor entirely', () => {
|
||||
const s = game(1, { mode: 'competitive', maxCollisionsPerDay: 0, maxCollisionsTotal: 0 });
|
||||
s.collisionsToday = 99;
|
||||
s.collisionsTotal = 99;
|
||||
s.clock.stage = 1;
|
||||
s.clock.phase = 'shiftChange';
|
||||
advance(s);
|
||||
assert.notEqual(s.status, 'finished');
|
||||
});
|
||||
|
||||
it('solitaire never checks the collision floor, whatever the counts', () => {
|
||||
const s = game(1, { mode: 'solitaire', maxCollisionsPerDay: 1, maxCollisionsTotal: 1 });
|
||||
s.collisionsToday = 99;
|
||||
s.collisionsTotal = 99;
|
||||
s.clock.stage = 1;
|
||||
s.clock.phase = 'shiftChange';
|
||||
advance(s);
|
||||
assert.notEqual(s.status, 'finished');
|
||||
assert.equal(s.outcome!.reason, 'targetReached');
|
||||
});
|
||||
});
|
||||
|
||||
@@ -749,156 +583,43 @@ describe('MILESTONE: a full solitaire game runs headless', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('X18 Circus / X17 Campaign — a point for setting up (Gitea#13)', () => {
|
||||
/**
|
||||
* REPORTED originally: "Circus train TX18 was stopped on a siding for a full Stage and I did not
|
||||
* get my Revenue point." It never could: `stopEarnsPoint` was declared on the profile and read
|
||||
* NOWHERE, along with eight other special-train rules.
|
||||
*
|
||||
* REDEFINED by Gitea#13 (Jesse, 2026-08-29), and these tests carry the three parts of that
|
||||
* ruling: the point is paid ONCE PER OFFICE AREA rather than once per game, only when the train
|
||||
* is FULLY LOADED, and only in an Office Area at all.
|
||||
*/
|
||||
const circusAt = (s: GameState, seat: number, coord: { row: number; col: number }, consist: unknown[]) => {
|
||||
describe('X18 Circus Train — a point for standing still', () => {
|
||||
it('pays once for a Stage spent stopped, and never again', () => {
|
||||
/**
|
||||
* REPORTED: "Circus train TX18 was stopped on a siding for a full Stage and I did not get my
|
||||
* Revenue point." It never could: `stopEarnsPoint` was declared on the profile and read
|
||||
* NOWHERE, along with eight other special-train rules. The one card in the deck that pays for
|
||||
* standing still paid nothing.
|
||||
*/
|
||||
const s = game();
|
||||
s.clock.phase = 'mainline';
|
||||
s.trays.set('circus', {
|
||||
id: 'circus', trainNumber: 18, trainIsExtra: true, engineAt: 0,
|
||||
consist, direction: 'east',
|
||||
position: { at: 'grid', seat, coord },
|
||||
consist: [], direction: 'east',
|
||||
position: { at: 'grid', seat: 0, coord: { row: -1, col: 0 } },
|
||||
movesUsed: 0,
|
||||
} as never);
|
||||
// A card under it, so the crew is somewhere real rather than off the grid.
|
||||
areaOf(s, seat as never).grid.set(`${coord.row},${coord.col}`, {
|
||||
areaOf(s, 0).grid.set('-1,0', {
|
||||
geometry: { kind: 'track', geometry: 'straight' },
|
||||
baseOperationalRail: true, standing: [], facility: null, modifiers: [], enhancements: [],
|
||||
} as never);
|
||||
};
|
||||
|
||||
const loaded = [
|
||||
{ type: 'boxcar', loaded: true },
|
||||
{ type: 'boxcar', loaded: true },
|
||||
{ type: 'coach', loaded: true },
|
||||
{ type: 'caboose', loaded: true },
|
||||
];
|
||||
|
||||
const runPhase = (s: GameState) => {
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
return pump(s);
|
||||
};
|
||||
|
||||
it('pays a fully loaded Circus for a Stage spent set up', () => {
|
||||
const s = game();
|
||||
circusAt(s, 0, { row: -1, col: 0 }, loaded);
|
||||
const before = s.players[0]!.revenue;
|
||||
const first = pump(s);
|
||||
assert.ok(
|
||||
pump(s).some((e) => e.type === 'trainStoodStill' && e.trainNumber === 18),
|
||||
first.some((e) => e.type === 'trainStoodStill' && e.trainNumber === 18),
|
||||
'the Circus Train stood still for a Stage and earned nothing',
|
||||
);
|
||||
assert.equal(s.players[0]!.revenue, before + 1, 'the point was not paid');
|
||||
});
|
||||
|
||||
it('pays once per Office Area, however long it parks there', () => {
|
||||
// "Once per stop in an office area" — a train that goes on standing in the same district does
|
||||
// not keep earning. This is the half that was already true, for a different reason.
|
||||
const s = game();
|
||||
circusAt(s, 0, { row: -1, col: 0 }, loaded);
|
||||
pump(s);
|
||||
assert.ok(!runPhase(s).some((e) => e.type === 'trainStoodStill'),
|
||||
'the Circus collected twice for the same set-up');
|
||||
assert.ok(!runPhase(s).some((e) => e.type === 'trainStoodStill'),
|
||||
'the Circus collected a third time for the same set-up');
|
||||
});
|
||||
|
||||
it('pays AGAIN in a different district — each player can be visited', () => {
|
||||
/**
|
||||
* The half that is new. "In a multiplayer game, each player could score if the circus stops in
|
||||
* their area" — so the claim is per seat, and a touring Circus is paid by each district it sets
|
||||
* up in. Before Gitea#13 this paid once per GAME and the second district got nothing.
|
||||
*/
|
||||
const s = createGame({
|
||||
id: 'g', seed: 5, config: baseConfig({ mode: 'competitive' }), playerNames: ['A', 'B'],
|
||||
});
|
||||
circusAt(s, 0, { row: -1, col: 0 }, loaded);
|
||||
pump(s);
|
||||
const paidFirst = s.players.map((p) => p.revenue);
|
||||
|
||||
// The same train, moved into the other player's district.
|
||||
const tray = s.trays.get('circus')!;
|
||||
areaOf(s, 1 as never).grid.set('-1,0', {
|
||||
geometry: { kind: 'track', geometry: 'straight' },
|
||||
baseOperationalRail: true, standing: [], facility: null, modifiers: [], enhancements: [],
|
||||
} as never);
|
||||
tray.position = { at: 'grid', seat: 1, coord: { row: -1, col: 0 } } as never;
|
||||
|
||||
assert.ok(runPhase(s).some((e) => e.type === 'trainStoodStill'),
|
||||
'the Circus set up in a second district and earned nothing');
|
||||
const owner = s.seating[1]!;
|
||||
assert.equal(
|
||||
s.players[owner]!.revenue,
|
||||
paidFirst[owner]! + 1,
|
||||
'the point did not go to whoever sits in the district it stopped in',
|
||||
);
|
||||
});
|
||||
|
||||
it('pays nothing when the cars are empty — "not much of a circus"', () => {
|
||||
const s = game();
|
||||
circusAt(s, 0, { row: -1, col: 0 }, [
|
||||
{ type: 'boxcar', loaded: false },
|
||||
{ type: 'coach', loaded: true },
|
||||
{ type: 'caboose', loaded: true },
|
||||
]);
|
||||
const before = s.players[0]!.revenue;
|
||||
assert.ok(!pump(s).some((e) => e.type === 'trainStoodStill'),
|
||||
'an empty car aboard still collected the set-up point');
|
||||
assert.equal(s.players[0]!.revenue, before, 'Revenue moved for a train that was not full');
|
||||
});
|
||||
|
||||
it('pays nothing to a train carrying nothing at all', () => {
|
||||
// `every` on an empty list is vacuously true, so the emptiest train of the lot is exactly the
|
||||
// one a careless test would pay.
|
||||
const s = game();
|
||||
circusAt(s, 0, { row: -1, col: 0 }, []);
|
||||
assert.ok(!pump(s).some((e) => e.type === 'trainStoodStill'),
|
||||
'a Circus carrying nothing was paid for setting up');
|
||||
});
|
||||
|
||||
it('pays nothing for standing out on the Mainline', () => {
|
||||
/**
|
||||
* It used to, and it misattributed the point: `playerAtSeat` needs a seat, there is none off
|
||||
* the grid, and the fallback handed it to PLAYER 0 wherever the train was standing. Jesse's
|
||||
* ruling scopes the rule to Office Areas, which removes the bug rather than patching it.
|
||||
*/
|
||||
const s = game();
|
||||
s.clock.phase = 'mainline';
|
||||
const index = s.division.nodes.findIndex((n) => n.kind === 'mainline');
|
||||
s.trays.set('circus', {
|
||||
id: 'circus', trainNumber: 18, trainIsExtra: true, engineAt: 0,
|
||||
consist: loaded, direction: 'east',
|
||||
position: { at: 'mainline', index },
|
||||
movesUsed: 0,
|
||||
} as never);
|
||||
const before = s.players[0]!.revenue;
|
||||
pump(s);
|
||||
assert.equal(s.players[0]!.revenue, before, 'a Mainline set-up paid a point');
|
||||
});
|
||||
|
||||
it('pays the Campaign Train only when its candidate is aboard', () => {
|
||||
// X17 carries one coach and no freight, so "fully loaded" is exactly "the coach is occupied".
|
||||
// It earned nothing at all before Gitea#13 — it had `stopThenExpedite` and no scoring rule.
|
||||
const occupied = game();
|
||||
circusAt(occupied, 0, { row: -1, col: 0 }, [{ type: 'coach', loaded: true }]);
|
||||
occupied.trays.get('circus')!.trainNumber = 17;
|
||||
const beforeOccupied = occupied.players[0]!.revenue;
|
||||
pump(occupied);
|
||||
assert.equal(occupied.players[0]!.revenue, beforeOccupied + 1, 'a full Campaign Train earned nothing');
|
||||
|
||||
const empty = game();
|
||||
circusAt(empty, 0, { row: -1, col: 0 }, [{ type: 'coach', loaded: false }]);
|
||||
empty.trays.get('circus')!.trainNumber = 17;
|
||||
const beforeEmpty = empty.players[0]!.revenue;
|
||||
pump(empty);
|
||||
assert.equal(empty.players[0]!.revenue, beforeEmpty, 'an empty Campaign Train was paid for its speech');
|
||||
// "One turn stopped" — once. A train that goes on standing there does not keep earning.
|
||||
const paidAgain = () => {
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
return pump(s).some((e) => e.type === 'trainStoodStill');
|
||||
};
|
||||
assert.ok(!paidAgain(), 'the Circus Train collected a second time for the same set-up');
|
||||
});
|
||||
});
|
||||
|
||||
@@ -987,7 +708,7 @@ describe('the history says WHY a train moved, and says it truthfully', () => {
|
||||
* which deadlocks the moment Local Operations wants an option chosen before it can be ended.
|
||||
*/
|
||||
const phasesWith = (trainNumber: number): { localOps: number; loadUnload: number; leftIn: string } => {
|
||||
const s = game(7, { days: 5 });
|
||||
const s = game(7, { length: 'standard' });
|
||||
for (const n of s.division.nodes) if (n.kind === 'mainline') n.card = 'plains';
|
||||
/**
|
||||
* A DIVISION WITH NOTHING ELSE ON IT. §8.1 can still hold any train, Expedited or not, on a
|
||||
@@ -1078,7 +799,7 @@ describe('the history says WHY a train moved, and says it truthfully', () => {
|
||||
// What Expedite actually restricts now: not WHEN the train leaves, but WHERE it may be left
|
||||
// standing in the meantime. Parked on Secondary Track — cleared there to make way for other
|
||||
// switching, say — it must not still be there when the next Mainline Phase begins.
|
||||
const s = game(7, { days: 5 });
|
||||
const s = game(7, { length: 'standard' });
|
||||
const area = areaOf(s, 0);
|
||||
const id = 'expedited';
|
||||
const secondary = { row: area.officeCoord.row, col: area.officeCoord.col + 1 };
|
||||
@@ -1106,7 +827,7 @@ describe('the history says WHY a train moved, and says it truthfully', () => {
|
||||
it('does not fault an Expedited train legitimately held at the station itself', () => {
|
||||
// A train sitting on the Office square is not "left" anywhere — including one §8.1 is holding
|
||||
// for a same-direction meet, which is an ordinary hold, not a Station Master failure.
|
||||
const s = game(7, { days: 5 });
|
||||
const s = game(7, { length: 'standard' });
|
||||
const area = areaOf(s, 0);
|
||||
const id = 'expedited';
|
||||
s.trays.set(id, {
|
||||
@@ -1151,25 +872,19 @@ describe('the history says WHY a train moved, and says it truthfully', () => {
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('an Extra starts where the player puts it (Gitea#4)', () => {
|
||||
describe('an Extra starts where its number sends it, or at a Control Point', () => {
|
||||
/**
|
||||
* REPORTED, v0.4.9e: "When extras are played the player doing so may choose where the extra
|
||||
* starts. They may choose either division point. And if the interchange mainline card has been
|
||||
* played, they may start the extra on that card and choose the direction from there. If there is
|
||||
* potential for conflict with other trains in that area the superintendent may hold the extra."
|
||||
* REPORTED: "Extras should start at Eastern or Western Division point based on their numbers. Even
|
||||
* trains run to the east (start at western DP), odd run to the west (start at eastern DP). They
|
||||
* can also start at a control point (any office except whistlepost) at player's choice."
|
||||
*
|
||||
* This SUPERSEDES the earlier ruling these tests used to assert — "the number decides, like
|
||||
* everything else on the timetable" — for Extras only. The number still decides for a timetabled
|
||||
* train. The reason the two cannot both hold: an odd (westbound) Extra placed at the WEST end
|
||||
* would leave the Division on its first move having crossed nothing, and be paid for the run.
|
||||
*
|
||||
* So: the start decides the direction. A Division Point runs the train away from itself; in the
|
||||
* middle of the railroad — an Interchange, a Control Point — the player says which way.
|
||||
* Every Extra used to launch eastbound from the West Division Point, hardcoded, with the
|
||||
* simplification flagged in a comment — so half the Extras ran the wrong way and the Control Point
|
||||
* option did not exist at all.
|
||||
*/
|
||||
const pending = (trainNumber: number, tier?: 'depot' | 'station'): GameState => {
|
||||
const s = game(11);
|
||||
// Queued by seat 0, who is therefore the one §7 lets place it.
|
||||
s.pendingExtras = [{ trainNumber, player: 0 }];
|
||||
s.pendingExtras = [trainNumber];
|
||||
s.timetable = s.timetable.map(() => null);
|
||||
if (tier) s.officeAreas.get(0)!.tier = tier;
|
||||
s.clock.phase = 'newTrain';
|
||||
@@ -1183,14 +898,6 @@ describe('an Extra starts where the player puts it (Gitea#4)', () => {
|
||||
return tray;
|
||||
};
|
||||
|
||||
/** Turn one Mainline card into an Interchange, and say which node it is. */
|
||||
const withInterchange = (s: GameState): number => {
|
||||
const i = s.division.nodes.findIndex((n) => n.kind === 'mainline');
|
||||
const node = s.division.nodes[i]!;
|
||||
if (node.kind === 'mainline') node.card = 'interchange';
|
||||
return i;
|
||||
};
|
||||
|
||||
it('stops for the decision instead of launching the train itself', () => {
|
||||
const s = pending(17);
|
||||
assert.equal(s.clock.phase, 'newTrain');
|
||||
@@ -1201,46 +908,36 @@ describe('an Extra starts where the player puts it (Gitea#4)', () => {
|
||||
);
|
||||
});
|
||||
|
||||
it('offers BOTH Division Points, not the one the number would dictate', () => {
|
||||
it('sends an odd Extra west from the EASTERN Division Point', () => {
|
||||
// §2.3 — odd runs west. It therefore starts at the end it runs away from.
|
||||
const s = pending(17);
|
||||
const sides = legalActions(s, 0)
|
||||
.filter((i) => i.type === 'newTrain.startExtra' && i.start?.kind === 'divisionPoint')
|
||||
.map((i) => (i.type === 'newTrain.startExtra' && i.start?.kind === 'divisionPoint' ? i.start.side : ''));
|
||||
assert.deepEqual([...sides].sort(), ['east', 'west']);
|
||||
assert.ok(applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 17, atSeat: null }).ok);
|
||||
const tray = started(s);
|
||||
assert.equal(tray.direction, 'west');
|
||||
assert.equal(tray.position.at === 'divisionPoint' && tray.position.side, 'east');
|
||||
});
|
||||
|
||||
it('runs an Extra AWAY from the Division Point it was placed at, whatever its number', () => {
|
||||
// X17 is odd. Under the superseded rule it could only ever start at the East end and run west.
|
||||
for (const [side, direction] of [['west', 'east'], ['east', 'west']] as const) {
|
||||
const s = pending(17);
|
||||
const r = applyIntent(s, 0, {
|
||||
type: 'newTrain.startExtra', trainNumber: 17, start: { kind: 'divisionPoint', side },
|
||||
});
|
||||
assert.ok(r.ok, `the ${side} Division Point was refused: ${r.ok ? '' : r.code}`);
|
||||
const tray = started(s);
|
||||
assert.equal(tray.direction, direction, `an Extra at the ${side} end must run ${direction}`);
|
||||
assert.equal(tray.position.at === 'divisionPoint' && tray.position.side, side);
|
||||
}
|
||||
it('sends an even Extra east from the WESTERN Division Point', () => {
|
||||
const s = pending(18);
|
||||
assert.ok(applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, atSeat: null }).ok);
|
||||
const tray = started(s);
|
||||
assert.equal(tray.direction, 'east');
|
||||
assert.equal(tray.position.at === 'divisionPoint' && tray.position.side, 'west');
|
||||
});
|
||||
|
||||
it('refuses a Whistle Post, which is not a Control Point, at every setting of the house rule', () => {
|
||||
for (const extraStart of ['divisionPointsOnly', 'ownOffice', 'anyOffice'] as const) {
|
||||
const s = pending(18);
|
||||
s.config = { ...s.config, houseRules: { ...s.config.houseRules, extraStart } };
|
||||
assert.equal(s.officeAreas.get(0)!.tier, 'whistlePost');
|
||||
const code = check(s, 0, {
|
||||
type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 }, direction: 'east',
|
||||
});
|
||||
assert.ok(code !== null, `a Whistle Post was allowed under ${extraStart}`);
|
||||
}
|
||||
it('refuses a Whistle Post, which is not a Control Point', () => {
|
||||
const s = pending(18);
|
||||
assert.equal(s.officeAreas.get(0)!.tier, 'whistlePost');
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, atSeat: 0 }),
|
||||
'NOT_A_CONTROL_POINT',
|
||||
);
|
||||
});
|
||||
|
||||
it('starts at a Control Point when the player picks one, taking an A/D track', () => {
|
||||
// Upgrading the Office is what buys this: a Depot is a Control Point, a Whistle Post is not.
|
||||
const s = pending(18, 'depot');
|
||||
const r = applyIntent(s, 0, {
|
||||
type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 }, direction: 'west',
|
||||
});
|
||||
const r = applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, atSeat: 0 });
|
||||
assert.ok(r.ok, `starting at the Depot was refused: ${r.ok ? '' : r.code}`);
|
||||
const tray = started(s);
|
||||
const area = s.officeAreas.get(0)!;
|
||||
@@ -1251,240 +948,16 @@ describe('an Extra starts where the player puts it (Gitea#4)', () => {
|
||||
'the Extra did not start on the Office card',
|
||||
);
|
||||
assert.ok(area.adOccupancy.includes(tray.id), 'it did not take an A/D track');
|
||||
// The point of the change: an EVEN Extra running WEST, because the player said so.
|
||||
assert.equal(tray.direction, 'west', 'the direction the player chose was not honoured');
|
||||
});
|
||||
|
||||
it('needs a direction anywhere that is not an end of the Division', () => {
|
||||
const s = pending(18, 'depot');
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 } }),
|
||||
'NO_DIRECTION_CHOSEN',
|
||||
);
|
||||
});
|
||||
|
||||
it('honours the extraStart house rule for Office starts, and never for the shared ground', () => {
|
||||
for (const [extraStart, code] of [
|
||||
['divisionPointsOnly', 'OFFICE_STARTS_NOT_ALLOWED'],
|
||||
['anyOffice', null],
|
||||
] as const) {
|
||||
const s = pending(18, 'depot');
|
||||
s.config = { ...s.config, houseRules: { ...s.config.houseRules, extraStart } };
|
||||
assert.equal(
|
||||
check(s, 0, {
|
||||
type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 }, direction: 'east',
|
||||
}),
|
||||
code,
|
||||
`office start under ${extraStart}`,
|
||||
);
|
||||
// The Division Points belong to nobody, so no setting ever closes them.
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'divisionPoint', side: 'west' } }),
|
||||
null,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
it('starts at an Interchange in the players yard, not out on the running line', () => {
|
||||
const s = pending(18);
|
||||
const node = withInterchange(s);
|
||||
const r = applyIntent(s, 0, {
|
||||
type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east',
|
||||
});
|
||||
assert.ok(r.ok, `the Interchange was refused: ${r.ok ? '' : r.code}`);
|
||||
const tray = started(s);
|
||||
const card = s.division.nodes[node]!;
|
||||
assert.equal(tray.direction, 'east');
|
||||
assert.deepEqual(tray.position, { at: 'mainline', index: node });
|
||||
assert.ok(card.kind === 'mainline' && card.holding?.includes(tray.id), 'it is not in the yard');
|
||||
assert.equal(card.kind === 'mainline' && card.transits.length, 0, 'it was put on the running line');
|
||||
});
|
||||
|
||||
it('refuses any Mainline card that is not an Interchange', () => {
|
||||
const s = pending(18);
|
||||
const plains = s.division.nodes.findIndex((n) => n.kind === 'mainline');
|
||||
const node = s.division.nodes[plains]!;
|
||||
if (node.kind === 'mainline') node.card = 'plains';
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node: plains }, direction: 'east' }),
|
||||
'NOT_AN_INTERCHANGE',
|
||||
);
|
||||
});
|
||||
|
||||
it('may be started at an Interchange however busy the card is — the yard forces no collision', () => {
|
||||
const s = pending(18);
|
||||
const node = withInterchange(s);
|
||||
const card = s.division.nodes[node]!;
|
||||
// Nose to tail with opposing traffic. §7: placing here still must not force a collision.
|
||||
if (card.kind === 'mainline') {
|
||||
card.transits.push({ tray: 'tray9', stagesRemaining: 2, stagesTotal: 2, direction: 'west' });
|
||||
}
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east' }),
|
||||
null,
|
||||
);
|
||||
});
|
||||
|
||||
/**
|
||||
* §7's last clause, and the reason the Interchange start is modelled as a yard at all: "If there
|
||||
* is potential for conflict with other trains in that area the superintendent may hold the extra."
|
||||
*
|
||||
* Jesse's split: a GUARANTEED collision holds the train at the Interchange for another Stage and
|
||||
* it tries again; a POTENTIAL one is the Superintendent's to rule on. Those are exactly §8.1's
|
||||
* two answers, so the Extra highballs out of the yard through `evaluateClearance` — the same
|
||||
* check a train leaving a Division Point goes through — rather than through anything new.
|
||||
*/
|
||||
describe('highballing out of the Interchange yard', () => {
|
||||
/** A pending X18 sitting in the yard of an Interchange, with the terrain pinned. */
|
||||
const inYard = (): { s: GameState; node: number; tray: CrewTray } => {
|
||||
const s = pending(18);
|
||||
const node = withInterchange(s);
|
||||
const r = applyIntent(s, 0, {
|
||||
type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east',
|
||||
});
|
||||
assert.ok(r.ok, `the Interchange was refused: ${r.ok ? '' : r.code}`);
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
return { s, node, tray: started(s) };
|
||||
};
|
||||
|
||||
const card = (s: GameState, node: number): Extract<DivisionNode, { kind: 'mainline' }> => {
|
||||
const n = s.division.nodes[node]!;
|
||||
assert.equal(n.kind, 'mainline');
|
||||
return n as Extract<DivisionNode, { kind: 'mainline' }>;
|
||||
};
|
||||
|
||||
it('pulls out onto the card at the next Mainline Phase when the Subdivision is clear', () => {
|
||||
const { s, node, tray } = inYard();
|
||||
advance(s);
|
||||
const n = card(s, node);
|
||||
assert.deepEqual(n.holding, [], 'it never left the yard');
|
||||
assert.ok(n.transits.some((t) => t.tray === tray.id), 'it is not on the running line');
|
||||
});
|
||||
|
||||
it('is held in the yard by a facing train, and tries again the next Stage', () => {
|
||||
const { s, node, tray } = inYard();
|
||||
// Westbound, against an eastbound Extra: §8.1 calls that an absolute bar, not a judgment call.
|
||||
card(s, node).transits.push({ tray: 'facing', stagesRemaining: 2, stagesTotal: 2, direction: 'west' });
|
||||
s.trays.set('facing', {
|
||||
id: 'facing', trainNumber: 3, trainIsExtra: false, engineAt: 0, consist: [],
|
||||
direction: 'west', position: { at: 'mainline', index: node }, movesUsed: 0,
|
||||
});
|
||||
|
||||
const r = advance(s);
|
||||
assert.equal(r.needsInput ?? false, false, 'a guaranteed collision is not a question to ask');
|
||||
assert.equal(s.clock.pendingDecision, null);
|
||||
assert.ok(card(s, node).holding?.includes(tray.id), 'it was not held in the yard');
|
||||
assert.ok(
|
||||
!card(s, node).transits.some((t) => t.tray === tray.id),
|
||||
'it pulled out in front of a train coming the other way',
|
||||
);
|
||||
assert.ok(s.trays.has(tray.id), 'the Extra was destroyed rather than held');
|
||||
|
||||
// AND IT TRIES AGAIN. The Extra waits in the yard, not on the pending list, so once the road
|
||||
// clears the next Mainline Phase takes it out with no further intervention.
|
||||
s.trays.delete('facing');
|
||||
card(s, node).transits = [];
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
advance(s);
|
||||
assert.deepEqual(card(s, node).holding, [], 'it did not try again once the road was clear');
|
||||
assert.ok(card(s, node).transits.some((t) => t.tray === tray.id), 'it never pulled out');
|
||||
});
|
||||
|
||||
it('puts a following train to the Superintendent rather than holding it automatically', () => {
|
||||
const { s, node, tray } = inYard();
|
||||
// Same direction: §8.1's judgment call, which is what "may hold the extra" means.
|
||||
card(s, node).transits.push({ tray: 'ahead', stagesRemaining: 2, stagesTotal: 2, direction: 'east' });
|
||||
s.trays.set('ahead', {
|
||||
id: 'ahead', trainNumber: 4, trainIsExtra: false, engineAt: 0, consist: [],
|
||||
direction: 'east', position: { at: 'mainline', index: node }, movesUsed: 0,
|
||||
});
|
||||
|
||||
const r = advance(s);
|
||||
assert.equal(r.needsInput, true, 'the phase must stop and ask');
|
||||
assert.equal(s.clock.pendingDecision?.train, tray.id);
|
||||
assert.equal((s.clock.pendingDecision as { occupiedBy: string } | null)?.occupiedBy, 'ahead');
|
||||
|
||||
// HOLD keeps it in the yard.
|
||||
assert.ok(applyIntent(s, s.clock.superintendent, { type: 'mainline.clearance', allow: false }).ok);
|
||||
advance(s);
|
||||
assert.ok(card(s, node).holding?.includes(tray.id), 'the Superintendent held it and it left anyway');
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* FOUND BY PLAYING IT, not by the tests above: an Extra started anywhere but a Division Point was
|
||||
* never offered a car and ran empty.
|
||||
*
|
||||
* `isBeingMadeUp` asked only "is this tray standing at a Division Point", which was the whole
|
||||
* truth while that was the only place to build a train. The Control Point start has therefore
|
||||
* shipped since it was added with a train that could not be loaded, and the Interchange start
|
||||
* would have shipped the same way — against Jesse's report, which says an Extra started at the
|
||||
* Interchange "would be Loaded with cars".
|
||||
*/
|
||||
describe('an Extra started away from a Division Point can still be made up', () => {
|
||||
const fill = (s: GameState): string[] => {
|
||||
for (let i = 0; i < MAX_CONSIST + 1; i++) {
|
||||
const options = legalActions(s, s.clock.currentActor ?? 0).filter((a) => a.type === 'newTrain.placeCar');
|
||||
if (options.length === 0) break;
|
||||
assert.ok(applyIntent(s, s.clock.currentActor ?? 0, options[0]!).ok);
|
||||
}
|
||||
return started(s).consist.map((c) => c.type);
|
||||
};
|
||||
|
||||
it('takes a consist in the Interchange yard', () => {
|
||||
const s = pending(18);
|
||||
const node = withInterchange(s);
|
||||
assert.ok(applyIntent(s, 0, {
|
||||
type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east',
|
||||
}).ok);
|
||||
assert.ok(fill(s).length > 0, 'the Extra was never offered a car and would have run empty');
|
||||
});
|
||||
|
||||
it('takes a consist at a Control Point', () => {
|
||||
const s = pending(18, 'depot');
|
||||
assert.ok(applyIntent(s, 0, {
|
||||
type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 }, direction: 'east',
|
||||
}).ok);
|
||||
assert.ok(fill(s).length > 0, 'the Extra was never offered a car and would have run empty');
|
||||
});
|
||||
|
||||
it('stops being made up the moment it starts running', () => {
|
||||
// Otherwise a train out on the Mainline could be handed cars from the Division Yard — the
|
||||
// "cars appearing on a train nobody was making up" bug `isBeingMadeUp` exists to prevent.
|
||||
const s = pending(18);
|
||||
const node = withInterchange(s);
|
||||
assert.ok(applyIntent(s, 0, {
|
||||
type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east',
|
||||
}).ok);
|
||||
const tray = started(s);
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
advance(s);
|
||||
assert.equal(s.trays.get(tray.id)?.beingMadeUp, undefined, 'a running train is still being made up');
|
||||
assert.equal(isBeingMadeUp(s.trays.get(tray.id)!), false);
|
||||
});
|
||||
});
|
||||
|
||||
it('replays a save written before the choice existed exactly as it meant it', () => {
|
||||
/**
|
||||
* A save is a seed and a list of intents, so an intent whose meaning moves is a save that
|
||||
* quietly replays as a different game. The legacy shape carried only `atSeat`: null meant the
|
||||
* Division Point the NUMBER sent it to, running in the number's direction.
|
||||
*/
|
||||
const s = pending(17);
|
||||
assert.ok(applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 17, atSeat: null }).ok);
|
||||
const tray = started(s);
|
||||
assert.equal(tray.direction, 'west', 'the legacy intent stopped meaning what it meant');
|
||||
assert.equal(tray.position.at === 'divisionPoint' && tray.position.side, 'east');
|
||||
assert.equal(tray.direction, 'east', 'an even Extra still runs east from wherever it starts');
|
||||
});
|
||||
|
||||
it('takes the Extra off the pending list once, whichever end it started from', () => {
|
||||
const s = pending(17);
|
||||
const at = { type: 'newTrain.startExtra', trainNumber: 17, start: { kind: 'divisionPoint', side: 'east' } } as const;
|
||||
assert.ok(applyIntent(s, 0, at).ok);
|
||||
assert.ok(applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 17, atSeat: null }).ok);
|
||||
assert.deepEqual(s.pendingExtras, []);
|
||||
assert.equal(check(s, 0, at), 'NO_EXTRA_PENDING');
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'newTrain.startExtra', trainNumber: 17, atSeat: null }),
|
||||
'NO_EXTRA_PENDING',
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
+5
-191
@@ -7,7 +7,6 @@ import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import { applyIntent, check, areaOf, facilityCarTypes, movesFor, reduce } from '../src/engine/apply.ts';
|
||||
import { pump } from '../src/engine/advance.ts';
|
||||
import { HAND_LIMIT, INDUSTRY_PROFILES, MAX_CONSIST, MOVES_PER_LOCAL_OPS, officeProfile } from '../src/engine/content.ts';
|
||||
import type { Intent } from '../src/engine/intents.ts';
|
||||
import { legalActions } from '../src/engine/legal.ts';
|
||||
@@ -18,13 +17,11 @@ import { cardDescription, snapshot } from '../src/sim/view.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -262,189 +259,6 @@ describe('Local Operations: drawing (§6.2)', () => {
|
||||
assert.equal(check(s, 0, { type: 'draw.end' }), null, 'the turn cannot be ended even at the limit');
|
||||
});
|
||||
|
||||
describe('which train cards may be discarded (Gitea#9, superseding Gitea#6)', () => {
|
||||
/**
|
||||
* Gitea#6's ruling, v0.4.9e playtest, was that NO train card may be discarded. Gitea#9 narrows
|
||||
* it — Jesse, 2026-08-24: "Timetabled trains are at the choice of the player: they can either
|
||||
* play or discard. If someone else wants to pick it up, they are more than able to. The reason:
|
||||
* I don't want, if you decide to play a game longer than five days, to decide that maybe there
|
||||
* are too many trains, the stations are jammed, and the railroad doesn't need any more."
|
||||
*
|
||||
* So a Timetabled train is discardable, an EXTRA still is not — it never joins the timetable, so
|
||||
* it cannot be what jams it — and whether the Timetabled half applies is a New Game setting,
|
||||
* because the reasoning is about long games and a five-Day game may want Gitea#6's pressure.
|
||||
*
|
||||
* Note there is still no FORCING mechanism, and deliberately so: the corner is what the two
|
||||
* existing rules produce together whenever the setting is off.
|
||||
*/
|
||||
const handOf = (s: GameState, kinds: string[]): string[] => {
|
||||
// Hand-pick cards of the wanted kinds straight out of the catalogue, so the test does not
|
||||
// depend on what the shuffle happened to deal.
|
||||
const picked: string[] = [];
|
||||
for (const want of kinds) {
|
||||
for (const [id, card] of s.cards) {
|
||||
if (card.kind.kind !== want || picked.includes(id)) continue;
|
||||
picked.push(id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert.equal(picked.length, kinds.length, 'the catalogue is missing a card this test needs');
|
||||
s.decks.hands.set(0, picked);
|
||||
return picked;
|
||||
};
|
||||
|
||||
/** The same game with the setting turned off — Gitea#6's rule, still reachable. */
|
||||
const strictGame = (): GameState =>
|
||||
createGame({
|
||||
id: 'g',
|
||||
seed: 77,
|
||||
config: { ...config, houseRules: { ...(config.houseRules ?? {}), discardTimetabled: false } },
|
||||
playerNames: ['Jesse'],
|
||||
});
|
||||
|
||||
it('lets a Timetabled train be discarded, and still refuses an Extra', () => {
|
||||
const s = game();
|
||||
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
||||
const [timetabled, extra, track] = handOf(s, ['timetabledTrain', 'extraTrain', 'track']);
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'card.discard', cardId: timetabled!, toSlot: 0 }),
|
||||
null,
|
||||
'Gitea#9 allows this and it was refused',
|
||||
);
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'card.discard', cardId: extra!, toSlot: 0 }),
|
||||
'TRAINS_ARE_NEVER_DISCARDED',
|
||||
'an Extra never joins the timetable, so Gitea#9 does not reach it',
|
||||
);
|
||||
assert.equal(check(s, 0, { type: 'card.discard', cardId: track!, toSlot: 0 }), null);
|
||||
});
|
||||
|
||||
it('puts the discarded train where a rival can pick it up', () => {
|
||||
// The other half of the ruling — "if someone else wants to pick it up, they are more than able
|
||||
// to" — needed no machinery, because a discard already goes face-up onto a Department pile.
|
||||
const s = game();
|
||||
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
||||
const [timetabled] = handOf(s, ['timetabledTrain', 'track']);
|
||||
assert.ok(applyIntent(s, 0, { type: 'card.discard', cardId: timetabled!, toSlot: 1 }).ok);
|
||||
const pile = s.decks.departments[1]!;
|
||||
assert.equal(pile[pile.length - 1], timetabled, 'the train is not face-up on the pile');
|
||||
});
|
||||
|
||||
it('offers the discard as a legal action, so the bot can take it', () => {
|
||||
const s = game();
|
||||
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
||||
const [timetabled, extra] = handOf(s, ['timetabledTrain', 'extraTrain', 'track']);
|
||||
const offered = legalActions(s, 0).filter((i) => i.type === 'card.discard');
|
||||
assert.ok(
|
||||
offered.some((i) => i.type === 'card.discard' && i.cardId === timetabled),
|
||||
'a Timetabled train was not offered as a discard',
|
||||
);
|
||||
assert.ok(
|
||||
!offered.some((i) => i.type === 'card.discard' && i.cardId === extra),
|
||||
'an Extra was offered as a discard',
|
||||
);
|
||||
});
|
||||
|
||||
it('keeps Gitea#6 reachable when the setting is off', () => {
|
||||
const s = strictGame();
|
||||
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
||||
const [timetabled, extra, track] = handOf(s, ['timetabledTrain', 'extraTrain', 'track']);
|
||||
for (const id of [timetabled!, extra!]) {
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'card.discard', cardId: id, toSlot: 0 }),
|
||||
'TRAINS_ARE_NEVER_DISCARDED',
|
||||
);
|
||||
}
|
||||
assert.equal(check(s, 0, { type: 'card.discard', cardId: track!, toSlot: 0 }), null);
|
||||
});
|
||||
|
||||
it('leaves PLAYING a train as the only way out of a hand of four, setting off', () => {
|
||||
const s = strictGame();
|
||||
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
||||
const four = handOf(s, ['timetabledTrain', 'timetabledTrain', 'timetabledTrain', 'extraTrain']);
|
||||
assert.ok(four.length > HAND_LIMIT, 'this test needs a hand over the limit');
|
||||
|
||||
// Over the limit, so the turn cannot be ended...
|
||||
assert.equal(check(s, 0, { type: 'draw.end' }), 'HAND_LIMIT');
|
||||
// ...and not one of them may be discarded...
|
||||
for (const id of four) {
|
||||
assert.equal(check(s, 0, { type: 'card.discard', cardId: id, toSlot: 0 }), 'TRAINS_ARE_NEVER_DISCARDED');
|
||||
}
|
||||
// ...but playing one is always legal, so the player is never actually stuck.
|
||||
assert.equal(check(s, 0, { type: 'card.play', cardId: four[0]! }), null);
|
||||
assert.ok(applyIntent(s, 0, { type: 'card.play', cardId: four[0]! }).ok);
|
||||
assert.equal(s.decks.hands.get(0)!.length, HAND_LIMIT);
|
||||
assert.equal(check(s, 0, { type: 'draw.end' }), null, 'playing a train did not free the turn');
|
||||
});
|
||||
|
||||
it('a hand of four Extras is the corner that survives Gitea#9 with the setting ON', () => {
|
||||
// Gitea#9 does not reach an Extra, so the deadlock-that-is-not-a-deadlock is still real in a
|
||||
// default game — worth pinning, since it is now the ONLY way to reach it.
|
||||
const s = game();
|
||||
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
||||
const four = handOf(s, ['extraTrain', 'extraTrain', 'extraTrain', 'extraTrain']);
|
||||
assert.equal(check(s, 0, { type: 'draw.end' }), 'HAND_LIMIT');
|
||||
for (const id of four) {
|
||||
assert.equal(check(s, 0, { type: 'card.discard', cardId: id, toSlot: 0 }), 'TRAINS_ARE_NEVER_DISCARDED');
|
||||
}
|
||||
assert.ok(applyIntent(s, 0, { type: 'card.play', cardId: four[0]! }).ok);
|
||||
assert.equal(check(s, 0, { type: 'draw.end' }), null);
|
||||
});
|
||||
|
||||
it('lets a train be held across Stages and into the next Day', () => {
|
||||
// "They may keep the card in their hand for multiple stages and even multiple days." Nothing
|
||||
// sweeps a hand at a Stage or Day boundary, and this is what says so out loud. An Extra is
|
||||
// used, because it is the card that still cannot be got rid of any other way.
|
||||
const s = game();
|
||||
const [extra] = handOf(s, ['extraTrain', 'track']);
|
||||
const startDay = s.clock.day;
|
||||
|
||||
// Play out Stages by taking whatever ends the current turn, until the Day turns over.
|
||||
for (let guard = 0; guard < 400 && s.clock.day === startDay; guard++) {
|
||||
pump(s);
|
||||
const actor = s.clock.currentActor;
|
||||
if (actor === null) break;
|
||||
const options = legalActions(s, actor);
|
||||
const end = options.find((i) => i.type.endsWith('.end')) ?? options[0];
|
||||
if (!end) break;
|
||||
applyIntent(s, actor, end);
|
||||
}
|
||||
|
||||
assert.ok(s.clock.day > startDay, `the Day never turned (stopped at ${s.clock.day}/${s.clock.stage})`);
|
||||
assert.ok(
|
||||
(s.decks.hands.get(0) ?? []).includes(extra!),
|
||||
'the train did not survive being held into the next Day',
|
||||
);
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'card.discard', cardId: extra!, toSlot: 0 }),
|
||||
'TRAINS_ARE_NEVER_DISCARDED',
|
||||
'a Day boundary made an Extra discardable',
|
||||
);
|
||||
});
|
||||
|
||||
it('tells the player on the card itself which of the two rules applies', () => {
|
||||
// The Gitea#2 lesson: a rule the player cannot see is a board with nothing to click and no
|
||||
// reason given. Since Gitea#9 there are TWO reasons, so the card has to say which.
|
||||
const s = game();
|
||||
handOf(s, ['timetabledTrain', 'extraTrain', 'track']);
|
||||
const f = snapshot(s, [], null);
|
||||
// `hand` is reversed for display, so compare as a set rather than by position.
|
||||
assert.deepEqual([...f.handDiscardable].sort(), [false, true, true]);
|
||||
const said = f.handKeepWhy.filter((w): w is string => w !== null);
|
||||
assert.equal(said.length, 1, 'exactly one card in this hand may not be discarded');
|
||||
assert.match(said[0]!, /An Extra is never discarded/);
|
||||
|
||||
const strict = strictGame();
|
||||
handOf(strict, ['timetabledTrain', 'extraTrain', 'track']);
|
||||
const sf = snapshot(strict, [], null);
|
||||
assert.deepEqual([...sf.handDiscardable].sort(), [false, false, true]);
|
||||
assert.ok(
|
||||
sf.handKeepWhy.some((w) => w !== null && /never discarded in this game/.test(w)),
|
||||
'the setting being off is not explained on the card',
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it('discards face up ON TOP of a chosen Department, burying what was there', () => {
|
||||
// The choice of WHICH Department is the strategy: a card put on an empty-ish pile is an offer, a
|
||||
// card put on top of one a rival wants takes that card out of reach. Overwriting the slot — what
|
||||
@@ -956,7 +770,7 @@ describe('the Superintendent clearance ruling (§8.1)', () => {
|
||||
const s = game();
|
||||
s.clock.phase = 'mainline';
|
||||
s.clock.currentActor = null; // nobody's turn — yet the Superintendent must still rule
|
||||
s.clock.pendingDecision = { kind: 'clearance', train: 'tray0', occupiedBy: 'tray1' };
|
||||
s.clock.pendingDecision = { train: 'tray0', occupiedBy: 'tray1' };
|
||||
const r = applyIntent(s, 0, { type: 'mainline.clearance', allow: false });
|
||||
assert.ok(r.ok);
|
||||
assert.equal(s.clock.pendingDecision, null);
|
||||
@@ -964,7 +778,7 @@ describe('the Superintendent clearance ruling (§8.1)', () => {
|
||||
|
||||
it('is refused to a player who is not the Superintendent', () => {
|
||||
const s = game();
|
||||
s.clock.pendingDecision = { kind: 'clearance', train: 'tray0', occupiedBy: 'tray1' };
|
||||
s.clock.pendingDecision = { train: 'tray0', occupiedBy: 'tray1' };
|
||||
s.clock.superintendent = 1;
|
||||
assert.equal(check(s, 0, { type: 'mainline.clearance', allow: true }), 'NOT_SUPERINTENDENT');
|
||||
});
|
||||
|
||||
@@ -13,18 +13,16 @@ 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, TrackArc, TrackCard } from '../src/engine/state.ts';
|
||||
import type { CrewTray, GameConfig, GameState, GridCoord, RollingStock, TrackCard } from '../src/engine/state.ts';
|
||||
import { carsOn, coordKey, turnOf } from '../src/engine/state.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -53,18 +51,12 @@ 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: 'n' | 's' | 'e' | 'w',
|
||||
facing: 'e' | 'w',
|
||||
engineAt = 0,
|
||||
railFacing: 'e' | 'w' = facing === 'w' ? 'w' : 'e',
|
||||
): string {
|
||||
const id = s.freeTrays.pop()!;
|
||||
s.trays.set(id, {
|
||||
@@ -73,9 +65,9 @@ function placeTray(
|
||||
trainIsExtra: false,
|
||||
engineAt,
|
||||
consist,
|
||||
direction: railFacing === 'w' ? 'west' : 'east',
|
||||
direction: facing === 'w' ? 'west' : 'east',
|
||||
facing,
|
||||
railFacing,
|
||||
railFacing: facing,
|
||||
position: { at: 'grid', seat: 0, coord },
|
||||
movesUsed: 0,
|
||||
} as CrewTray);
|
||||
@@ -379,85 +371,3 @@ 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');
|
||||
});
|
||||
});
|
||||
|
||||
+8
-118
@@ -14,16 +14,13 @@ import { applyIntent, areaOf, check, hasDistrictEnhancement, isProtectedFromDera
|
||||
import { ENHANCEMENT_RULES, enhancementRule, trainProfile } from '../src/engine/content.ts';
|
||||
import { createGame } from '../src/engine/setup.ts';
|
||||
import type { GameConfig, GameState, GridCoord, TrackCard } from '../src/engine/state.ts';
|
||||
import { coordKey, decisionActor, subdivisions, turnOf } from '../src/engine/state.ts';
|
||||
import { coordKey, subdivisions, turnOf } from '../src/engine/state.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
|
||||
};
|
||||
const game = (seed = 5): GameState => createGame({ id: 'g', seed, config, playerNames: ['p'] });
|
||||
const at = (row: number, col: number): GridCoord => ({ row, col });
|
||||
@@ -287,124 +284,17 @@ describe('Interlocking and Yard Office relieve the Office', () => {
|
||||
assert.equal(s.players[0]!.revenue, -5);
|
||||
});
|
||||
|
||||
/**
|
||||
* §11, THE YARD OFFICE (Gitea#5) — offered, not imposed, and only down a route that exists.
|
||||
*
|
||||
* Jesse: "you have to ask if non-coach trains wish to go in there, rather than to the office",
|
||||
* "if the Yard Office is not accessible in one move, you should not get the option", and cars on
|
||||
* the way in "result in a crash". All three were missing: the train was teleported onto the card.
|
||||
*/
|
||||
const answer = (s: GameState, take: boolean) => {
|
||||
const who = decisionActor(s);
|
||||
assert.notEqual(who, null, 'nothing was pending, so there was nothing to answer');
|
||||
const r = applyIntent(s, who!, { type: 'mainline.yardOffice', take });
|
||||
assert.ok(r.ok, 'the district owner could not answer the Yard Office offer');
|
||||
advance(s);
|
||||
};
|
||||
|
||||
it('OFFERS the Yard Office to the district owner rather than diverting automatically', () => {
|
||||
it('diverts a coachless train to the Yard Office', () => {
|
||||
const s = game();
|
||||
const card = straight();
|
||||
card.enhancements.push('yardOffice');
|
||||
addCard(s, at(0, 2), card);
|
||||
addCard(s, at(-1, 0), card);
|
||||
const id = inbound(s, [{ type: 'hopper', loaded: true }]);
|
||||
|
||||
advance(s);
|
||||
assert.equal(s.clock.pendingDecision?.kind, 'yardOffice', 'the phase did not stop to ask');
|
||||
assert.equal(decisionActor(s), 0, 'the question went to the wrong player');
|
||||
const pos = s.trays.get(id)!.position;
|
||||
assert.ok(pos.at !== 'grid' || pos.coord.col !== 2, 'the train moved before anyone answered');
|
||||
});
|
||||
|
||||
it('takes the Yard Office when the owner says yes', () => {
|
||||
const s = game();
|
||||
const card = straight();
|
||||
card.enhancements.push('yardOffice');
|
||||
addCard(s, at(0, 2), card);
|
||||
const id = inbound(s, [{ type: 'hopper', loaded: true }]);
|
||||
|
||||
advance(s);
|
||||
answer(s, true);
|
||||
const pos = s.trays.get(id)!.position;
|
||||
assert.ok(pos.at === 'grid' && pos.coord.col === 2, 'did not arrive at the Yard Office');
|
||||
assert.ok(!areaOf(s, 0).adOccupancy.includes(id), 'took an A/D track anyway');
|
||||
assert.equal(s.players[0]!.revenue, 0, 'a clear lead should not have collided');
|
||||
});
|
||||
|
||||
it('goes to the Train Order Office when the owner says no', () => {
|
||||
// "They can of course still choose to have the train go to the standard office."
|
||||
const s = game();
|
||||
const card = straight();
|
||||
card.enhancements.push('yardOffice');
|
||||
addCard(s, at(0, 2), card);
|
||||
const id = inbound(s, [{ type: 'hopper', loaded: true }]);
|
||||
|
||||
advance(s);
|
||||
answer(s, false);
|
||||
assert.ok(areaOf(s, 0).adOccupancy.includes(id), 'declining did not put it on an A/D track');
|
||||
});
|
||||
|
||||
it('does not offer what cannot be reached, and says why in the history', () => {
|
||||
/**
|
||||
* Jesse, 2026-08-29: "make sure this is logged in history — why can't move so user knows why
|
||||
* they can't get to yard." A silent absence is indistinguishable from a broken feature, which
|
||||
* is how the missing reachability check survived this long.
|
||||
*/
|
||||
const s = game();
|
||||
const card = straight();
|
||||
card.enhancements.push('yardOffice');
|
||||
// Far off the Running Track, with nothing laid between: no route in one move.
|
||||
addCard(s, at(3, 4), card);
|
||||
inbound(s, [{ type: 'hopper', loaded: true }]);
|
||||
|
||||
const events = advance(s).events;
|
||||
assert.equal(s.clock.pendingDecision, null, 'offered a Yard Office it cannot reach');
|
||||
const said = events.find(
|
||||
(e) => e.type === 'trainDiverted' && e.reason.includes('could not be offered'),
|
||||
);
|
||||
assert.ok(said, `nothing in the history explains why:\n${JSON.stringify(events, null, 1)}`);
|
||||
assert.match(
|
||||
(said as { reason: string }).reason,
|
||||
/one move/,
|
||||
'the reason does not say it is out of reach in one move',
|
||||
);
|
||||
});
|
||||
|
||||
it('offers a fouled lead, and taking it collides', () => {
|
||||
/**
|
||||
* The third missing condition. "Just like other trains finding cars on the tracks you use to
|
||||
* get into either result in a crash" — and Jesse's ruling keeps the OFFER: a route that exists
|
||||
* is offered, and the consequence of taking it is the player's. §8.3 already reads cars in the
|
||||
* path of an arriving train as a collision rather than a coupling.
|
||||
*/
|
||||
const s = game();
|
||||
const card = straight();
|
||||
card.enhancements.push('yardOffice');
|
||||
addCard(s, at(0, 2), card);
|
||||
// A car standing on the lead between the Office and the yard.
|
||||
areaOf(s, 0).grid.get(coordKey(at(0, 1)))!.standing = [{ type: 'boxcar', loaded: false }];
|
||||
const id = inbound(s, [{ type: 'hopper', loaded: true }]);
|
||||
|
||||
advance(s);
|
||||
assert.equal(s.clock.pendingDecision?.kind, 'yardOffice', 'a fouled lead was not offered at all');
|
||||
|
||||
answer(s, true);
|
||||
assert.equal(s.players[0]!.revenue, -5, 'running through standing cars did not collide');
|
||||
assert.ok(!s.trays.has(id), 'the train survived the collision');
|
||||
});
|
||||
|
||||
it('declining a fouled lead is safe — the standard Office is unaffected', () => {
|
||||
const s = game();
|
||||
const card = straight();
|
||||
card.enhancements.push('yardOffice');
|
||||
addCard(s, at(0, 2), card);
|
||||
areaOf(s, 0).grid.get(coordKey(at(0, 1)))!.standing = [{ type: 'boxcar', loaded: false }];
|
||||
const id = inbound(s, [{ type: 'hopper', loaded: true }]);
|
||||
|
||||
advance(s);
|
||||
answer(s, false);
|
||||
assert.equal(s.players[0]!.revenue, 0, 'declining the Yard Office still cost a collision');
|
||||
assert.ok(areaOf(s, 0).adOccupancy.includes(id), 'the train did not reach the Office');
|
||||
assert.ok(pos.at === 'grid' && pos.coord.row === -1, 'arrived at the Yard Office');
|
||||
assert.ok(!areaOf(s, 0).adOccupancy.includes(id), 'did not take an A/D track');
|
||||
});
|
||||
|
||||
it('does not divert a train carrying coaches', () => {
|
||||
|
||||
@@ -48,18 +48,6 @@ const KNOWN_UNREDUCED = [
|
||||
'dispatchBonusUsed',
|
||||
'expediteFault',
|
||||
'phaseBegan',
|
||||
/**
|
||||
* §Q, Red Flags (Gitea#19). The flag comes down inside the phase driver as it stops a train, so
|
||||
* this is described rather than reduced like everything else here.
|
||||
*
|
||||
* ADDED DELIBERATELY, and it cost a bug first: the flag was originally taken down in a `reduce`
|
||||
* case, which never fires for an event `advance.ts` emits — so it stayed up and held every train
|
||||
* that came. That is precisely the failure this list exists to make visible.
|
||||
*/
|
||||
'redFlagSpent',
|
||||
// Employee Rotation moves `seating` in the phase driver and then describes what it did, which is
|
||||
// the pattern every entry on this list follows.
|
||||
'seatsRotated',
|
||||
'stageBegan',
|
||||
'trainArrived',
|
||||
'trainCompleted',
|
||||
|
||||
@@ -1,256 +0,0 @@
|
||||
/**
|
||||
* §3.3, EXTENDED PLAY — Gitea#11, "when game ends allow players to continue playing if they wish".
|
||||
*
|
||||
* The rule as Jesse specified it (2026-08-28), which is what these tests are written against:
|
||||
*
|
||||
* - the OFFICIAL result is decided at the original game length and never changes. "In a five-day
|
||||
* game, even if it's extended to eight or nine days, the winner and the official answer is the
|
||||
* winner at the end of five days";
|
||||
* - extending grants exactly ONE Day, and the question is put again at the end of it;
|
||||
* - solitaire: the player decides alone. Multiplayer: unanimous, and one refusal ends it there;
|
||||
* - only days-based endings offer it. A §3.4 collision breach is final, during an extended Day
|
||||
* just as during the regular game.
|
||||
*
|
||||
* The persistence half matters as much as the rules half: a save is `{ seed, config, history }`
|
||||
* replayed through the engine, so an extension that is not an INTENT does not survive a reload, an
|
||||
* Undo, or a server restart. `replays the extension` below is the test that pins that.
|
||||
*/
|
||||
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import { advance, pump } from '../src/engine/advance.ts';
|
||||
import { applyIntent, check } from '../src/engine/apply.ts';
|
||||
import { STAGES_PER_DAY } from '../src/engine/content.ts';
|
||||
import { legalActions } from '../src/engine/legal.ts';
|
||||
import { createGame } from '../src/engine/setup.ts';
|
||||
import { developerBot, playGame, randomBot } from '../src/sim/bot.ts';
|
||||
import type { GameConfig, GameState } from '../src/engine/state.ts';
|
||||
|
||||
const baseConfig = (over: Partial<GameConfig> = {}): GameConfig => ({
|
||||
mode: 'solitaire',
|
||||
days: 3,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
|
||||
...over,
|
||||
});
|
||||
|
||||
const game = (over: Partial<GameConfig> = {}, names = ['Jesse']): GameState =>
|
||||
createGame({ id: 'g', seed: 1, config: baseConfig(over), playerNames: names });
|
||||
|
||||
/** Parks a game on the last Stage of its final Day, so one `advance` runs the clock off the end. */
|
||||
function atTheEnd(s: GameState): GameState {
|
||||
s.clock.day = s.config.days + s.extraDays + 1;
|
||||
s.clock.stage = STAGES_PER_DAY;
|
||||
s.clock.phase = 'shiftChange';
|
||||
return s;
|
||||
}
|
||||
|
||||
describe('§3.3 extended play — the ending pauses rather than stopping (Gitea#11)', () => {
|
||||
it('offers another Day on a days-based ending, and records the result anyway', () => {
|
||||
const s = atTheEnd(game());
|
||||
advance(s);
|
||||
assert.equal(s.status, 'awaitingExtension', 'a days-based ending did not offer another Day');
|
||||
assert.ok(s.outcome, 'the result was not decided');
|
||||
assert.ok(s.official, 'the official result was not frozen');
|
||||
assert.equal(s.official!.day, s.config.days, 'the official Day is not the original game length');
|
||||
});
|
||||
|
||||
it('does NOT offer another Day after a collision breach — §3.4 is final', () => {
|
||||
const s = game({ mode: 'competitive', maxCollisionsPerDay: 2 });
|
||||
s.collisionsToday = 2;
|
||||
s.clock.stage = 1;
|
||||
s.clock.phase = 'shiftChange';
|
||||
advance(s);
|
||||
assert.equal(s.status, 'finished', 'a railroad declared unsafe offered to carry on');
|
||||
assert.equal(s.outcome!.reason, 'collisionFloor');
|
||||
});
|
||||
|
||||
it('refuses every ordinary intent while the extension question is open', () => {
|
||||
const s = atTheEnd(game());
|
||||
advance(s);
|
||||
assert.equal(check(s, 0, { type: 'draw.fromHomeOffice' }), 'WRONG_PHASE');
|
||||
assert.equal(check(s, 0, { type: 'game.extend', player: 0, agree: true }), null, 'the vote itself was refused');
|
||||
});
|
||||
|
||||
it('offers only the two votes, and only to a seat that has not voted', () => {
|
||||
const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B']));
|
||||
advance(s);
|
||||
assert.deepEqual(
|
||||
legalActions(s, 0).map((i) => i.type),
|
||||
['game.extend', 'game.extend'],
|
||||
'something other than the vote is legal while the game is stopped',
|
||||
);
|
||||
applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
assert.equal(legalActions(s, 0).length, 0, 'a seat was offered a second vote');
|
||||
assert.equal(check(s, 0, { type: 'game.extend', player: 0, agree: true }), 'ALREADY_VOTED');
|
||||
assert.equal(legalActions(s, 1).length, 2, 'the seat still to vote was not offered the vote');
|
||||
});
|
||||
|
||||
it('refuses the vote when no extension is pending', () => {
|
||||
const s = game();
|
||||
assert.equal(check(s, 0, { type: 'game.extend', player: 0, agree: true }), 'NOT_AWAITING_EXTENSION');
|
||||
});
|
||||
});
|
||||
|
||||
describe('§3.3 extended play — one Day at a time (Gitea#11)', () => {
|
||||
it('grants exactly one Day in solitaire, then asks again at the end of it', () => {
|
||||
const s = atTheEnd(game());
|
||||
advance(s);
|
||||
const official = { ...s.official!.outcome };
|
||||
|
||||
applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
assert.equal(s.status, 'active', 'agreeing did not resume play');
|
||||
assert.equal(s.extraDays, 1, 'more or less than one Day was granted');
|
||||
assert.deepEqual(s.extensionVotes, [null], 'the votes were not cleared for the next question');
|
||||
|
||||
// Run the extra Day off the end: the question comes round again.
|
||||
atTheEnd(s);
|
||||
advance(s);
|
||||
assert.equal(s.status, 'awaitingExtension', 'the second ending did not ask again');
|
||||
assert.equal(s.extraDays, 1, 'a second Day was granted without being asked for');
|
||||
assert.deepEqual(s.official!.outcome, official, 'the official result was rewritten');
|
||||
assert.equal(s.official!.day, s.config.days, 'the official Day moved with the extension');
|
||||
});
|
||||
|
||||
it('ends the moment one seat declines, without waiting for the rest', () => {
|
||||
const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B', 'C']));
|
||||
advance(s);
|
||||
applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
assert.equal(s.status, 'awaitingExtension', 'one yes ended the vote');
|
||||
|
||||
applyIntent(s, 1, { type: 'game.extend', player: 1, agree: false });
|
||||
assert.equal(s.status, 'finished', 'a refusal did not end the game immediately');
|
||||
assert.equal(s.extraDays, 0, 'a Day was granted despite a refusal');
|
||||
assert.equal(check(s, 2, { type: 'game.extend', player: 2, agree: true }), 'NOT_AWAITING_EXTENSION',
|
||||
'the seat that never voted is still being waited on');
|
||||
});
|
||||
|
||||
it('needs every seat before it grants the Day', () => {
|
||||
const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B', 'C']));
|
||||
advance(s);
|
||||
applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
applyIntent(s, 1, { type: 'game.extend', player: 1, agree: true });
|
||||
assert.equal(s.status, 'awaitingExtension', 'two of three votes granted the Day');
|
||||
applyIntent(s, 2, { type: 'game.extend', player: 2, agree: true });
|
||||
assert.equal(s.status, 'active', 'a unanimous table was not given its Day');
|
||||
assert.equal(s.extraDays, 1);
|
||||
});
|
||||
|
||||
it('keeps the official result when a collision ends an EXTENDED Day', () => {
|
||||
// The case the freeze exists for: a railroad declared unsafe on the extra Day does not retract
|
||||
// who won on the last scheduled one.
|
||||
const s = atTheEnd(game({ mode: 'competitive', maxCollisionsPerDay: 2 }, ['A', 'B']));
|
||||
s.players[0]!.revenue = 9;
|
||||
s.players[1]!.revenue = 2;
|
||||
advance(s);
|
||||
const official = { ...s.official!.outcome };
|
||||
assert.equal(official.result, 'win');
|
||||
assert.equal(official.winner, 0);
|
||||
|
||||
applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
applyIntent(s, 1, { type: 'game.extend', player: 1, agree: true });
|
||||
assert.equal(s.status, 'active');
|
||||
|
||||
s.collisionsToday = 2;
|
||||
s.clock.stage = 1;
|
||||
s.clock.phase = 'shiftChange';
|
||||
advance(s);
|
||||
assert.equal(s.status, 'finished');
|
||||
assert.equal(s.outcome!.reason, 'collisionFloor', 'the current evaluation was not updated');
|
||||
assert.deepEqual(s.official!.outcome, official, 'a late collision rewrote a recorded win');
|
||||
});
|
||||
|
||||
it('decides the winner at the ORIGINAL game length, whoever leads afterwards', () => {
|
||||
const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B']));
|
||||
s.players[0]!.revenue = 9;
|
||||
s.players[1]!.revenue = 2;
|
||||
advance(s);
|
||||
assert.equal(s.official!.outcome.winner, 0);
|
||||
assert.deepEqual(s.official!.revenues, [9, 2], 'the official standings were not frozen');
|
||||
|
||||
applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
applyIntent(s, 1, { type: 'game.extend', player: 1, agree: true });
|
||||
|
||||
// B overtakes A during the extra Day, and it changes nothing official.
|
||||
s.players[1]!.revenue = 40;
|
||||
atTheEnd(s);
|
||||
advance(s);
|
||||
assert.equal(s.official!.outcome.winner, 0, 'overtaking after the timetable took the win');
|
||||
assert.deepEqual(s.official!.revenues, [9, 2], 'the frozen standings moved');
|
||||
assert.equal(s.outcome!.winner, 1, 'the informational evaluation did not follow the new leader');
|
||||
});
|
||||
});
|
||||
|
||||
describe('§3.3 extended play — it survives being replayed (Gitea#11)', () => {
|
||||
it('reproduces an extended game from seed and intents alone', () => {
|
||||
// The reason the vote is an intent at all. A save is a replay, so a decision that is not in the
|
||||
// history did not happen — an extended game would evaporate on the next reload.
|
||||
const play = (): GameState => {
|
||||
const s = atTheEnd(game());
|
||||
advance(s);
|
||||
applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
return s;
|
||||
};
|
||||
const a = play();
|
||||
const b = play();
|
||||
assert.equal(a.extraDays, b.extraDays);
|
||||
assert.equal(a.status, b.status);
|
||||
assert.deepEqual(a.official!.outcome, b.official!.outcome);
|
||||
});
|
||||
|
||||
it('narrates the vote, so a table can see who called time', () => {
|
||||
const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B']));
|
||||
advance(s);
|
||||
const yes = applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
assert.ok(yes.ok);
|
||||
assert.deepEqual(yes.events.map((e) => e.type), ['extensionVoted']);
|
||||
const no = applyIntent(s, 1, { type: 'game.extend', player: 1, agree: false });
|
||||
assert.ok(no.ok);
|
||||
assert.deepEqual(no.events.map((e) => e.type), ['extensionVoted', 'playConcluded']);
|
||||
});
|
||||
|
||||
it('announces the granted Day', () => {
|
||||
const s = atTheEnd(game());
|
||||
advance(s);
|
||||
const r = applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
assert.ok(r.ok);
|
||||
assert.deepEqual(r.events.map((e) => e.type), ['extensionVoted', 'dayExtended']);
|
||||
const extended = r.events.find((e) => e.type === 'dayExtended');
|
||||
assert.equal(extended && 'day' in extended ? extended.day : null, s.config.days + 1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('§3.3 extended play — bots play the timetable they were dealt (Gitea#11)', () => {
|
||||
it('REGRESSION: a simulated game terminates whatever the policy would vote', () => {
|
||||
/**
|
||||
* `playGame` declines on the driver's own account rather than leaving it to the policy, and this
|
||||
* is why. `randomBot` picks uniformly among its legal options, so it takes another Day about
|
||||
* half the time — and since a table may go on granting Days for ever, the game then runs to
|
||||
* `maxTurns`. It did: `test/sim.test.ts` went from under a second to an unbounded hang, every
|
||||
* seeded game in the harness playing fifty thousand turns instead of a couple of hundred.
|
||||
*
|
||||
* `randomBot` is the policy that exposes it, but the guarantee has to hold for any policy,
|
||||
* including ones not written yet — hence the fix living in the driver and the test living here.
|
||||
*/
|
||||
const s = createGame({ id: 'g', seed: 9, config: baseConfig({ days: 1 }), playerNames: ['Jesse'] });
|
||||
const out = playGame(s, randomBot(7), pump, 4_000);
|
||||
assert.equal(s.status, 'finished', 'a simulated game did not finish');
|
||||
assert.equal(s.extraDays, 0, 'the harness played Days the game was not dealt');
|
||||
assert.ok(out.turns < 4_000, `ran to the turn cap (${out.turns}) instead of ending`);
|
||||
});
|
||||
|
||||
it('developerBot declines, so a bot-only game ends on schedule', () => {
|
||||
// "If only bots are playing, they never vote to extend" (Jesse, 2026-08-28). The server votes
|
||||
// yes on a bot's behalf once every human has already agreed; this policy is what is left when
|
||||
// there are no humans to follow.
|
||||
const s = atTheEnd(game());
|
||||
advance(s);
|
||||
const choice = developerBot.choose(s, 0, legalActions(s, 0));
|
||||
assert.equal(choice.type, 'game.extend');
|
||||
assert.equal('agree' in choice ? choice.agree : null, false, 'a bot asked for another Day');
|
||||
});
|
||||
});
|
||||
@@ -1,86 +0,0 @@
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import { areaOf } from '../src/engine/apply.ts';
|
||||
import { createGame } from '../src/engine/setup.ts';
|
||||
import { coordKey } from '../src/engine/state.ts';
|
||||
import type { GameConfig, GameState } from '../src/engine/state.ts';
|
||||
import { applyDelta, deltaFrame } from '../src/sim/frame-delta.ts';
|
||||
import { snapshot } from '../src/sim/view.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
};
|
||||
|
||||
const game = (seed = 1): GameState => createGame({ id: 'g', seed, config, playerNames: ['a'] });
|
||||
|
||||
describe('deltaFrame — the live one-step-back board diff', () => {
|
||||
it('nulls cells/facilities/division when the board has not changed, keeps everything else', () => {
|
||||
const s = game();
|
||||
const first = snapshot(s, [], null);
|
||||
s.players[0]!.revenue = 42; // a non-board change
|
||||
const second = snapshot(s, [], null);
|
||||
|
||||
const delta = deltaFrame(first, second);
|
||||
assert.equal(delta.cells, null, 'unchanged cells were not nulled');
|
||||
assert.equal(delta.facilities, null, 'unchanged facilities were not nulled');
|
||||
assert.equal(delta.division, null, 'unchanged division was not nulled');
|
||||
assert.equal(delta.revenue, 42, 'a real change was dropped along with the unchanged board');
|
||||
});
|
||||
|
||||
it('sends the real board when it changed', () => {
|
||||
const s = game();
|
||||
const first = snapshot(s, [], null);
|
||||
const area = areaOf(s, 0);
|
||||
area.grid.set(coordKey({ row: area.runningRow - 1, col: 0 }), {
|
||||
geometry: { kind: 'track', geometry: 'straight' },
|
||||
baseOperationalRail: true, standing: [], standingWest: 0, facility: null, modifiers: [], enhancements: [],
|
||||
});
|
||||
const second = snapshot(s, [], null);
|
||||
|
||||
const delta = deltaFrame(first, second);
|
||||
assert.notEqual(delta.cells, null, 'a real board change was nulled');
|
||||
assert.deepEqual(delta.cells, second.cells);
|
||||
});
|
||||
|
||||
it('never nulls anything on a first connect (no previous Frame)', () => {
|
||||
const s = game();
|
||||
const frame = snapshot(s, [], null);
|
||||
const delta = deltaFrame(null, frame);
|
||||
assert.deepEqual(delta.cells, frame.cells);
|
||||
assert.deepEqual(delta.facilities, frame.facilities);
|
||||
assert.deepEqual(delta.division, frame.division);
|
||||
});
|
||||
|
||||
it('applyDelta round-trips: merge(delta(A, B)) against A reconstructs B exactly', () => {
|
||||
const s = game();
|
||||
const a = snapshot(s, [], null);
|
||||
s.players[0]!.revenue = 7;
|
||||
const area = areaOf(s, 0);
|
||||
area.grid.set(coordKey({ row: area.runningRow - 1, col: 1 }), {
|
||||
geometry: { kind: 'track', geometry: 'straight' },
|
||||
baseOperationalRail: true, standing: [], standingWest: 0, facility: null, modifiers: [], enhancements: [],
|
||||
});
|
||||
const b = snapshot(s, [], null);
|
||||
|
||||
const merged = applyDelta(a, deltaFrame(a, b));
|
||||
assert.deepEqual(merged, b);
|
||||
});
|
||||
|
||||
it('throws rather than silently reconstructing garbage when previous is missing but the delta says "unchanged"', () => {
|
||||
const s = game();
|
||||
const frame = snapshot(s, [], null);
|
||||
const delta = deltaFrame(frame, frame); // everything nulled, since nothing changed
|
||||
assert.throws(() => applyDelta(null, delta));
|
||||
});
|
||||
});
|
||||
+12
-39
@@ -29,13 +29,11 @@ const root = join(dirname(fileURLToPath(import.meta.url)), '..');
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -228,28 +226,14 @@ describe('the game conserves Rolling Stock', () => {
|
||||
for (let t = 0; t < 50_000; t++) {
|
||||
const before = census(s);
|
||||
const pumped = pump(s);
|
||||
/**
|
||||
* 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`,
|
||||
// §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`,
|
||||
);
|
||||
if (s.status === 'finished') break;
|
||||
const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
|
||||
@@ -304,18 +288,7 @@ describe('every published replay actually replays', () => {
|
||||
`${f} is dead — it replays ${back.history.length} of ${save.history.length} intents. ` +
|
||||
'Re-record it with save-replay.ts rather than editing the file.',
|
||||
);
|
||||
/**
|
||||
* `awaitingExtension` counts as the end since Gitea#11 — and for a published file it is the
|
||||
* EXPECTED end. These saves were recorded before extended play existed, so their histories
|
||||
* carry no `game.extend` vote: replaying one runs the timetable out and stops on the question
|
||||
* nobody was there to answer. That is a game that reached the end of its own history, which is
|
||||
* what this test is about. `active` would still be a dead replay.
|
||||
*/
|
||||
assert.ok(
|
||||
back.state.status === 'finished' || back.state.status === 'awaitingExtension',
|
||||
`${f} does not reach the end of its game — status ${back.state.status}`,
|
||||
);
|
||||
assert.ok(back.state.official !== null, `${f} ends without recording a result`);
|
||||
assert.equal(back.state.status, 'finished', `${f} does not reach the end of its game`);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
+99
-506
@@ -12,7 +12,6 @@
|
||||
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';
|
||||
@@ -28,36 +27,19 @@ import {
|
||||
import { createGame } from '../src/engine/setup.ts';
|
||||
import type { GameEvent } from '../src/engine/events.ts';
|
||||
import type { GameConfig, GameState, GridCoord, TrackCard } from '../src/engine/state.ts';
|
||||
import { coordKey, decisionActor, turnOf } from '../src/engine/state.ts';
|
||||
import { coordKey, turnOf } from '../src/engine/state.ts';
|
||||
import { snapshot } from '../src/sim/view.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
|
||||
};
|
||||
const game = (seed = 5): GameState => createGame({ id: 'g', seed, config, playerNames: ['p'] });
|
||||
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 };
|
||||
@@ -66,10 +48,7 @@ function hand(s: GameState, kind: string, key: string): string {
|
||||
return id;
|
||||
}
|
||||
}
|
||||
const id = `zero-copy-${kind}-${key}`;
|
||||
s.cards.set(id, { id, kind: { kind, key } } as never);
|
||||
s.decks.hands.set(0, [id]);
|
||||
return id;
|
||||
throw new Error(`no ${kind} card: ${key}`);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -108,124 +87,53 @@ function drawTurn(s: GameState): void {
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* 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);
|
||||
describe('grade modifiers change crossing time', () => {
|
||||
it('a Heavy Grade takes two Stages bare', () => {
|
||||
assert.equal(crossingStages('heavyGrade', 'fast', false), 2);
|
||||
});
|
||||
|
||||
it('Brakeman speeds the descent but not the climb', () => {
|
||||
// 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);
|
||||
// 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);
|
||||
});
|
||||
|
||||
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('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('Helpers speed the climb but not the descent', () => {
|
||||
// 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);
|
||||
assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'east', 'east'), 1);
|
||||
assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'west', 'east'), 2);
|
||||
});
|
||||
|
||||
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('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('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(
|
||||
cross('heavyGrade', { modifiers: ['brakeman', 'airbrakes', 'helpers'], direction: 'west' }),
|
||||
crossingStages('heavyGrade', 'fast', false, ['brakeman', 'airbrakes'], 'west', 'east'),
|
||||
1,
|
||||
);
|
||||
});
|
||||
|
||||
it('leaves non-grade cards alone', () => {
|
||||
// Brakeman on Plains would be an illegal placement anyway; the maths must not move regardless.
|
||||
assert.equal(cross('plains', { modifiers: ['brakeman'], direction: 'west' }), 1);
|
||||
assert.equal(cross('curves', { modifiers: ['helpers'] }), 2);
|
||||
assert.equal(crossingStages('plains', 'fast', false, ['brakeman'], 'west', 'east'), 1);
|
||||
assert.equal(crossingStages('curves', 'fast', false, ['helpers'], 'east', 'east'), 2);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -298,8 +206,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 prints two regions, Plains one, so realigning halves the time.
|
||||
assert.equal(cross(node.card), 1);
|
||||
// The point of the card: Curves is a 30 (two Stages), Plains a 60 (one).
|
||||
assert.equal(crossingStages(node.card, 'fast', false), 1);
|
||||
});
|
||||
|
||||
it('refuses a card with no conversion listed', () => {
|
||||
@@ -317,177 +225,77 @@ describe('Realignment converts one Mainline type to another', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('Red Flags hold a train out of your Limits (Gitea#19)', () => {
|
||||
/**
|
||||
* REPLACES the old rule outright (Jesse, 2026-08-29). Red Flags used to be played on a stopped
|
||||
* train out on the Mainline and protected it from a rear-ender — measured at 4,212 offers and 4
|
||||
* plays across 600 games, a mechanic nobody used. ABS Signals already does that job better.
|
||||
*
|
||||
* Now: "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits
|
||||
* from that direction (i.e. Flag East holds westbound trains)." Spent on the train it stops —
|
||||
* one card, one train.
|
||||
*/
|
||||
|
||||
/** A westbound train one Stage from entering seat 0's district from the east. */
|
||||
function approaching(s: GameState) {
|
||||
const officeIndex = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
|
||||
const node = pinned(s, officeIndex + 1, 'plains');
|
||||
node.transits.push({ tray: 'inbound', stagesRemaining: 1, stagesTotal: 1, direction: 'west' });
|
||||
s.trays.set('inbound', {
|
||||
id: 'inbound', trainNumber: 9, trainIsExtra: false, engineAt: 0,
|
||||
consist: [{ type: 'hopper', loaded: true }], direction: 'west',
|
||||
position: { at: 'mainline', index: officeIndex + 1 }, movesUsed: 0,
|
||||
describe('Red Flags protect a stopped train', () => {
|
||||
/** A slow train `behind` closing on a stopped train `ahead`, both eastbound on node 1. */
|
||||
function rearEnder(s: GameState) {
|
||||
const node = pinned(s, 1, 'plains');
|
||||
node.transits.push({ tray: 'ahead', stagesRemaining: 2, stagesTotal: 2, direction: 'east' });
|
||||
s.trays.set('ahead', {
|
||||
id: 'ahead', trainNumber: 4, trainIsExtra: false, engineAt: 0,
|
||||
consist: [], direction: 'east', position: { at: 'mainline', index: 1 }, movesUsed: 0,
|
||||
});
|
||||
s.trays.set('behind', {
|
||||
id: 'behind', trainNumber: 2, trainIsExtra: false, engineAt: 0,
|
||||
consist: [], direction: 'east', position: { at: 'divisionPoint', side: 'west' }, movesUsed: 0,
|
||||
});
|
||||
const dp = s.division.nodes[0];
|
||||
if (dp?.kind === 'divisionPoint') dp.holding.push('behind');
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
return s.division.nodes[officeIndex] as Extract<typeof s.division.nodes[0], { kind: 'office' }>;
|
||||
return node;
|
||||
}
|
||||
|
||||
it('FLAG EAST holds a westbound train short of the Limits', () => {
|
||||
it('holds the approaching train instead of letting it close', () => {
|
||||
const s = game();
|
||||
const office = approaching(s);
|
||||
office.redFlag = 'east';
|
||||
const node = rearEnder(s);
|
||||
node.redFlagged = ['ahead'];
|
||||
|
||||
advance(s);
|
||||
const pos = s.trays.get('inbound')!.position;
|
||||
assert.equal(pos.at, 'mainline', 'the flagged train came in anyway');
|
||||
assert.ok(!areaOf(s, 0).adOccupancy.includes('inbound'), 'it reached an A/D track');
|
||||
assert.deepEqual(
|
||||
s.trays.get('behind')!.position,
|
||||
{ at: 'divisionPoint', side: 'west' },
|
||||
'the flagged train must not be approached',
|
||||
);
|
||||
});
|
||||
|
||||
it('is spent on the train it stops — one card, one train', () => {
|
||||
it('comes in when the protected train rolls', () => {
|
||||
const s = game();
|
||||
const office = approaching(s);
|
||||
office.redFlag = 'east';
|
||||
const node = rearEnder(s);
|
||||
node.redFlagged = ['ahead'];
|
||||
// Bring the protected train to the end of its crossing so it leaves the card.
|
||||
node.transits[0]!.stagesRemaining = 1;
|
||||
|
||||
advance(s);
|
||||
assert.equal(office.redFlag, undefined, 'the flag stayed up after stopping a train');
|
||||
for (let i = 0; i < 12 && (node.redFlagged?.length ?? 0) > 0; i++) advance(s);
|
||||
assert.deepEqual(node.redFlagged, [], 'flags come in once the train moves off');
|
||||
});
|
||||
|
||||
it('lets the train in on the next Mainline Phase', () => {
|
||||
// "Loses one Mainline Phase" — it buys a Stage to clear the lead, not permanent protection.
|
||||
const s = game();
|
||||
const office = approaching(s);
|
||||
office.redFlag = 'east';
|
||||
advance(s);
|
||||
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
advance(s);
|
||||
assert.ok(areaOf(s, 0).adOccupancy.includes('inbound'), 'the train never came in');
|
||||
});
|
||||
|
||||
it('does not hold a train coming from the OTHER side', () => {
|
||||
// "Flag East holds westbound trains" — an eastbound train arrives from the west.
|
||||
const s = game();
|
||||
const office = approaching(s);
|
||||
office.redFlag = 'west';
|
||||
|
||||
advance(s);
|
||||
assert.ok(areaOf(s, 0).adOccupancy.includes('inbound'), 'a west flag held a train from the east');
|
||||
assert.equal(office.redFlag, 'west', 'the wrong-side flag was spent');
|
||||
});
|
||||
|
||||
it('is played on a side, not on a train', () => {
|
||||
it('only protects a train out on the Mainline', () => {
|
||||
const s = game();
|
||||
rearEnder(s);
|
||||
s.clock.phase = 'localOps';
|
||||
s.clock.currentActor = 0;
|
||||
const cardId = hand(s, 'maneuver', 'redFlags');
|
||||
|
||||
assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'east' }), null);
|
||||
assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'west' }), null);
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'maneuver.redFlags', cardId, trayId: 'behind' }),
|
||||
'NO_PLACEMENT',
|
||||
'a train sitting at a Division Point cannot be rear-ended',
|
||||
);
|
||||
assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, trayId: 'ahead' }), null);
|
||||
});
|
||||
|
||||
it('will not double-flag the same side', () => {
|
||||
it('will not double-flag the same train', () => {
|
||||
const s = game();
|
||||
const node = rearEnder(s);
|
||||
s.clock.phase = 'localOps';
|
||||
s.clock.currentActor = 0;
|
||||
const cardId = hand(s, 'maneuver', 'redFlags');
|
||||
const officeIndex = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
|
||||
const office = s.division.nodes[officeIndex] as { redFlag?: string };
|
||||
office.redFlag = 'east';
|
||||
node.redFlagged = ['ahead'];
|
||||
|
||||
assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'east' }), 'ALREADY_FLAGGED');
|
||||
assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'west' }), null,
|
||||
'the other side should still be free');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Red Flags offered at the moment of danger (Gitea#19)', () => {
|
||||
/**
|
||||
* "In actual cases of danger… if there is a train or cars on the track and there will be a
|
||||
* collision, then you break in with a dialog that says COLLISION RISK! FLAG AGAINST T2? This way,
|
||||
* you can play the card normally or out of phase, but only if you need it."
|
||||
*
|
||||
* The engine establishes the danger, so the player is never asked to judge it — which is also why
|
||||
* the bot can now use this card at all. It is offered ONLY to somebody holding one.
|
||||
*/
|
||||
function dangerous(s: GameState, giveCard: boolean) {
|
||||
const officeIndex = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
|
||||
const node = pinned(s, officeIndex + 1, 'plains');
|
||||
node.transits.push({ tray: 'inbound', stagesRemaining: 1, stagesTotal: 1, direction: 'west' });
|
||||
s.trays.set('inbound', {
|
||||
id: 'inbound', trainNumber: 9, trainIsExtra: false, engineAt: 0,
|
||||
consist: [{ type: 'hopper', loaded: true }], direction: 'west',
|
||||
position: { at: 'mainline', index: officeIndex + 1 }, movesUsed: 0,
|
||||
});
|
||||
// A hopper fouling the Running Track: §8.3 makes this arrival a collision.
|
||||
const area = areaOf(s, 0);
|
||||
area.grid.get(coordKey(area.officeCoord))!.standing = [{ type: 'hopper', loaded: false }];
|
||||
if (giveCard) hand(s, 'maneuver', 'redFlags');
|
||||
s.clock.phase = 'mainline';
|
||||
s.movedThisPhase = new Set();
|
||||
}
|
||||
|
||||
it('breaks in to offer the flag when an arrival would collide', () => {
|
||||
const s = game();
|
||||
dangerous(s, true);
|
||||
advance(s);
|
||||
assert.equal(s.clock.pendingDecision?.kind, 'redFlag', 'no prompt before a certain collision');
|
||||
assert.equal(decisionActor(s), 0, 'the prompt went to the wrong player');
|
||||
});
|
||||
|
||||
it('flagging holds the train and costs the card', () => {
|
||||
const s = game();
|
||||
dangerous(s, true);
|
||||
advance(s);
|
||||
const before = (s.decks.hands.get(0) ?? []).length;
|
||||
|
||||
const r = applyIntent(s, 0, { type: 'mainline.redFlag', flag: true });
|
||||
assert.ok(r.ok, 'the flag was refused');
|
||||
advance(s);
|
||||
|
||||
assert.equal(s.players[0]!.revenue, 0, 'the collision happened anyway');
|
||||
assert.equal(s.trays.get('inbound')!.position.at, 'mainline', 'the train came in regardless');
|
||||
assert.equal((s.decks.hands.get(0) ?? []).length, before - 1, 'the card was not spent');
|
||||
});
|
||||
|
||||
it('declining lets the collision happen', () => {
|
||||
const s = game();
|
||||
dangerous(s, true);
|
||||
advance(s);
|
||||
|
||||
assert.ok(applyIntent(s, 0, { type: 'mainline.redFlag', flag: false }).ok);
|
||||
advance(s);
|
||||
assert.equal(s.players[0]!.revenue, -5, 'waving it through did not collide');
|
||||
});
|
||||
|
||||
it('does not offer a flag to a player holding none', () => {
|
||||
// A prompt with one button is not a choice, and it leaks that a collision is coming.
|
||||
const s = game();
|
||||
dangerous(s, false);
|
||||
advance(s);
|
||||
assert.equal(s.clock.pendingDecision, null, 'offered a flag to a player with no card');
|
||||
assert.equal(s.players[0]!.revenue, -5, 'the collision should have happened');
|
||||
});
|
||||
|
||||
it('stays quiet when the arrival is safe', () => {
|
||||
const s = game();
|
||||
dangerous(s, true);
|
||||
// Clear the hazard: nothing fouling the Running Track, and room at the Office.
|
||||
const area = areaOf(s, 0);
|
||||
area.grid.get(coordKey(area.officeCoord))!.standing = [];
|
||||
advance(s);
|
||||
assert.equal(s.clock.pendingDecision, null, 'interrupted the phase for a safe arrival');
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'maneuver.redFlags', cardId, trayId: 'ahead' }),
|
||||
'OPTION_ALREADY_CHOSEN',
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -870,100 +678,6 @@ describe('a turnout may be laid on top of a card already down', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('extras that must run loaded, and one that must not (Gitea#13)', () => {
|
||||
/**
|
||||
* "I've redefined some of the extra trains that they have to run full boxcars — military trains,
|
||||
* circus trains, etc. If not loaded, then empty, and if none available, run without."
|
||||
*
|
||||
* A PREFERENCE ORDER, so every test here is about what the DIVISION YARD still holds. The rule
|
||||
* has nothing to say about a train once it is running; it decides which car may be taken next.
|
||||
*/
|
||||
const madeUp = (trainNumber: number) => {
|
||||
const s = game();
|
||||
s.clock.phase = 'newTrain';
|
||||
s.trays.set('t', {
|
||||
id: 't', trainNumber, trainIsExtra: true, engineAt: 0,
|
||||
consist: [], direction: 'east', position: { at: 'divisionPoint', side: 'west' }, movesUsed: 0,
|
||||
});
|
||||
return s;
|
||||
};
|
||||
const place = (carType: string, loaded: boolean) =>
|
||||
({ type: 'newTrain.placeCar', trayId: 't', carType, loaded }) as never;
|
||||
/** Leaves the Division Yard holding exactly the cars described. */
|
||||
const stockYard = (s: ReturnType<typeof madeUp>, cars: { type: string; loaded: boolean }[]) => {
|
||||
s.yards.divisionYard.length = 0;
|
||||
s.yards.divisionYard.push(...(cars as never[]));
|
||||
};
|
||||
|
||||
it('refuses an empty while the yard can still supply a loaded one (X18 Circus)', () => {
|
||||
const s = madeUp(18);
|
||||
stockYard(s, [{ type: 'boxcar', loaded: true }, { type: 'boxcar', loaded: false }]);
|
||||
assert.equal(check(s, 0, place('boxcar', false)), 'NO_SUITABLE_CAR',
|
||||
'an empty was accepted while a loaded boxcar was still in the yard');
|
||||
assert.equal(check(s, 0, place('boxcar', true)), null, 'the loaded boxcar was refused');
|
||||
});
|
||||
|
||||
it('accepts an empty once the yard has no loaded car of that kind left', () => {
|
||||
// "If not loaded, then empty." The rule releases as soon as the yard cannot supply.
|
||||
const s = madeUp(18);
|
||||
stockYard(s, [{ type: 'boxcar', loaded: false }]);
|
||||
assert.equal(check(s, 0, place('boxcar', false)), null,
|
||||
'an empty was refused when the yard held no loaded car at all');
|
||||
});
|
||||
|
||||
it('does not let a loaded car of the WRONG category unlock the rule', () => {
|
||||
// A loaded coach is no reason to refuse an empty boxcar: the preference is per category, since
|
||||
// that is the slot the car is competing for.
|
||||
const s = madeUp(18);
|
||||
stockYard(s, [{ type: 'coach', loaded: true }, { type: 'boxcar', loaded: false }]);
|
||||
assert.equal(check(s, 0, place('boxcar', false)), null,
|
||||
'a loaded coach blocked an empty boxcar');
|
||||
});
|
||||
|
||||
it('exempts the caboose, which is never empty in the supply', () => {
|
||||
const s = madeUp(18);
|
||||
stockYard(s, [{ type: 'caboose', loaded: true }, { type: 'boxcar', loaded: true }]);
|
||||
assert.equal(check(s, 0, place('caboose', true)), null, 'the caboose its card calls for was refused');
|
||||
});
|
||||
|
||||
it('applies to the Military train too', () => {
|
||||
const s = madeUp(19);
|
||||
stockYard(s, [{ type: 'coach', loaded: true }, { type: 'coach', loaded: false }]);
|
||||
assert.equal(check(s, 0, place('coach', false)), 'NO_SUITABLE_CAR',
|
||||
'the Military train took an empty coach over a loaded one');
|
||||
});
|
||||
|
||||
it('leaves trains without the rule alone', () => {
|
||||
// X21 Freight Extra has no loading rule: an empty is as good as a loaded one.
|
||||
const s = madeUp(21);
|
||||
stockYard(s, [{ type: 'boxcar', loaded: true }, { type: 'boxcar', loaded: false }]);
|
||||
assert.equal(check(s, 0, place('boxcar', false)), null,
|
||||
'a train with no loading rule was made to prefer loaded cars');
|
||||
});
|
||||
|
||||
it('REGRESSION: X13 Appleseed is empties-only, and now the rules say so too', () => {
|
||||
/**
|
||||
* `ConsistSpec.emptiesOnly` was declared on the card, RENDERED to the player as "(empties only)"
|
||||
* by `web/game.ts` and `sim/view.ts`, and enforced by NOTHING — `acceptsCar` never read it. So
|
||||
* the Appleseed could be made up with loaded cars while its own card said it could not. Found
|
||||
* while building Gitea#13, which is the same rule pointing the other way.
|
||||
*/
|
||||
const s = madeUp(13);
|
||||
stockYard(s, [{ type: 'boxcar', loaded: true }, { type: 'boxcar', loaded: false }]);
|
||||
assert.equal(check(s, 0, place('boxcar', true)), 'NO_SUITABLE_CAR',
|
||||
'the Appleseed took a loaded car despite printing "empties only"');
|
||||
assert.equal(check(s, 0, place('boxcar', false)), null, 'the Appleseed refused an empty');
|
||||
});
|
||||
|
||||
it('still lets the Appleseed take the caboose its consist calls for', () => {
|
||||
// Every caboose in ROLLING_STOCK_SUPPLY is minted loaded, so an unexempted empties-only rule
|
||||
// would bar the one car the card explicitly lists.
|
||||
const s = madeUp(13);
|
||||
stockYard(s, [{ type: 'caboose', loaded: true }]);
|
||||
assert.equal(check(s, 0, place('caboose', true)), null, 'the empties-only rule ate the caboose');
|
||||
});
|
||||
});
|
||||
|
||||
describe("a train is made up to its card's consist (§8.2)", () => {
|
||||
it('takes a caboose when the card calls for one, and refuses a fourth freight car', () => {
|
||||
// Train 9 "Heavy Freight" is freight 3 + caboose 1. It was being made up with FOUR hoppers and
|
||||
@@ -1019,8 +733,8 @@ describe('regions on a Mainline card (§2.1, §8.2)', () => {
|
||||
id: 'reg',
|
||||
seed: 4,
|
||||
config: {
|
||||
mode: 'solitaire', days: 5, minCombinedRevenue: 0, maxCollisionsPerDay: 0, maxCollisionsTotal: 0, pvpCardsAllowed: false,
|
||||
optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
|
||||
mode: 'solitaire', victory: 'highestAfterDays', length: 'standard',
|
||||
optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
|
||||
},
|
||||
playerNames: ['Solitaire'],
|
||||
});
|
||||
@@ -1079,35 +793,18 @@ 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[] } => {
|
||||
/**
|
||||
* 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', days: 5, minCombinedRevenue: 0, maxCollisionsPerDay: 0, maxCollisionsTotal: 0, pvpCardsAllowed: false,
|
||||
optionalRules: { reducedVisibility: 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 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');
|
||||
const node = s.division.nodes[index]!;
|
||||
assert.ok(node.kind === 'mainline');
|
||||
if (node.kind !== 'mainline') throw new Error('unreachable');
|
||||
@@ -1163,116 +860,12 @@ describe('Q13 — a train that catches the one ahead runs into it', () => {
|
||||
);
|
||||
});
|
||||
|
||||
/**
|
||||
* 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.
|
||||
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.
|
||||
const passing = MAINLINE_PROFILES.filter((m) => m.trainsMayPass).map((m) => m.kind);
|
||||
assert.deepEqual(passing, ['doubleTrack']);
|
||||
assert.deepEqual(passing, ['doubleTrack', 'uncontrolledSiding']);
|
||||
});
|
||||
});
|
||||
|
||||
+7
-381
@@ -11,34 +11,22 @@ import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import { advance, pump } from '../src/engine/advance.ts';
|
||||
import { applyIntent, areaAtSeat, areaOf, check } from '../src/engine/apply.ts';
|
||||
import { STAGES_PER_DAY, STAGES_PER_SHIFT, crewTrayCount } from '../src/engine/content.ts';
|
||||
import { areaAtSeat, areaOf } from '../src/engine/apply.ts';
|
||||
import { STAGES_PER_SHIFT, crewTrayCount } from '../src/engine/content.ts';
|
||||
import { createGame } from '../src/engine/setup.ts';
|
||||
import { legalActions } from '../src/engine/legal.ts';
|
||||
import type { GameConfig, GameState, PlayerIndex } from '../src/engine/state.ts';
|
||||
import { coordKey, playerAtSeat, playerLeftOf, seatOf, subdivisions } from '../src/engine/state.ts';
|
||||
import { coordKey, playerAtSeat, seatOf, subdivisions } from '../src/engine/state.ts';
|
||||
import { developerBot, playGame } from '../src/sim/bot.ts';
|
||||
import { snapshot } from '../src/sim/view.ts';
|
||||
import { divisionSvg } from '../src/sim/board-svg.ts';
|
||||
import { impediments, narrate } from '../src/sim/narrate.ts';
|
||||
import { impediments } from '../src/sim/narrate.ts';
|
||||
import { readFileSync, readdirSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { actionMenu } from '../src/web/game.ts';
|
||||
import type { Game } from '../src/web/game.ts';
|
||||
|
||||
/** The thin wrapper `actionMenu` expects, built directly around an already-created multi-player state
|
||||
* — `newGame` (game.ts) hardcodes one player, so it cannot construct this for a multi-seat game. */
|
||||
const wrap = (s: GameState): Game =>
|
||||
({ state: s, seed: s.seed, history: [], log: [], mustPlayCard: false, cues: [], scheduled: null, justDrawn: null, announced: null });
|
||||
|
||||
const competitive: GameConfig = {
|
||||
mode: 'competitive',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
|
||||
};
|
||||
|
||||
const game = (players: number, seed = 4242): GameState =>
|
||||
@@ -486,9 +474,6 @@ describe('the view shows one seat at a time', () => {
|
||||
* which is a list of squares that do not exist on the board they are looking at.
|
||||
*/
|
||||
const s = game(3);
|
||||
// A real floor to pace against — the shared `competitive` fixture leaves it off (0) since most
|
||||
// tests in this file don't care, but pacing against "off" is trivially "always on pace" (view.ts).
|
||||
s.config.minCombinedRevenue = 10;
|
||||
s.players[0]!.revenue = 1;
|
||||
s.players[1]!.revenue = 9;
|
||||
s.players[2]!.revenue = 17;
|
||||
@@ -615,362 +600,3 @@ describe('scoring lands on the right seat', () => {
|
||||
assert.notEqual(areaAtSeat(s, 1), areaAtSeat(s, 2), 'two seats share one Office Area object');
|
||||
});
|
||||
});
|
||||
|
||||
describe('the New Train phase car-placement round rotates (§7, Gap 9)', () => {
|
||||
/**
|
||||
* REGRESSION. `newTrainPhase` used to hand the whole car-filling loop to a fixed actor —
|
||||
* `actorOffset` is reset to 0 entering the phase and was never incremented, so `actorAt(s, 0)`
|
||||
* always resolved to the Superintendent, who placed every car of every train alone. The written
|
||||
* rule (`rules-v0.2.md` §7, Gap 9) is explicit: "starting with the Superintendent and working
|
||||
* left, each player may place ONE car... the round repeats... until the consist is full," with a
|
||||
* worked example showing seats alternating. The fix reads the round position off
|
||||
* `tray.consist.length` instead, which is already exactly that counter and resets per train.
|
||||
*/
|
||||
it('cycles Superintendent-then-left, one car per player, wrapping as the round repeats', () => {
|
||||
// Train 5, "The Sparrow" — 3 coaches, no freight or caboose (content.ts) — small enough to
|
||||
// exercise both a player count that wraps (2p: seats 0,1,0) and one that doesn't (3p: 0,1,2).
|
||||
// It was Train 1 until Gitea#7 swapped the coach counts on 1/2 and 5/6; the test needs a
|
||||
// THREE-car consist and the Crack Limited now carries two, so it follows the three coaches.
|
||||
for (const players of [2, 3]) {
|
||||
const s = game(players);
|
||||
s.clock.phase = 'newTrain';
|
||||
s.trays.set('t1', {
|
||||
id: 't1',
|
||||
trainNumber: 5,
|
||||
trainIsExtra: false,
|
||||
engineAt: 0,
|
||||
consist: [],
|
||||
direction: 'west',
|
||||
position: { at: 'divisionPoint', side: 'east' },
|
||||
movesUsed: 0,
|
||||
});
|
||||
s.yards.divisionYard.push(
|
||||
{ type: 'coach', loaded: false },
|
||||
{ type: 'coach', loaded: false },
|
||||
{ type: 'coach', loaded: false },
|
||||
);
|
||||
|
||||
const expected = [0, 1, 2].map((offset) => playerLeftOf(s, s.clock.superintendent, offset));
|
||||
const seenActors: PlayerIndex[] = [];
|
||||
for (let guard = 0; guard < 10; guard++) {
|
||||
const r = advance(s);
|
||||
if (!r.needsInput) break;
|
||||
const actor = s.clock.currentActor!;
|
||||
seenActors.push(actor);
|
||||
const result = applyIntent(s, actor, {
|
||||
type: 'newTrain.placeCar',
|
||||
trayId: 't1',
|
||||
carType: 'coach',
|
||||
loaded: false,
|
||||
});
|
||||
assert.ok(result.ok, `${players}p: placeCar rejected — ${result.ok ? '' : result.code}`);
|
||||
}
|
||||
|
||||
const wanted = [0, 1, 2].map((i) => expected[i % players]!);
|
||||
assert.deepEqual(
|
||||
seenActors,
|
||||
wanted,
|
||||
`${players}p: actor sequence was [${seenActors}], wanted [${wanted}] (Superintendent-then-left)`,
|
||||
);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('an Extra belongs to the player who played it (§7)', () => {
|
||||
/**
|
||||
* REPORTED BY JESSE 2026-08-23, from a two-player game on StartOS: one seat played a train card
|
||||
* and the OTHER was asked to build the train. For a Timetabled train that is correct — the round
|
||||
* above starts at the Superintendent — but §7 states the Extra rule a paragraph later and it is
|
||||
* the opposite one: "the player who played the card may place the Crew Tray at either Division
|
||||
* Point ... and may load the consist as he chooses."
|
||||
*
|
||||
* The engine could not honour it: `pendingExtras` was a bare `number[]`, so nothing recorded whose
|
||||
* Extra it was and the phase asked whoever the acting order happened to be on. Invisible in
|
||||
* solitaire, where that is always the same person.
|
||||
*/
|
||||
const withPendingExtra = (players: number, owner: PlayerIndex) => {
|
||||
const s = game(players);
|
||||
s.clock.phase = 'newTrain';
|
||||
s.timetable = s.timetable.map(() => null);
|
||||
// X22 "Pee-Dee" — a caboose-only Extra, so the consist is short and the round would be visible.
|
||||
s.pendingExtras = [{ trainNumber: 22, player: owner }];
|
||||
return s;
|
||||
};
|
||||
|
||||
it('asks the player who played it where it starts — not whoever the round is on', () => {
|
||||
// The owner is deliberately NOT the Superintendent, which is the case that used to go wrong.
|
||||
const s = withPendingExtra(2, 1 as PlayerIndex);
|
||||
const notSuper = playerLeftOf(s, s.clock.superintendent, 1);
|
||||
s.pendingExtras = [{ trainNumber: 22, player: notSuper }];
|
||||
|
||||
const r = advance(s);
|
||||
assert.equal(r.needsInput, true, 'the phase did not stop to place the Extra');
|
||||
assert.equal(s.clock.currentActor, notSuper, 'the wrong player was asked where the Extra starts');
|
||||
});
|
||||
|
||||
it('refuses another seat placing it, and offers it to nobody else', () => {
|
||||
const s = withPendingExtra(2, 0 as PlayerIndex);
|
||||
const intent = {
|
||||
type: 'newTrain.startExtra' as const,
|
||||
trainNumber: 22,
|
||||
start: { kind: 'divisionPoint' as const, side: 'west' as const },
|
||||
};
|
||||
const theirs = applyIntent(s, 0 as PlayerIndex, intent);
|
||||
assert.ok(theirs.ok, `the owner could not place their own Extra — ${theirs.ok ? '' : theirs.code}`);
|
||||
|
||||
/**
|
||||
* TWO EXTRAS, TWO OWNERS — the case where the guard is actually reachable. The phase stops on
|
||||
* the first pending Extra's owner, so seat 0 is legitimately the current actor; nothing but this
|
||||
* rule stops them placing seat 1's train while they are there.
|
||||
*/
|
||||
const both = withPendingExtra(2, 0 as PlayerIndex);
|
||||
both.pendingExtras = [
|
||||
{ trainNumber: 22, player: 0 as PlayerIndex },
|
||||
{ trainNumber: 24, player: 1 as PlayerIndex },
|
||||
];
|
||||
advance(both);
|
||||
assert.equal(both.clock.currentActor, 0, 'the first pending Extra should have stopped on its owner');
|
||||
assert.equal(check(both, 0 as PlayerIndex, { ...intent, trainNumber: 24 }), 'NOT_YOUR_EXTRA');
|
||||
const notTheirs = applyIntent(both, 0 as PlayerIndex, { ...intent, trainNumber: 24 });
|
||||
assert.equal(notTheirs.ok, false, 'a seat placed somebody else’s Extra while it was their turn');
|
||||
// And it is not even offered: a menu that lists an action `check` will refuse is a menu lying.
|
||||
assert.equal(
|
||||
legalActions(both, 0 as PlayerIndex).some(
|
||||
(i) => i.type === 'newTrain.startExtra' && i.trainNumber === 24,
|
||||
),
|
||||
false,
|
||||
'somebody else’s Extra was offered a start point',
|
||||
);
|
||||
});
|
||||
|
||||
it('lets its player load the whole consist, rather than passing the round', () => {
|
||||
// §7: "may load the consist as he chooses" — no going round the table for an Extra.
|
||||
const s = withPendingExtra(2, 0 as PlayerIndex);
|
||||
const owner = 0 as PlayerIndex;
|
||||
const placed = applyIntent(s, owner, {
|
||||
type: 'newTrain.startExtra',
|
||||
trainNumber: 22,
|
||||
start: { kind: 'divisionPoint', side: 'west' },
|
||||
});
|
||||
assert.ok(placed.ok, 'the Extra could not be placed');
|
||||
s.yards.divisionYard.push({ type: 'caboose', loaded: false }, { type: 'caboose', loaded: false });
|
||||
|
||||
const asked: PlayerIndex[] = [];
|
||||
for (let guard = 0; guard < 4; guard++) {
|
||||
const r = advance(s);
|
||||
if (!r.needsInput) break;
|
||||
const actor = s.clock.currentActor!;
|
||||
asked.push(actor);
|
||||
const tray = [...s.trays.values()].find((t) => t.trainIsExtra);
|
||||
assert.ok(tray, 'the Extra has no tray');
|
||||
const result = applyIntent(s, actor, { type: 'newTrain.passCar', trayId: tray.id });
|
||||
if (!result.ok) break;
|
||||
}
|
||||
assert.ok(asked.length > 0, 'nobody was asked to load the Extra');
|
||||
assert.deepEqual(
|
||||
[...new Set(asked)],
|
||||
[owner],
|
||||
`the Extra's consist went round the table (asked ${asked.join(', ')}) instead of staying with its player`,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('actionMenu is seat-safe (Phase 2 prep)', () => {
|
||||
/**
|
||||
* REGRESSION. `actionMenu(game, seat)` used `seat` only for the `hand` field — `options`/`direct`/
|
||||
* `placeable`/`makeUp` all came from `currentActor(game)` regardless of which seat was asked. A
|
||||
* server computing every connected seat's Menu would have handed the acting player's legal moves to
|
||||
* a waiting seat, paired with the WRONG seat's hand. Found tracing Phase 2's per-seat Menu step.
|
||||
*/
|
||||
it('gives the acting seat its real options, and every other seat none at all', () => {
|
||||
const s = game(3);
|
||||
const g = wrap(s);
|
||||
const actorSeat = s.clock.currentActor!;
|
||||
const waiting = [0, 1, 2].filter((seat) => seat !== actorSeat);
|
||||
|
||||
const actorMenu = actionMenu(g, actorSeat as PlayerIndex);
|
||||
assert.ok(actorMenu.options.length > 0, "the acting seat's Menu had no options at all");
|
||||
|
||||
for (const seat of waiting) {
|
||||
const menu = actionMenu(g, seat as PlayerIndex);
|
||||
assert.deepEqual(menu.options, [], `seat ${seat} (not acting) was given real options`);
|
||||
assert.deepEqual(menu.direct, [], `seat ${seat} (not acting) was given direct actions`);
|
||||
assert.deepEqual(menu.placeable, [], `seat ${seat} (not acting) was given placeable actions`);
|
||||
assert.equal(menu.makeUp, null, `seat ${seat} (not acting) was given a make-up panel`);
|
||||
}
|
||||
});
|
||||
|
||||
it('still shows a waiting seat its own hand, just nothing to do with it', () => {
|
||||
const s = game(3);
|
||||
const g = wrap(s);
|
||||
const actorSeat = s.clock.currentActor!;
|
||||
const waitingSeat = [0, 1, 2].find((seat) => seat !== actorSeat)! as PlayerIndex;
|
||||
|
||||
const menu = actionMenu(g, waitingSeat);
|
||||
const expectedHand = s.decks.hands.get(waitingSeat) ?? [];
|
||||
assert.equal(menu.hand.length, expectedHand.length, "the waiting seat's own hand did not come through");
|
||||
for (const card of menu.hand) {
|
||||
assert.equal(card.playNow, null, 'a waiting seat was offered a way to play a card');
|
||||
assert.equal(card.spots, 0, 'a waiting seat was offered somewhere to place a card');
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('the map says whose railroad is whose', () => {
|
||||
it('the Frame names its own viewer, which nothing on it did before', () => {
|
||||
// Every private field is already scoped to one player — hand, Office Area, revenue, option —
|
||||
// but a page rendering that could not say WHICH player, so it could not tell you which of four
|
||||
// railroads was yours.
|
||||
const s = game(4);
|
||||
for (const viewer of [0, 1, 2, 3] as PlayerIndex[]) {
|
||||
const f = snapshot(s, [], null, null, null, false, viewer);
|
||||
assert.equal(f.viewer, viewer);
|
||||
assert.equal(f.viewerSeat, seatOf(s, viewer), 'viewerSeat must be the seat, not the player index');
|
||||
}
|
||||
});
|
||||
|
||||
it('carries the opening D12 that decided the west-to-east chain', () => {
|
||||
const s = game(4);
|
||||
const f = snapshot(s, [], null, null, null, false, 0 as PlayerIndex);
|
||||
assert.equal(f.openingRolls.division.length, 4, 'one division roll per player');
|
||||
assert.equal(f.openingRolls.superintendent.length, 4);
|
||||
|
||||
// The rule the rolls implement: ascending by roll, west to east — so sorting the players by
|
||||
// their roll must reproduce the seating exactly (§4.4).
|
||||
const bySeat = [...f.players].sort((a, b) => a.seat - b.seat).map((p) => p.index);
|
||||
const byRoll = [...f.players]
|
||||
.map((p) => p.index)
|
||||
.sort((a, b) => f.openingRolls.division[a]! - f.openingRolls.division[b]! || b - a);
|
||||
assert.deepEqual(bySeat, byRoll, 'seating does not follow the opening rolls');
|
||||
});
|
||||
|
||||
it('is not always the host at the eastern end — the roll decides', () => {
|
||||
// The question this answers: player 0 is the lobby host, and the eastern end is the LAST seat.
|
||||
// If the two were the same thing, every seed would put player 0 there.
|
||||
const easternPlayer = (seed: number): number => {
|
||||
const s = game(4, seed);
|
||||
const f = snapshot(s, [], null, null, null, false, 0 as PlayerIndex);
|
||||
return [...f.players].sort((a, b) => b.seat - a.seat)[0]!.index;
|
||||
};
|
||||
const seen = new Set([101, 202, 303, 404, 505, 606].map(easternPlayer));
|
||||
assert.ok(seen.size > 1, `the eastern end was always player ${[...seen][0]} across six seeds`);
|
||||
});
|
||||
|
||||
it('labels each Office with its owner, marking whose move it is and which one is yours', () => {
|
||||
const s = game(3);
|
||||
const viewer = 1 as PlayerIndex;
|
||||
const f = snapshot(s, [], null, null, null, false, viewer);
|
||||
const svg = divisionSvg(f.division, { players: f.players, actor: f.actor, viewer: f.viewer });
|
||||
|
||||
const owners = [...svg.matchAll(/<text class="bs-name([^"]*bs-owner[^"]*)"[^>]*>([^<]*)<\/text>/g)].map(
|
||||
(m) => ({ classes: m[1]!, text: m[2]! }),
|
||||
);
|
||||
assert.equal(owners.length, 3, 'expected one owner-labelled Office per player');
|
||||
|
||||
// Every player is named somewhere, in seat order.
|
||||
const bySeat = [...f.players].sort((a, b) => a.seat - b.seat);
|
||||
assert.deepEqual(
|
||||
owners.map((o) => o.text.replace(' (you)', '')),
|
||||
bySeat.map((p) => p.name),
|
||||
);
|
||||
|
||||
const you = owners.find((o) => o.classes.includes('bs-you'));
|
||||
assert.ok(you, 'the viewer’s own Office is not marked');
|
||||
assert.ok(you!.text.endsWith('(you)'), 'colour alone cannot say which railroad is the reader’s');
|
||||
assert.equal(
|
||||
you!.text.replace(' (you)', ''),
|
||||
f.players.find((p) => p.index === viewer)!.name,
|
||||
'the (you) mark is on the wrong Office',
|
||||
);
|
||||
|
||||
const turn = owners.filter((o) => o.classes.includes('bs-turn'));
|
||||
assert.equal(turn.length, f.actor === null ? 0 : 1, 'exactly one Office is the current actor’s');
|
||||
if (f.actor !== null) {
|
||||
assert.equal(turn[0]!.text.replace(' (you)', ''), f.players.find((p) => p.index === f.actor)!.name);
|
||||
}
|
||||
});
|
||||
|
||||
it('draws no owner marks at all when given no roster, so the replay still renders', () => {
|
||||
const s = game(3);
|
||||
const f = snapshot(s, [], null, null, null, false, 0 as PlayerIndex);
|
||||
assert.equal(divisionSvg(f.division).includes('bs-owner'), false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Employee Rotation (Appendix B)', () => {
|
||||
/**
|
||||
* Straight to the Day boundary, which is the only moment a rotation happens — the same shortcut
|
||||
* `advance.test.ts` uses to roll the clock over without playing twelve Stages of real turns.
|
||||
*/
|
||||
const atDayEnd = (on: boolean): GameState => {
|
||||
const s = createGame({
|
||||
id: 'rot',
|
||||
seed: 4242,
|
||||
config: { ...competitive, optionalRules: { ...competitive.optionalRules, employeeRotation: on } },
|
||||
playerNames: ['Alice', 'Bob', 'Carol'],
|
||||
});
|
||||
s.clock.stage = STAGES_PER_DAY;
|
||||
s.clock.phase = 'shiftChange';
|
||||
return s;
|
||||
};
|
||||
|
||||
it('is off unless asked for — the clock alone must not move anybody', () => {
|
||||
const s = atDayEnd(false);
|
||||
const before = [...s.seating];
|
||||
advance(s);
|
||||
assert.equal(s.clock.day, 2, 'the clock did not roll over');
|
||||
assert.deepEqual(s.seating, before, 'seats moved with the rule switched off');
|
||||
});
|
||||
|
||||
it('moves every player one chair left at the Day boundary', () => {
|
||||
const s = atDayEnd(true);
|
||||
const before = [...s.seating];
|
||||
advance(s);
|
||||
assert.equal(s.clock.day, 2);
|
||||
// "One chair to the left" is seat + 1, the direction `playerLeftOf` already turns the table.
|
||||
const expected = before.map((_, seat, all) => all[(seat - 1 + all.length) % all.length]!);
|
||||
assert.deepEqual(s.seating, expected);
|
||||
// Everyone moved, and nobody was lost or duplicated on the way round.
|
||||
assert.deepEqual([...s.seating].sort(), [...before].sort());
|
||||
assert.notDeepEqual(s.seating, before);
|
||||
});
|
||||
|
||||
it('takes your points and the Fedora with you, and leaves the district behind', () => {
|
||||
const s = atDayEnd(true);
|
||||
const traveller = 1 as PlayerIndex;
|
||||
s.players[traveller]!.revenue = 17;
|
||||
const seatBefore = seatOf(s, traveller);
|
||||
/**
|
||||
* The Fedora is compared against the SAME game with the rule off, not against its own value
|
||||
* before the advance — Stage 12 is a shift change (§5), so it passes here anyway for reasons
|
||||
* that have nothing to do with rotation. What matters is that moving the chairs does not move
|
||||
* it: it names a player, and players are exactly what the rotation does not renumber.
|
||||
*/
|
||||
const control = atDayEnd(false);
|
||||
advance(control);
|
||||
// Identity, not a field: anything mutable is liable to be reset at a Day boundary anyway (the
|
||||
// once-a-Day dispatch reset clears `dispatchUsedToday` right there), and the claim under test
|
||||
// is about which OBJECT is attached to which chair.
|
||||
const districtLeftBehind = areaAtSeat(s, seatBefore);
|
||||
|
||||
advance(s);
|
||||
|
||||
assert.notEqual(seatOf(s, traveller), seatBefore, 'the traveller did not move');
|
||||
assert.equal(s.players[traveller]!.revenue, 17, 'Revenue is keyed by player and must travel');
|
||||
assert.equal(s.clock.superintendent, control.clock.superintendent, 'rotating the chairs moved the Fedora');
|
||||
// The Office stayed exactly where it was, so whoever sits there now inherits it as they find
|
||||
// it. That is the rule rather than a side effect of it — you take over the next station up the
|
||||
// line, mess and all.
|
||||
assert.equal(areaAtSeat(s, seatBefore), districtLeftBehind, 'the district moved with the player');
|
||||
assert.notEqual(areaOf(s, traveller), districtLeftBehind, 'the traveller kept their old district');
|
||||
});
|
||||
|
||||
it('says who is now sitting where, by name', () => {
|
||||
const s = atDayEnd(true);
|
||||
const { events } = advance(s);
|
||||
const rotated = events.find((e) => e.type === 'seatsRotated');
|
||||
assert.ok(rotated, 'no seatsRotated event was emitted');
|
||||
const line = narrate(rotated, { playerName: (p) => s.players[p]!.name }).text;
|
||||
for (const name of ['Alice', 'Bob', 'Carol']) assert.match(line, new RegExp(name));
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,179 +0,0 @@
|
||||
/**
|
||||
* The four game types (`src/web/presets.ts`) — Jesse's design, 2026-08-23.
|
||||
*
|
||||
* These numbers are a DESIGN, not an implementation detail: they say what Co-op asks of a table and
|
||||
* what Cutthroat refuses to. Pinned here so that changing one is a decision somebody makes on
|
||||
* purpose rather than something a refactor can do quietly.
|
||||
*/
|
||||
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import {
|
||||
PRESETS,
|
||||
closestPreset,
|
||||
configFromPreset,
|
||||
configFromSettings,
|
||||
differencesFrom,
|
||||
gameTypeLabel,
|
||||
preset,
|
||||
presetOf,
|
||||
presetSettings,
|
||||
settingsOf,
|
||||
} from '../src/web/presets.ts';
|
||||
import type { PresetName } from '../src/web/presets.ts';
|
||||
|
||||
const NAMES: PresetName[] = ['solitaire', 'coop', 'competitive', 'cutthroat'];
|
||||
|
||||
describe('what each game type is', () => {
|
||||
it('deals six cards in every type — the hand limit is three, so the first turn is a discard', () => {
|
||||
for (const name of NAMES) {
|
||||
assert.equal(presetSettings(name, 4, 5).startingHand, 'sixRandom', `${name} does not deal six`);
|
||||
}
|
||||
});
|
||||
|
||||
it('scores Cutthroat as Competitive, and Co-op as itself', () => {
|
||||
assert.equal(preset('cutthroat').scoring, 'competitive');
|
||||
assert.equal(preset('competitive').scoring, 'competitive');
|
||||
assert.equal(preset('coop').scoring, 'coop');
|
||||
assert.equal(preset('solitaire').scoring, 'solitaire');
|
||||
});
|
||||
|
||||
it('lets the opponent-directed cards into Competitive and Cutthroat only', () => {
|
||||
// Co-op has no opponent to point them at; solitaire has nobody at all. Inert either way until
|
||||
// the cards are built (`setup.ts`), which is why no screen offers this as a control any more.
|
||||
assert.deepEqual(
|
||||
PRESETS.filter((p) => p.pvpCards).map((p) => p.name),
|
||||
['competitive', 'cutthroat'],
|
||||
);
|
||||
});
|
||||
|
||||
it('pays for a transit in Co-op alone — the one economy that pays everybody at once', () => {
|
||||
assert.equal(presetSettings('coop', 4, 5).trainPerTransit, 1);
|
||||
for (const name of ['solitaire', 'competitive', 'cutthroat'] as PresetName[]) {
|
||||
assert.equal(presetSettings(name, 4, 5).trainPerTransit, 0, `${name} pays for transits`);
|
||||
}
|
||||
});
|
||||
|
||||
it('lets an Extra be planted in another player’s district in Cutthroat only', () => {
|
||||
assert.equal(presetSettings('cutthroat', 4, 5).extraStart, 'anyOffice');
|
||||
assert.equal(presetSettings('coop', 4, 5).extraStart, 'ownOffice');
|
||||
assert.equal(presetSettings('competitive', 4, 5).extraStart, 'ownOffice');
|
||||
// At one player the two rules are the same rule.
|
||||
assert.equal(presetSettings('solitaire', 1, 5).extraStart, 'anyOffice');
|
||||
});
|
||||
|
||||
it('leaves every optional rule off, in every type', () => {
|
||||
for (const name of NAMES) {
|
||||
const s = presetSettings(name, 4, 5);
|
||||
assert.deepEqual(
|
||||
[s.reducedVisibility, s.employeeRotation, s.emergencyToolbox],
|
||||
[false, false, false],
|
||||
`${name} switches an optional rule on`,
|
||||
);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('the Revenue floor is a formula, not a number', () => {
|
||||
/**
|
||||
* Jesse gave these at five Days — Co-op 15 × players, Competitive 10 × players — and they scale,
|
||||
* because a ten-Day game with a five-Day target is not a target. The floor follows the table size
|
||||
* AND the length, which is exactly why both sit above the type radios as parameters rather than
|
||||
* below them as rules.
|
||||
*/
|
||||
it('asks 15 per player in Co-op at five Days, and 10 in Competitive', () => {
|
||||
for (const players of [2, 3, 4]) {
|
||||
assert.equal(presetSettings('coop', players, 5).minCombinedRevenue, 15 * players);
|
||||
assert.equal(presetSettings('competitive', players, 5).minCombinedRevenue, 10 * players);
|
||||
}
|
||||
});
|
||||
|
||||
it('scales both ways with the Day count', () => {
|
||||
assert.equal(presetSettings('coop', 3, 8).minCombinedRevenue, 3 * 3 * 8);
|
||||
assert.equal(presetSettings('coop', 3, 3).minCombinedRevenue, 3 * 3 * 3);
|
||||
assert.equal(presetSettings('competitive', 4, 10).minCombinedRevenue, 2 * 4 * 10);
|
||||
assert.equal(presetSettings('competitive', 2, 3).minCombinedRevenue, 2 * 2 * 3);
|
||||
});
|
||||
|
||||
it('asks nothing at all in Cutthroat, and leaves only the per-Day collision check standing', () => {
|
||||
const s = presetSettings('cutthroat', 4, 5);
|
||||
assert.equal(s.minCombinedRevenue, 0, 'Cutthroat has a Revenue floor');
|
||||
assert.equal(s.maxCollisionsTotal, 0, 'Cutthroat caps collisions across the game');
|
||||
assert.equal(s.maxCollisionsPerDay, 3, 'three collisions in one Day still ends a Cutthroat game');
|
||||
});
|
||||
});
|
||||
|
||||
describe('naming a game from its numbers', () => {
|
||||
it('reads every type back as itself, at every table size and length', () => {
|
||||
for (const name of NAMES) {
|
||||
const players = name === 'solitaire' ? 1 : 3;
|
||||
for (const days of [3, 5, 10]) {
|
||||
const config = configFromPreset(name, players, days);
|
||||
assert.equal(presetOf(config, players, days), name, `${name} at ${days} Days did not read back`);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('tells Cutthroat and Competitive apart, though they are scored the same way', () => {
|
||||
const cut = configFromPreset('cutthroat', 4, 5);
|
||||
const comp = configFromPreset('competitive', 4, 5);
|
||||
assert.equal(cut.mode, comp.mode, 'these two are meant to share a scoring mode');
|
||||
assert.equal(presetOf(cut, 4, 5), 'cutthroat');
|
||||
assert.equal(presetOf(comp, 4, 5), 'competitive');
|
||||
});
|
||||
|
||||
it('calls a changed rule Custom, and says which rule', () => {
|
||||
const base = configFromPreset('coop', 4, 5);
|
||||
const settings = { ...settingsOf(base), emergencyToolbox: true };
|
||||
const custom = configFromSettings(settings, 'coop', 5, false);
|
||||
assert.equal(presetOf(custom, 4, 5), 'custom');
|
||||
assert.deepEqual(differencesFrom('coop', settings, 4, 5), ['emergencyToolbox']);
|
||||
});
|
||||
|
||||
it('does not call a Co-op game Competitive just because its dials line up', () => {
|
||||
// The scoring mode is part of the comparison: the same numbers under a different mode are a
|
||||
// different game, and the type is what a player reads to know which.
|
||||
const settings = presetSettings('competitive', 4, 5);
|
||||
const coopScored = configFromSettings(settings, 'coop', 5, false);
|
||||
assert.notEqual(presetOf(coopScored, 4, 5), 'competitive');
|
||||
assert.equal(presetOf(coopScored, 4, 5), 'custom');
|
||||
});
|
||||
|
||||
it('measures a Custom game against the nearest type it is scored as', () => {
|
||||
// A join preview is handed a finished config and nothing else — "Custom" alone would tell a
|
||||
// player nothing about what they are sitting down to.
|
||||
const settings = { ...presetSettings('cutthroat', 4, 5), freightPerLoad: 3 };
|
||||
const config = configFromSettings(settings, 'competitive', 5, true);
|
||||
const near = closestPreset(config, 4, 5);
|
||||
assert.equal(near.name, 'cutthroat', 'a tuned Cutthroat game was measured against something else');
|
||||
assert.deepEqual(near.differing, ['freightPerLoad']);
|
||||
});
|
||||
|
||||
it('says what a Custom game is scored as, since the dials cannot', () => {
|
||||
assert.match(gameTypeLabel('custom', 'coop'), /Co-op/);
|
||||
assert.match(gameTypeLabel('custom', 'competitive'), /Competitive/);
|
||||
assert.equal(gameTypeLabel('cutthroat', 'competitive'), 'Cutthroat');
|
||||
});
|
||||
});
|
||||
|
||||
describe('the config a form produces', () => {
|
||||
it('carries the type’s scoring mode and its stance on the opponent cards', () => {
|
||||
for (const name of NAMES) {
|
||||
const config = configFromPreset(name, name === 'solitaire' ? 1 : 4, 5);
|
||||
assert.equal(config.mode, preset(name).scoring);
|
||||
assert.equal(config.pvpCardsAllowed, preset(name).pvpCards);
|
||||
}
|
||||
});
|
||||
|
||||
it('spells out every house rule rather than leaving one to a default somewhere else', () => {
|
||||
const config = configFromPreset('competitive', 3, 5);
|
||||
assert.ok(config.houseRules?.startingHand, 'the opening hand was left unnamed');
|
||||
assert.ok(config.houseRules?.extraStart, 'the Extra rule was left unnamed');
|
||||
assert.deepEqual(config.houseRules?.revenue, {
|
||||
passengerPerCoach: 1,
|
||||
freightPerLoad: 1,
|
||||
trainPerTransit: 0,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,141 +0,0 @@
|
||||
/**
|
||||
* §7's redaction test — "the single most important test in the plan."
|
||||
*
|
||||
* Everything else about `Frame` degrades gracefully; a redaction bug hands one player's hand to
|
||||
* another and cannot be walked back once it has been seen. `test/multiplayer.test.ts`'s "the view
|
||||
* shows one seat at a time" section already proves `snapshot(s, ..., viewer)` gives each seat its
|
||||
* own hand, board and Revenue — spot-checks that today's code does the right thing. This is the
|
||||
* different, exhaustive check: serialize a seat's whole `Frame` and assert none of some OTHER seat's
|
||||
* actual secret data appears anywhere in it, so a future careless edit is caught rather than assumed
|
||||
* safe. No server needed — `snapshot()` and a multi-player `GameState` are all this exercises.
|
||||
*/
|
||||
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import { pump } from '../src/engine/advance.ts';
|
||||
import { createGame } from '../src/engine/setup.ts';
|
||||
import type { GameConfig, GameState, PlayerIndex } from '../src/engine/state.ts';
|
||||
import { developerBot, playGame } from '../src/sim/bot.ts';
|
||||
import { snapshot } from '../src/sim/view.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'competitive',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
};
|
||||
|
||||
/** Plays a real multi-player game partway — enough for every seat to hold a real, distinct hand. */
|
||||
function midGame(players: number, seed: number): GameState {
|
||||
const s = createGame({
|
||||
id: `redact-${players}`,
|
||||
seed,
|
||||
config,
|
||||
playerNames: Array.from({ length: players }, (_, i) => `p${i}`),
|
||||
});
|
||||
const r = playGame(s, developerBot, pump, 400);
|
||||
// A partial or finished game both exercise real hands — either is fine for this check.
|
||||
void r;
|
||||
return s;
|
||||
}
|
||||
|
||||
describe('redaction — a seat\'s Frame never carries another seat\'s secrets', () => {
|
||||
it('never contains another seat\'s actual hand-card ids', () => {
|
||||
for (const players of [3, 4]) {
|
||||
const s = midGame(players, 1000 + players);
|
||||
for (let viewer = 0 as PlayerIndex; viewer < players; viewer++) {
|
||||
const serialized = JSON.stringify(snapshot(s, [], null, null, null, false, viewer));
|
||||
for (let other = 0 as PlayerIndex; other < players; other++) {
|
||||
if (other === viewer) continue;
|
||||
for (const cardId of s.decks.hands.get(other) ?? []) {
|
||||
assert.ok(
|
||||
!serialized.includes(`"${cardId}"`),
|
||||
`${players}p seed ${1000 + players}: seat ${viewer}'s Frame contains seat ${other}'s ` +
|
||||
`hand card id "${cardId}"`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('never contains the Home Office deck\'s order or contents, only its count', () => {
|
||||
for (const players of [3, 4]) {
|
||||
const s = midGame(players, 2000 + players);
|
||||
// The deck's own card ids are the thing that must never leak — distinct from any hand's ids,
|
||||
// since a card once dealt is removed from `homeOffice` (state.ts).
|
||||
const deckIds = new Set(s.decks.homeOffice);
|
||||
for (let viewer = 0 as PlayerIndex; viewer < players; viewer++) {
|
||||
const frame = snapshot(s, [], null, null, null, false, viewer);
|
||||
assert.equal(frame.deck, s.decks.homeOffice.length, 'deck field is not a plain count');
|
||||
const serialized = JSON.stringify(frame);
|
||||
for (const cardId of deckIds) {
|
||||
assert.ok(
|
||||
!serialized.includes(`"${cardId}"`),
|
||||
`${players}p seed ${2000 + players}: seat ${viewer}'s Frame contains a Home Office deck id "${cardId}"`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('never carries the seed or rngState — Frame has no field for either', () => {
|
||||
// A structural guarantee, not a runtime one: confirmed here so a future field addition to Frame
|
||||
// that reintroduces one of these is at least forced past a reader of this test, if not the type
|
||||
// system directly (see Frame in src/sim/view.ts, which carries neither today).
|
||||
const s = midGame(3, 3003);
|
||||
const frame = snapshot(s, [], null, null, null, false, 0);
|
||||
assert.ok(!('seed' in frame), 'Frame gained a seed field');
|
||||
assert.ok(!('rngState' in frame), 'Frame gained an rngState field');
|
||||
const serialized = JSON.stringify(frame);
|
||||
assert.ok(!serialized.includes(String(s.seed)), 'the seed value leaked into the Frame some other way');
|
||||
});
|
||||
|
||||
it('the tally that rides the Frame is aggregate counts, never a card id (Gitea#16)', () => {
|
||||
// Gitea#16's statistics live on `GameState` and reach a remote client on the Frame, which is
|
||||
// only safe because nothing in a Tally identifies a card. That is a property of what
|
||||
// `tally.ts` chooses to count, and nothing in the type system enforces it — so it is asserted
|
||||
// here, where a future counter that stashed a `cardId` "just for badges" would be caught.
|
||||
for (const players of [3, 4]) {
|
||||
const s = midGame(players, 5000 + players);
|
||||
const secrets = new Set<string>([...s.decks.homeOffice]);
|
||||
for (const hand of s.decks.hands.values()) for (const id of hand) secrets.add(id);
|
||||
for (let viewer = 0 as PlayerIndex; viewer < players; viewer++) {
|
||||
const serialized = JSON.stringify(snapshot(s, [], null, null, null, false, viewer).tally);
|
||||
for (const cardId of secrets) {
|
||||
assert.ok(!serialized.includes(`"${cardId}"`), `the tally carries card id "${cardId}"`);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('every seat sees the SAME tally — it is the table\'s account, not a private one', () => {
|
||||
const s = midGame(3, 5555);
|
||||
const tallies = [0, 1, 2].map((p) => snapshot(s, [], null, null, null, false, p as PlayerIndex).tally);
|
||||
for (const t of tallies) assert.deepEqual(t, tallies[0], 'the tally differs by seat');
|
||||
});
|
||||
|
||||
it('only the viewer\'s own hand and handCount are non-public — everything else matches across seats', () => {
|
||||
// The redaction surface is four fields (§7), not sixty event types. Cross-check that seats agree
|
||||
// on everything else a Frame carries about shared state.
|
||||
const s = midGame(3, 4004);
|
||||
const frames = [0, 1, 2].map((p) => snapshot(s, [], null, null, null, false, p as PlayerIndex));
|
||||
for (const f of frames) {
|
||||
assert.deepEqual(f.timetable, frames[0]!.timetable, 'the public timetable differs by seat');
|
||||
assert.deepEqual(f.deck, frames[0]!.deck, 'the deck count differs by seat');
|
||||
assert.deepEqual(
|
||||
f.players.map((p) => ({ index: p.index, revenue: p.revenue, hand: p.hand })),
|
||||
frames[0]!.players.map((p) => ({ index: p.index, revenue: p.revenue, hand: p.hand })),
|
||||
'public standing (names, Revenue, hand COUNTS) differs by seat',
|
||||
);
|
||||
}
|
||||
});
|
||||
});
|
||||
+4
-96
@@ -9,28 +9,21 @@ 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 } from '../src/engine/state.ts';
|
||||
import type { GameConfig, GameState } from '../src/engine/state.ts';
|
||||
import type { GameConfig } 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,
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -140,91 +133,6 @@ describe('impediments', () => {
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* 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 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');
|
||||
|
||||
|
||||
@@ -1,346 +0,0 @@
|
||||
/**
|
||||
* The lobby (`src/server/lobby.ts`) — pure logic, no sockets, no filesystem, exercised directly.
|
||||
*/
|
||||
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import type { GameConfig } from '../../src/engine/state.ts';
|
||||
import {
|
||||
createLobby,
|
||||
freshGameCode,
|
||||
joinLobby,
|
||||
leaveLobby,
|
||||
playerCountAllowed,
|
||||
reassignHost,
|
||||
setBotSeat,
|
||||
startLobby,
|
||||
} from '../../src/server/lobby.ts';
|
||||
|
||||
const competitive: GameConfig = {
|
||||
mode: 'competitive',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
};
|
||||
const solitaire: GameConfig = { ...competitive, mode: 'solitaire' };
|
||||
|
||||
describe('creating and joining', () => {
|
||||
it('seats the host at 0 and lays out the whole table at once', () => {
|
||||
const { lobby, session } = createLobby(competitive, 'Alice', 'RAIL-0001', 3);
|
||||
assert.equal(session.player, 0);
|
||||
assert.equal(lobby.hostToken, session.token);
|
||||
// The table is its full size immediately — the empty chairs exist and are waiting, rather
|
||||
// than being appended as people arrive.
|
||||
assert.equal(lobby.seats.length, 3);
|
||||
assert.deepEqual(lobby.seats[0], { kind: 'human', token: session.token, displayName: 'Alice' });
|
||||
assert.deepEqual(lobby.seats.slice(1), [null, null]);
|
||||
assert.deepEqual(lobby.joinOrder, [session.token]);
|
||||
});
|
||||
|
||||
it('fills the next empty seat, in order', () => {
|
||||
const { lobby: l1, session: s1 } = createLobby(competitive, 'Alice', 'RAIL-0001', 4);
|
||||
const j2 = joinLobby(l1, 'Bob');
|
||||
assert.ok(j2.ok);
|
||||
if (!j2.ok) return;
|
||||
assert.equal(j2.session.player, 1);
|
||||
const j3 = joinLobby(j2.lobby, 'Carol');
|
||||
assert.ok(j3.ok);
|
||||
if (!j3.ok) return;
|
||||
assert.equal(j3.session.player, 2);
|
||||
assert.deepEqual(j3.lobby.joinOrder, [s1.token, j2.session.token, j3.session.token]);
|
||||
});
|
||||
|
||||
it('refuses a join once every chair is taken', () => {
|
||||
let lobby = createLobby(competitive, 'Alice', 'RAIL-0001', 4).lobby;
|
||||
for (const name of ['Bob', 'Carol', 'Dave']) {
|
||||
const r = joinLobby(lobby, name);
|
||||
assert.ok(r.ok);
|
||||
if (r.ok) lobby = r.lobby;
|
||||
}
|
||||
const fifth = joinLobby(lobby, 'Eve');
|
||||
assert.deepEqual(fifth, { ok: false, code: 'LOBBY_FULL' });
|
||||
});
|
||||
|
||||
it('refuses a 2nd join to a one-chair table', () => {
|
||||
const { lobby } = createLobby(solitaire, 'Alice', 'RAIL-0002', 1);
|
||||
const second = joinLobby(lobby, 'Bob');
|
||||
assert.deepEqual(second, { ok: false, code: 'LOBBY_FULL' });
|
||||
});
|
||||
|
||||
it('rejoins into a seat an earlier player vacated, not past the end', () => {
|
||||
// Joining always fills the FIRST empty seat, so a bot-seat cleared back to empty (setBotSeat)
|
||||
// is exactly as joinable as one nobody ever filled.
|
||||
let lobby = createLobby(competitive, 'Alice', 'RAIL-0003', 3).lobby;
|
||||
lobby = setBotSeat(lobby, 1, true);
|
||||
lobby = setBotSeat(lobby, 1, false);
|
||||
const r = joinLobby(lobby, 'Bob');
|
||||
assert.ok(r.ok);
|
||||
if (!r.ok) return;
|
||||
assert.equal(r.session.player, 1, 'should take the reopened chair 1');
|
||||
assert.equal(r.lobby.seats.length, 3, 'joining must never resize the table');
|
||||
assert.equal(r.lobby.seats[2], null);
|
||||
});
|
||||
|
||||
it('never grows the table, whoever asks', () => {
|
||||
// The old model appended a seat for anyone who turned up, which is how a lobby could end up
|
||||
// holding more chairs than the host ever asked for.
|
||||
const { lobby } = createLobby(competitive, 'Alice', 'RAIL-0013', 2);
|
||||
const bob = joinLobby(lobby, 'Bob');
|
||||
assert.ok(bob.ok);
|
||||
if (!bob.ok) return;
|
||||
assert.equal(bob.lobby.seats.length, 2);
|
||||
assert.deepEqual(joinLobby(bob.lobby, 'Carol'), { ok: false, code: 'LOBBY_FULL' });
|
||||
});
|
||||
});
|
||||
|
||||
describe('bot seats', () => {
|
||||
it('fills only an empty seat, and clears only a bot seat', () => {
|
||||
const { lobby: l0 } = createLobby(competitive, 'Alice', 'RAIL-0004', 2);
|
||||
const withBot = setBotSeat(l0, 1, true);
|
||||
assert.deepEqual(withBot.seats[1], { kind: 'bot' });
|
||||
|
||||
// Filling an already-bot seat again is a no-op, not a crash.
|
||||
const stillBot = setBotSeat(withBot, 1, true);
|
||||
assert.deepEqual(stillBot.seats[1], { kind: 'bot' });
|
||||
|
||||
// Clearing seat 0 (a human) does nothing — a host is removed by leaving, not overwritten.
|
||||
const untouched = setBotSeat(withBot, 0, false);
|
||||
assert.deepEqual(untouched.seats[0], l0.seats[0]);
|
||||
|
||||
const cleared = setBotSeat(withBot, 1, false);
|
||||
assert.equal(cleared.seats[1], null);
|
||||
});
|
||||
|
||||
it('refuses a chair that is not at the table, instead of padding one in', () => {
|
||||
// Padding is what used to put a hole in the seats array: dropping a bot into chair 3 of a
|
||||
// 2-chair table grew it to 4 with a null at 2, and Start then refused for reasons the host
|
||||
// had no way to see.
|
||||
const { lobby } = createLobby(competitive, 'Alice', 'RAIL-0014', 2);
|
||||
assert.equal(setBotSeat(lobby, 3, true), lobby);
|
||||
assert.equal(setBotSeat(lobby, 2, true), lobby);
|
||||
assert.equal(lobby.seats.length, 2);
|
||||
});
|
||||
});
|
||||
|
||||
describe('host transfer', () => {
|
||||
it('passes to the earliest-joined remaining human seat when the host departs', () => {
|
||||
let lobby = createLobby(competitive, 'Alice', 'RAIL-0005', 2).lobby;
|
||||
const hostToken = lobby.hostToken;
|
||||
const j2 = joinLobby(lobby, 'Bob');
|
||||
assert.ok(j2.ok);
|
||||
if (!j2.ok) return;
|
||||
lobby = j2.lobby;
|
||||
// Alice's own seat is cleared (simulating her leaving the table entirely, not just dropping
|
||||
// her connection) so the transfer target is unambiguous in this test.
|
||||
lobby = { ...lobby, seats: [null, lobby.seats[1]!] };
|
||||
const after = reassignHost(lobby, hostToken);
|
||||
assert.equal(after.hostToken, j2.session.token);
|
||||
});
|
||||
|
||||
it('does nothing when the departing token is not the host', () => {
|
||||
const { lobby } = createLobby(competitive, 'Alice', 'RAIL-0006', 2);
|
||||
const after = reassignHost(lobby, 'not-a-real-token');
|
||||
assert.equal(after, lobby);
|
||||
});
|
||||
|
||||
it('leaves hostToken alone when no other human seat exists', () => {
|
||||
const { lobby, session } = createLobby(competitive, 'Alice', 'RAIL-0007', 2);
|
||||
const after = reassignHost(lobby, session.token);
|
||||
assert.equal(after.hostToken, session.token);
|
||||
});
|
||||
});
|
||||
|
||||
describe('starting', () => {
|
||||
it('refuses a non-host caller', () => {
|
||||
const { lobby } = createLobby(competitive, 'Alice', 'RAIL-0008', 2);
|
||||
joinLobby(lobby, 'Bob');
|
||||
assert.deepEqual(startLobby(lobby, 'someone-elses-token'), { ok: false, code: 'NOT_HOST' });
|
||||
});
|
||||
|
||||
it('refuses to start while a chair is still empty', () => {
|
||||
const lobby = createLobby(competitive, 'Alice', 'RAIL-0009', 3).lobby;
|
||||
const j2 = joinLobby(lobby, 'Bob');
|
||||
assert.ok(j2.ok);
|
||||
if (!j2.ok) return;
|
||||
assert.deepEqual(startLobby(j2.lobby, j2.lobby.hostToken), { ok: false, code: 'BAD_PLAYER_COUNT' });
|
||||
});
|
||||
|
||||
it('refuses a solo human at a table sized for more', () => {
|
||||
const { lobby } = createLobby(competitive, 'Alice', 'RAIL-0010', 2);
|
||||
assert.deepEqual(startLobby(lobby, lobby.hostToken), { ok: false, code: 'BAD_PLAYER_COUNT' });
|
||||
});
|
||||
|
||||
it('starts a full 2-player lobby, naming humans by their display name and numbering the bot', () => {
|
||||
let lobby = createLobby(competitive, 'Alice', 'RAIL-0011', 2).lobby;
|
||||
lobby = setBotSeat(lobby, 1, true);
|
||||
const r = startLobby(lobby, lobby.hostToken);
|
||||
assert.deepEqual(r, { ok: true, playerNames: ['Alice', 'Bot 1'], botSeats: [1] });
|
||||
});
|
||||
|
||||
it('numbers bots so two of them at one table can be told apart', () => {
|
||||
// They are two different railroads on the Division map, and a map that labels both "Bot"
|
||||
// cannot answer "which one is that".
|
||||
let lobby = createLobby(competitive, 'Alice', 'RAIL-0016', 3).lobby;
|
||||
lobby = setBotSeat(setBotSeat(lobby, 1, true), 2, true);
|
||||
const r = startLobby(lobby, lobby.hostToken);
|
||||
assert.ok(r.ok);
|
||||
if (!r.ok) return;
|
||||
assert.deepEqual(r.playerNames, ['Alice', 'Bot 1', 'Bot 2']);
|
||||
assert.deepEqual(r.botSeats, [1, 2]);
|
||||
});
|
||||
|
||||
it('starts a solitaire lobby of exactly 1', () => {
|
||||
const { lobby } = createLobby(solitaire, 'Alice', 'RAIL-0012', 1);
|
||||
const r = startLobby(lobby, lobby.hostToken);
|
||||
assert.deepEqual(r, { ok: true, playerNames: ['Alice'], botSeats: [] });
|
||||
});
|
||||
|
||||
it('seat index is player index, with no compaction to shift it', () => {
|
||||
// The seats array is never resized or squeezed, so the chair a player joined into is the
|
||||
// player index the game gives them — which is what every PlayerSession already recorded at
|
||||
// join time, and what /api/stream and /api/intent route by.
|
||||
let lobby = createLobby(competitive, 'Alice', 'RAIL-0015', 4).lobby;
|
||||
const bob = joinLobby(lobby, 'Bob');
|
||||
assert.ok(bob.ok);
|
||||
if (!bob.ok) return;
|
||||
lobby = setBotSeat(setBotSeat(bob.lobby, 2, true), 3, true);
|
||||
const r = startLobby(lobby, lobby.hostToken);
|
||||
assert.deepEqual(r, { ok: true, playerNames: ['Alice', 'Bob', 'Bot 1', 'Bot 2'], botSeats: [2, 3] });
|
||||
assert.equal(bob.session.player, 1, "Bob's stored player index still names his chair");
|
||||
});
|
||||
});
|
||||
|
||||
describe('playerCountAllowed', () => {
|
||||
it('solitaire is exactly 1', () => {
|
||||
assert.equal(playerCountAllowed('solitaire', 1), true);
|
||||
assert.equal(playerCountAllowed('solitaire', 0), false);
|
||||
assert.equal(playerCountAllowed('solitaire', 2), false);
|
||||
});
|
||||
|
||||
it('competitive and coop are 2-4', () => {
|
||||
for (const mode of ['competitive', 'coop'] as const) {
|
||||
assert.equal(playerCountAllowed(mode, 1), false);
|
||||
assert.equal(playerCountAllowed(mode, 2), true);
|
||||
assert.equal(playerCountAllowed(mode, 4), true);
|
||||
assert.equal(playerCountAllowed(mode, 5), false);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('game codes', () => {
|
||||
it('skips codes the caller marks taken', () => {
|
||||
let calls = 0;
|
||||
const code = freshGameCode((c) => {
|
||||
calls++;
|
||||
return calls < 3; // taken twice, free on the third
|
||||
});
|
||||
assert.equal(typeof code, 'string');
|
||||
assert.equal(calls, 3);
|
||||
});
|
||||
|
||||
it('is speakable — a word, a dash, four digits', () => {
|
||||
const code = freshGameCode(() => false);
|
||||
assert.match(code, /^[A-Z]+-\d{4}$/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('a name nobody else at the table is using', () => {
|
||||
/**
|
||||
* The display name is not decoration: it labels the district on the Division map, it is what the
|
||||
* turn chart means by "waiting on Jesse", and `record()` puts it in front of every line that
|
||||
* player causes. Two identical names make all three ambiguous, and the names lock at
|
||||
* `Lobby.Start` — so the refusal has to happen at the door.
|
||||
*/
|
||||
it('refuses a second player using a name already at the table, whatever the case or spacing', () => {
|
||||
const { lobby } = createLobby(competitive, 'Alice', 'RAIL-0001', 4);
|
||||
for (const attempt of ['Alice', 'alice', ' ALICE ']) {
|
||||
const result = joinLobby(lobby, attempt);
|
||||
assert.equal(result.ok, false, `"${attempt}" was allowed alongside Alice`);
|
||||
if (!result.ok) assert.equal(result.code, 'NAME_TAKEN');
|
||||
}
|
||||
});
|
||||
|
||||
it('frees the name again when that player leaves', () => {
|
||||
const { lobby, session } = createLobby(competitive, 'Alice', 'RAIL-0001', 4);
|
||||
const joined = joinLobby(lobby, 'Bob');
|
||||
assert.ok(joined.ok);
|
||||
if (!joined.ok) return;
|
||||
const after = leaveLobby(joined.lobby, joined.session.token);
|
||||
const again = joinLobby(after.lobby, 'Bob');
|
||||
assert.equal(again.ok, true, 'a departed player’s name was still held against the table');
|
||||
assert.equal(after.empty, false, 'the host is still seated');
|
||||
assert.equal(after.lobby.hostToken, session.token, 'a non-host leaving moved the host chair');
|
||||
});
|
||||
});
|
||||
|
||||
describe('leaving a lobby', () => {
|
||||
/**
|
||||
* There was no way out at all before 2026-08-23. Start needs every chair filled and `setBotSeat`
|
||||
* refuses to touch an occupied human seat, so a mis-join or a player who wandered off wedged the
|
||||
* whole table.
|
||||
*/
|
||||
const table = () => {
|
||||
const { lobby, session } = createLobby(competitive, 'Alice', 'RAIL-0001', 3);
|
||||
const bob = joinLobby(lobby, 'Bob');
|
||||
assert.ok(bob.ok);
|
||||
if (!bob.ok) throw new Error('Bob could not sit down');
|
||||
const carol = joinLobby(bob.lobby, 'Carol');
|
||||
assert.ok(carol.ok);
|
||||
if (!carol.ok) throw new Error('Carol could not sit down');
|
||||
return { lobby: carol.lobby, alice: session, bob: bob.session, carol: carol.session };
|
||||
};
|
||||
|
||||
it('empties the chair and forgets the token, leaving the rest of the table alone', () => {
|
||||
const { lobby, bob } = table();
|
||||
const after = leaveLobby(lobby, bob.token);
|
||||
assert.equal(after.lobby.seats[1], null, 'the seat was not freed');
|
||||
assert.equal(after.lobby.seats.length, 3, 'the table changed size');
|
||||
assert.ok(!after.lobby.joinOrder.includes(bob.token), 'the departed token is still in the join order');
|
||||
assert.equal((after.lobby.seats[0] as { displayName: string }).displayName, 'Alice');
|
||||
assert.equal((after.lobby.seats[2] as { displayName: string }).displayName, 'Carol');
|
||||
});
|
||||
|
||||
it('names a seat to clear somebody else — what the host’s "remove" does', () => {
|
||||
const { lobby, alice, carol } = table();
|
||||
const after = leaveLobby(lobby, alice.token, 2);
|
||||
assert.equal(after.lobby.seats[2], null, 'the named seat was not cleared');
|
||||
assert.ok(!after.lobby.joinOrder.includes(carol.token));
|
||||
// Seat index IS player index (`lobby.ts`), so nothing may shuffle up to fill the hole.
|
||||
assert.equal((after.lobby.seats[0] as { displayName: string }).displayName, 'Alice');
|
||||
assert.equal((after.lobby.seats[1] as { displayName: string }).displayName, 'Bob');
|
||||
});
|
||||
|
||||
it('passes host rights on when the host is the one who leaves', () => {
|
||||
const { lobby, alice, bob } = table();
|
||||
const after = leaveLobby(lobby, alice.token);
|
||||
assert.equal(after.lobby.hostToken, bob.token, 'the earliest-joined remaining player did not become host');
|
||||
assert.equal(after.empty, false);
|
||||
});
|
||||
|
||||
it('reports the table empty when the last human goes, so the caller can drop it', () => {
|
||||
const { lobby, alice, bob, carol } = table();
|
||||
const one = leaveLobby(lobby, bob.token);
|
||||
const two = leaveLobby(one.lobby, carol.token);
|
||||
assert.equal(two.empty, false, 'Alice is still sitting there');
|
||||
const three = leaveLobby(two.lobby, alice.token);
|
||||
assert.equal(three.empty, true, 'a lobby with nobody human in it did not report itself empty');
|
||||
});
|
||||
|
||||
it('leaves a bot seat to the bot controls, and ignores a token holding no seat', () => {
|
||||
const { lobby, alice } = table();
|
||||
const withBot = setBotSeat(leaveLobby(lobby, alice.token, 1).lobby, 1, true);
|
||||
// `leaveLobby` is about people. A bot is removed with the button that put it there.
|
||||
const after = leaveLobby(withBot, alice.token, 1);
|
||||
assert.deepEqual(after.lobby.seats[1], { kind: 'bot' }, 'leaving cleared a bot seat');
|
||||
const stranger = leaveLobby(withBot, 'not-a-token');
|
||||
assert.equal(stranger.lobby, withBot, 'an unknown token changed the lobby');
|
||||
});
|
||||
});
|
||||
@@ -1,100 +0,0 @@
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { mkdtemp, readFile, rm } from 'node:fs/promises';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { join } from 'node:path';
|
||||
|
||||
import type { GameConfig } from '../../src/engine/state.ts';
|
||||
import type { SavedGame } from '../../src/server/session.ts';
|
||||
import { appendTiming, loadGame, writeGame } from '../../src/server/persistence.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'competitive',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
};
|
||||
|
||||
const saved: SavedGame = {
|
||||
seed: 42,
|
||||
config,
|
||||
playerNames: ['Alice', 'Bob'],
|
||||
history: [{ type: 'localOps.choose', option: 'draw' }],
|
||||
status: 'active',
|
||||
createdAt: 1000,
|
||||
botSeats: [],
|
||||
};
|
||||
|
||||
async function withTempDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {
|
||||
const dir = await mkdtemp(join(tmpdir(), 'station-master-persist-'));
|
||||
try {
|
||||
return await fn(dir);
|
||||
} finally {
|
||||
await rm(dir, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
describe('game persistence (Phase 3)', () => {
|
||||
it('writes and reads back exactly what was written', () =>
|
||||
withTempDir(async (dir) => {
|
||||
await writeGame(dir, saved, '1.2.3');
|
||||
const result = await loadGame(dir);
|
||||
assert.equal(result.found, true);
|
||||
if (!result.found) return;
|
||||
assert.deepEqual(result.saved, saved);
|
||||
}));
|
||||
|
||||
it('reports the version that wrote the file without judging it', () =>
|
||||
withTempDir(async (dir) => {
|
||||
// Reading a save no longer refuses on the version. The stamp is the PACKAGE version, which
|
||||
// moves for reasons unrelated to the rules, and gating on it destroyed every game in progress
|
||||
// across four releases — one of which only changed how the board is drawn. Whether a save
|
||||
// still replays is decided by replaying it (`tryResumeSession`); the version is kept because
|
||||
// it is worth naming in a failure, and nothing else.
|
||||
await writeGame(dir, saved, '1.2.3');
|
||||
const result = await loadGame(dir);
|
||||
assert.equal(result.found, true);
|
||||
if (!result.found) return;
|
||||
assert.equal(result.storedVersion, '1.2.3');
|
||||
assert.deepEqual(result.saved, saved);
|
||||
}));
|
||||
|
||||
it('reports not-found rather than throwing when nothing has been saved yet', () =>
|
||||
withTempDir(async (dir) => {
|
||||
const result = await loadGame(dir);
|
||||
assert.deepEqual(result, { found: false });
|
||||
}));
|
||||
|
||||
it('a later writeGame fully replaces the earlier one, not merges with it', () =>
|
||||
withTempDir(async (dir) => {
|
||||
await writeGame(dir, saved, '1.2.3');
|
||||
const grown: SavedGame = { ...saved, history: [...saved.history, { type: 'draw.end' }] };
|
||||
await writeGame(dir, grown, '1.2.3');
|
||||
const result = await loadGame(dir);
|
||||
assert.equal(result.found, true);
|
||||
if (!result.found) return;
|
||||
assert.equal(result.saved.history.length, 2);
|
||||
}));
|
||||
|
||||
it('never leaves a stray .tmp file behind after a write', () =>
|
||||
withTempDir(async (dir) => {
|
||||
await writeGame(dir, saved, '1.2.3');
|
||||
await assert.rejects(() => readFile(join(dir, 'game.json.tmp')));
|
||||
}));
|
||||
|
||||
it('appendTiming accumulates across calls rather than overwriting', () =>
|
||||
withTempDir(async (dir) => {
|
||||
await appendTiming(dir, { player: 0, phase: 'localOps', day: 1, stage: 1, startedAt: 1, endedAt: 2 });
|
||||
await appendTiming(dir, { player: 1, phase: 'localOps', day: 1, stage: 1, startedAt: 2, endedAt: 3 });
|
||||
const text = await readFile(join(dir, 'turn-timings.json'), 'utf8');
|
||||
const timings = JSON.parse(text) as unknown[];
|
||||
assert.equal(timings.length, 2);
|
||||
}));
|
||||
});
|
||||
@@ -1,533 +0,0 @@
|
||||
/**
|
||||
* The game session host (`src/server/session.ts`) — pure logic, no sockets, exercised directly.
|
||||
*/
|
||||
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import type { GameConfig, PlayerIndex } from '../../src/engine/state.ts';
|
||||
import type { GameSession, Push } from '../../src/server/session.ts';
|
||||
import { createSession, resumeSession, tryResumeSession } from '../../src/server/session.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'competitive',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
};
|
||||
|
||||
describe('the game session host', () => {
|
||||
it('gives a fresh connect a full Frame — nothing nulled', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const push = session.connect(0 as PlayerIndex);
|
||||
assert.notEqual(push.frame!.cells, null, 'a first connect nulled the board');
|
||||
assert.notEqual(push.frame!.division, null, 'a first connect nulled the division');
|
||||
});
|
||||
|
||||
it('only the current actor gets a real Menu; every other seat gets null', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const a = session.connect(0 as PlayerIndex);
|
||||
const b = session.connect(1 as PlayerIndex);
|
||||
const actorPushes = [a, b].filter((p) => p.menu !== null);
|
||||
assert.equal(actorPushes.length, 1, 'more than one seat (or zero) was given a real Menu');
|
||||
});
|
||||
|
||||
it('rejects an intent from a seat that is not the current actor, with NOT_YOUR_TURN', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
// Whichever seat is NOT the current actor should be refused, regardless of the intent's content.
|
||||
const bPush = session.connect(1 as PlayerIndex);
|
||||
const notActor = (bPush.menu === null ? 1 : 0) as PlayerIndex;
|
||||
const result = session.intent(notActor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(result.accepted, false);
|
||||
if (!result.accepted) assert.equal(result.code, 'NOT_YOUR_TURN');
|
||||
});
|
||||
|
||||
it('accepts a legal intent from the current actor and pushes every seat', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const aPush = session.connect(0 as PlayerIndex);
|
||||
const actor = (aPush.menu !== null ? 0 : 1) as PlayerIndex;
|
||||
|
||||
const result = session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(result.accepted, true);
|
||||
if (result.accepted) assert.equal(result.pushes.size, 2, 'not every connected seat was pushed to');
|
||||
});
|
||||
|
||||
it('rejects an illegal intent with its real RejectionCode, and does not remember the seq', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const aPush = session.connect(0 as PlayerIndex);
|
||||
const actor = (aPush.menu !== null ? 0 : 1) as PlayerIndex;
|
||||
|
||||
// Discarding before ever drawing is illegal on an opening hand at the limit — a safe "this is
|
||||
// definitely rejected" fixture that does not depend on exactly which cards were dealt.
|
||||
const bad = session.intent(actor, 1, { type: 'card.discard', cardId: 'not-a-real-card', toSlot: 0 });
|
||||
assert.equal(bad.accepted, false);
|
||||
if (!bad.accepted) assert.ok(bad.code.length > 0, 'a rejection carried no code at all');
|
||||
|
||||
// The same seq, now with a legal intent, must still go through — a rejection is not "applied".
|
||||
const retry = session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(retry.accepted, true, 'a seq burned by an earlier rejection could not be reused');
|
||||
});
|
||||
|
||||
it('treats a repeated seq as an already-applied no-op, not a second application', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const aPush = session.connect(0 as PlayerIndex);
|
||||
const actor = (aPush.menu !== null ? 0 : 1) as PlayerIndex;
|
||||
|
||||
const first = session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(first.accepted, true);
|
||||
const second = session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(second.accepted, true, 'a resend of an already-applied seq was rejected instead of ignored');
|
||||
if (second.accepted) assert.equal(second.pushes.size, 0, 'a resend produced pushes as if newly applied');
|
||||
});
|
||||
|
||||
it('deltas the board on a second push when it has not changed since the first', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const aPush = session.connect(0 as PlayerIndex);
|
||||
session.connect(1 as PlayerIndex); // both seats need a baseline Frame before a delta means anything
|
||||
const actor = (aPush.menu !== null ? 0 : 1) as PlayerIndex;
|
||||
|
||||
const result = session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(result.accepted, true);
|
||||
if (!result.accepted) return;
|
||||
// Choosing "draw" doesn't move a single card on the board — the division/cells should be nulled
|
||||
// on this push for a seat that already had them from `connect`.
|
||||
const push = result.pushes.get(actor)!;
|
||||
assert.equal(push.frame!.division, null, 'the board was resent even though nothing on it changed');
|
||||
});
|
||||
|
||||
it('only sends narration NEW since the last push to that specific seat', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const aPush = session.connect(0 as PlayerIndex);
|
||||
const actor = (aPush.menu !== null ? 0 : 1) as PlayerIndex;
|
||||
// A first connect is this seat's first contact, so it gets everything narrated so far (the
|
||||
// "Game Begins" intro and whatever `drain()` said entering the first Stage) — not an empty log.
|
||||
assert.ok(aPush.lines.length > 0, 'a first connect got no narration at all, not even the game-begins intro');
|
||||
|
||||
const first = session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(first.accepted, true);
|
||||
if (!first.accepted) return;
|
||||
const firstLines = first.pushes.get(actor)!.lines;
|
||||
assert.ok(firstLines.length > 0, 'the acting seat got no narration for its own action');
|
||||
|
||||
const second = session.intent(actor, 2, { type: 'draw.end' });
|
||||
assert.equal(second.accepted, true);
|
||||
if (!second.accepted) return;
|
||||
const secondLines = second.pushes.get(actor)!.lines;
|
||||
assert.ok(secondLines.length > 0, 'a second real action produced no narration at all');
|
||||
for (const line of firstLines) {
|
||||
assert.ok(!secondLines.includes(line), 'the second push repeated narration already sent in the first');
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('turn timings (lobby-and-sessions.md §5)', () => {
|
||||
it('records a wall-clock span once the acting player, phase, Day or Stage changes', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
let pushes = new Map<PlayerIndex, Push>([
|
||||
[0 as PlayerIndex, session.connect(0 as PlayerIndex)],
|
||||
[1 as PlayerIndex, session.connect(1 as PlayerIndex)],
|
||||
]);
|
||||
const seq = new Map<PlayerIndex, number>([[0 as PlayerIndex, 1], [1 as PlayerIndex, 1]]);
|
||||
const timings = [];
|
||||
|
||||
for (let step = 0; step < 60 && timings.length === 0; step++) {
|
||||
const acting = [0, 1].find((seat) => pushes.get(seat as PlayerIndex)!.menu !== null) as PlayerIndex | undefined;
|
||||
const menu = acting === undefined ? null : pushes.get(acting)!.menu;
|
||||
if (acting === undefined || !menu || menu.options.length === 0) break;
|
||||
|
||||
const n = seq.get(acting)!;
|
||||
seq.set(acting, n + 1);
|
||||
const result = session.intent(acting, n, menu.options[0]!);
|
||||
assert.equal(result.accepted, true, `step ${step}: ${JSON.stringify(menu.options[0])} rejected`);
|
||||
if (!result.accepted) break;
|
||||
if (result.timing) timings.push(result.timing);
|
||||
pushes = result.pushes;
|
||||
}
|
||||
|
||||
assert.ok(timings.length > 0, 'no turn timing ever closed across 60 real steps of actual play');
|
||||
const [timing] = timings;
|
||||
assert.ok(timing!.endedAt >= timing!.startedAt, 'a span ended before it started');
|
||||
assert.ok([0, 1].includes(timing!.player), 'a timing named a player outside the table');
|
||||
});
|
||||
});
|
||||
|
||||
describe('bot seats (Phase 4 — D8, lobby-and-sessions.md §2)', () => {
|
||||
it('a bot never becomes the observable current actor — it plays before anyone can see it waiting', () => {
|
||||
// Seat 0 acts first (the opening Superintendent), so marking it a bot exercises `driveBots()`
|
||||
// at CONSTRUCTION time — before any external `intent()` has run at all.
|
||||
const session = createSession(11, config, ['Bot', 'Alice'], [0 as PlayerIndex]);
|
||||
assert.equal(session.isBot(0 as PlayerIndex), true);
|
||||
assert.equal(session.isBot(1 as PlayerIndex), false);
|
||||
|
||||
const botPush = session.connect(0 as PlayerIndex);
|
||||
const humanPush = session.connect(1 as PlayerIndex);
|
||||
assert.equal(botPush.menu, null, 'the bot seat was handed a real decision to make');
|
||||
assert.notEqual(humanPush.menu, null, 'nobody was left with a turn to take — the bot never played');
|
||||
});
|
||||
|
||||
it('botSeats round-trips through exportSave/resumeSession', () => {
|
||||
const session = createSession(11, config, ['Bot', 'Alice'], [0 as PlayerIndex]);
|
||||
const resumed = resumeSession(session.exportSave());
|
||||
assert.equal(resumed.isBot(0 as PlayerIndex), true);
|
||||
assert.equal(resumed.connect(0 as PlayerIndex).menu, null, 'a resumed bot seat still never gets a real decision');
|
||||
});
|
||||
|
||||
it('a bot seat is driven forward after a human intent too, not only at construction', () => {
|
||||
// Two bots and one human: whichever of the two non-human seats comes up next after the human's
|
||||
// own move must be played automatically, with no external `intent()` for either of them.
|
||||
const session = createSession(11, config, ['Alice', 'Bot', 'Bot'], [1 as PlayerIndex, 2 as PlayerIndex]);
|
||||
const before = session.exportSave().history.length;
|
||||
const applied = session.intent(0 as PlayerIndex, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(applied.accepted, true);
|
||||
assert.equal(session.connect(1 as PlayerIndex).menu, null, 'bot seat 1 was left with a real decision');
|
||||
assert.equal(session.connect(2 as PlayerIndex).menu, null, 'bot seat 2 was left with a real decision');
|
||||
// Not a strict proof either bot actually moved (the human's own turn may not have ended yet),
|
||||
// but the history can only ever have grown, never shrunk, and never rejected mid-drive.
|
||||
assert.ok(session.exportSave().history.length >= before + 1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('persistence hooks — exportSave / resumeSession (Phase 3)', () => {
|
||||
it('exportSave carries enough to reconstruct the exact same game', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const push = session.connect(0 as PlayerIndex);
|
||||
const actor = (push.menu !== null ? 0 : 1) as PlayerIndex;
|
||||
const applied = session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(applied.accepted, true);
|
||||
|
||||
const saved = session.exportSave();
|
||||
assert.equal(saved.seed, 42);
|
||||
assert.deepEqual(saved.playerNames, ['Alice', 'Bob']);
|
||||
assert.equal(saved.history.length, 1);
|
||||
assert.equal(saved.status, 'active');
|
||||
assert.ok(saved.createdAt > 0, 'createdAt was not set');
|
||||
|
||||
const resumed = resumeSession(saved);
|
||||
const before = session.connect(actor);
|
||||
const after = resumed.connect(actor);
|
||||
assert.deepEqual(after.frame, before.frame, 'resumeSession did not reconstruct the same board/state');
|
||||
});
|
||||
|
||||
it('a resumed session keeps enforcing whose turn it is', () => {
|
||||
const session = createSession(7, config, ['Alice', 'Bob']);
|
||||
const push = session.connect(0 as PlayerIndex);
|
||||
const actor = (push.menu !== null ? 0 : 1) as PlayerIndex;
|
||||
session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
|
||||
const resumed = resumeSession(session.exportSave());
|
||||
const notActor = (actor === 0 ? 1 : 0) as PlayerIndex;
|
||||
const rejected = resumed.intent(notActor, 1, { type: 'draw.end' });
|
||||
assert.equal(rejected.accepted, false);
|
||||
if (!rejected.accepted) assert.equal(rejected.code, 'NOT_YOUR_TURN');
|
||||
});
|
||||
|
||||
it('marks status finished only once the game actually is', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
assert.equal(session.exportSave().status, 'active');
|
||||
});
|
||||
});
|
||||
|
||||
describe('summary() — what an administrator sees without replaying the game', () => {
|
||||
it('describes a fresh game: who is at the table, where it has got to, and who it waits on', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const s = session.summary();
|
||||
|
||||
assert.equal(s.playerCount, 2);
|
||||
assert.deepEqual(s.playerNames, ['Alice', 'Bob']);
|
||||
assert.equal(s.status, 'active');
|
||||
assert.equal(s.day, 1);
|
||||
assert.equal(s.stage, 1);
|
||||
assert.equal(typeof s.phase, 'string');
|
||||
assert.ok(s.waitingOn, 'a game in play must be waiting on somebody');
|
||||
assert.equal(s.waitingOn!.name, s.playerNames[s.waitingOn!.seat]);
|
||||
});
|
||||
|
||||
it('does not hand back a copy of the history the way exportSave must', () => {
|
||||
// The health check polls this on a timer, so it answering with every intent of every game
|
||||
// would make a question about none of them cost a copy of all of them.
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
assert.equal('history' in session.summary(), false);
|
||||
});
|
||||
|
||||
it('moves lastMoveAt when a move is accepted, and leaves it alone when one is refused', async () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const created = session.summary();
|
||||
assert.equal(created.lastMoveAt, created.createdAt, 'an untouched game has not moved since it began');
|
||||
|
||||
const actor = (session.connect(0 as PlayerIndex).menu !== null ? 0 : 1) as PlayerIndex;
|
||||
const idle = (1 - actor) as PlayerIndex;
|
||||
|
||||
// A rejection is not a move — a player poking at a game they cannot act in must not make it
|
||||
// look alive to whoever is deciding whether it has stalled.
|
||||
session.intent(idle, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(session.summary().lastMoveAt, created.lastMoveAt, 'a refused intent moved the clock');
|
||||
|
||||
await new Promise((r) => setTimeout(r, 2));
|
||||
const accepted = session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(accepted.accepted, true);
|
||||
assert.ok(session.summary().lastMoveAt > created.lastMoveAt, 'an accepted intent did not move the clock');
|
||||
});
|
||||
|
||||
it('carries lastMoveAt across a restart, and falls back to createdAt for a save without one', async () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob']);
|
||||
const actor = (session.connect(0 as PlayerIndex).menu !== null ? 0 : 1) as PlayerIndex;
|
||||
await new Promise((r) => setTimeout(r, 2));
|
||||
session.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
|
||||
const saved = session.exportSave();
|
||||
assert.equal(resumeSession(saved).summary().lastMoveAt, saved.lastMoveAt);
|
||||
|
||||
// A game written before the field existed still has to load, and reads as untouched since it
|
||||
// began rather than as having just moved.
|
||||
const { lastMoveAt: _dropped, ...older } = saved;
|
||||
const revived = resumeSession(older).summary();
|
||||
assert.equal(revived.lastMoveAt, saved.createdAt);
|
||||
});
|
||||
|
||||
it('reports a finished game as waiting on nobody', () => {
|
||||
// Every seat a bot, so the game plays itself to a finish inside the constructor.
|
||||
const session = createSession(4242, config, ['A', 'B'], [0 as PlayerIndex, 1 as PlayerIndex]);
|
||||
const s = session.summary();
|
||||
assert.equal(s.status, 'finished');
|
||||
assert.equal(s.waitingOn, null, 'a finished game must not name somebody to wait for');
|
||||
});
|
||||
});
|
||||
|
||||
describe('a save survives a release that did not change the rules', () => {
|
||||
/** Plays a couple of real moves so the history is worth replaying. */
|
||||
const played = (): ReturnType<GameSession['exportSave']> => {
|
||||
const s = createSession(42, config, ['Alice', 'Bob']);
|
||||
const actor = (s.connect(0 as PlayerIndex).menu !== null ? 0 : 1) as PlayerIndex;
|
||||
s.intent(actor, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
return s.exportSave();
|
||||
};
|
||||
|
||||
it('resumes whatever version stamped it, so long as the moves still replay', () => {
|
||||
// This is the whole point. The engine version used to gate this, and it is the PACKAGE version
|
||||
// — it moves for a CSS fix. Four releases in a row destroyed every game in progress, one of
|
||||
// them for a change that only altered how the board is drawn.
|
||||
const saved = played();
|
||||
const r = tryResumeSession(saved);
|
||||
assert.equal(r.ok, true, 'a replayable save was refused');
|
||||
if (!r.ok) return;
|
||||
assert.deepEqual(r.session.exportSave().history, saved.history);
|
||||
});
|
||||
|
||||
it('refuses a save whose moves no longer replay, and says which move and why', () => {
|
||||
// A rules change is simulated by corrupting one intent — the engine cannot apply it, which is
|
||||
// exactly the shape a genuinely incompatible save has.
|
||||
const saved = played();
|
||||
const broken = {
|
||||
...saved,
|
||||
history: [...saved.history, { type: 'localOps.choose', option: 'not-a-real-option' } as never],
|
||||
};
|
||||
const r = tryResumeSession(broken);
|
||||
assert.equal(r.ok, false, 'a save the rules reject was accepted');
|
||||
if (r.ok) return;
|
||||
assert.equal(r.failure.of, broken.history.length);
|
||||
assert.equal(r.failure.stoppedAt, broken.history.length - 1, 'wrong move blamed');
|
||||
assert.equal(r.failure.intent, 'localOps.choose');
|
||||
assert.ok(r.failure.code.length > 0, 'no rejection code to act on');
|
||||
});
|
||||
|
||||
it('never silently truncates — the old loop stopped at a bad move and said nothing', () => {
|
||||
// The silence was survivable only because the version check meant a doomed replay was never
|
||||
// attempted. Now that the replay IS the check, a partial one must be impossible to mistake for
|
||||
// a whole one.
|
||||
const saved = played();
|
||||
const broken = { ...saved, history: [{ type: 'draw.end' } as never, ...saved.history] };
|
||||
const r = tryResumeSession(broken);
|
||||
assert.equal(r.ok, false, 'a truncated replay was returned as a healthy session');
|
||||
});
|
||||
});
|
||||
|
||||
describe('the four transient signals (2026-08-23)', () => {
|
||||
/**
|
||||
* Multiplayer had none of these: `createRemoteSession` answered every one of them with an empty
|
||||
* value, so a game on a server had no sound, no timetable flash, no announcement when a completed
|
||||
* run paid the table, and no badge on the card you had just drawn. They ride on the push now — and
|
||||
* `justDrawn` is the one that has to be careful, because `game.justDrawn` is ONE field for the
|
||||
* whole game and does not say whose card it is.
|
||||
*/
|
||||
|
||||
/** Drives the game until the current actor draws a card, and returns that turn's pushes. */
|
||||
const drawSomething = (session: GameSession, players: number): { seat: PlayerIndex; pushes: Map<PlayerIndex, Push> } => {
|
||||
for (let seat = 0 as PlayerIndex; seat < players; seat++) {
|
||||
if (session.connect(seat).menu === null) continue;
|
||||
// Two steps: §6's three options are exclusive, so the turn is spent on drawing before a card
|
||||
// actually leaves the deck.
|
||||
const chose = session.intent(seat, 1, { type: 'localOps.choose', option: 'draw' });
|
||||
assert.equal(chose.accepted, true, 'the actor could not choose to draw');
|
||||
const result = session.intent(seat, 2, { type: 'draw.fromHomeOffice' });
|
||||
assert.equal(result.accepted, true, 'the actor could not draw from the Home Office deck');
|
||||
if (!result.accepted) throw new Error('unreachable');
|
||||
return { seat, pushes: result.pushes };
|
||||
}
|
||||
throw new Error('no seat was able to act');
|
||||
};
|
||||
|
||||
it('sends the drawn card to the seat that drew it, and to nobody else', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob', 'Carol']);
|
||||
const { seat, pushes } = drawSomething(session, 3);
|
||||
const mine = pushes.get(seat);
|
||||
assert.ok(mine?.justDrawn, 'the drawing seat was not told which card it drew');
|
||||
for (const [other, push] of pushes) {
|
||||
if (other === seat) continue;
|
||||
assert.equal(
|
||||
push.justDrawn,
|
||||
undefined,
|
||||
`seat ${other} was told which card seat ${seat} drew — that is a hand leak`,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
it('keeps the badge across a reconnect, still only for its owner', () => {
|
||||
const session = createSession(42, config, ['Alice', 'Bob', 'Carol']);
|
||||
const { seat, pushes } = drawSomething(session, 3);
|
||||
const drawn = pushes.get(seat)?.justDrawn;
|
||||
assert.equal(session.connect(seat).justDrawn, drawn, 'a refresh lost the card the player just drew');
|
||||
const other = ((seat + 1) % 3) as PlayerIndex;
|
||||
assert.equal(session.connect(other).justDrawn, undefined, 'a reconnecting seat was told about someone else’s draw');
|
||||
});
|
||||
|
||||
it('sends the shared signals to every seat, identically, and drains them', () => {
|
||||
// A collision anywhere on the Division, the Stage bell, a train running off the end and paying
|
||||
// everyone: these are the table's, not one player's.
|
||||
const session = createSession(42, config, ['Alice', 'Bob', 'Carol']);
|
||||
const { pushes } = drawSomething(session, 3);
|
||||
const cues = [...pushes.values()].map((p) => JSON.stringify(p.cues ?? []));
|
||||
assert.equal(new Set(cues).size, 1, 'seats were sent different sound cues for the same events');
|
||||
|
||||
// Drained: a signal marks a moment, so a later connect must not replay it.
|
||||
const later = session.connect(0 as PlayerIndex);
|
||||
assert.equal(later.cues, undefined, 'a reconnecting client was sent the sounds of what it missed');
|
||||
assert.equal(later.announcement, undefined, 'a reconnecting client was re-sent an old announcement');
|
||||
assert.equal(later.scheduled, undefined, 'a reconnecting client was re-sent an old timetable flash');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('§3.3 extended play across the server (Gitea#11)', () => {
|
||||
/**
|
||||
* A one-Day game, so these tests reach the end of the timetable by actually PLAYING to it.
|
||||
*
|
||||
* There is no back door into a session's engine state and there should not be — `connect`,
|
||||
* `intent`, `exportSave` and `summary` are the whole surface. So the clock is run down through the
|
||||
* same calls a client makes, which has the side benefit of exercising the real path: what is under
|
||||
* test here is the session's handling of the vote (the turn guard, the bots, the saved status),
|
||||
* and reaching it any other way would prove less.
|
||||
*/
|
||||
const oneDay: GameConfig = { ...config, days: 1 };
|
||||
|
||||
/** What seat `seat` can currently see. `connect` always yields a full Frame, never a delta. */
|
||||
const frameOf = (session: GameSession, seat: PlayerIndex) => session.connect(seat).frame!;
|
||||
|
||||
/** Plays until the game stops asking for ordinary moves. Returns the Frame it stopped on. */
|
||||
function playToTheEnd(session: GameSession, seats: PlayerIndex[]) {
|
||||
let seq = 0;
|
||||
for (let i = 0; i < 5_000; i++) {
|
||||
const acting = seats.find((s) => session.connect(s).menu !== null);
|
||||
if (acting === undefined) break;
|
||||
const menu = session.connect(acting).menu!;
|
||||
if (menu.options.length === 0) break;
|
||||
if (!session.intent(acting, seq++, menu.options[0]!).accepted) break;
|
||||
}
|
||||
return { frame: frameOf(session, seats[0]!), seq };
|
||||
}
|
||||
|
||||
it('stops to ask rather than ending, and every seat can see the question', () => {
|
||||
const session = createSession(42, oneDay, ['Alice', 'Bob']);
|
||||
const { frame } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
|
||||
assert.equal(frame.status, 'awaitingExtension', 'the game did not stop to ask');
|
||||
assert.ok(frame.official, 'the official result did not reach the client');
|
||||
assert.deepEqual(frame.extensionVotes, [null, null], 'the votes did not reach the client');
|
||||
});
|
||||
|
||||
it('accepts the vote from a seat that is not the current actor', () => {
|
||||
// `currentActor` is null once the game has stopped, so the ordinary turn guard would refuse
|
||||
// every vote with NOT_YOUR_TURN. Both seats vote here and neither of them is the actor.
|
||||
const session = createSession(42, oneDay, ['Alice', 'Bob']);
|
||||
const { seq } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
|
||||
const a = session.intent(0 as PlayerIndex, seq + 1, { type: 'game.extend', player: 0, agree: true });
|
||||
assert.equal(a.accepted, true, 'seat 0 could not vote');
|
||||
const b = session.intent(1 as PlayerIndex, seq + 2, { type: 'game.extend', player: 1, agree: true });
|
||||
assert.equal(b.accepted, true, 'seat 1 could not vote');
|
||||
|
||||
const after = frameOf(session, 0 as PlayerIndex);
|
||||
assert.equal(after.extraDays, 1, 'a unanimous table was not given its Day');
|
||||
assert.equal(after.status, 'active', 'play did not resume');
|
||||
});
|
||||
|
||||
it('bots agree only once every human has, and never lead', () => {
|
||||
// "Bots will not disagree with the human. Humans get to vote first" (Jesse, 2026-08-28).
|
||||
const session = createSession(42, oneDay, ['Alice', 'Botty'], [1 as PlayerIndex]);
|
||||
const { seq } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
|
||||
assert.equal(frameOf(session, 0 as PlayerIndex).status, 'awaitingExtension');
|
||||
assert.equal(
|
||||
frameOf(session, 0 as PlayerIndex).extensionVotes[1],
|
||||
null,
|
||||
'the bot voted before the human did',
|
||||
);
|
||||
|
||||
session.intent(0 as PlayerIndex, seq + 1, { type: 'game.extend', player: 0, agree: true });
|
||||
const after = frameOf(session, 0 as PlayerIndex);
|
||||
assert.equal(after.extraDays, 1, 'the bot did not follow the human into another Day');
|
||||
assert.equal(after.status, 'active');
|
||||
});
|
||||
|
||||
it('a human refusal ends it, and no bot overrides that', () => {
|
||||
const session = createSession(42, oneDay, ['Alice', 'Botty'], [1 as PlayerIndex]);
|
||||
const { seq } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
|
||||
session.intent(0 as PlayerIndex, seq + 1, { type: 'game.extend', player: 0, agree: false });
|
||||
const after = frameOf(session, 0 as PlayerIndex);
|
||||
assert.equal(after.status, 'finished');
|
||||
assert.equal(after.extraDays, 0);
|
||||
});
|
||||
|
||||
it('REGRESSION: an all-bot game ends rather than hanging on the question', () => {
|
||||
/**
|
||||
* `driveBots` loops on `currentActor`, which is null the moment the game stops to ask — so it
|
||||
* cannot cast the vote itself, and the bots' vote is driven separately. The first cut of that
|
||||
* driver returned early when there were no humans to follow, on the reasoning that a bot-only
|
||||
* table would decline through the ordinary path. It has no ordinary path: nothing ever asked
|
||||
* the bots, and an all-bot session sat on the question for ever without reaching `finished`.
|
||||
* Caught by `summary()`'s own "a finished game waits on nobody" test.
|
||||
*/
|
||||
const session = createSession(4242, oneDay, ['A', 'B'], [0, 1] as PlayerIndex[]);
|
||||
assert.equal(frameOf(session, 0 as PlayerIndex).status, 'finished', 'the bots never answered');
|
||||
assert.equal(session.summary().waitingOn, null);
|
||||
assert.equal(frameOf(session, 0 as PlayerIndex).extraDays, 0, 'bots voted themselves another Day');
|
||||
});
|
||||
|
||||
it('saves a game awaiting its vote as ACTIVE, so a restart resumes it', () => {
|
||||
// `server/index.ts` never loads a `finished` game back into memory. A game paused on the
|
||||
// extension question is waiting on its table, not over — persisting it as finished would strand
|
||||
// it on disk mid-decision.
|
||||
const session = createSession(42, oneDay, ['Alice', 'Bob']);
|
||||
playToTheEnd(session, [0, 1] as PlayerIndex[]);
|
||||
assert.equal(frameOf(session, 0 as PlayerIndex).status, 'awaitingExtension');
|
||||
assert.equal(session.exportSave().status, 'active', 'a paused game was saved as finished');
|
||||
assert.equal(session.summary().status, 'active');
|
||||
});
|
||||
|
||||
it('resumes a paused game from its history, vote and all', () => {
|
||||
const session = createSession(42, oneDay, ['Alice', 'Bob']);
|
||||
const { seq } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
|
||||
session.intent(0 as PlayerIndex, seq + 1, { type: 'game.extend', player: 0, agree: true });
|
||||
|
||||
const resumed = resumeSession(session.exportSave());
|
||||
const a = frameOf(session, 0 as PlayerIndex);
|
||||
const b = frameOf(resumed, 0 as PlayerIndex);
|
||||
assert.deepEqual(b.extensionVotes, a.extensionVotes, 'the votes did not survive the replay');
|
||||
assert.equal(b.extraDays, a.extraDays, 'the extra Day did not survive the replay');
|
||||
assert.deepEqual(b.official, a.official, 'the official result did not survive the replay');
|
||||
});
|
||||
});
|
||||
+2
-35
@@ -14,12 +14,11 @@
|
||||
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFileSync, readdirSync } from 'node:fs';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
|
||||
import { actionGroups, currentActor, handPlayable, newGame, overHandLimit, submit, toSave, view } from '../src/web/game.ts';
|
||||
import { createLocalSession } from '../src/web/session.ts';
|
||||
import { seatLabel } from '../src/sim/view.ts';
|
||||
|
||||
/**
|
||||
* Drive a session by always taking the first offered action.
|
||||
@@ -63,13 +62,7 @@ describe('a local session plays the same game as the calls it replaced', () => {
|
||||
assert.ok(turns > 50, `only ${turns} decisions — the game stalled`);
|
||||
|
||||
const f = session.view();
|
||||
/**
|
||||
* `awaitingExtension` since Gitea#11, not `finished`: both loops stop when there is no actor,
|
||||
* and a days-based ending now parks the game on the "play one more Day?" question rather than
|
||||
* ending it outright. What this test is actually about is unchanged — the two sides reach the
|
||||
* SAME position — and the assertion below is still the one carrying that.
|
||||
*/
|
||||
assert.equal(f.status, 'awaitingExtension');
|
||||
assert.equal(f.status, 'finished');
|
||||
assert.equal(f.status, view(game).status);
|
||||
assert.equal(f.day, view(game).day);
|
||||
assert.deepEqual(f.cells, view(game).cells, 'the board differs across the boundary');
|
||||
@@ -225,32 +218,6 @@ describe('the page stays on the near side of the boundary', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('seats are counted from 1 wherever a person reads them', () => {
|
||||
it('seatLabel shifts the zero-based index the whole engine uses', () => {
|
||||
assert.deepEqual([0, 1, 2, 3].map(seatLabel), [1, 2, 3, 4]);
|
||||
});
|
||||
|
||||
it('no user-facing "Seat N" bypasses it', () => {
|
||||
// The internal convention is zero-based and must stay that way — it indexes `seating`, the
|
||||
// seats array and every route. The DISPLAYED number is the one a player would say out loud, so
|
||||
// the two have to be converted at exactly one place; anything interpolating a raw seat into a
|
||||
// "Seat …" string has quietly reintroduced "Seat 0".
|
||||
const roots = ['src/web', 'src/sim', 'src/server'];
|
||||
const offenders: string[] = [];
|
||||
for (const dir of roots) {
|
||||
const base = join(import.meta.dirname, '..', dir);
|
||||
for (const name of readdirSync(base, { recursive: true, encoding: 'utf8' })) {
|
||||
if (!name.endsWith('.ts')) continue;
|
||||
const text = readFileSync(join(base, name), 'utf8');
|
||||
for (const m of text.matchAll(/`[^`]*Seat \$\{([^}]*)\}/g)) {
|
||||
if (!m[1]!.includes('seatLabel')) offenders.push(`${dir}/${name}: ${m[0]!.slice(0, 60)}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
assert.deepEqual(offenders, [], 'a seat is shown to a player without going through seatLabel');
|
||||
});
|
||||
});
|
||||
|
||||
describe('capabilities say what only a local session can do', () => {
|
||||
it('offers undo, a local save and a new deal', () => {
|
||||
// The page hides these rather than calling them and failing. A server can offer none of them: it
|
||||
|
||||
+49
-125
@@ -22,7 +22,6 @@ import {
|
||||
deckComposition,
|
||||
isFreightHouse,
|
||||
lengthProfile,
|
||||
MAINLINE_DECK,
|
||||
mainlineCardCount,
|
||||
nextOfficeTier,
|
||||
officeProfile,
|
||||
@@ -35,13 +34,11 @@ import { subdivisions } from '../src/engine/state.ts';
|
||||
|
||||
const solitaireConfig: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -63,73 +60,56 @@ const gameDealtWith = (startingHand: StartingHand, seed = 1234) =>
|
||||
|
||||
describe('card catalogue (component 1)', () => {
|
||||
it('composes the deck from the design', () => {
|
||||
// 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.
|
||||
// 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.
|
||||
//
|
||||
// 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.
|
||||
// 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.
|
||||
//
|
||||
// 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);
|
||||
// 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);
|
||||
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, {
|
||||
// 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,
|
||||
// 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,
|
||||
modifier: 23,
|
||||
train: 22,
|
||||
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,
|
||||
spaceUse: 12,
|
||||
enhancement: 18,
|
||||
mainlineModifier: 7,
|
||||
// 6, not 7 — Poling is dealt no copies until its rule is known.
|
||||
maneuver: 6,
|
||||
action: 10,
|
||||
});
|
||||
});
|
||||
|
||||
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 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);
|
||||
// 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);
|
||||
for (const c of DEFENCE_ONLY_CARDS) {
|
||||
assert.ok(c.answers, `${c.name} is held back without saying what it answers`);
|
||||
assert.ok(
|
||||
@@ -148,12 +128,11 @@ describe('card catalogue (component 1)', () => {
|
||||
});
|
||||
|
||||
it('deals track FROM the deck, at the sheet\'s counts', () => {
|
||||
// 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);
|
||||
// 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);
|
||||
const deck = buildDeck();
|
||||
for (const t of TRACK_CARDS) {
|
||||
const n = deck.filter(
|
||||
@@ -164,26 +143,11 @@ describe('card catalogue (component 1)', () => {
|
||||
});
|
||||
|
||||
it('makes track the largest category in the deck', () => {
|
||||
// 48 of 121. Building a district is paid for in the industry or train you did not draw, which
|
||||
// 96 of 235. 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 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`);
|
||||
const track = deck.filter((c) => c.kind.kind === 'track').length;
|
||||
assert.ok(track > deck.length / 3, `track is only ${track} of ${deck.length} cards`);
|
||||
});
|
||||
|
||||
it('has 12 timetabled trains, odd westbound and even eastbound', () => {
|
||||
@@ -342,16 +306,12 @@ describe('card catalogue (component 1)', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('keeps the three day-count presets sim/CLI tooling still relies on', () => {
|
||||
// Gap 10e's fixed targets retired 2026-08-20 — `minCombinedRevenue` is a free `GameConfig`
|
||||
// variable now, not a `length`-keyed lookup. `LENGTH_PROFILES` survives only as a convenience
|
||||
// preset for tools that still want a short/standard/campaign argument (`harness.ts`, `compare.ts`,
|
||||
// `replay.ts`).
|
||||
it('uses the Gap 10e revised victory targets', () => {
|
||||
assert.deepEqual(
|
||||
LENGTH_PROFILES.map((p) => [p.length, p.days]),
|
||||
[['short', 3], ['standard', 5], ['campaign', 10]],
|
||||
LENGTH_PROFILES.map((p) => [p.target, p.days]),
|
||||
[[10, 3], [20, 5], [45, 10]],
|
||||
);
|
||||
assert.equal(lengthProfile('standard').days, 5);
|
||||
assert.equal(lengthProfile('standard').target, 20);
|
||||
});
|
||||
|
||||
it('scales fixed supplies with player count', () => {
|
||||
@@ -447,42 +407,6 @@ describe('game setup (component 2)', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('deals the Mainline cards from the printed deck, without replacement', () => {
|
||||
/**
|
||||
* `buildDivision` drew uniformly from the nine card TYPES with replacement, so a Division could
|
||||
* be dealt two Interchanges (or two Tunnels), and Plains — printed twice in the deck — carried
|
||||
* the same weight as cards printed once. That became a rules question rather than a flavour one
|
||||
* when an Extra gained the right to start "at the Interchange if one is on the board" (§7): the
|
||||
* board has to hold at most one for that to mean anything.
|
||||
*
|
||||
* Swept over many seeds because a single deal cannot tell a deck from a die.
|
||||
*/
|
||||
const seen = new Map<string, number>();
|
||||
for (let seed = 0; seed < 400; seed++) {
|
||||
for (const players of [1, 2, 3, 4]) {
|
||||
const g = createGame({
|
||||
id: 'deck', seed,
|
||||
config: players === 1 ? solitaireConfig : { ...solitaireConfig, mode: 'competitive' },
|
||||
playerNames: Array.from({ length: players }, (_, i) => `P${i}`),
|
||||
});
|
||||
const cards = g.division.nodes.flatMap((n) => (n.kind === 'mainline' ? [n.card] : []));
|
||||
assert.equal(cards.length, mainlineCardCount(players));
|
||||
const counts = new Map<string, number>();
|
||||
for (const c of cards) {
|
||||
const n = (counts.get(c) ?? 0) + 1;
|
||||
counts.set(c, n);
|
||||
seen.set(c, (seen.get(c) ?? 0) + 1);
|
||||
// Plains is the one card printed twice; nothing else may be dealt twice at all.
|
||||
assert.ok(n <= (c === 'plains' ? 2 : 1), `${c} dealt ${n} times at seed ${seed}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Every card in the deck reachable, so the deal is not quietly missing one.
|
||||
for (const kind of new Set(MAINLINE_DECK)) {
|
||||
assert.ok((seen.get(kind) ?? 0) > 0, `${kind} was never dealt in 400 seeds`);
|
||||
}
|
||||
});
|
||||
|
||||
it('opens with the whole railroad as one Subdivision', () => {
|
||||
// §8 — every Office is a Whistle Post, which is not a Control Point.
|
||||
const g = newSolitaireGame();
|
||||
|
||||
+36
-100
@@ -22,13 +22,11 @@ import { anomalies, strategyBuckets } from '../src/sim/stats.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: 3,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
victory: 'highestAfterDays',
|
||||
length: 'short',
|
||||
optionalRules: {
|
||||
reducedVisibility: false,
|
||||
sisterTrains: false,
|
||||
employeeRotation: false,
|
||||
emergencyToolbox: false,
|
||||
},
|
||||
@@ -157,7 +155,7 @@ describe('the revenue chain works end to end (regression)', () => {
|
||||
// more cars in total (22 vs 19 over forty games). Widened so it fails for the reason it names.
|
||||
let spotted = 0;
|
||||
for (const seed of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]) {
|
||||
const s = createGame({ id: 'g', seed, config: { ...config, days: 5 }, playerNames: ['bot'] });
|
||||
const s = createGame({ id: 'g', seed, config: { ...config, length: 'standard' }, playerNames: ['bot'] });
|
||||
playGame(s, developerBot, pump);
|
||||
for (const card of s.officeAreas.get(0)!.grid.values()) {
|
||||
if (card.facility?.kind === 'freight') spotted += card.facility.industryTrack.cars.length;
|
||||
@@ -174,7 +172,7 @@ describe('the revenue chain works end to end (regression)', () => {
|
||||
// the old 52-card placeholder it was 10 in 52.
|
||||
let placed = 0;
|
||||
for (const seed of [11, 23, 47, 91, 137, 211]) {
|
||||
const s = createGame({ id: 'g', seed, config: { ...config, days: 10 }, playerNames: ['bot'] });
|
||||
const s = createGame({ id: 'g', seed, config: { ...config, length: 'campaign' }, playerNames: ['bot'] });
|
||||
playGame(s, developerBot, pump);
|
||||
for (const card of s.officeAreas.get(0)!.grid.values()) {
|
||||
if (card.geometry.kind !== 'facility') continue;
|
||||
@@ -191,26 +189,15 @@ 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: 200,
|
||||
games: 40,
|
||||
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 200 games');
|
||||
assert.ok(freight > 0, 'no freight load completed across 40 games');
|
||||
});
|
||||
|
||||
it('grows the Office Area off the Running Track, on either side', () => {
|
||||
@@ -219,7 +206,7 @@ describe('the revenue chain works end to end (regression)', () => {
|
||||
// "downward only" is gone, and with it the rule that rejected every square above row 0.
|
||||
const rows = new Set<number>();
|
||||
for (const seed of [3, 9, 27, 81]) {
|
||||
const s = createGame({ id: 'g', seed, config: { ...config, days: 10 }, playerNames: ['bot'] });
|
||||
const s = createGame({ id: 'g', seed, config: { ...config, length: 'campaign' }, playerNames: ['bot'] });
|
||||
playGame(s, developerBot, pump);
|
||||
for (const key of s.officeAreas.get(0)!.grid.keys()) rows.add(Number(key.split(',')[0]));
|
||||
}
|
||||
@@ -285,7 +272,7 @@ describe('the deck is closed — no card is created or destroyed', () => {
|
||||
// Every card is in exactly one place: the Home Office deck, a Department pile, the Salvage Yard,
|
||||
// a hand, or on the board — grid cells, enhancements laid on them, and Mainline modifiers.
|
||||
for (const seed of [3, 17, 91]) {
|
||||
const s = createGame({ id: `cc-${seed}`, seed, config: { ...config, days: 5 }, playerNames: ['bot'] });
|
||||
const s = createGame({ id: `cc-${seed}`, seed, config: { ...config, length: 'standard' }, playerNames: ['bot'] });
|
||||
const total = s.cards.size;
|
||||
playGame(s, developerBot, pump);
|
||||
|
||||
@@ -307,7 +294,7 @@ describe('the deck is closed — no card is created or destroyed', () => {
|
||||
// The sharper form of the same guard. A discard moves a card from a hand to a Department pile
|
||||
// and a draw moves one back, so the count across deck + Departments + Salvage Yard + hands can
|
||||
// only fall by cards actually placed on the board — never by one being overwritten.
|
||||
const s = createGame({ id: 'cc', seed: 5, config: { ...config, days: 5 }, playerNames: ['bot'] });
|
||||
const s = createGame({ id: 'cc', seed: 5, config: { ...config, length: 'standard' }, playerNames: ['bot'] });
|
||||
const before = s.cards.size;
|
||||
playGame(s, developerBot, pump);
|
||||
const loose =
|
||||
@@ -362,32 +349,7 @@ 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.
|
||||
*/
|
||||
/**
|
||||
* RED FLAGS JOINS IT, and the reason CHANGED with Gitea#19 — the exemption stays, but it no
|
||||
* longer means what it used to.
|
||||
*
|
||||
* IT USED TO MEAN "the bot will not take it": measured over 600 games under the old rule,
|
||||
* `maneuver.redFlags` was OFFERED 4,212 times and PLAYED 4. The card protected a stopped train
|
||||
* out on the Mainline, it was always available, and the bot simply declined it.
|
||||
*
|
||||
* SINCE Gitea#19 the bot would take it every time — `worthFlagging` accepts the out-of-phase
|
||||
* prompt unconditionally, because the engine only raises that prompt when an arrival is
|
||||
* certainly about to collide, so there is nothing left for the bot to judge. It still never
|
||||
* plays one. MEASURED after the redesign, 200 solitaire games: `redFlagsSet` fires ZERO times.
|
||||
*
|
||||
* The reason is now arithmetic rather than judgement, and it is worth writing down because it
|
||||
* says what would actually change it. The prompt needs two things to coincide — an arrival that
|
||||
* would collide (0.14 collisions per game, so roughly one game in seven) AND the district's
|
||||
* owner holding a Red Flags card at that moment, out of a three-card hand drawn from 121. The
|
||||
* bot also never plants a flag speculatively, which is the other half of the card and the half
|
||||
* a human would use to buy time for switching.
|
||||
*
|
||||
* So this canary is measuring deck luck, not reachability. `test/mainline-cards.test.ts`
|
||||
* exercises both halves of the rule end to end on a hand-built board, which is where the
|
||||
* behaviour is actually pinned. Removing this line still proves something worth proving — that
|
||||
* the bot has learned to plant a flag on purpose rather than only when handed one.
|
||||
*/
|
||||
const KNOWN_UNREACHABLE_BY_THE_BOT = ['event flyingSwitch', 'event redFlagsSet'];
|
||||
const KNOWN_UNREACHABLE_BY_THE_BOT = ['event flyingSwitch'];
|
||||
const found = anomalies(report.perGame);
|
||||
const never = found
|
||||
.filter((a) => a.severity === 'never')
|
||||
@@ -424,22 +386,13 @@ describe('switching accomplishes something (regression)', () => {
|
||||
// no switching at all (§9.2 works coaches straight off the A/D track), so an entire Local
|
||||
// Operations action was wasted.
|
||||
/**
|
||||
* ACROSS SEEDS, because one game cannot tell a fixed bug from a lucky deal — and the sample has
|
||||
* to be big enough that it cannot tell a lucky DEAL from a fixed bug either.
|
||||
*
|
||||
* It was 16 hand-picked seeds against a bar of 70% clean, on a measurement of 13/16. Dealing the
|
||||
* Mainline cards from the printed deck instead of rolling them (`buildDivision`) re-dealt every
|
||||
* one of those boards and the same 16 came back 11/16, which read as a regression and was not
|
||||
* one: re-measured over 80 seeds the rate is **70.0% clean, worst run 5** — the identical
|
||||
* behaviour, and 13/16 was the lucky draw. A bar sitting exactly on the true rate fails half the
|
||||
* time it is moved.
|
||||
*
|
||||
* So: a wider sweep, and a bar well below the measured rate. What the test is really guarding is
|
||||
* the every-game waste it was written for, which shows up as a rate near ZERO, not as a few
|
||||
* points of drift. The ceiling on the worst run is the sharp half of the assertion and is
|
||||
* unchanged. The residual is recorded in TODO.md with the rest of the bot work.
|
||||
* ACROSS SEEDS, because one game cannot tell a fixed bug from a lucky deal. Measured over these
|
||||
* 16: thirteen show no oscillation at all and three reach a run of five, so the shuttling is a
|
||||
* minority behaviour rather than the every-game waste this test was written to catch. The bar is
|
||||
* therefore a RATE — most games clean — plus a ceiling on how bad the worst may get. The residual
|
||||
* is recorded in TODO.md with the rest of the bot work.
|
||||
*/
|
||||
const seeds = Array.from({ length: 48 }, (_, i) => i + 1);
|
||||
const seeds = [1234, 5, 77, 430, 202, 999, 21, 555, 4321, 31337, 60606, 7777, 123456, 888, 31, 42];
|
||||
let clean = 0;
|
||||
let worstAnywhere = 0;
|
||||
for (const seed of seeds) {
|
||||
@@ -471,7 +424,7 @@ describe('switching accomplishes something (regression)', () => {
|
||||
}
|
||||
|
||||
assert.ok(
|
||||
clean >= seeds.length * 0.55,
|
||||
clean >= seeds.length * 0.7,
|
||||
`only ${clean}/${seeds.length} games were free of aimless shuttling`,
|
||||
);
|
||||
assert.ok(worstAnywhere <= 5, `a crew oscillated ${worstAnywhere + 1} times without doing any work`);
|
||||
@@ -590,7 +543,7 @@ describe('the bot builds sidings that are actually sidings (regression)', () =>
|
||||
const s = createGame({
|
||||
id: `sd-${i}`,
|
||||
seed: 1000 + i * 7919,
|
||||
config: { ...config, days: 5 },
|
||||
config: { ...config, length: 'standard' },
|
||||
playerNames: ['bot'],
|
||||
});
|
||||
playGame(s, developerBot, pump);
|
||||
@@ -679,21 +632,16 @@ 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.
|
||||
// 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.
|
||||
// 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.
|
||||
const dropped = new Set<string>();
|
||||
for (let i = 0; i < 300; i++) {
|
||||
for (let i = 0; i < 100; i++) {
|
||||
const s = createGame({
|
||||
id: `cs-${i}`,
|
||||
seed: 1000 + i * 7919,
|
||||
config: { ...config, days: 5 },
|
||||
config: { ...config, length: 'standard' },
|
||||
playerNames: ['bot'],
|
||||
});
|
||||
const r = playGame(s, developerBot, pump);
|
||||
@@ -777,7 +725,7 @@ describe('the bot does not throw away its own freight (regression)', () => {
|
||||
const s = createGame({
|
||||
id: `uj-${i}`,
|
||||
seed: 1000 + i * 7919,
|
||||
config: { ...config, days: 5 },
|
||||
config: { ...config, length: 'standard' },
|
||||
playerNames: ['bot'],
|
||||
});
|
||||
const r = playGame(s, developerBot, pump);
|
||||
@@ -806,7 +754,7 @@ describe('the bot does not throw away its own freight (regression)', () => {
|
||||
// The other half of the regression above. Gutting the fallback entirely would satisfy "never
|
||||
// unjams a green box" while leaving a real jam to block the industry forever — a load stranded
|
||||
// on WORK keeps the track locked, which now stops trains passing as well as stopping (§9.3).
|
||||
const s = createGame({ id: 'jam', seed: 5, config: { ...config, days: 5 }, playerNames: ['bot'] });
|
||||
const s = createGame({ id: 'jam', seed: 5, config: { ...config, length: 'standard' }, playerNames: ['bot'] });
|
||||
const area = s.officeAreas.get(0)!;
|
||||
area.grid.set('-1,0', {
|
||||
geometry: { kind: 'facility', facility: 'mineTipple' },
|
||||
@@ -851,7 +799,7 @@ describe('Enhancements can reach the board at all (regression)', () => {
|
||||
const s = createGame({
|
||||
id: `st-${i}`,
|
||||
seed: 1000 + i * 7919,
|
||||
config: { ...config, days: 5 },
|
||||
config: { ...config, length: 'standard' },
|
||||
playerNames: ['bot'],
|
||||
});
|
||||
playGame(s, developerBot, pump);
|
||||
@@ -888,7 +836,7 @@ describe('Enhancements can reach the board at all (regression)', () => {
|
||||
const s = createGame({
|
||||
id: `il-${i}`,
|
||||
seed: 1000 + i * 7919,
|
||||
config: { ...config, days: 5 },
|
||||
config: { ...config, length: 'standard' },
|
||||
playerNames: ['bot'],
|
||||
});
|
||||
playGame(s, developerBot, pump);
|
||||
@@ -926,7 +874,7 @@ describe('rolling stock returns to service (regression)', () => {
|
||||
const s = createGame({
|
||||
id: 'refill',
|
||||
seed: 4,
|
||||
config: { ...config, days: 5 },
|
||||
config: { ...config, length: 'standard' },
|
||||
playerNames: ['bot'],
|
||||
});
|
||||
|
||||
@@ -965,7 +913,7 @@ describe('measurement discipline', () => {
|
||||
// the observer hook cannot drift from the log, so probes have one trustworthy way in and no
|
||||
// reason to hand-roll the drive loop again.
|
||||
const seen: string[] = [];
|
||||
const s = createGame({ id: 'obs', seed: 4242, config: { ...config, days: 5 }, playerNames: ['b'] });
|
||||
const s = createGame({ id: 'obs', seed: 4242, config: { ...config, length: 'standard' }, playerNames: ['b'] });
|
||||
const out = playGame(s, developerBot, pump, 50_000, (e) => seen.push(e.type));
|
||||
|
||||
assert.ok(out.events.length > 0, 'a finished game must produce events');
|
||||
@@ -977,7 +925,7 @@ describe('measurement discipline', () => {
|
||||
// Asserted across several seeds because a single game may never draw a Depot card.
|
||||
let upgrades = 0;
|
||||
for (let seed = 0; seed < 25; seed++) {
|
||||
const s = createGame({ id: `u${seed}`, seed, config: { ...config, days: 5 }, playerNames: ['b'] });
|
||||
const s = createGame({ id: `u${seed}`, seed, config: { ...config, length: 'standard' }, playerNames: ['b'] });
|
||||
const out = playGame(s, developerBot, pump);
|
||||
upgrades += out.events.filter((e) => e.type === 'officeUpgraded').length;
|
||||
}
|
||||
@@ -997,7 +945,7 @@ describe('the bot does not lay track that cannot work (regression)', () => {
|
||||
const s = createGame({
|
||||
id: `lay-${seed}`,
|
||||
seed,
|
||||
config: { ...config, days: 5 },
|
||||
config: { ...config, length: 'standard' },
|
||||
playerNames: ['Solitaire'],
|
||||
});
|
||||
const laid: Lay[] = [];
|
||||
@@ -1039,12 +987,6 @@ 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;
|
||||
/**
|
||||
@@ -1056,7 +998,7 @@ describe('the bot does not lay track that cannot work (regression)', () => {
|
||||
for (const seed of SEEDS) {
|
||||
const s = createGame({
|
||||
id: `dp-${seed}`, seed,
|
||||
config: { ...config, days: 5 },
|
||||
config: { ...config, length: 'standard' },
|
||||
playerNames: ['Solitaire'],
|
||||
});
|
||||
const spy = {
|
||||
@@ -1141,18 +1083,12 @@ 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 < 150; i++) {
|
||||
for (let i = 0; i < 40; i++) {
|
||||
const seed = 1000 + i * 7919;
|
||||
const s = createGame({
|
||||
id: `fu-${seed}`, seed,
|
||||
config: { ...config, days: 5 },
|
||||
config: { ...config, length: 'standard' },
|
||||
playerNames: ['bot'],
|
||||
});
|
||||
const r = playGame(s, developerBot, pump);
|
||||
|
||||
@@ -1,214 +0,0 @@
|
||||
/**
|
||||
* THE EVENT TALLY — Gitea#16's statistics, and the one property they depend on.
|
||||
*
|
||||
* "I don't know if we keep statistics on…" is the question the issue opens with. Nothing was being
|
||||
* kept; `GameState.tally` now is, folded from the event stream at the two places every event passes
|
||||
* through (`engine/tally.ts` explains which and why).
|
||||
*
|
||||
* The property that matters is EXACTLY ONCE. A statistic folded twice reads high and a statistic
|
||||
* folded nowhere reads zero, and both are indistinguishable from a quiet game when you are looking
|
||||
* at a results screen. So the central test here does not assert particular numbers: it plays real
|
||||
* games, collects every event the engine emitted along the way, counts them independently, and
|
||||
* checks the tally against that count. A fold hooked in the wrong place fails it whatever the seed.
|
||||
*/
|
||||
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
import { advance } from '../src/engine/advance.ts';
|
||||
import { tallyEvent } from '../src/engine/tally.ts';
|
||||
import { applyIntent } from '../src/engine/apply.ts';
|
||||
import { STAGES_PER_DAY } from '../src/engine/content.ts';
|
||||
import { legalActions } from '../src/engine/legal.ts';
|
||||
import { createGame } from '../src/engine/setup.ts';
|
||||
import { developerBot } from '../src/sim/bot.ts';
|
||||
import type { GameEvent } from '../src/engine/events.ts';
|
||||
import type { GameConfig, GameState } from '../src/engine/state.ts';
|
||||
|
||||
const baseConfig = (over: Partial<GameConfig> = {}): GameConfig => ({
|
||||
mode: 'solitaire',
|
||||
days: 3,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
|
||||
...over,
|
||||
});
|
||||
|
||||
/** Plays a whole game with the developer bot, keeping every event the engine produced. */
|
||||
function playKeepingEvents(
|
||||
seed: number,
|
||||
over: Partial<GameConfig> = {},
|
||||
names = ['Jesse'],
|
||||
): { state: GameState; events: GameEvent[] } {
|
||||
const state = createGame({ id: 'g', seed, config: baseConfig(over), playerNames: names });
|
||||
const events: GameEvent[] = [];
|
||||
for (let i = 0; i < 20_000; i++) {
|
||||
const r = advance(state);
|
||||
events.push(...r.events);
|
||||
if (state.status === 'finished') break;
|
||||
if (!r.needsInput) continue;
|
||||
|
||||
// The bot declines an extension, so this terminates on the timetable it was dealt (Gitea#11).
|
||||
const actor =
|
||||
state.status === 'awaitingExtension'
|
||||
? state.extensionVotes.findIndex((v) => v === null)
|
||||
: state.clock.pendingDecision !== null
|
||||
? state.clock.superintendent
|
||||
: state.clock.currentActor;
|
||||
if (actor === null || actor < 0) break;
|
||||
const options = legalActions(state, actor);
|
||||
if (options.length === 0) break;
|
||||
const applied = applyIntent(state, actor, developerBot.choose(state, actor, options));
|
||||
if (!applied.ok) break;
|
||||
events.push(...applied.events);
|
||||
}
|
||||
return { state, events };
|
||||
}
|
||||
|
||||
/** Counts events the way `tally.ts` should have, without sharing any of its code. */
|
||||
function countIndependently(events: GameEvent[]) {
|
||||
let sum = 0;
|
||||
const n = (type: GameEvent['type']): number => events.filter((e) => e.type === type).length;
|
||||
for (const e of events) {
|
||||
if (e.type === 'carsCoupled' || e.type === 'carsDropped') sum += e.stock.length;
|
||||
}
|
||||
return {
|
||||
trainsCompleted: n('trainCompleted'),
|
||||
loadsCompleted: n('loadCompleted'),
|
||||
unloadsCompleted: n('unloadCompleted'),
|
||||
loadsStarted: n('loadStarted'),
|
||||
unloadsBegun: n('unloadBegan'),
|
||||
passengersBoarded: n('passengersBoarded'),
|
||||
passengersDetrained: n('passengersDetrained'),
|
||||
cardsDrawn: n('cardDrawn'),
|
||||
cardsPlayed: n('cardPlayed'),
|
||||
cardsDiscarded: n('cardDiscarded'),
|
||||
officeUpgrades: n('officeUpgraded'),
|
||||
flyingSwitches: n('flyingSwitch'),
|
||||
extrasStarted: n('extraStarted'),
|
||||
secondSections: n('secondSectionOrdered'),
|
||||
trainsHeld: n('trainHeld'),
|
||||
trainsDiverted: n('trainDiverted'),
|
||||
expediteFaults: n('expediteFault'),
|
||||
facilitiesUnjammed: n('facilityUnjammed'),
|
||||
dispatchBonusesUsed: n('dispatchBonusUsed'),
|
||||
clearancesRequested: n('clearanceRequested'),
|
||||
switchedCars: sum,
|
||||
};
|
||||
}
|
||||
|
||||
describe('the tally counts every event exactly once (Gitea#16)', () => {
|
||||
for (const seed of [1, 7, 42, 116956197]) {
|
||||
it(`agrees with an independent count of the event stream — seed ${seed}`, () => {
|
||||
const { state, events } = playKeepingEvents(seed);
|
||||
const want = countIndependently(events);
|
||||
const t = state.tally;
|
||||
|
||||
assert.equal(t.trainsCompleted, want.trainsCompleted, 'trains through the Division');
|
||||
assert.equal(t.loadsCompleted, want.loadsCompleted, 'loads made up');
|
||||
assert.equal(t.unloadsCompleted, want.unloadsCompleted, 'loads broken');
|
||||
assert.equal(t.loadsStarted, want.loadsStarted, 'loads started');
|
||||
assert.equal(t.unloadsBegun, want.unloadsBegun, 'unloads begun');
|
||||
assert.equal(t.passengersBoarded, want.passengersBoarded, 'passengers boarded');
|
||||
assert.equal(t.passengersDetrained, want.passengersDetrained, 'passengers detrained');
|
||||
assert.equal(t.cardsDrawn, want.cardsDrawn, 'cards drawn');
|
||||
assert.equal(t.cardsPlayed, want.cardsPlayed, 'cards played');
|
||||
assert.equal(t.cardsDiscarded, want.cardsDiscarded, 'cards discarded');
|
||||
assert.equal(t.officeUpgrades, want.officeUpgrades, 'offices upgraded');
|
||||
assert.equal(t.flyingSwitches, want.flyingSwitches, 'flying switches');
|
||||
assert.equal(t.extrasStarted, want.extrasStarted, 'extras started');
|
||||
assert.equal(t.secondSections, want.secondSections, 'second sections');
|
||||
assert.equal(t.trainsHeld, want.trainsHeld, 'trains held');
|
||||
assert.equal(t.trainsDiverted, want.trainsDiverted, 'trains diverted');
|
||||
assert.equal(t.expediteFaults, want.expediteFaults, 'expedite faults');
|
||||
assert.equal(t.facilitiesUnjammed, want.facilitiesUnjammed, 'facilities unjammed');
|
||||
assert.equal(t.dispatchBonusesUsed, want.dispatchBonusesUsed, 'dispatch bonuses');
|
||||
assert.equal(t.clearancesRequested, want.clearancesRequested, 'clearances requested');
|
||||
assert.equal(t.carsCoupled + t.carsDropped, want.switchedCars, 'cars switched');
|
||||
});
|
||||
}
|
||||
|
||||
it('actually counted something — a tally of zeroes would pass the check above vacuously', () => {
|
||||
// The trap `stats.ts` warns about in its own doc comment: "this never happened" is a finding,
|
||||
// not something to scroll past. A fold hooked nowhere at all agrees perfectly with an
|
||||
// independent count of an event stream nobody looked at, so the exactly-once tests above cannot
|
||||
// catch it on their own.
|
||||
//
|
||||
// ASSERTED ON WHAT THE DEVELOPER BOT ACTUALLY DOES, which is not much: `node src/sim/harness.ts
|
||||
// 12 standard` means 1.1 Revenue per game at an 8% freight share and loses every game on the
|
||||
// revenue floor, and it goes whole games without coupling a single car. That is a known
|
||||
// property of the bot (TODO.md, Bot Performance) and not this fold's business — so this test
|
||||
// asserts on traffic and cards, which happen in every game, rather than on switching, which
|
||||
// would make it a bot-strength test wearing a statistics test's clothes.
|
||||
const { state, events } = playKeepingEvents(1);
|
||||
assert.ok(events.length > 500, `only ${events.length} events — the game barely ran`);
|
||||
assert.ok(state.tally.cardsDrawn > 0, 'no cards were drawn all game');
|
||||
assert.ok(state.tally.trainsCompleted > 0, 'no train ever left the Division');
|
||||
assert.ok(state.tally.cardsPlayed > 0, 'no card was ever played');
|
||||
});
|
||||
|
||||
it('splits Revenue into what was earned and what was given back', () => {
|
||||
// Reconciliation is the real assertion and it holds for any game, earned or not: gained minus
|
||||
// lost IS the score the engine kept. Seed 42 is named because it is one where Revenue actually
|
||||
// moves in both directions — it earns 1 and gives back 5 to a collision — so the two halves are
|
||||
// being told apart rather than both sitting at zero.
|
||||
for (const seed of [1, 7, 42]) {
|
||||
const { state } = playKeepingEvents(seed);
|
||||
const me = state.tally.byPlayer[0]!;
|
||||
assert.equal(
|
||||
me.revenueGained - me.revenueLost,
|
||||
state.players[0]!.revenue,
|
||||
`seed ${seed}: gained minus lost does not reconcile with the score the engine kept`,
|
||||
);
|
||||
}
|
||||
const { state } = playKeepingEvents(42);
|
||||
const me = state.tally.byPlayer[0]!;
|
||||
assert.ok(me.revenueGained > 0, 'seed 42 earned nothing — the gained half is not being counted');
|
||||
assert.ok(me.revenueLost > 0, 'seed 42 lost nothing — the lost half is not being counted');
|
||||
});
|
||||
|
||||
it('records a Circus set-up as the one-off it is, not as a streak', () => {
|
||||
/**
|
||||
* `trainStoodStill` is NOT "this train did not move this Stage". It fires only for a train whose
|
||||
* profile sets `stopEarnsPoint` — the X18 Circus — and `advance.ts` claims it once per train
|
||||
* with `stopPointClaimed`, so it can never fire twice for the same one.
|
||||
*
|
||||
* Gitea#16 asks for "longest engine sat on a siding" and its comment assumed this event would
|
||||
* answer it. It cannot, and a streak folded from it would have read "1 Stage" for ever. Pinned
|
||||
* here so that the day a real per-Stage signal is added, whoever adds it finds this test rather
|
||||
* than the old wrong assumption.
|
||||
*/
|
||||
const s = createGame({ id: 'g', seed: 1, config: baseConfig(), playerNames: ['Jesse'] });
|
||||
const feed = (e: GameEvent): void => tallyEvent(s, e);
|
||||
feed({ type: 'trainStoodStill', trainNumber: 18, where: '(0,0)' });
|
||||
assert.deepEqual(s.tally.circusStops, [{ trainNumber: 18, where: '(0,0)' }]);
|
||||
assert.ok(!('longestStand' in s.tally), 'a streak that cannot be computed is being reported');
|
||||
});
|
||||
});
|
||||
|
||||
describe('the official result freezes the tally with it (Gitea#11 + #16)', () => {
|
||||
it('records the statistics as they stood when the timetable ran out', () => {
|
||||
const { state } = playKeepingEvents(1);
|
||||
assert.ok(state.official, 'no official result was recorded');
|
||||
// Nothing was played after the ending in this game, so the two agree — which is the check that
|
||||
// the freeze happens AFTER the last batch of events is folded rather than before it.
|
||||
assert.equal(state.official!.tally.trainsCompleted, state.tally.trainsCompleted);
|
||||
assert.ok(state.official!.tally.cardsDrawn > 0, 'the frozen tally is empty');
|
||||
});
|
||||
|
||||
it('keeps the frozen copy still while the live tally moves on', () => {
|
||||
const s = createGame({ id: 'g', seed: 1, config: baseConfig(), playerNames: ['Jesse'] });
|
||||
s.clock.day = s.config.days + 1;
|
||||
s.clock.stage = STAGES_PER_DAY;
|
||||
s.clock.phase = 'shiftChange';
|
||||
advance(s);
|
||||
const frozen = s.official!.tally.cardsDrawn;
|
||||
|
||||
applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
|
||||
tallyEvent(s, { type: 'cardDrawn', player: 0, source: 'homeOffice', cardId: 'x' });
|
||||
assert.equal(s.tally.cardsDrawn, frozen + 1, 'the live tally did not move');
|
||||
assert.equal(s.official!.tally.cardsDrawn, frozen, 'the frozen tally moved with it');
|
||||
});
|
||||
});
|
||||
+2
-106
@@ -128,8 +128,8 @@ function gameWith(area: OfficeArea): GameState {
|
||||
const s = createGame({
|
||||
id: 'g', seed: 5,
|
||||
config: {
|
||||
mode: 'solitaire', days: 5, minCombinedRevenue: 0, maxCollisionsPerDay: 0, maxCollisionsTotal: 0, pvpCardsAllowed: false,
|
||||
optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
|
||||
mode: 'solitaire', victory: 'highestAfterDays', length: 'standard',
|
||||
optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
|
||||
},
|
||||
playerNames: ['p'],
|
||||
});
|
||||
@@ -540,100 +540,6 @@ 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');
|
||||
@@ -657,16 +563,6 @@ describe('placement and drop-off', () => {
|
||||
assert.ok(canDropCarsAt(area, at(0, 1)), 'ordinary Operational Rail');
|
||||
});
|
||||
|
||||
it('allows a coach, and only a coach, to be dropped at the Office (v0.5.0 §A.4 exception)', () => {
|
||||
const area = areaFrom(
|
||||
{ [coordKey(at(0, 0))]: officeCard(), [coordKey(at(0, 1))]: straight() },
|
||||
at(0, 0),
|
||||
);
|
||||
assert.ok(!canDropCarsAt(area, at(0, 0), 1, false), 'not asking for the coach exception');
|
||||
assert.ok(canDropCarsAt(area, at(0, 0), 1, true), 'one coach');
|
||||
assert.ok(canDropCarsAt(area, at(0, 0), 2, true), 'more than one coach');
|
||||
});
|
||||
|
||||
it('forbids dropping cars on a locked industry track', () => {
|
||||
const area = areaFrom(
|
||||
{
|
||||
|
||||
@@ -19,12 +19,9 @@ import { trainRules } from '../src/sim/view.ts';
|
||||
|
||||
const config: GameConfig = {
|
||||
mode: 'solitaire',
|
||||
days: 5,
|
||||
minCombinedRevenue: 0,
|
||||
maxCollisionsPerDay: 0,
|
||||
maxCollisionsTotal: 0,
|
||||
pvpCardsAllowed: false,
|
||||
optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
|
||||
victory: 'highestAfterDays',
|
||||
length: 'standard',
|
||||
optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
|
||||
};
|
||||
const game = (seed = 5): GameState => createGame({ id: 'g', seed, config, playerNames: ['p'] });
|
||||
const at = (row: number, col: number): GridCoord => ({ row, col });
|
||||
@@ -49,9 +46,9 @@ function switching(
|
||||
): string {
|
||||
const area = areaOf(s, 0);
|
||||
const office = area.officeCoord;
|
||||
// The crew stands one square west of the Office and works westward, away from the Office square's
|
||||
// own special-cased drop rule (§A.4 forbids everything but a coach there, v0.5.0) — tests that want
|
||||
// that exception exercise it directly instead.
|
||||
// The crew stands one square west of the Office and works westward. It may NOT stand on the Office
|
||||
// itself: §A.4 forbids leaving Rolling Stock on the Office track, so every drop there is refused
|
||||
// whatever the train's own card says.
|
||||
const here = { row: office.row, col: office.col - 1 };
|
||||
area.grid.set(coordKey(here), straight());
|
||||
area.grid.set(coordKey({ row: office.row, col: office.col - 2 }), straight(westCars));
|
||||
@@ -74,8 +71,6 @@ const west = (s: GameState, n = 2): GridCoord => {
|
||||
};
|
||||
|
||||
const boxcar = (loaded = false): RollingStock => ({ type: 'boxcar', loaded });
|
||||
/** As `ROLLING_STOCK_SUPPLY` mints them: there is no empty caboose in the game. */
|
||||
const caboose = (): RollingStock => ({ type: 'caboose', loaded: true });
|
||||
const coach = (loaded = false): RollingStock => ({ type: 'coach', loaded });
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -143,23 +138,6 @@ describe('§7 — what a train may couple', () => {
|
||||
'EMPTIES_ONLY',
|
||||
);
|
||||
});
|
||||
|
||||
it('X22 Pee-Dee may still couple a caboose, which is not a load (Gitea#8)', () => {
|
||||
// Every caboose in the game is minted `loaded: true` because the supply table's loaded/empty
|
||||
// split doubles as a piece count. Taken literally that left the per-diem train unable to pick
|
||||
// up ANY caboose, its own included: set it out at the end of a sweep and it was stranded there.
|
||||
const s = game();
|
||||
switching(s, 22, true, [], [caboose()]);
|
||||
assert.equal(check(s, 0, { type: 'switch.move', trayId: 't', to: west(s), reverse: false }), null);
|
||||
|
||||
// The restriction itself is untouched — a loaded car alongside the caboose still refuses.
|
||||
const withLoad = game();
|
||||
switching(withLoad, 22, true, [], [caboose(), boxcar(true)]);
|
||||
assert.equal(
|
||||
check(withLoad, 0, { type: 'switch.move', trayId: 't', to: west(withLoad), reverse: false }),
|
||||
'EMPTIES_ONLY',
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('§7 — one freight car per location (trains 3/4)', () => {
|
||||
@@ -224,41 +202,6 @@ describe('§7 — the Local keeps its coach (trains 7/8)', () => {
|
||||
switching(s, 9, false, [boxcar(), coach()]);
|
||||
assert.equal(check(s, 0, { type: 'switch.dropCars', trayId: 't', count: 1 }), null);
|
||||
});
|
||||
|
||||
it('may set the coach out at the Office — the one place §A.4 now allows it (v0.5.0)', () => {
|
||||
const s = game();
|
||||
const area = areaOf(s, 0);
|
||||
const office = area.officeCoord;
|
||||
s.trays.set('t', {
|
||||
id: 't',
|
||||
trainNumber: 7,
|
||||
trainIsExtra: false,
|
||||
engineAt: 0,
|
||||
consist: [boxcar(), coach()],
|
||||
direction: 'west',
|
||||
facing: 'w',
|
||||
position: { at: 'grid', seat: 0, coord: office },
|
||||
movesUsed: 0,
|
||||
});
|
||||
s.clock.phase = 'localOps';
|
||||
s.clock.currentActor = 0;
|
||||
turnOf(s, 0).option = 'switch';
|
||||
turnOf(s, 0).movesRemaining = 6;
|
||||
|
||||
assert.equal(
|
||||
check(s, 0, { type: 'switch.dropCars', trayId: 't', count: 1 }),
|
||||
null,
|
||||
'the coach may be cut loose at the Office',
|
||||
);
|
||||
assert.ok(applyIntent(s, 0, { type: 'switch.dropCars', trayId: 't', count: 1 }).ok);
|
||||
const officeCard = area.grid.get(coordKey(office))!;
|
||||
assert.deepEqual(
|
||||
officeCard.standing.map((c) => c.type),
|
||||
['coach'],
|
||||
'the coach is parked on the Office card',
|
||||
);
|
||||
assert.equal(s.trays.get('t')!.consist.length, 1, 'the coach left the tray');
|
||||
});
|
||||
});
|
||||
|
||||
describe('§7 — trains Porters may not work', () => {
|
||||
|
||||
+104
-1337
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user