140 lines
7.8 KiB
TypeScript
140 lines
7.8 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { TERRITORIES } from '../game/board';
|
|
import { viewGame, type Game } from '../game/engine';
|
|
import { botActions } from '../game/bots';
|
|
import { revivalPromiseModeSupported } from '../game/revival-promises';
|
|
import { act, advance, clean, createKullBribeFixture, inventory, player } from './fixture-kull-bribe';
|
|
|
|
function source() {
|
|
const f = createKullBribeFixture();
|
|
let game = structuredClone(f.game);
|
|
// The original driver selects the scalar lottery and dials one for each
|
|
// player in the next Storm. Select a real empty next-Storm sand sector.
|
|
const sector = game.storm % 18 + 1;
|
|
const destination = TERRITORIES.find(place => place.type === 'sand' && place.sectors.includes(sector) &&
|
|
game.players.every(seat => !Object.keys(seat.forces).some(key => key.startsWith(`${place.id}:`))));
|
|
assert.ok(destination);
|
|
game = act(game, f.actor, { type: 'ship', territory: destination.id, sector, amount: 3, elite: 0, allyPayment: 0 });
|
|
game = advance(game, clean);
|
|
game = act(game, f.actor, { type: 'endMovement' });
|
|
// Reorder only the still-unopened Spice deck so the next turn has a normal
|
|
// blow and cannot open an unrelated random Nexus decision.
|
|
const safe = game.spiceDeck.findIndex(card => 'territory' in card && !card.discovery);
|
|
assert.ok(safe >= 0); game.spiceDeck.unshift(game.spiceDeck.splice(safe, 1)[0]);
|
|
game = advance(game, state => state.turn === 2 && state.phase === 3 && clean(state) && state.auction?.active === f.actor);
|
|
assert.equal(player(game, f.actor).tanks, 3);
|
|
assert.equal(player(game, f.actor).spice, 4);
|
|
assert.deepEqual(inventory(game), f.originalCards);
|
|
return { ...f, game };
|
|
}
|
|
|
|
function ask(f: ReturnType<typeof source>, game: Game) {
|
|
game = act(game, f.asker, { type: 'card', card: f.truth });
|
|
while (game.truthtrance?.stage === 'priority') {
|
|
const passer = game.players.find(seat => !game.truthtrance!.passed.includes(seat.id));
|
|
assert.ok(passer); game = act(game, passer.id, { type: 'truthPass' });
|
|
}
|
|
return act(game, f.asker, { type: 'truthAsk', question: {
|
|
kind: 'revival', target: f.actor, turn: game.turn, counter: 'total', minimum: 3,
|
|
} });
|
|
}
|
|
|
|
void test('Basic printed Kull permits native Revival questions while preserving module fences', () => {
|
|
const native = { advanced: false, expansions: ['choam', 'ix'],
|
|
players: [{ faction: 'choam' }, { faction: 'emperor' }], kullPreview: true };
|
|
assert.equal(revivalPromiseModeSupported(native), true);
|
|
for (const option of ['semutaPreview', 'nexusKullPreview', 'nexusCards', 'leaderSkills',
|
|
'richeseBetrayalPreview', 'guildBetrayalPreview'] as const)
|
|
assert.equal(revivalPromiseModeSupported({ ...native, [option]: true }), false, option);
|
|
assert.equal(revivalPromiseModeSupported({ ...native, advanced: true }), false);
|
|
assert.equal(revivalPromiseModeSupported({ ...native, players: [{ faction: 'emperor' }, { faction: 'guild' }] }), false);
|
|
});
|
|
|
|
void test('a genuine Kull game binds and completes an ordinary Revival Yes after real Storm losses', () => {
|
|
const f = source();
|
|
let game = advance(f.game, state => state.phase === 4 && clean(state));
|
|
game = ask(f, game);
|
|
assert.ok(viewGame(game, f.actor).truthRevivalAnswers?.includes('yes'));
|
|
game = act(game, f.actor, { type: 'truthAnswer', answer: 'yes' });
|
|
const guide = viewGame(game, f.actor).revivalPromiseGuide; assert.ok(guide);
|
|
assert.equal(guide.action.type, 'revive'); assert.equal(guide.action.amount, 3);
|
|
const bot = viewGame(game, f.actor); bot.players.find(p => p.id === f.actor)!.bot = 'Easy';
|
|
const botRevival = botActions(bot).find(action => action.revivalPromiseEvent === guide.action.revivalPromiseEvent); assert.ok(botRevival);
|
|
assert.equal(act(structuredClone(game), f.actor, botRevival).decision?.kind, 'choamFreeRevival');
|
|
game = act(game, f.actor, guide.action);
|
|
assert.equal(game.decision?.kind, 'choamFreeRevival');
|
|
assert.equal(game.revivalPromises?.[0].progress, 0);
|
|
game = advance(game, clean);
|
|
assert.equal(game.revivalPromises?.[0].progress, 3);
|
|
assert.equal(game.revivalPromises?.[0].fulfilled, true);
|
|
assert.equal(player(game, f.actor).tanks, 0);
|
|
assert.deepEqual(inventory(game), f.originalCards);
|
|
});
|
|
|
|
void test('a successful Kull auction block cannot be forecast as a Karama payment funding Revival', () => {
|
|
const f = source();
|
|
let game = act(f.game, f.actor, { type: 'card', mode: 'purchase', card: f.karama });
|
|
const reaction = viewGame(game, f.reactor).kullReaction; assert.ok(reaction);
|
|
game = act(game, f.reactor, { type: 'kullDecision', event: reaction.event, source: 'printed', card: f.kull });
|
|
game = advance(game, clean);
|
|
assert.ok(viewGame(game, f.actor).karamaBlocked);
|
|
game = act(game, f.actor, { type: 'bid', amount: 3, allyPayment: 0 });
|
|
game = ask(f, game);
|
|
assert.deepEqual(viewGame(game, f.actor).truthRevivalAnswers, ['no']);
|
|
const before = structuredClone(game);
|
|
assert.throws(() => act(game, f.actor, { type: 'truthAnswer', answer: 'yes' }));
|
|
assert.deepEqual(game, before);
|
|
game = act(game, f.actor, { type: 'truthAnswer', answer: 'no' });
|
|
assert.equal(game.revivalPromises?.[0].answer, false);
|
|
assert.deepEqual(inventory(game), f.originalCards);
|
|
});
|
|
|
|
function outstandingPayment() {
|
|
const f = source();
|
|
let game = act(f.game, f.actor, { type: 'bid', amount: 3, allyPayment: 0 });
|
|
game = ask(f, game);
|
|
assert.ok(viewGame(game, f.actor).truthRevivalAnswers?.includes('yes'));
|
|
game = act(game, f.actor, { type: 'truthAnswer', answer: 'yes' });
|
|
const promise = structuredClone(game.revivalPromises);
|
|
game = advance(game, state => !state.response && !state.phaseOpening &&
|
|
state.decision?.kind === 'auctionPayment' && state.decision.player === f.actor);
|
|
const payment = viewGame(game, f.actor).revivalPromiseGuide; assert.ok(payment);
|
|
assert.equal(payment.action.type, 'decision'); assert.equal(payment.action.karama, true);
|
|
game = act(game, f.actor, payment.action);
|
|
assert.equal(game.pendingKull?.stage, 'offer');
|
|
assert.deepEqual(game.revivalPromises, promise);
|
|
assert.equal(viewGame(game, f.actor).revivalPromiseGuide, null);
|
|
const reaction = viewGame(game, f.reactor).kullReaction; assert.ok(reaction);
|
|
game = act(game, f.reactor, { type: 'kullDecision', event: reaction.event, source: 'printed', card: f.kull });
|
|
assert.equal(game.pendingKull?.stage, 'counter');
|
|
assert.deepEqual(game.revivalPromises, promise);
|
|
assert.equal(viewGame(game, f.actor).revivalPromiseGuide, null);
|
|
return { f, game, promise };
|
|
}
|
|
|
|
void test('an opposing successful Kull may release a Revival Yes only after preventing its actual payment', () => {
|
|
const { f, game: offered, promise } = outstandingPayment();
|
|
const game = advance(offered, clean);
|
|
assert.equal(promise?.[0].released, undefined);
|
|
assert.equal(game.revivalPromises?.[0].progress, 0);
|
|
assert.equal(game.revivalPromises?.[0].released, true);
|
|
assert.equal(player(game, f.actor).spice, 1);
|
|
assert.ok(player(game, f.actor).hand.some(card => card.id === f.karama));
|
|
assert.deepEqual(inventory(game), f.originalCards);
|
|
});
|
|
|
|
void test('a distinct Kull counter preserves the original payment and outstanding Revival Yes', () => {
|
|
const { f, game: offered, promise } = outstandingPayment();
|
|
assert.ok(viewGame(offered, f.counterOwner).responseControls?.cancelCards.includes(f.counter));
|
|
let game = act(offered, f.counterOwner, { type: 'card', mode: 'cancel', card: f.counter });
|
|
game = advance(game, state => state.phase === 4 && clean(state));
|
|
assert.deepEqual(game.revivalPromises, promise);
|
|
assert.equal(player(game, f.actor).spice, 4);
|
|
const guide = viewGame(game, f.actor).revivalPromiseGuide; assert.ok(guide);
|
|
game = advance(act(game, f.actor, guide.action), clean);
|
|
assert.equal(game.revivalPromises?.[0].progress, 3);
|
|
assert.equal(game.revivalPromises?.[0].fulfilled, true);
|
|
assert.deepEqual(inventory(game), f.originalCards);
|
|
});
|