156 lines
8.2 KiB
TypeScript
156 lines
8.2 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { createGame, joinGame, newPlayer, viewGame, type Game } from '../game/engine';
|
|
import { botActions, runBots } from '../game/bots';
|
|
import { DIFFICULTIES, type Difficulty } from '../game/bot-profiles';
|
|
import {
|
|
actFremenRevivalGrant as act,
|
|
advanceFremenRevivalGrant as advance,
|
|
fremenRevivalGrantClean as clean,
|
|
fremenRevivalGrantPlayer as player,
|
|
passFremenRevivalGrantResponses as pass,
|
|
} from './fixture-fremen-revival-grant';
|
|
|
|
/** Actual Advanced public setup and first ordered Revival. Reversing the two
|
|
* original lobby seats changes the real storm order. At Revival only, the
|
|
* reciprocal prior alliance and three ordinary Atreides casualties are staged;
|
|
* the counters move from his reserves into Tanks, without inventing supply.
|
|
* This controlled alliance is not a claim about Nexus history or full games. */
|
|
function source(fremenFirstSeat: boolean) {
|
|
const first = fremenFirstSeat ? newPlayer('fremen', 'Fremen', 'fremen')
|
|
: newPlayer('atreides', 'Atreides', 'atreides');
|
|
const second = fremenFirstSeat ? newPlayer('atreides', 'Atreides', 'atreides')
|
|
: newPlayer('fremen', 'Fremen', 'fremen');
|
|
let game = createGame('FREMENORDEREDBOT', first, true);
|
|
joinGame(game, second);
|
|
joinGame(game, newPlayer('emperor', 'Emperor', 'emperor'));
|
|
for (const p of game.players) game = act(game, p.id, { type: 'ready' });
|
|
game = act(game, game.host, { type: 'start', advancedPreview: true });
|
|
game = advance(game, state => state.status === 'playing');
|
|
// Select only two original unopened ordinary blows, avoiding incidental worms.
|
|
for (let position = 0; position < 2; position++) {
|
|
const index = game.spiceDeck.findIndex((card, i) => i >= position && 'territory' in card && !card.discovery);
|
|
assert.ok(index >= position);
|
|
game.spiceDeck.splice(position, 0, game.spiceDeck.splice(index, 1)[0]);
|
|
}
|
|
game = advance(game, state => state.phase === 4 && clean(state));
|
|
assert.ok(game.revivalOrder);
|
|
const ally = player(game, 'atreides'), fremen = player(game, 'fremen');
|
|
fremen.ally = ally.id; ally.ally = fremen.id;
|
|
assert.ok(ally.reserves >= 3);
|
|
ally.reserves -= 3; ally.tanks += 3;
|
|
return game;
|
|
}
|
|
|
|
let cached: { earlier: Game; later: Game } | undefined;
|
|
function sources() {
|
|
if (cached) return cached;
|
|
const options = [source(true), source(false)];
|
|
const earlier = options.find(g => g.order.indexOf('fremen') < g.order.indexOf('atreides'));
|
|
const later = options.find(g => g.order.indexOf('fremen') > g.order.indexOf('atreides'));
|
|
assert.ok(earlier && later, 'Opposite real seat assignments must produce both relative Revival orders');
|
|
cached = { earlier, later }; return cached;
|
|
}
|
|
function awaitingAlly(order: 'earlier' | 'later', level: Difficulty = 'Easy') {
|
|
let game = structuredClone(sources()[order]);
|
|
while (game.revivalOrder?.remaining[0] !== 'atreides') {
|
|
const actor = game.revivalOrder?.remaining[0]; assert.ok(actor);
|
|
game = act(game, actor, { type: 'ready' });
|
|
}
|
|
assert.ok(game.revivalOrder);
|
|
assert.equal(game.revivalOrder.remaining[0], 'atreides');
|
|
assert.equal(game.revivalOrder.completed.includes('fremen'), order === 'earlier');
|
|
game = act(game, 'atreides', { type: 'setAutopilot', difficulty: level });
|
|
return game;
|
|
}
|
|
function swapKaramaToObserver(game: Game) {
|
|
const observer = player(game, 'emperor');
|
|
if (observer.hand.some(card => card.effect === 'karama')) return observer.hand.find(card => card.effect === 'karama')!.id;
|
|
const held = observer.hand[0]; assert.ok(held);
|
|
const pools = [game.deck, game.discard, ...game.players.filter(p => p.id !== observer.id).map(p => p.hand)];
|
|
const pool = pools.find(cards => cards.some(card => card.effect === 'karama')); assert.ok(pool);
|
|
const index = pool.findIndex(card => card.effect === 'karama');
|
|
const card = pool[index]; pool[index] = held; observer.hand[0] = card;
|
|
return card.id;
|
|
}
|
|
|
|
for (const order of ['earlier', 'later'] as const) for (const level of DIFFICULTIES) void test(
|
|
`Advanced ${level} allied bot waits for human Fremen ${order} in ordered Revival and uses a real grant`, () => {
|
|
let game = awaitingAlly(order, level);
|
|
const before = structuredClone(game.revivalOrder), ally = player(game, 'atreides');
|
|
const tanks = ally.tanks, spice = ally.spice;
|
|
game = runBots(game, 1);
|
|
assert.deepEqual(game.revivalOrder, before);
|
|
assert.equal(player(game, 'atreides').revived, 0);
|
|
assert.equal(player(game, 'atreides').tanks, tanks);
|
|
game = act(game, 'fremen', { type: 'grantRevival' });
|
|
if (game.response) game = pass(game);
|
|
assert.equal(viewGame(game, 'atreides').revival.freeRemaining, 3);
|
|
const offered = botActions(viewGame(game, 'atreides')).find(action => action.type === 'revive' && action.amount === 3);
|
|
assert.ok(offered);
|
|
game = runBots(game, 1);
|
|
assert.equal(player(game, 'atreides').tanks, tanks - 3);
|
|
assert.equal(player(game, 'atreides').spice, spice);
|
|
assert.equal(player(game, 'atreides').freeForcesRevived, 3);
|
|
},
|
|
);
|
|
|
|
for (const order of ['earlier', 'later'] as const) void test(
|
|
`Fremen ${order} in the ordered queue can release an automated ally without forfeiting a later grant`, () => {
|
|
let game = awaitingAlly(order);
|
|
const before = structuredClone(game.revivalOrder);
|
|
assert.ok(!viewGame(game, 'fremen').fremenRevivalGrant?.waitReleased);
|
|
game = act(game, 'fremen', { type: 'releaseFremenRevivalWait', target: 'atreides' });
|
|
assert.deepEqual(game.revivalOrder, before);
|
|
assert.equal(viewGame(game, 'fremen').fremenRevivalGrant?.waitReleased, true);
|
|
assert.equal(viewGame(game, 'fremen').fremenRevivalGrant?.blocked, null);
|
|
assert.equal(game.freeRevival.includes('atreides'), false);
|
|
let granted = act(game, 'fremen', {type:'grantRevival'});
|
|
if (granted.response) granted = pass(granted);
|
|
assert.equal(granted.freeRevival.includes('atreides'), true);
|
|
const resumed = runBots(game, 1);
|
|
assert.ok(player(resumed, 'atreides').revived > 0 || resumed.ready.includes('atreides'));
|
|
},
|
|
);
|
|
|
|
void test('Fremen can release a future ally, while other seats and stale releases are rejected', () => {
|
|
let game = structuredClone(sources().earlier);
|
|
game = act(game, 'atreides', {type:'setAutopilot', difficulty:'Easy'});
|
|
assert.ok(game.revivalOrder?.remaining.includes('atreides'));
|
|
assert.notEqual(game.revivalOrder?.remaining[0], 'atreides');
|
|
const before = structuredClone(game);
|
|
assert.throws(() => act(game, 'emperor', {type:'releaseFremenRevivalWait', target:'atreides'}));
|
|
assert.deepEqual(game, before);
|
|
game = act(game, 'fremen', {type:'releaseFremenRevivalWait', target:'atreides'});
|
|
assert.equal(viewGame(game, 'fremen').fremenRevivalGrant?.waitReleased, true);
|
|
assert.equal(viewGame(game, 'emperor').fremenRevivalGrant, null);
|
|
const released = structuredClone(game);
|
|
assert.throws(() => act(game, 'fremen', {type:'releaseFremenRevivalWait', target:'atreides'}));
|
|
assert.deepEqual(game, released);
|
|
});
|
|
|
|
void test('real Karama prevention releases the Advanced bot with its intrinsic free rate', () => {
|
|
let game = awaitingAlly('later', 'Medium');
|
|
// Conserved exchange of original Treachery cards gives Emperor a counter.
|
|
const karama = swapKaramaToObserver(game);
|
|
game = act(game, 'fremen', { type: 'grantRevival' });
|
|
assert.equal(game.response?.kind, 'fremenRevivalGrant');
|
|
game = act(game, 'emperor', { type: 'card', card: karama, mode: 'cancel' });
|
|
assert.ok(game.revivalRules?.fremenGrantBlocked?.includes('atreides'));
|
|
assert.equal(viewGame(game, 'atreides').revival.freeRemaining, 2);
|
|
const resumed = runBots(game, 1);
|
|
assert.ok(player(resumed, 'atreides').revived > 0 || resumed.ready.includes('atreides'));
|
|
});
|
|
|
|
void test('Advanced bots do not wait for an unnecessary grant or an automated Fremen', () => {
|
|
for (const variant of ['two-tanks', 'automated-fremen'] as const) {
|
|
let game = awaitingAlly('later');
|
|
if (variant === 'two-tanks') {
|
|
// Return one ordinary counter from Tanks to its original reserve supply.
|
|
player(game, 'atreides').tanks--; player(game, 'atreides').reserves++;
|
|
} else game = act(game, 'fremen', { type: 'setAutopilot', difficulty: 'Easy' });
|
|
game = runBots(game, 1);
|
|
assert.ok(player(game, 'atreides').revived > 0 || game.ready.includes('atreides'));
|
|
}
|
|
});
|