304 lines
14 KiB
TypeScript
304 lines
14 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { createGame, newPlayer, type Game } from '../game/engine';
|
|
import { FACTIONS, type FactionId } from '../game/catalog';
|
|
import { createNexusCards, discardNexusCard } from '../game/nexus-cards';
|
|
import { createTechTokens } from '../game/tech-tokens';
|
|
import { createStrongholdCards } from '../game/stronghold-cards';
|
|
import { createLeaderSkills } from '../game/leader-skills';
|
|
import { createHomeworldCustody } from '../game/homeworld-custody';
|
|
import {
|
|
createEmperorNexusRevival,
|
|
emperorNexusEvent,
|
|
emperorNexusPools,
|
|
emperorNexusSignature,
|
|
quoteEmperorNexusRevival,
|
|
settleEmperorNexusRevival,
|
|
validateEmperorNexusRevival,
|
|
type NexusEmperorRevival,
|
|
type NexusEmperorRevivalRequest,
|
|
} from '../game/nexus-emperor-secret-ally';
|
|
import { newRevivalRules, normalRevivalAllowance } from '../game/revival';
|
|
|
|
/** Focused unit state, not a genuine game trace or runtime admission fixture. */
|
|
function sample(faction: FactionId = 'atreides', advanced = true, nativeTleilaxu = false) {
|
|
const g = createGame('EXTRASOURCE', newPlayer('owner', 'Holder', faction), advanced);
|
|
const rival: FactionId = faction === 'atreides' ? 'harkonnen' : 'atreides';
|
|
g.players.push(newPlayer('rival', 'Rival', rival));
|
|
g.players.push(newPlayer('third', 'Third', nativeTleilaxu ? 'tleilaxu' : 'guild'));
|
|
g.expansions = [...new Set(g.players.map(p => FACTIONS.find(f => f.id === p.faction)!.expansion)
|
|
.filter(expansion => expansion !== 'base'))];
|
|
g.status = 'playing';
|
|
g.phase = 4;
|
|
g.turn = 3;
|
|
g.revivalRules = newRevivalRules();
|
|
const p = g.players[0];
|
|
p.tanks = 6;
|
|
p.reserves -= 6;
|
|
if (faction === 'fremen' && advanced)
|
|
p.elites = { reserves: 1, tanks: 2, forces: {}, revived: 0 };
|
|
if (faction === 'ixians') {
|
|
p.elites!.reserves = 4;
|
|
p.elites!.tanks = 3;
|
|
}
|
|
const cards = createNexusCards(g.players, () => 0.5);
|
|
cards.deck = cards.deck.filter(card => card !== 'emperor');
|
|
cards.hands.owner = 'emperor';
|
|
g.nexusCards = { cards, phase: null };
|
|
return g;
|
|
}
|
|
|
|
function commit(g: Game, receipt: NexusEmperorRevivalRequest) {
|
|
g.nexusCards!.cards = discardNexusCard(g.nexusCards!.cards!, receipt.owner, g.players);
|
|
(g.nexusEmperorSecretHistory ??= []).push(receipt);
|
|
(g.nexusEmperorSecretEvents ??= []).push(receipt.event);
|
|
}
|
|
|
|
/** Model the native physical producer before income and optional deployment. */
|
|
function physicalReturn(g: Game, receipt: NexusEmperorRevivalRequest) {
|
|
const p = g.players.find(p => p.id === receipt.owner)!;
|
|
p.reserves += 3;
|
|
p.tanks -= 3;
|
|
if (p.elites) {
|
|
p.elites.reserves += receipt.elite;
|
|
p.elites.tanks -= receipt.elite;
|
|
p.elites.revived += receipt.elite;
|
|
}
|
|
}
|
|
|
|
function signed<T extends NexusEmperorRevival>(receipt: T): T {
|
|
receipt.signature = emperorNexusSignature(receipt);
|
|
return receipt;
|
|
}
|
|
|
|
void test('declaration is a pure signed exact-three source and cannot settle before custody is committed', () => {
|
|
const g = sample();
|
|
const before = structuredClone(g);
|
|
const quote = quoteEmperorNexusRevival(g, 'owner');
|
|
assert.equal(quote.blocked, null);
|
|
assert.deepEqual(quote.eliteOptions, [0]);
|
|
const receipt = createEmperorNexusRevival(g, 'owner', 0);
|
|
assert.equal(receipt.version, 2);
|
|
assert.equal(receipt.stage, 'requested');
|
|
assert.equal(receipt.after, null);
|
|
assert.equal(receipt.event, quote.event);
|
|
assert.equal(receipt.sequence, 0);
|
|
assert.equal(receipt.signature, emperorNexusSignature(receipt));
|
|
assert.deepEqual(receipt.before, emperorNexusPools(g.players[0]));
|
|
validateEmperorNexusRevival(g, receipt);
|
|
assert.deepEqual(g, before);
|
|
assert.throws(() => settleEmperorNexusRevival(g, receipt, 'returned'));
|
|
assert.throws(() => createEmperorNexusRevival(g, 'owner', 1));
|
|
assert.deepEqual(g, before);
|
|
});
|
|
|
|
void test('native typed Tanks determine exact-three choices and Ix Cyborgs are not capped at one', () => {
|
|
for (const advanced of [false, true]) {
|
|
const ix = sample('ixians', advanced);
|
|
ix.players[0].elites!.revived = 4;
|
|
assert.equal(quoteEmperorNexusRevival(ix, 'owner').blocked, null);
|
|
assert.deepEqual(quoteEmperorNexusRevival(ix, 'owner').eliteOptions, [0, 1, 2, 3]);
|
|
assert.equal(createEmperorNexusRevival(ix, 'owner', 3).elite, 3);
|
|
}
|
|
const basicFremen = sample('fremen', false);
|
|
basicFremen.players[0].elites = { reserves: 0, tanks: 3, forces: {}, revived: 2 };
|
|
assert.deepEqual(quoteEmperorNexusRevival(basicFremen, 'owner').eliteOptions, [0, 1, 2, 3]);
|
|
assert.equal(createEmperorNexusRevival(basicFremen, 'owner', 3).elite, 3);
|
|
const fremen = sample('fremen');
|
|
assert.deepEqual(quoteEmperorNexusRevival(fremen, 'owner').eliteOptions, [0, 1]);
|
|
fremen.players[0].elites!.revived = 1;
|
|
assert.deepEqual(quoteEmperorNexusRevival(fremen, 'owner').eliteOptions, [0]);
|
|
assert.throws(() => createEmperorNexusRevival(fremen, 'owner', 1));
|
|
fremen.players[0].tanks = 3;
|
|
assert.equal(quoteEmperorNexusRevival(fremen, 'owner').amount, 1);
|
|
assert.deepEqual(quoteEmperorNexusRevival(fremen, 'owner').eliteOptions, [0]);
|
|
assert.equal(createEmperorNexusRevival(fremen, 'owner', 0).amount, 1);
|
|
const short = sample();
|
|
short.players[0].tanks = 2;
|
|
assert.equal(quoteEmperorNexusRevival(short, 'owner').amount, 2);
|
|
assert.deepEqual(quoteEmperorNexusRevival(short, 'owner').eliteOptions, [0]);
|
|
assert.equal(createEmperorNexusRevival(short, 'owner', 0).amount, 2);
|
|
});
|
|
|
|
void test('original native modules allow revival independently of classic purchase admission', () => {
|
|
for (const faction of ['atreides', 'ixians', 'tleilaxu', 'choam', 'richese', 'ecaz', 'moritani'] as const) {
|
|
const g = sample(faction);
|
|
g.techTokens = createTechTokens();
|
|
g.strongholdCards = createStrongholdCards();
|
|
assert.equal(quoteEmperorNexusRevival(g, 'owner').blocked, null, faction);
|
|
const before = structuredClone(g);
|
|
createEmperorNexusRevival(g, 'owner', 0);
|
|
assert.deepEqual(g, before);
|
|
g.homeworlds = { custody: createHomeworldCustody({
|
|
advanced: g.advanced,
|
|
players: g.players.map(p => ({
|
|
id: p.id, faction: p.faction, reserves: p.reserves,
|
|
eliteReserves: p.elites?.reserves ?? 0,
|
|
})),
|
|
}) };
|
|
assert.equal(quoteEmperorNexusRevival(g, 'owner').blocked, null, `${faction} with Homeworlds`);
|
|
g.discoveryEnabled = true;
|
|
assert.equal(quoteEmperorNexusRevival(g, 'owner').blocked, null, `${faction} with Discovery`);
|
|
g.leaderSkills = createLeaderSkills(() => 0.5);
|
|
assert.equal(quoteEmperorNexusRevival(g, 'owner').blocked, null, `${faction} with Skills`);
|
|
}
|
|
});
|
|
|
|
void test('ordinary high rates, expanded ceilings, Recruits and ordinary free blocking do not reprice the grant', () => {
|
|
for (const faction of ['atreides', 'fremen', 'choam'] as const) {
|
|
for (const blocked of [false, true]) {
|
|
const g = sample(faction);
|
|
g.revivalRules!.expanded.push('owner');
|
|
g.freeRevival.push('owner');
|
|
g.recruits = { turn: g.turn, player: 'owner', card: 'ecaz-recruits' };
|
|
if (blocked) g.revivalRules!.freeBlocked = ['owner'];
|
|
g.players[0].revived = 5;
|
|
g.players[0].freeForcesRevived = 3;
|
|
const allowance = normalRevivalAllowance(g, g.players[0]);
|
|
const rules = structuredClone(g.revivalRules);
|
|
const receipt = createEmperorNexusRevival(g, 'owner', 0);
|
|
commit(g, receipt);
|
|
physicalReturn(g, receipt);
|
|
const returned = settleEmperorNexusRevival(g, receipt, 'returned');
|
|
assert.equal(returned.stage, 'returned');
|
|
assert.deepEqual(returned.after, { ...receipt.before,
|
|
reserves: receipt.before.reserves + 3, tanks: receipt.before.tanks - 3 });
|
|
assert.deepEqual(normalRevivalAllowance(g, g.players[0]), allowance);
|
|
assert.deepEqual(g.revivalRules, rules);
|
|
}
|
|
}
|
|
});
|
|
|
|
void test('native prevention remains distinct from ordinary free blocking and source timing/custody stay strict', () => {
|
|
const original = sample('atreides', true, true);
|
|
original.revivalRules!.freeBlocked = ['owner'];
|
|
assert.equal(quoteEmperorNexusRevival(original, 'owner').blocked, null);
|
|
original.revivalPrevention = { player: 'owner', turn: original.turn };
|
|
assert.notEqual(quoteEmperorNexusRevival(original, 'owner').blocked, null);
|
|
assert.throws(() => createEmperorNexusRevival(original, 'owner', 0));
|
|
for (const change of [
|
|
(g: Game) => { g.nexusCards!.cards!.hands.owner = null; },
|
|
(g: Game) => { g.players[0].ally = 'rival'; },
|
|
(g: Game) => { g.players.push(newPlayer('emperor', 'Native', 'emperor')); },
|
|
(g: Game) => { g.phase = 5; },
|
|
(g: Game) => { g.status = 'setup'; },
|
|
(g: Game) => { g.pendingCapture = { player: 'owner', loser: 'rival', territory: 'arrakeen' }; },
|
|
]) {
|
|
const g = sample();
|
|
change(g);
|
|
assert.notEqual(quoteEmperorNexusRevival(g, 'owner').blocked, null);
|
|
assert.throws(() => createEmperorNexusRevival(g, 'owner', 0));
|
|
}
|
|
assert.notEqual(quoteEmperorNexusRevival(sample(), 'unknown').blocked, null);
|
|
});
|
|
|
|
void test('returned and denied receipts capture actual typed physical facts without moving or refunding anything', () => {
|
|
for (const outcome of ['returned', 'denied'] as const) {
|
|
const g = sample('ixians', true, true);
|
|
const receipt = createEmperorNexusRevival(g, 'owner', 3);
|
|
commit(g, receipt);
|
|
if (outcome === 'returned') physicalReturn(g, receipt);
|
|
const beforeSettlement = structuredClone(g);
|
|
const result = settleEmperorNexusRevival(g, receipt, outcome);
|
|
assert.equal(result.stage, outcome);
|
|
assert.equal(result.signature, emperorNexusSignature(result));
|
|
assert.deepEqual(result.after, emperorNexusPools(g.players[0]));
|
|
assert.deepEqual(g, beforeSettlement);
|
|
assert.equal(receipt.stage, 'requested');
|
|
assert.equal(receipt.after, null);
|
|
assert.equal(g.nexusCards!.cards!.hands.owner, null);
|
|
assert.equal(g.nexusCards!.cards!.discard.filter(card => card === 'emperor').length, 1);
|
|
if (outcome === 'denied') assert.deepEqual(result.after, receipt.before);
|
|
else assert.deepEqual(result.after, { ...receipt.before,
|
|
reserves: receipt.before.reserves + 3, tanks: receipt.before.tanks - 3,
|
|
eliteReserves: receipt.before.eliteReserves + 3, eliteTanks: receipt.before.eliteTanks - 3,
|
|
eliteRevived: receipt.before.eliteRevived + 3 });
|
|
assert.throws(() => settleEmperorNexusRevival(g, result, outcome));
|
|
// Historical evidence survives later ordinary ledger, wallet and custody changes.
|
|
g.turn++;
|
|
g.phase = 5;
|
|
g.players[0].spice += 10;
|
|
g.players[0].revived += 2;
|
|
g.players[0].freeForcesRevived = 2;
|
|
g.players[0].reserves--;
|
|
validateEmperorNexusRevival(g, result);
|
|
}
|
|
});
|
|
|
|
void test('settlement rejects wrong actual amount, typed composition, ordinary ledgers and premature income', () => {
|
|
for (const change of [
|
|
(g: Game) => { g.players[0].reserves--; g.players[0].tanks++; },
|
|
(g: Game) => { g.players[0].elites!.reserves--; g.players[0].elites!.tanks++; },
|
|
(g: Game) => { g.players[0].elites!.revived--; },
|
|
(g: Game) => { g.players[0].revived++; },
|
|
(g: Game) => { g.players[0].freeForcesRevived = 1; },
|
|
(g: Game) => { g.players[0].spice++; },
|
|
]) {
|
|
const g = sample('ixians');
|
|
const receipt = createEmperorNexusRevival(g, 'owner', 3);
|
|
commit(g, receipt);
|
|
physicalReturn(g, receipt);
|
|
change(g);
|
|
const before = structuredClone(g);
|
|
assert.throws(() => settleEmperorNexusRevival(g, receipt, 'returned'));
|
|
assert.deepEqual(g, before);
|
|
}
|
|
const g = sample();
|
|
const receipt = createEmperorNexusRevival(g, 'owner', 0);
|
|
commit(g, receipt);
|
|
physicalReturn(g, receipt);
|
|
assert.throws(() => settleEmperorNexusRevival(g, receipt, 'denied'));
|
|
});
|
|
|
|
void test('receipt stage, signature, independent sequence and event markers cannot be fabricated or silently repaired', () => {
|
|
const g = sample();
|
|
const receipt = createEmperorNexusRevival(g, 'owner', 0);
|
|
commit(g, receipt);
|
|
for (const change of [
|
|
(r: NexusEmperorRevivalRequest) => { r.signature = 'unsigned'; },
|
|
(r: NexusEmperorRevivalRequest) => { r.sequence++; r.signature = emperorNexusSignature(r); },
|
|
(r: NexusEmperorRevivalRequest) => { r.event = emperorNexusEvent(r.turn, 4, 'rival', r.sequence); r.signature = emperorNexusSignature(r); },
|
|
]) {
|
|
const bad = structuredClone(receipt);
|
|
change(bad);
|
|
assert.throws(() => validateEmperorNexusRevival(g, bad));
|
|
}
|
|
const withAfter = signed({ ...receipt, after: receipt.before } as unknown as NexusEmperorRevivalRequest);
|
|
assert.throws(() => validateEmperorNexusRevival(g, withAfter));
|
|
const finalWithoutAfter = signed({ ...receipt, stage: 'returned', after: null } as unknown as NexusEmperorRevival);
|
|
assert.throws(() => validateEmperorNexusRevival(g, finalWithoutAfter));
|
|
for (const change of [
|
|
(state: Game) => { state.nexusEmperorSecretEvents![0] = 'wrong'; },
|
|
(state: Game) => { state.nexusEmperorSecretHistory![0] = signed({ ...receipt, before: { ...receipt.before, spice: 999 } }); },
|
|
(state: Game) => { state.nexusCards!.cards!.discard = []; },
|
|
]) {
|
|
const bad = structuredClone(g);
|
|
change(bad);
|
|
assert.throws(() => settleEmperorNexusRevival(bad, receipt, 'denied'));
|
|
}
|
|
});
|
|
|
|
void test('strict old physical receipts stay readable as history, never become expansion source permissions', () => {
|
|
const g = sample();
|
|
const receipt = createEmperorNexusRevival(g, 'owner', 0);
|
|
const { version: _version, stage: _stage, ...identity } = receipt;
|
|
const old: NexusEmperorRevival = signed({ ...identity, after: {
|
|
...receipt.before, reserves: receipt.before.reserves + 3, tanks: receipt.before.tanks - 3,
|
|
} });
|
|
const before = structuredClone(g);
|
|
validateEmperorNexusRevival(g, old);
|
|
assert.deepEqual(g, before);
|
|
assert.throws(() => settleEmperorNexusRevival(g, old, 'returned'));
|
|
g.players[0].spice += 5;
|
|
g.players[0].revived = 3;
|
|
g.turn++;
|
|
validateEmperorNexusRevival(g, old);
|
|
const badLedger = signed({ ...old, after: { ...old.after!, revived: old.before.revived + 3 } });
|
|
assert.throws(() => validateEmperorNexusRevival(g, badLedger));
|
|
const expanded = sample('ixians');
|
|
const fabricated = signed({ ...old, faction: 'ixians' as const });
|
|
assert.throws(() => validateEmperorNexusRevival(expanded, fabricated));
|
|
const metadata = signed({ ...old, version: 1 } as unknown as NexusEmperorRevival);
|
|
assert.throws(() => validateEmperorNexusRevival(g, metadata));
|
|
});
|