104 lines
6.5 KiB
TypeScript
104 lines
6.5 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { createGame, joinGame, newPlayer, viewGame, type Game } from '../game/engine';
|
|
import { ambassadorPlacementDestinations } from '../game/ecaz-ambassador-placement';
|
|
import { validateAmbassadors } from '../game/ecaz-ambassadors';
|
|
import { DUKE_VIDAL_ID } from '../game/duke-vidal';
|
|
import { botActions } from '../game/bots';
|
|
import { DIFFICULTIES } from '../game/bot-profiles';
|
|
import { actDukeAmbassador as act, advanceDukeAmbassador as advance,
|
|
dukeAmbassadorClean as clean, dukeAmbassadorPlayer as player } from './fixture-duke-ambassador';
|
|
|
|
const cards = (game: Game) => [...game.deck, ...game.discard, ...game.players.flatMap(p => p.hand)]
|
|
.map(card => card.id).sort();
|
|
const balances = (game: Game) => game.players.map(p => ({ id: p.id, spice: p.spice,
|
|
reserves: p.reserves, tanks: p.tanks, forces: p.forces, hand: p.hand,
|
|
revived: p.revived, freeForcesRevived: p.freeForcesRevived, leaderRevived: p.leaderRevived,
|
|
ecazRevivalCohort: p.ecazRevivalCohort }));
|
|
|
|
/** Genuine Advanced setup and Ambassador placement/entry. The selected packet
|
|
* token and public Duke death are explicitly staged for this focused path. */
|
|
function nativeAdvancedGrant() {
|
|
let game = createGame('ADVANCEDDUKEAMBASSADOR', newPlayer('ecaz', 'Ecaz', 'ecaz'), true, ['ecaz']);
|
|
for (const faction of ['harkonnen', 'guild'] as const) joinGame(game, newPlayer(faction, faction, faction));
|
|
for (const p of game.players) game = act(game, p.id, { type: 'ready' });
|
|
game = act(game, 'ecaz', { type: 'start', advancedPreview: true });
|
|
game = advance(game, state => state.status === 'playing');
|
|
const originalCards = cards(game);
|
|
for (const position of [0, 1]) {
|
|
const index = game.spiceDeck.findIndex((card, i) => i >= position && 'territory' in card && !card.discovery);
|
|
assert.ok(index >= position);
|
|
[game.spiceDeck[position], game.spiceDeck[index]] = [game.spiceDeck[index], game.spiceDeck[position]];
|
|
}
|
|
game = advance(game, state => state.turn === 1 && state.phase === 4 && !state.response &&
|
|
!state.phaseOpening && state.decision?.kind === 'ecazPlacement');
|
|
const ambassadors = game.ecazAmbassadors!;
|
|
const originalTokens = ambassadors.tokens.map(token => token.id).sort();
|
|
const token = ambassadors.tokens.find(row => row.effect === 'tleilaxu'); assert.ok(token);
|
|
// Select the actual Tleilaxu disc in the original five-token packet, swapping
|
|
// custody with one unplaced selected disc rather than creating a marker.
|
|
if (token.zone === 'pool') {
|
|
const replaced = ambassadors.tokens.find(row => row.zone === 'supply' && row.effect !== 'ecaz');
|
|
assert.ok(replaced);
|
|
const index = ambassadors.cohort.indexOf(replaced.id); assert.ok(index >= 0);
|
|
ambassadors.cohort[index] = token.id;
|
|
replaced.zone = 'pool'; token.zone = 'supply';
|
|
}
|
|
validateAmbassadors(ambassadors);
|
|
const destinations = ambassadorPlacementDestinations(game);
|
|
const candidate = [
|
|
{ territory: 'habbanya_ridge_sietch', sector: 17 },
|
|
{ territory: 'sietch_tabr', sector: 14 },
|
|
{ territory: 'arrakeen', sector: 10 },
|
|
].find(row => destinations.some(destination => destination.id === row.territory));
|
|
assert.ok(candidate);
|
|
game = act(game, 'ecaz', { type: 'decision', token: token.id, territory: candidate.territory });
|
|
game = advance(game, state => !state.response && state.decision?.kind === 'ecazPlacement');
|
|
assert.equal(game.ecazAmbassadors!.tokens.find(row => row.id === token.id)!.zone, 'placed');
|
|
game = act(game, 'ecaz', { type: 'decision', decline: true });
|
|
game = advance(game, state => state.turn === 1 && state.phase === 5 && state.active === 'guild' && clean(state));
|
|
assert.ok(game.dukeVidal); assert.equal(game.dukeVidal.controller, null);
|
|
assert.equal(game.dukeVidal.leader.dead, false);
|
|
// Stage a publicly dead shared disc, after ordinary Revival has concluded.
|
|
game.dukeVidal.leader.dead = true;
|
|
game.dukeVidal.leader.deaths = 1;
|
|
game = act(game, 'guild', { type: 'ship', amount: 1, territory: candidate.territory, sector: candidate.sector });
|
|
game = advance(game, state => !state.response && state.pendingAmbassador?.stage === 'offer');
|
|
assert.equal(game.pendingAmbassador!.token, token.id);
|
|
const event = game.pendingAmbassador!.event;
|
|
game = act(game, 'ecaz', { type: 'decision', event, trigger: true, beneficiary: 'ecaz', choice: 'effect' });
|
|
assert.equal(game.pendingAmbassador?.stage, 'revival');
|
|
return { game, event, token: token.id, originalTokens, originalCards, candidate };
|
|
}
|
|
|
|
void test('Advanced Tleilaxu entry returns the public Duke with Harkonnen seated and preserves custody and ordinary allowance', () => {
|
|
const { game, event, token, originalTokens, originalCards, candidate } = nativeAdvancedGrant();
|
|
assert.equal(game.advanced, true); assert.deepEqual(game.expansions, ['ecaz']);
|
|
assert.equal(player(game, 'ecaz').tanks, 0);
|
|
assert.ok(player(game, 'ecaz').leaders.every(leader => !leader.dead));
|
|
assert.deepEqual(viewGame(game, 'ecaz').ambassadorEntry!.revival!.leaders.map(leader => leader.id), [DUKE_VIDAL_ID]);
|
|
assert.equal(viewGame(game, 'guild').ambassadorEntry!.revival, null);
|
|
const done = act(game, 'ecaz', { type: 'decision', event, leader: DUKE_VIDAL_ID });
|
|
assert.deepEqual(balances(done), balances(game));
|
|
assert.equal(done.dukeVidal!.leader.dead, false); assert.equal(done.dukeVidal!.leader.deaths, 1);
|
|
assert.equal(done.dukeVidal!.controller, null);
|
|
assert.ok(done.players.every(p => p.leaders.every(leader => leader.id !== DUKE_VIDAL_ID)));
|
|
assert.deepEqual(done.ecazAmbassadors!.tokens.map(row => row.id).sort(), originalTokens);
|
|
assert.equal(done.ecazAmbassadors!.tokens.find(row => row.id === token)!.zone, 'used');
|
|
validateAmbassadors(done.ecazAmbassadors!);
|
|
assert.deepEqual(cards(done), originalCards);
|
|
assert.equal(done.pendingAmbassador, null); assert.equal(done.active, 'guild');
|
|
assert.equal(player(done, 'guild').forces[`${candidate.territory}:${candidate.sector}`], 1);
|
|
const ended = act(done, 'guild', { type: 'endMovement' });
|
|
assert.equal(ended.movementRemaining?.includes('guild') ?? false, false);
|
|
|
|
for (const difficulty of DIFFICULTIES) {
|
|
const view = viewGame(game, 'ecaz'); view.players.find(p => p.id === 'ecaz')!.bot = difficulty;
|
|
const action = botActions(view)[0]; assert.equal(action.leader, DUKE_VIDAL_ID, difficulty);
|
|
const resumed = act(game, 'ecaz', action);
|
|
assert.equal(resumed.dukeVidal!.leader.dead, false); assert.equal(resumed.dukeVidal!.controller, null);
|
|
assert.equal(resumed.pendingAmbassador, null); assert.equal(resumed.active, 'guild');
|
|
assert.deepEqual(balances(resumed), balances(game));
|
|
}
|
|
});
|