357 lines
14 KiB
TypeScript
357 lines
14 KiB
TypeScript
/**
|
|
* Enhancement cards (implications.md §7).
|
|
*
|
|
* These are the 18 cards that make up the largest block of the "third of the deck that does
|
|
* nothing". Several change core loops — Small Yard makes the facing-point switching puzzle
|
|
* solvable at all, and ABS Signals amends Gap 2's unconditional collisions.
|
|
*/
|
|
|
|
import { describe, it } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
|
|
import { advance } from '../src/engine/advance.ts';
|
|
import { applyIntent, areaOf, check, hasDistrictEnhancement, isProtectedFromDerail } from '../src/engine/apply.ts';
|
|
import { ENHANCEMENT_RULES, enhancementRule } 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 } from '../src/engine/state.ts';
|
|
|
|
const config: GameConfig = {
|
|
mode: 'solitaire',
|
|
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 });
|
|
|
|
const straight = (): TrackCard => ({
|
|
geometry: { kind: 'track', geometry: 'straight' },
|
|
baseOperationalRail: true,
|
|
standing: [],
|
|
facility: null,
|
|
modifiers: [],
|
|
enhancements: [],
|
|
});
|
|
|
|
function addCard(s: GameState, coord: GridCoord, card: TrackCard): void {
|
|
areaOf(s, 0).grid.set(coordKey(coord), card);
|
|
}
|
|
|
|
/** Puts an enhancement card in hand and returns its id. */
|
|
function handEnhancement(s: GameState, key: string): string {
|
|
for (const [id, card] of s.cards) {
|
|
if (card.kind.kind === 'enhancement' && card.kind.key === key) {
|
|
s.decks.hands.set(0, [id]);
|
|
return id;
|
|
}
|
|
}
|
|
throw new Error(`no enhancement card: ${key}`);
|
|
}
|
|
|
|
function placeTray(s: GameState, coord: GridCoord, consist: TrackCard['standing'] = []): string {
|
|
const id = s.freeTrays.pop()!;
|
|
s.trays.set(id, {
|
|
id, trainNumber: 9, trainIsExtra: false, engineFront: true,
|
|
consist, direction: 'east', position: { at: 'grid', owner: 0, coord }, movesUsed: 0,
|
|
});
|
|
return id;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('enhancement placement', () => {
|
|
it('defines a rule for every enhancement card', () => {
|
|
assert.equal(ENHANCEMENT_RULES.length, 10);
|
|
for (const r of ENHANCEMENT_RULES) assert.ok(enhancementRule(r.key), r.key);
|
|
});
|
|
|
|
it('puts Interlocking on a Running Track straight, not a Secondary one', () => {
|
|
const s = game();
|
|
addCard(s, at(0, 2), straight());
|
|
addCard(s, at(-1, 0), straight());
|
|
const id = handEnhancement(s, 'interlocking');
|
|
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
|
assert.equal(check(s, 0, { type: 'card.play', cardId: id, placement: at(0, 2) }), null);
|
|
assert.equal(check(s, 0, { type: 'card.play', cardId: id, placement: at(-1, 0) }), 'NOT_CONNECTED');
|
|
});
|
|
|
|
it('puts Small Yard on a Secondary Track straight, not the Running Track', () => {
|
|
const s = game();
|
|
addCard(s, at(0, 2), straight());
|
|
addCard(s, at(-1, 0), straight());
|
|
const id = handEnhancement(s, 'smallYard');
|
|
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
|
assert.equal(check(s, 0, { type: 'card.play', cardId: id, placement: at(-1, 0) }), null);
|
|
assert.equal(check(s, 0, { type: 'card.play', cardId: id, placement: at(0, 2) }), 'NOT_CONNECTED');
|
|
});
|
|
|
|
it('stacks Telephone on Telegraph and Radio on Telephone, never bare', () => {
|
|
const s = game();
|
|
addCard(s, at(0, 2), straight());
|
|
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
|
|
|
const phone = handEnhancement(s, 'telephone');
|
|
assert.equal(check(s, 0, { type: 'card.play', cardId: phone, placement: at(0, 2) }), 'NOT_CONNECTED');
|
|
|
|
const tel = handEnhancement(s, 'telegraph');
|
|
assert.ok(applyIntent(s, 0, { type: 'card.play', cardId: tel, placement: at(0, 2) }).ok);
|
|
|
|
const phone2 = handEnhancement(s, 'telephone');
|
|
assert.equal(check(s, 0, { type: 'card.play', cardId: phone2, placement: at(0, 2) }), null);
|
|
});
|
|
|
|
it('requires an Interlocking in the district before Facing Point Locks', () => {
|
|
const s = game();
|
|
addCard(s, at(0, 2), straight());
|
|
applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
|
|
const fpl = handEnhancement(s, 'facingPointLocks');
|
|
assert.equal(check(s, 0, { type: 'card.play', cardId: fpl, placement: at(0, 2) }), 'NOT_CONNECTED');
|
|
|
|
const lock = handEnhancement(s, 'interlocking');
|
|
applyIntent(s, 0, { type: 'card.play', cardId: lock, placement: at(0, 2) });
|
|
const fpl2 = handEnhancement(s, 'facingPointLocks');
|
|
assert.equal(check(s, 0, { type: 'card.play', cardId: fpl2, placement: at(0, 2) }), null);
|
|
assert.ok(isProtectedFromDerail(areaOf(s, 0)) === false, 'not protected until actually played');
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('Small Yard — the card that makes switching solvable', () => {
|
|
function yardGame() {
|
|
const s = game();
|
|
const yard = at(-1, 0);
|
|
const card = straight();
|
|
card.enhancements.push('smallYard');
|
|
addCard(s, yard, card);
|
|
const tray = placeTray(s, yard, [
|
|
{ type: 'boxcar', loaded: false },
|
|
{ type: 'hopper', loaded: true },
|
|
{ type: 'coach', loaded: false },
|
|
]);
|
|
applyIntent(s, 0, { type: 'localOps.choose', option: 'switch' });
|
|
return { s, tray, yard };
|
|
}
|
|
|
|
it('re-orders a consist, including bringing a buried car to the end', () => {
|
|
// §A.3 forces cars off in seated order, so without this the middle car can never be spotted.
|
|
const { s, tray } = yardGame();
|
|
const r = applyIntent(s, 0, { type: 'switch.sortConsist', trayId: tray, order: [0, 2, 1] });
|
|
assert.ok(r.ok);
|
|
assert.deepEqual(
|
|
s.trays.get(tray)!.consist.map((c) => c.type),
|
|
['boxcar', 'coach', 'hopper'],
|
|
'the hopper is now on the droppable end',
|
|
);
|
|
});
|
|
|
|
it('costs one Move — "spends one move in the yard"', () => {
|
|
const { s, tray } = yardGame();
|
|
const before = s.turn.movesRemaining;
|
|
applyIntent(s, 0, { type: 'switch.sortConsist', trayId: tray, order: [2, 1, 0] });
|
|
assert.equal(s.turn.movesRemaining, before - 1);
|
|
});
|
|
|
|
it('is refused anywhere without a Small Yard', () => {
|
|
const s = game();
|
|
addCard(s, at(-1, 0), straight());
|
|
const tray = placeTray(s, at(-1, 0), [
|
|
{ type: 'boxcar', loaded: false },
|
|
{ type: 'hopper', loaded: true },
|
|
]);
|
|
applyIntent(s, 0, { type: 'localOps.choose', option: 'switch' });
|
|
assert.equal(
|
|
check(s, 0, { type: 'switch.sortConsist', trayId: tray, order: [1, 0] }),
|
|
'NOT_CONNECTED',
|
|
);
|
|
});
|
|
|
|
it('refuses an order that is not a permutation of the consist', () => {
|
|
const { s, tray } = yardGame();
|
|
for (const bad of [[0, 1], [0, 1, 1], [0, 1, 5]]) {
|
|
assert.equal(
|
|
check(s, 0, { type: 'switch.sortConsist', trayId: tray, order: bad }),
|
|
'CONSIST_ORDER',
|
|
`accepted ${JSON.stringify(bad)}`,
|
|
);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('Interlocking and Yard Office relieve the Office', () => {
|
|
function inbound(s: GameState, consist: TrackCard['standing']) {
|
|
const id = 'inbound';
|
|
s.trays.set(id, {
|
|
id, trainNumber: 9, trainIsExtra: false, engineFront: true,
|
|
consist, direction: 'east', position: { at: 'mainline', index: 1 }, movesUsed: 0,
|
|
});
|
|
const ml = s.division.nodes[1];
|
|
if (ml?.kind === 'mainline') ml.transits.push({ tray: id, stagesRemaining: 1, direction: 'east' });
|
|
s.clock.phase = 'mainline';
|
|
s.movedThisPhase = new Set();
|
|
return id;
|
|
}
|
|
|
|
it('holds a train at the Limits instead of colliding when the Office is full', () => {
|
|
// Gap 2d made a full Office an automatic collision. Interlocking is the designed answer.
|
|
const s = game();
|
|
const card = straight();
|
|
card.enhancements.push('interlocking');
|
|
addCard(s, at(0, 2), card);
|
|
areaOf(s, 0).adOccupancy = ['blocker'];
|
|
const id = inbound(s, [{ type: 'hopper', loaded: true }]);
|
|
|
|
advance(s);
|
|
assert.equal(s.players[0]!.revenue, 0, 'no collision penalty');
|
|
assert.ok(areaOf(s, 0).heldAtLimits.includes(id), 'train is held at the Limits');
|
|
});
|
|
|
|
it('still collides without an Interlocking', () => {
|
|
const s = game();
|
|
areaOf(s, 0).adOccupancy = ['blocker'];
|
|
inbound(s, [{ type: 'hopper', loaded: true }]);
|
|
advance(s);
|
|
assert.equal(s.players[0]!.revenue, -5);
|
|
});
|
|
|
|
it('diverts a coachless train to the Yard Office', () => {
|
|
const s = game();
|
|
const card = straight();
|
|
card.enhancements.push('yardOffice');
|
|
addCard(s, at(-1, 0), card);
|
|
const id = inbound(s, [{ type: 'hopper', loaded: true }]);
|
|
|
|
advance(s);
|
|
const pos = s.trays.get(id)!.position;
|
|
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', () => {
|
|
// "An inbound train with NO COACHES" — passengers must reach the Train Order Office.
|
|
const s = game();
|
|
const card = straight();
|
|
card.enhancements.push('yardOffice');
|
|
addCard(s, at(-1, 0), card);
|
|
const id = inbound(s, [{ type: 'coach', loaded: true }]);
|
|
|
|
advance(s);
|
|
assert.ok(areaOf(s, 0).adOccupancy.includes(id), 'a coach train must use the Office');
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('ABS Signals amend the collision rule', () => {
|
|
it('turns a following-train judgment into a plain hold', () => {
|
|
// "Trains on this card will not rear-end each other. They will stop short of a collision."
|
|
const s = game();
|
|
const ml = s.division.nodes[1];
|
|
if (ml?.kind === 'mainline') {
|
|
// Pin the terrain — see the meet tests below. Double Track and Uncontrolled Siding let trains
|
|
// pass, so the following train would never be held and there would be nothing for ABS to do.
|
|
ml.card = 'plains';
|
|
ml.absSignals = true;
|
|
ml.transits.push({ tray: 'ahead', stagesRemaining: 2, direction: 'east' });
|
|
}
|
|
s.trays.set('ahead', {
|
|
id: 'ahead', trainNumber: 4, trainIsExtra: false, engineFront: true,
|
|
consist: [], direction: 'east', position: { at: 'mainline', index: 1 }, movesUsed: 0,
|
|
});
|
|
s.trays.set('behind', {
|
|
id: 'behind', trainNumber: 2, trainIsExtra: false, engineFront: true,
|
|
consist: [], direction: 'east', position: { at: 'divisionPoint', side: 'west' }, movesUsed: 0,
|
|
});
|
|
s.clock.phase = 'mainline';
|
|
s.movedThisPhase = new Set();
|
|
|
|
const r = advance(s);
|
|
assert.equal(r.needsInput, false, 'no clearance decision is needed with signals');
|
|
assert.equal(s.clock.pendingDecision, null);
|
|
assert.deepEqual(s.trays.get('behind')!.position, { at: 'divisionPoint', side: 'west' });
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('Telegraph, Telephone and Radio dispatch meets', () => {
|
|
function meet(s: GameState, device?: string) {
|
|
if (device) {
|
|
const card = straight();
|
|
card.enhancements.push(device);
|
|
addCard(s, at(0, 2), card);
|
|
}
|
|
// An oncoming senior train — §8.1 makes this an absolute bar without a device.
|
|
s.trays.set('oncoming', {
|
|
id: 'oncoming', trainNumber: 3, trainIsExtra: false, engineFront: true,
|
|
consist: [], direction: 'west', position: { at: 'mainline', index: 1 }, movesUsed: 0,
|
|
});
|
|
const ml = s.division.nodes[1];
|
|
if (ml?.kind === 'mainline') {
|
|
// Pin the terrain. Mainline types are drawn from the shuffled deck, so deck composition would
|
|
// otherwise decide this test's outcome — and Double Track / Uncontrolled Siding set
|
|
// `trainsMayPass`, which legitimately removes the §8.1 bar this test is about.
|
|
ml.card = 'plains';
|
|
ml.transits.push({ tray: 'oncoming', stagesRemaining: 2, direction: 'west' });
|
|
}
|
|
s.trays.set('mine', {
|
|
id: 'mine', trainNumber: 9, trainIsExtra: false, engineFront: true,
|
|
consist: [], direction: 'east', position: { at: 'divisionPoint', side: 'west' }, movesUsed: 0,
|
|
});
|
|
s.clock.phase = 'mainline';
|
|
s.movedThisPhase = new Set();
|
|
}
|
|
|
|
it('holds a facing train with no device — §8.1 stands', () => {
|
|
const s = game();
|
|
meet(s);
|
|
advance(s);
|
|
assert.deepEqual(s.trays.get('mine')!.position, { at: 'divisionPoint', side: 'west' });
|
|
});
|
|
|
|
it('lets a junior train win the meet with a Telegraph', () => {
|
|
// Train 9 against Train 3: +4 makes the other count as 7 — still senior. Radio's +12 wins.
|
|
const s = game();
|
|
meet(s, 'radio');
|
|
advance(s);
|
|
assert.equal(s.trays.get('mine')!.position.at, 'mainline', 'the meet was dispatched');
|
|
assert.ok(areaOf(s, 0).dispatchUsedToday.includes('radio'));
|
|
});
|
|
|
|
it('spends each device only once a Day', () => {
|
|
const s = game();
|
|
meet(s, 'radio');
|
|
advance(s);
|
|
assert.deepEqual(areaOf(s, 0).dispatchUsedToday, ['radio']);
|
|
// Reset happens at the Day boundary.
|
|
s.clock.stage = 12;
|
|
s.clock.phase = 'shiftChange';
|
|
advance(s);
|
|
assert.deepEqual(areaOf(s, 0).dispatchUsedToday, [], 'devices reset each Day');
|
|
});
|
|
|
|
it('gives Radio the largest bonus and Telegraph the smallest', () => {
|
|
assert.equal(enhancementRule('telegraph')!.dispatchBonus, 4);
|
|
assert.equal(enhancementRule('telephone')!.dispatchBonus, 8);
|
|
assert.equal(enhancementRule('radio')!.dispatchBonus, 12);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('defensive enhancements', () => {
|
|
it('reports district protection only once actually built', () => {
|
|
// These guard against opponent-directed cards, which a solitaire deck omits entirely (Q6).
|
|
const s = game();
|
|
assert.equal(isProtectedFromDerail(areaOf(s, 0)), false);
|
|
const card = straight();
|
|
card.enhancements.push('facingPointLocks');
|
|
addCard(s, at(0, 2), card);
|
|
assert.equal(isProtectedFromDerail(areaOf(s, 0)), true);
|
|
assert.equal(hasDistrictEnhancement(areaOf(s, 0), 'waterColumn'), false);
|
|
});
|
|
});
|