Implement Enhancements, Mainline modifiers and Maneuvers; fix unplayable track
This commit is contained in:
Jesse
@@ -0,0 +1,356 @@
|
||||
/**
|
||||
* 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);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user