201 lines
11 KiB
TypeScript
201 lines
11 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { applyAction, createGame, joinGame, newPlayer, normalizeAutomaticGame, viewGame, type Action, type Game } from '../game/engine';
|
|
import { botActions } from '../game/bots';
|
|
import { DIFFICULTIES } from '../game/bot-profiles';
|
|
import { placeTerror } from '../game/moritani-terror';
|
|
import { SEMUTA_DRUG_ID } from '../game/semuta-drug';
|
|
import type { Card } from '../game/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 inventory = (game: Game) => {
|
|
const ids = [...game.deck, ...game.discard, ...(game.richeseCache ?? []),
|
|
...(game.richeseRemoved ?? []), ...game.players.flatMap(player => player.hand)].map(card => card.id).sort();
|
|
assert.equal(new Set(ids).size, ids.length); return ids;
|
|
};
|
|
const take = (game: Game, predicate: (card: Card) => boolean): Card => {
|
|
for (const zone of [game.deck, game.discard, game.richeseCache ?? []]) {
|
|
const index = zone.findIndex(predicate);
|
|
if (index >= 0) return zone.splice(index, 1)[0];
|
|
}
|
|
throw new Error('An original physical card is unavailable.');
|
|
};
|
|
const ordinaryCard = (game: Game) => take(game, card =>
|
|
['projectile', 'poison', 'shield', 'snooper', 'worthless'].includes(card.kind));
|
|
|
|
/** Control only Atomics' two scalar draws; UUID and all other entropy remain
|
|
* native. The original random choice always takes each staged hand's first card. */
|
|
function withAtomicsRolls<T>(run: () => T): T {
|
|
const descriptor = Object.getOwnPropertyDescriptor(crypto, 'getRandomValues');
|
|
const original = crypto.getRandomValues.bind(crypto); let draws = 0;
|
|
crypto.getRandomValues = <V extends ArrayBufferView | null>(array: V): V => {
|
|
if (array instanceof Uint32Array && array.length === 1) { array[0] = 0; draws++; }
|
|
else Reflect.apply(original, crypto, [array]);
|
|
return array;
|
|
};
|
|
try { const result = run(); assert.equal(draws, 2); return result; }
|
|
finally {
|
|
if (descriptor) Object.defineProperty(crypto, 'getRandomValues', descriptor);
|
|
else Reflect.deleteProperty(crypto, 'getRandomValues');
|
|
}
|
|
}
|
|
|
|
/** Genuine Basic selected-faction start. The alliance, phase, card custody,
|
|
* force positions and original Atomics token placement are staged with
|
|
* conserved physical components; shipment and detonation use actual actions. */
|
|
function fixture(holder: 'ally' | 'third' = 'ally') {
|
|
let game = createGame('SEMUTAATOMICS', newPlayer('m', 'Moritani', 'moritani'), false, ['choam', 'ecaz']);
|
|
joinGame(game, newPlayer('r', 'Richese', 'richese'));
|
|
joinGame(game, newPlayer('a', 'Atreides', 'atreides'));
|
|
game = act(game, 'm', {type:'moduleOption', module:'ecazTreachery', enabled:true});
|
|
for (const player of game.players) game = act(game, player.id, {type:'ready'});
|
|
game = act(game, 'm', {type:'start'});
|
|
assert.equal(game.status, 'setup');
|
|
assert.equal(game.semutaRecruitsPreview, true);
|
|
assert.equal(game.semutaPreview, undefined);
|
|
for (let count = 0; game.status === 'setup' && count < 160; count++) {
|
|
let next: {id:string; action:Action} | undefined;
|
|
for (const player of game.players) {
|
|
const view = viewGame(game, player.id);
|
|
view.players.find(row => row.id === player.id)!.bot = 'Medium';
|
|
const action = botActions(view)[0];
|
|
if (action) { next = {id:player.id, action}; break; }
|
|
}
|
|
assert.ok(next, 'Native setup must have a legal action.');
|
|
game = act(game, next.id, next.action);
|
|
}
|
|
assert.equal(game.status, 'playing');
|
|
const original = inventory(game);
|
|
game.deck.push(...game.players.flatMap(player => player.hand));
|
|
for (const player of game.players) {
|
|
player.hand = [];
|
|
player.reserves += player.tanks + Object.values(player.forces).reduce((sum, count) => sum + count, 0);
|
|
player.forces = {}; player.tanks = 0; player.spice = 20;
|
|
player.shipped = false; player.moved = 0;
|
|
assert.equal(player.reserves, 20);
|
|
}
|
|
const owner = seat(game, 'm'), ally = seat(game, 'r');
|
|
owner.ally = ally.id; ally.ally = owner.id;
|
|
owner.forces['carthag:11'] = 2; owner.reserves -= 2;
|
|
for (let i = 0; i < 4; i++) owner.hand.push(ordinaryCard(game));
|
|
for (let i = 0; i < 3; i++) ally.hand.push(ordinaryCard(game));
|
|
const semuta = take(game, card => card.id === SEMUTA_DRUG_ID);
|
|
if (holder === 'ally') ally.hand.push(semuta);
|
|
else { ally.hand.push(ordinaryCard(game)); seat(game, 'a').hand.push(semuta); }
|
|
const otherDiscard = owner.hand[0].id, ownDiscard = ally.hand[0].id;
|
|
const token = game.moritaniTerror!.tokens.find(row => row.kind === 'atomics'); assert.ok(token);
|
|
game.moritaniTerror = placeTerror(game.moritaniTerror!, token.id, 'carthag', 1);
|
|
Object.assign(game, {turn:2, phase:5, storm:18, active:'a', order:['a','m','r'],
|
|
movementRemaining:['a','m','r'], ready:[], response:null, decision:null, phaseOpening:null});
|
|
assert.deepEqual(inventory(game), original);
|
|
game = act(game, 'a', {type:'ship', territory:'carthag', sector:11, amount:2, elite:0, allyPayment:0});
|
|
assert.equal(game.pendingTerrorEntry?.stage, 'offer');
|
|
game = withAtomicsRolls(() => act(game, 'm', {type:'decision', reveal:true}));
|
|
return {game, original, token:token.id, otherDiscard, ownDiscard};
|
|
}
|
|
|
|
for (const chosenOwner of ['m', 'r'] as const) {
|
|
void test(`A third-party Semuta holder privately chooses the ${chosenOwner === 'm' ? 'Moritani' : 'allied Richese'} Atomics discard`, () => {
|
|
const f = fixture('third'), frame = f.game.pendingTreacheryDiscard; assert.ok(frame?.reaction);
|
|
assert.deepEqual(frame.batch.entries.map(entry => [entry.card.id, entry.discardedBy, entry.publicFace]),
|
|
[[f.otherDiscard, 'm', false], [f.ownDiscard, 'r', false]]);
|
|
for (const player of f.game.players)
|
|
assert.deepEqual(viewGame(f.game, player.id).semutaReaction?.candidates, []);
|
|
const event = frame.batch.event;
|
|
let game = act(f.game, 'a', {type:'semutaCommit', event});
|
|
assert.equal(game.pendingTreacheryDiscard?.reaction?.stage, 'select');
|
|
assert.deepEqual(viewGame(game, 'a').semutaReaction?.candidates.map(card => card.id),
|
|
[f.otherDiscard, f.ownDiscard]);
|
|
for (const id of ['m', 'r']) assert.deepEqual(viewGame(game, id).semutaReaction?.candidates, []);
|
|
const chosen = chosenOwner === 'm' ? f.otherDiscard : f.ownDiscard;
|
|
const other = chosenOwner === 'm' ? f.ownDiscard : f.otherDiscard;
|
|
game = act(game, 'a', {type:'semutaSelect', event, card:chosen});
|
|
assert.equal(game.pendingTreacheryDiscard, null);
|
|
assert.equal(seat(game, 'a').hand.some(card => card.id === chosen), true);
|
|
assert.equal(game.discard.some(card => card.id === chosen), false);
|
|
assert.equal(game.discard.some(card => card.id === other), true);
|
|
assert.equal(game.discard.some(card => card.id === SEMUTA_DRUG_ID), true);
|
|
assert.equal(seat(game, 'm').tanks, 2);
|
|
assert.equal(seat(game, 'a').tanks, 2);
|
|
assert.equal(game.moritaniAtomics?.territory, 'carthag');
|
|
assert.deepEqual(inventory(game), f.original);
|
|
});
|
|
}
|
|
|
|
void test('a saved Atomics frame without a Semuta reaction finishes without adding a new offer', () => {
|
|
const f = fixture(), legacy = structuredClone(f.game);
|
|
assert.ok(legacy.pendingTreacheryDiscard?.reaction);
|
|
delete legacy.pendingTreacheryDiscard.reaction;
|
|
const resumed = normalizeAutomaticGame(legacy);
|
|
assert.equal(resumed.pendingTreacheryDiscard, null);
|
|
assert.equal(resumed.pendingTerrorEntry ?? null, null);
|
|
assert.equal(seat(resumed, 'm').tanks, 2);
|
|
assert.equal(seat(resumed, 'a').tanks, 2);
|
|
assert.equal(resumed.discard.some(card => card.id === f.otherDiscard), true);
|
|
assert.equal(resumed.discard.some(card => card.id === f.ownDiscard), true);
|
|
assert.equal(seat(resumed, 'r').hand.some(card => card.id === SEMUTA_DRUG_ID), true);
|
|
assert.deepEqual(inventory(resumed), f.original);
|
|
});
|
|
|
|
void test('a saved Atomics continuation cannot replace its authoritative Aftermath', () => {
|
|
const f = fixture(), damaged = structuredClone(f.game);
|
|
const continuation = damaged.pendingTreacheryDiscard?.continuation;
|
|
assert.equal(continuation?.kind, 'terrorAtomics');
|
|
if (continuation?.kind !== 'terrorAtomics') throw new Error('Expected original Atomics continuation.');
|
|
continuation.aftermath = {...continuation.aftermath, turn: continuation.aftermath.turn + 1};
|
|
assert.throws(() => normalizeAutomaticGame(damaged));
|
|
});
|
|
|
|
for (const claimed of [false, true]) {
|
|
void test(`Basic Moritani Atomics random private discards offer Semuta ${claimed ? 'claim' : 'pass'}`, () => {
|
|
const f = fixture(), pending = f.game.pendingTreacheryDiscard; assert.ok(pending?.reaction);
|
|
assert.equal(pending.continuation.kind, 'terrorAtomics');
|
|
assert.equal(pending.batch.cause, 'terror:atomics');
|
|
assert.deepEqual(pending.batch.entries.map(row => [row.card.id, row.discardedBy, row.publicFace]),
|
|
[[f.otherDiscard, 'm', false], [f.ownDiscard, 'r', false]]);
|
|
assert.equal(seat(f.game, 'm').tanks, 2);
|
|
assert.equal(seat(f.game, 'a').tanks, 2);
|
|
assert.equal(f.game.moritaniAtomics?.territory, 'carthag');
|
|
assert.equal(f.game.moritaniAtomics?.allyAtActivation, 'r');
|
|
assert.equal(f.game.moritaniTerror!.tokens.find(row => row.id === f.token)!.status, 'removed');
|
|
for (const player of f.game.players) assert.deepEqual(viewGame(f.game, player.id).semutaReaction?.candidates, []);
|
|
assert.equal(viewGame(f.game, 'r').semutaReaction?.canCommit, true);
|
|
for (const difficulty of DIFFICULTIES) {
|
|
const view = viewGame(f.game, 'r'); view.players.find(row => row.id === 'r')!.bot = difficulty;
|
|
const action = botActions(view).find(item => item.type === 'semutaCommit' || item.type === 'semutaPass');
|
|
assert.ok(action); assert.doesNotThrow(() => act(f.game, 'r', action));
|
|
}
|
|
const event = pending.batch.event;
|
|
let game = f.game;
|
|
if (claimed) {
|
|
game = act(game, 'r', {type:'semutaCommit', event});
|
|
if (game.pendingTreacheryDiscard?.reaction?.stage === 'select') {
|
|
assert.deepEqual(viewGame(game, 'r').semutaReaction?.candidates.map(card => card.id), [f.otherDiscard]);
|
|
assert.deepEqual(viewGame(game, 'm').semutaReaction?.candidates, []);
|
|
assert.throws(() => act(game, 'r', {type:'semutaSelect', event, card:f.ownDiscard}));
|
|
game = act(game, 'r', {type:'semutaSelect', event, card:f.otherDiscard});
|
|
}
|
|
} else {
|
|
for (const player of game.players) game = act(game, player.id, {type:'semutaPass', event});
|
|
}
|
|
assert.equal(game.pendingTreacheryDiscard, null);
|
|
assert.equal(game.pendingTerrorEntry ?? null, null);
|
|
assert.equal(seat(game, 'm').tanks, 2);
|
|
assert.equal(seat(game, 'a').tanks, 2);
|
|
assert.equal(seat(game, 'a').forces['carthag:11'], undefined);
|
|
assert.equal(game.moritaniAtomics?.territory, 'carthag');
|
|
assert.equal(game.moritaniTerror!.tokens.find(row => row.id === f.token)!.status, 'removed');
|
|
assert.equal(seat(game, 'r').hand.some(card => card.id === f.otherDiscard), claimed);
|
|
assert.equal(game.discard.some(card => card.id === f.otherDiscard), !claimed);
|
|
assert.equal(game.discard.some(card => card.id === f.ownDiscard), true);
|
|
assert.equal(game.discard.some(card => card.id === SEMUTA_DRUG_ID), claimed);
|
|
assert.equal(seat(game, 'm').hand.length, 3);
|
|
assert.equal(seat(game, 'r').hand.length, 3);
|
|
assert.throws(() => act(game, 'r', {type:'semutaCommit', event}));
|
|
assert.deepEqual(inventory(game), f.original);
|
|
});
|
|
}
|