185 lines
10 KiB
TypeScript
185 lines
10 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { applyAction, createGame, joinGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
|
|
import { TERRITORIES } from '../game/board';
|
|
import { homeworldContext } from '../game/homeworld-game';
|
|
import { currentHomeworldOccupationSnapshot, homeworldOccupationMarker, homeworldOccupationSnapshotPresence } from '../game/homeworld-occupation-history';
|
|
import { nextIndependentCardModulesStep } from './fixture-independent-card-modules';
|
|
|
|
const owner = 'richese', native = 'atreides', guild = 'guild';
|
|
const source = 'homeworld:atreides', destination = 'homeworld:guild';
|
|
const seat = (game: Game, id: string) => {
|
|
const result = game.players.find(player => player.id === id);
|
|
assert.ok(result); return result;
|
|
};
|
|
const quiet = (game: Game) => !game.response && !game.decision && !game.phaseOpening &&
|
|
!game.truthtrance && !game.pendingTreacheryDiscard;
|
|
|
|
/** Original native action/response continuations, including a real Guild
|
|
* interception when Advanced allows one. No saved phase or custody is staged. */
|
|
function advance(game: Game, until: (game: Game) => boolean): Game {
|
|
let state = game;
|
|
for (let count = 0; count < 2500; count++) {
|
|
if (until(state)) return state;
|
|
assert.notEqual(state.status, 'finished');
|
|
if (state.decision?.kind === 'homeworldShipmentGuild') {
|
|
const decision = state.decision;
|
|
state = applyAction(state, decision.player, { type: 'decision', event: decision.event, allow: true });
|
|
continue;
|
|
}
|
|
const next = nextIndependentCardModulesStep(state);
|
|
assert.ok(next, `Native continuation stopped at ${state.phase}/${state.decision?.kind ?? 'no decision'}.`);
|
|
// Preserve the native Atreides cash needed for its intentional full
|
|
// shipment by passing the actual Richese cache lot, rather than buying it.
|
|
if (next.actor === native && next.action.type === 'richeseBid') {
|
|
state = applyAction(state, native, { type: 'richeseBid', event: next.action.event, amount: 0, allyPayment: 0 });
|
|
continue;
|
|
}
|
|
state = applyAction(state, next.actor, next.action);
|
|
}
|
|
throw Error('The native Homeworld transfer programme did not reach its requested boundary.');
|
|
}
|
|
|
|
/** Actual original lobby/start and force choices. Atreides deliberately ships
|
|
* its whole real reserve to a legal stronghold before the first marker arrives,
|
|
* so that the marker survives the intervening Battle phase without inventing
|
|
* a battle exemption. */
|
|
function setup(advanced: boolean): Game {
|
|
let game = createGame('RICHESEWORLDMIXED', newPlayer(native, native, 'atreides'), advanced, ['choam']);
|
|
joinGame(game, newPlayer(owner, owner, 'richese'));
|
|
joinGame(game, newPlayer(guild, guild, 'guild'));
|
|
game = applyAction(game, native, { type: 'homeworlds', enabled: true });
|
|
for (const player of game.players) game = applyAction(game, player.id, { type: 'ready' });
|
|
game = applyAction(game, native, advanced ? { type: 'start', advancedPreview: true } : { type: 'start' });
|
|
// Select one undealt original card position, ensuring Guild has a real
|
|
// physical Karama for the response/stop case. Never add or duplicate cards.
|
|
const karama = game.deck.findIndex(card => card.effect === 'karama');
|
|
assert.ok(karama >= 0 && game.deck.length >= 3);
|
|
[game.deck[2], game.deck[karama]] = [game.deck[karama], game.deck[2]];
|
|
game = advance(game, state => state.status === 'playing');
|
|
assert.ok(seat(game, guild).hand.some(card => card.effect === 'karama'));
|
|
game = advance(game, state => state.phase === 5 && state.active === native && quiet(state));
|
|
const amount = seat(game, native).reserves;
|
|
assert.ok(amount > 0);
|
|
let shipped: Game | null = null;
|
|
for (const target of TERRITORIES.filter(territory => territory.type === 'stronghold')) {
|
|
for (const sector of target.sectors) {
|
|
if (sector === game.storm) continue;
|
|
try {
|
|
shipped = applyAction(game, native, { type: 'ship', territory: target.id, sector, amount,
|
|
elite: 0, allyPayment: 0, homeworldSources: { [source]: { normal: amount, elite: 0 } } });
|
|
break;
|
|
} catch { /* Try another legal native stronghold; rejected actions are immutable. */ }
|
|
}
|
|
if (shipped) break;
|
|
}
|
|
assert.ok(shipped, 'Atreides can ship its real starting reserve to a legal stronghold.');
|
|
game = advance(shipped, quiet);
|
|
assert.equal(seat(game, native).reserves, 0);
|
|
game = applyAction(game, native, { type: 'endMovement' });
|
|
game = advance(game, state => state.phase === 5 && state.active === owner && quiet(state) &&
|
|
!!viewGame(state, owner).homeworldShipment && !!viewGame(state, owner).richeseNoField?.canShip);
|
|
return game;
|
|
}
|
|
|
|
|
|
function nextOwnerTurn(game: Game): Game {
|
|
const turn = game.turn;
|
|
game = applyAction(game, owner, { type: 'endMovement' });
|
|
return advance(game, state => state.turn > turn && state.phase === 5 && state.active === owner &&
|
|
quiet(state) && !seat(state, owner).shipped && !!viewGame(state, owner).homeworldShipment &&
|
|
!viewGame(state, owner).homeworldShipment!.blocked);
|
|
}
|
|
|
|
function visitor(game: Game, world: string) {
|
|
return game.homeworlds!.custody!.visitors[world]?.[owner];
|
|
}
|
|
|
|
/** The source counter group and marker arrive in two actual consecutive turns.
|
|
* The native evacuation above ensures neither is invented or protected from battle. */
|
|
function prepare(advanced: boolean) {
|
|
let game = setup(advanced);
|
|
let own = viewGame(game, owner);
|
|
game = applyAction(game, owner, { type: 'homeworldShip', event: own.homeworldShipment!.event,
|
|
destination: source, sources: { 'homeworld:richese': { normal: 2, elite: 0 } }, allyPayment: 0 });
|
|
game = advance(game, state => state.phase === 5 && state.active === owner && quiet(state) &&
|
|
seat(state, owner).shipped && !state.pendingHomeworldShipment);
|
|
assert.deepEqual(visitor(game, source), { normal: 2, elite: 0 });
|
|
game = nextOwnerTurn(game);
|
|
assert.deepEqual(visitor(game, source), { normal: 2, elite: 0 });
|
|
own = viewGame(game, owner);
|
|
const info = own.richeseNoField!;
|
|
const token = info.private!.tokens.find(candidate => candidate.value === 3);
|
|
assert.ok(token);
|
|
game = applyAction(game, owner, { type: 'homeworldShip', event: own.homeworldShipment!.event,
|
|
destination: source, sources: {}, noField: token.id, noFieldEvent: info.event, allyPayment: 0 });
|
|
game = advance(game, state => state.phase === 5 && state.active === owner && quiet(state) &&
|
|
seat(state, owner).shipped && !!seat(state, owner).noField?.deployed);
|
|
assert.deepEqual(seat(game, owner).noField!.deployed!.location, { homeworld: source });
|
|
assert.deepEqual(visitor(game, source), { normal: 2, elite: 0 });
|
|
game = nextOwnerTurn(game);
|
|
assert.deepEqual(visitor(game, source), { normal: 2, elite: 0 });
|
|
assert.equal(seat(game, owner).noField!.lastShipped, token.id);
|
|
return { game, token: token.id };
|
|
}
|
|
|
|
function declaration(game: Game, token: string): Action {
|
|
const own = viewGame(game, owner);
|
|
return { type: 'homeworldShip', event: own.homeworldShipment!.event, destination,
|
|
sources: { [source]: { normal: 1, elite: 0 } }, noField: token,
|
|
noFieldEvent: own.richeseNoField!.event, noFieldFrom: source, allyPayment: 0 };
|
|
}
|
|
|
|
function presence(game: Game, world: string) {
|
|
const snapshot = currentHomeworldOccupationSnapshot(homeworldContext(game), game.homeworlds!.custody!,
|
|
homeworldOccupationMarker(game.players));
|
|
return homeworldOccupationSnapshotPresence(snapshot, world);
|
|
}
|
|
|
|
for (const advanced of [false, true]) void test(`${advanced ? 'Advanced' : 'Basic'} mixed marker and physical Homeworld transfer uses one shipment`, () => {
|
|
const ready = prepare(advanced);
|
|
let game = ready.game;
|
|
const before = structuredClone(game), action = declaration(game, ready.token);
|
|
assert.ok(seat(before, owner).spice >= 2, 'The actual Richese seat can pay the two-spice price.');
|
|
assert.deepEqual(presence(before, source), [owner]);
|
|
for (const stale of [{ ...action, noFieldEvent: 'stale-marker-event' }, { ...action, event: 'stale-shipment-event' }]) {
|
|
assert.throws(() => applyAction(game, owner, stale));
|
|
assert.deepEqual(game, before, 'A stale event leaves the real game unchanged.');
|
|
}
|
|
const malformed = { ...action, sources: { [source]: null } } as unknown as Action;
|
|
assert.throws(() => applyAction(game, owner, malformed), 'A null typed source cannot be dropped from a mixed transfer.');
|
|
assert.deepEqual(game, before, 'Rejecting a malformed source leaves the game unchanged.');
|
|
game = applyAction(game, owner, action);
|
|
game = advance(game, state => state.phase === 5 && state.active === owner && quiet(state) &&
|
|
seat(state, owner).shipped && !state.pendingHomeworldShipment);
|
|
assert.equal(seat(game, owner).spice, seat(before, owner).spice - 2);
|
|
assert.equal(seat(game, owner).reserves, seat(before, owner).reserves);
|
|
assert.deepEqual(visitor(game, source), { normal: 1, elite: 0 });
|
|
assert.deepEqual(visitor(game, destination), { normal: 1, elite: 0 });
|
|
assert.equal(seat(game, owner).noField!.deployed!.tokenId, ready.token);
|
|
assert.deepEqual(seat(game, owner).noField!.deployed!.location, { homeworld: destination });
|
|
assert.equal(seat(game, owner).noField!.lastShipped, ready.token);
|
|
assert.deepEqual(presence(game, source), [owner]);
|
|
assert.deepEqual(presence(game, destination).sort(), [guild, owner].sort());
|
|
});
|
|
|
|
void test('Advanced Guild can stop a mixed Homeworld transfer without payment, moving either group, or changing marker history', () => {
|
|
const ready = prepare(true);
|
|
let game = ready.game;
|
|
const before = structuredClone(game);
|
|
game = applyAction(game, owner, declaration(game, ready.token));
|
|
game = advance(game, state => state.decision?.kind === 'homeworldShipmentGuild');
|
|
assert.match(game.log.at(-1)!.text, /one concealed No-Field and 1 physical forces/);
|
|
const karama = seat(game, guild).hand.find(card => card.effect === 'karama'); assert.ok(karama);
|
|
game = applyAction(game, guild, { type: 'card', mode: 'special', card: karama.id });
|
|
game = advance(game, state => state.phase === 5 && state.active === owner && quiet(state) &&
|
|
!state.pendingHomeworldShipment);
|
|
assert.equal(seat(game, owner).shipped, true);
|
|
assert.deepEqual(seat(game, owner).noField, seat(before, owner).noField);
|
|
assert.equal(seat(game, owner).reserves, seat(before, owner).reserves);
|
|
assert.equal(seat(game, owner).spice, seat(before, owner).spice);
|
|
assert.deepEqual(game.homeworlds!.custody, before.homeworlds!.custody);
|
|
assert.deepEqual(presence(game, source), presence(before, source));
|
|
assert.deepEqual(presence(game, destination), presence(before, destination));
|
|
});
|