172 lines
10 KiB
TypeScript
172 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 { territory } from '../game/board';
|
|
import { placeTerror } from '../game/moritani-terror';
|
|
import { nextStrongholdFactionsNativeStep } from './fixture-stronghold-factions';
|
|
import { createTruthTurnAmalFixture, truthTurnAmalInventory as inventory } from './fixture-truth-turn-amal';
|
|
import { beforeIxSpiceDraw, orderIxSpiceCards } from './fixture-ix-spice-cards';
|
|
|
|
const act = (game: Game, id: string, action: Action) => applyAction(game, id, action);
|
|
const seat = (game: Game, id: string) => { const player = game.players.find(row => row.id === id); assert.ok(player); return player; };
|
|
const copy = (game: Game): Game => JSON.parse(JSON.stringify(game));
|
|
const pay = (target: string, amount: number): Action => ({type:'bribe', target, amount});
|
|
|
|
/** Public Basic Ix Harkonnen/Atreides/Emperor start. The Ix fixture uses a
|
|
* real native phase-opening chronology and selects only unopened card order. */
|
|
void test('Basic Ix opening bribe preserves passes and the native Amal uses the post-payment wallets', () => {
|
|
const f = createTruthTurnAmalFixture();
|
|
let game = f.game;
|
|
const original = inventory(game);
|
|
// Move the physical Amal to an unpassed seat so its later real play is possible.
|
|
const owner = seat(game, 'emperor'), index = owner.hand.findIndex(card => card.id === f.amal);
|
|
assert.ok(index >= 0); seat(game, 'atreides').hand.push(owner.hand.splice(index, 1)[0]);
|
|
assert.deepEqual(inventory(game), original);
|
|
game = act(game, 'harkonnen', {type:'ready'});
|
|
game = act(game, 'emperor', {type:'ready'});
|
|
const opening = structuredClone(game.phaseOpening), payer = seat(game, 'harkonnen').spice;
|
|
const recipient = seat(game, 'emperor').spice, deferred = seat(game, 'emperor').bribes;
|
|
assert.equal(viewGame(game, 'harkonnen').bribeOptions.blocked, null);
|
|
assert.equal(viewGame(game, 'harkonnen').bribeOptions.receiptTiming, 'upcoming');
|
|
game = act(game, 'harkonnen', pay('emperor', 2));
|
|
assert.deepEqual(game.phaseOpening, opening);
|
|
assert.equal(seat(game, 'harkonnen').spice, payer - 2);
|
|
assert.equal(seat(game, 'emperor').spice, recipient);
|
|
assert.equal(seat(game, 'emperor').bribes, deferred + 2);
|
|
const beforeAmal = game.players.map(player => player.spice);
|
|
game = act(game, 'atreides', {type:'card', card:f.amal});
|
|
assert.deepEqual(game.phaseOpening?.passed, []);
|
|
assert.deepEqual(game.players.map(player => player.spice), beforeAmal.map(amount => Math.floor(amount / 2)));
|
|
assert.equal(seat(game, 'emperor').bribes, deferred + 2);
|
|
assert.equal(game.discard.filter(card => card.id === f.amal).length, 1);
|
|
for (const player of game.players) game = act(game, player.id, {type:'ready'});
|
|
assert.equal(game.phaseOpening, null); assert.deepEqual(inventory(game), original);
|
|
});
|
|
|
|
void test('bribe before real Mentat initialization is collected at that opening', () => {
|
|
const f = createTruthTurnAmalFixture({phase:8, incoming:4});
|
|
let game = f.game;
|
|
assert.equal(game.phaseOpening?.initialize, true);
|
|
game = act(game, 'atreides', {type:'ready'});
|
|
const opening = structuredClone(game.phaseOpening), before = seat(game, 'emperor').spice;
|
|
assert.equal(seat(game, 'emperor').bribes, 4);
|
|
assert.equal(viewGame(game, 'atreides').bribeOptions.receiptTiming, 'upcoming');
|
|
game = act(game, 'atreides', pay('emperor', 2));
|
|
assert.deepEqual(game.phaseOpening, opening);
|
|
assert.equal(seat(game, 'emperor').spice, before);
|
|
assert.equal(seat(game, 'emperor').bribes, 6);
|
|
game = act(game, 'emperor', {type:'ready'});
|
|
game = act(game, 'harkonnen', {type:'ready'});
|
|
assert.equal(game.phaseOpening, null);
|
|
assert.equal(seat(game, 'emperor').spice, before + 6);
|
|
assert.equal(seat(game, 'emperor').bribes, 0);
|
|
});
|
|
|
|
/** Public Basic Ecaz-deck Moritani setup. As in the original Extortion gift
|
|
* fixture, stage only a legal prior physical Terror placement, phase/turn and
|
|
* two wallets; actual shipment, reveal, bank award and queue are native. */
|
|
function extortion() {
|
|
let game = createGame('BRIBEEXTORTION', newPlayer('m', 'Moritani', 'moritani'), false, ['ecaz']);
|
|
joinGame(game, newPlayer('e', 'Emperor', 'emperor'));
|
|
joinGame(game, newPlayer('a', 'Atreides', 'atreides'));
|
|
joinGame(game, newPlayer('h', 'Harkonnen', 'harkonnen'));
|
|
for (const player of game.players) game = act(game, player.id, {type:'ready'});
|
|
game = act(game, 'm', {type:'start'});
|
|
for (let i = 0; i < 100 && game.status === 'setup'; i++) {
|
|
if (game.decision?.kind === 'moritaniSetup')
|
|
game = act(game, 'm', {type:'decision', territory:'sietch_tabr', sector:territory('sietch_tabr').sectors[0]});
|
|
else {
|
|
const step = nextStrongholdFactionsNativeStep(game); assert.ok(step);
|
|
game = act(game, step.actor, step.action);
|
|
}
|
|
}
|
|
assert.equal(game.status, 'playing');
|
|
const token = game.moritaniTerror!.tokens.find(row => row.kind === 'extortion'); assert.ok(token);
|
|
game.moritaniTerror = placeTerror(game.moritaniTerror!, token.id, 'habbanya_ridge_sietch', 1);
|
|
Object.assign(game, {phase:5, turn:2, storm:18, order:['e','a','h','m'], active:'e',
|
|
movementRemaining:['e','a','h','m'], response:null, decision:null, phaseOpening:null, ready:[]});
|
|
seat(game, 'e').spice = 10; seat(game, 'a').spice = 2;
|
|
game = act(game, 'e', {type:'ship', territory:'habbanya_ridge_sietch', sector:17, amount:1});
|
|
assert.equal(game.decision?.kind, 'moritaniTerror');
|
|
game = act(game, 'm', {type:'decision', reveal:true});
|
|
assert.equal(game.moritaniTerror!.tokens.find(row => row.id === token.id)?.status, 'extortion');
|
|
game.phase = 7; game.ready = [];
|
|
for (const player of game.players) game = act(game, player.id, {type:'ready'});
|
|
assert.equal(game.decision?.kind, 'moritaniPlacement');
|
|
game = act(game, 'm', {type:'decision', decline:true});
|
|
assert.equal(game.decision?.kind, 'moritaniExtortion');
|
|
game = act(game, 'e', {type:'decision', event:game.decision.event, pay:false});
|
|
assert.equal(game.decision?.kind, 'moritaniExtortion'); assert.equal(game.decision.player, 'a');
|
|
return {game, token:token.id};
|
|
}
|
|
|
|
void test('Basic Extortion bribe leaves the queue intact and reaches the next real Mentat collection', () => {
|
|
const f = extortion(); let game = f.game;
|
|
const decision = structuredClone(game.decision), obligation = structuredClone(game.moritaniExtortion);
|
|
const payer = seat(game, 'h').spice, current = seat(game, 'a').spice;
|
|
assert.equal(viewGame(game, 'h').bribeOptions.blocked, null);
|
|
assert.equal(viewGame(game, 'h').bribeOptions.receiptTiming, 'nextTurn');
|
|
assert.equal(viewGame(game, 'a').extortion.pending?.canPay, false);
|
|
game = act(game, 'h', pay('a', 4));
|
|
assert.deepEqual(game.decision, decision); assert.deepEqual(game.moritaniExtortion, obligation);
|
|
assert.equal(seat(game, 'h').spice, payer - 4);
|
|
assert.equal(seat(game, 'a').spice, current); assert.equal(seat(game, 'a').bribes, 4);
|
|
assert.equal(viewGame(game, 'a').extortion.pending?.canPay, false);
|
|
assert.ok(game.decision?.kind === 'moritaniExtortion');
|
|
game = act(game, 'a', {type:'decision', event:game.decision.event, pay:false});
|
|
assert.ok(game.decision?.kind === 'moritaniExtortion'); assert.equal(game.decision.player, 'h');
|
|
game = act(game, 'h', {type:'decision', event:game.decision.event, pay:true});
|
|
assert.equal(game.moritaniExtortion, undefined);
|
|
assert.equal(game.moritaniTerror!.tokens.find(row => row.id === f.token)?.status, 'removed');
|
|
// Continue with real native actions until the last readiness before the
|
|
// next Mentat. Only the unopened turn-three Spice position is selected to
|
|
// avoid an incidental worm; no future resource, phase, turn or escrow is staged.
|
|
let ordered = false;
|
|
for (let i = 0; i < 1900; i++) {
|
|
if (!ordered && game.turn === 3 && beforeIxSpiceDraw(game)) {
|
|
orderIxSpiceCards(game, ['land']); ordered = true;
|
|
}
|
|
if (game.turn === 3 && game.phase === 7 && !game.response && !game.decision &&
|
|
!game.phaseOpening && game.players.filter(player => !game.ready.includes(player.id)).length === 1) break;
|
|
assert.notEqual(game.status, 'finished');
|
|
const next = nextStrongholdFactionsNativeStep(game); assert.ok(next);
|
|
game = act(game, next.actor, next.action);
|
|
}
|
|
assert.equal(game.turn, 3); assert.equal(game.phase, 7);
|
|
assert.equal(seat(game, 'a').bribes, 4);
|
|
const before = seat(game, 'a').spice;
|
|
const last = game.players.find(player => !game.ready.includes(player.id)); assert.ok(last);
|
|
game = act(game, last.id, {type:'ready'});
|
|
assert.equal(game.phase, 8); assert.equal(seat(game, 'a').spice, before + 4);
|
|
assert.equal(seat(game, 'a').bribes, 0);
|
|
});
|
|
|
|
void test('invalid Basic pending bribes preserve their original parent and game', () => {
|
|
const f = createTruthTurnAmalFixture(); const game = f.game;
|
|
seat(game, 'emperor').ally = 'atreides'; seat(game, 'atreides').ally = 'emperor';
|
|
const before = copy(game);
|
|
for (const [actor, action] of [
|
|
['emperor', pay('atreides', 1)], ['emperor', pay('emperor', 1)],
|
|
['emperor', pay('harkonnen', 0)], ['emperor', pay('harkonnen', seat(game, 'emperor').spice + 1)],
|
|
] as [string, Action][]) {
|
|
assert.throws(() => act(game, actor, action)); assert.deepEqual(game, before);
|
|
}
|
|
const pending = extortion().game, saved = copy(pending);
|
|
assert.throws(() => act(pending, 'h', pay('a', seat(pending, 'h').spice + 1)));
|
|
assert.deepEqual(pending, saved);
|
|
});
|
|
|
|
void test('an immediate deal cannot bypass its unchanged timing during an opening', () => {
|
|
let game = createTruthTurnAmalFixture().game;
|
|
game = act(game, 'harkonnen', {type:'dealOffer', target:'emperor', terms:'Information for spice.',
|
|
payment:{kind:'immediateBribe', payer:'harkonnen', recipient:'emperor', amount:1}});
|
|
const deal = game.deals?.at(-1); assert.ok(deal);
|
|
const before = copy(game);
|
|
assert.throws(() => act(game, 'emperor', {type:'dealRespond', deal:deal.id, accept:true}));
|
|
assert.deepEqual(game, before);
|
|
assert.equal(viewGame(game, 'harkonnen').bribeOptions.blocked, null);
|
|
game = act(game, 'harkonnen', pay('emperor', 1));
|
|
assert.deepEqual(game.phaseOpening, before.phaseOpening);
|
|
assert.equal(game.deals?.at(-1)?.status, 'offered');
|
|
});
|