126 lines
7.1 KiB
TypeScript
126 lines
7.1 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { botActions } from '../game/bots';
|
|
import { DIFFICULTIES } from '../game/bot-profiles';
|
|
import { coalitionOf } from '../game/coalition-alliance';
|
|
import { applyAction, createGame, joinGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
|
|
import { advanceShortAlliance, shortAllianceLobby, type ShortAllianceStep } from './fixture-short-alliance-victory';
|
|
|
|
const apply = (game: Game, actor: string, action: Action) => applyAction(game, actor, action);
|
|
function lobby(): Game {
|
|
const game = shortAllianceLobby();
|
|
joinGame(game, newPlayer('ha', 'Harkonnen', 'harkonnen'));
|
|
return game;
|
|
}
|
|
function ready(game: Game): Game {
|
|
for (const player of game.players) if (!player.ready) game = apply(game, player.id, {type:'ready'});
|
|
return game;
|
|
}
|
|
function answer(game: Game, actor: string): Game {
|
|
const proposal = game.coalitionState?.proposal; assert.ok(proposal);
|
|
return apply(game, actor, {type:'coalitionAnswer', event:proposal.event, nexus:proposal.nexus,
|
|
turn:proposal.turn, accept:true, expectedRevision:game.coalitionState!.revision});
|
|
}
|
|
|
|
void test('host selects a group preview, clearing readiness, and can restore ordinary rules', () => {
|
|
let game = ready(lobby());
|
|
assert.equal(viewGame(game, 'at').coalitionPreview, 'off');
|
|
const original = structuredClone(game);
|
|
assert.throws(() => apply(game,'em',{type:'coalitionPreview',variant:'three'}));
|
|
assert.deepEqual(game, original);
|
|
assert.throws(() => apply(game,'at',{type:'coalitionPreview',variant:'bad'}));
|
|
assert.throws(() => apply(game,'at',{type:'coalitionPreview',variant:'three', extra:true}));
|
|
game = apply(game,'at',{type:'coalitionPreview',variant:'three'});
|
|
assert.equal(viewGame(game,'em').coalitionPreview,'three');
|
|
assert.ok(game.players.every(player => !player.ready));
|
|
game = apply(ready(game),'at',{type:'coalitionPreview',variant:'off'});
|
|
assert.equal(viewGame(game,'em').coalitionPreview,'off');
|
|
assert.ok(game.players.every(player => !player.ready));
|
|
game = apply(ready(game),'at',{type:'start'});
|
|
assert.equal(game.coalitionState, undefined);
|
|
});
|
|
|
|
void test('each selected Basic group variant starts a genuine game with the intended fresh ledger', () => {
|
|
for (const variant of ['three','three-short','unlimited'] as const) {
|
|
let game = apply(lobby(),'at',{type:'coalitionPreview',variant});
|
|
game = apply(ready(game),'at',{type:'start'});
|
|
assert.ok(game.coalitionState);
|
|
assert.equal(game.coalitionState.variant, variant === 'three' ? undefined : variant);
|
|
assert.deepEqual(game.coalitionState.groups, []);
|
|
assert.equal(game.coalitionState.proposal, null);
|
|
assert.equal(viewGame(game,'em').coalitionPreview,variant);
|
|
}
|
|
});
|
|
|
|
void test('group preview refuses incompatible rules and optional alliance settings at start', () => {
|
|
let advanced = apply(lobby(),'at',{type:'coalitionPreview',variant:'three'});
|
|
advanced = apply(advanced,'at',{type:'rules',advanced:true});
|
|
advanced = ready(advanced);
|
|
assert.throws(() => apply(advanced,'at',{type:'start'}), /Advanced.*preview/i);
|
|
let shortened = apply(lobby(),'at',{type:'coalitionPreview',variant:'three'});
|
|
shortened = apply(shortened,'at',{type:'shortAllianceVictory',enabled:true});
|
|
shortened = ready(shortened);
|
|
assert.throws(() => apply(shortened,'at',{type:'start'}), /group|alliance/i);
|
|
for (const action of [{type:'homeworlds',enabled:true}, {type:'techTokens',enabled:true},
|
|
{type:'moduleOption',module:'leaderSkills',enabled:true}] as const) {
|
|
let configured = apply(lobby(),'at',{type:'coalitionPreview',variant:'three'});
|
|
configured = apply(configured,'at',action);
|
|
configured = ready(configured);
|
|
assert.throws(() => apply(configured,'at',{type:'start'}), /group|alliance/i);
|
|
}
|
|
let expansion = createGame('GROUPEXP',newPlayer('at','Atreides','atreides'),false,['ix']);
|
|
joinGame(expansion,newPlayer('em','Emperor','emperor'));
|
|
joinGame(expansion,newPlayer('gu','Guild','guild'));
|
|
expansion = apply(expansion,'at',{type:'coalitionPreview',variant:'three'});
|
|
expansion = ready(expansion);
|
|
assert.throws(() => apply(expansion,'at',{type:'start'}), /group|alliance/i);
|
|
let twoSeats = createGame('GROUP2',newPlayer('at','Atreides','atreides'));
|
|
joinGame(twoSeats,newPlayer('em','Emperor','emperor'));
|
|
twoSeats = apply(twoSeats,'at',{type:'coalitionPreview',variant:'three'});
|
|
twoSeats = ready(twoSeats);
|
|
assert.throws(() => apply(twoSeats,'at',{type:'start'}), /three|3|group/i);
|
|
});
|
|
|
|
/** Real deal and setup, native first-turn actions, and actual Nexus negotiation.
|
|
* Only an unopened original worm card is moved to the top of the Spice deck. */
|
|
function groupNexus(): Game {
|
|
let game = apply(lobby(),'at',{type:'coalitionPreview',variant:'three-short'});
|
|
game = apply(ready(game),'at',{type:'start'});
|
|
const actions: ShortAllianceStep[] = [];
|
|
game = advanceShortAlliance(game, state => state.status === 'playing' && state.turn === 2 && state.phase === 0, actions);
|
|
const worm = game.spiceDeck.findIndex(card => 'worm' in card && !card.greatMaker && !card.suppressed && !card.thumper);
|
|
assert.ok(worm >= 0);
|
|
game.spiceDeck.unshift(game.spiceDeck.splice(worm, 1)[0]);
|
|
game = advanceShortAlliance(game, state => state.nexus && !state.spiceWindow && !state.spiceResolution &&
|
|
!state.response && !state.decision && !state.truthtrance && !state.phaseOpening, actions);
|
|
game = apply(game,'at',{type:'alliance',target:'em'});
|
|
return apply(game,'em',{type:'alliance',target:'at'});
|
|
}
|
|
|
|
void test('an actual started preview reaches group formation, unanimous consent and legal bot proposals', () => {
|
|
const original = groupNexus();
|
|
const pair = coalitionOf(original.players,original.coalitionState,'at'); assert.ok(pair);
|
|
assert.deepEqual(new Set(pair.members),new Set(['at','em']));
|
|
let formed: Game | undefined;
|
|
for (const difficulty of DIFFICULTIES) {
|
|
const view = viewGame(original,'gu'); view.players.find(player => player.id === 'gu')!.bot = difficulty;
|
|
const proposal = botActions(view).find(action => action.type === 'coalitionPropose'); assert.ok(proposal,difficulty);
|
|
let game = apply(original,'gu',proposal);
|
|
game = answer(game,'at'); game = answer(game,'em');
|
|
assert.deepEqual(new Set(coalitionOf(game.players,game.coalitionState,'at')!.members),new Set(['at','em','gu']));
|
|
assert.equal(game.coalitionState!.proposal,null);
|
|
const progress = viewGame(game,'at').victoryProgress.find(row => row.player === 'at'); assert.ok(progress);
|
|
assert.equal(progress.target,3);
|
|
formed = game;
|
|
}
|
|
assert.ok(formed);
|
|
// Once all original seats finish Nexus, use native controls for the rest of
|
|
// the turn. The next Storm opens before another Nexus can change alliances.
|
|
for (const player of formed.players)
|
|
if (formed.nexus && !formed.ready.includes(player.id)) formed = apply(formed,player.id,{type:'ready'});
|
|
const continued = advanceShortAlliance(formed,
|
|
state => state.status === 'playing' && state.turn === 3 && state.phase === 0, []);
|
|
assert.equal(continued.turn,3);
|
|
assert.deepEqual(new Set(coalitionOf(continued.players,continued.coalitionState,'at')!.members),new Set(['at','em','gu']));
|
|
});
|