Connect Emperor Nexus retention to original Ambassador purchases
This commit is contained in:
1 parent
d3e1c2f242
commit
3ce2e1d32a
19 files changed
+1228
-107
No files matched your search
@@ -0,0 +1,237 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { baseDeck } from '../game/cards';
|
||||
import { createGame, handLimit, newPlayer, type Game } from '../game/engine';
|
||||
import { createNexusCards, drawNexusCard } from '../game/nexus-cards';
|
||||
import {
|
||||
createAmbassadors, placeAmbassador, triggerAmbassador, validateAmbassadors,
|
||||
type AmbassadorEffect,
|
||||
} from '../game/ecaz-ambassadors';
|
||||
import {
|
||||
EmperorNexusPurchaseError, createEmperorNexusAmbassadorPurchase,
|
||||
emperorNexusAmbassadorPurchaseModeSupported,
|
||||
quoteEmperorNexusAmbassadorPurchase, signEmperorNexusPurchase, validateEmperorNexusPurchase,
|
||||
type EmperorNexusAmbassadorPurchase,
|
||||
} from '../game/nexus-emperor-purchase';
|
||||
|
||||
const ENTRY = 'ambassador:2:1:57';
|
||||
|
||||
type FixtureOptions = {
|
||||
phase?: 1 | 5;
|
||||
/** Ecaz allied with Harkonnen, so the ally would be the beneficiary. */
|
||||
ally?: boolean;
|
||||
beneficiary?: string;
|
||||
/** Ecaz keeps the concealed Emperor Nexus Secret Ally card. */
|
||||
holder?: boolean;
|
||||
spice?: number;
|
||||
fullHand?: boolean;
|
||||
supply?: number;
|
||||
/** Set false to leave the physical token unconsumed in its stronghold. */
|
||||
consumed?: boolean;
|
||||
/** The Bene Gesserit token copies the Richese effect instead of the real token. */
|
||||
copy?: boolean;
|
||||
copyChoices?: AmbassadorEffect[];
|
||||
effect?: 'atreides' | 'richese';
|
||||
entrant?: string;
|
||||
turn?: number;
|
||||
};
|
||||
|
||||
function fixture(options: FixtureOptions = {}) {
|
||||
const g = createGame('AMBQUOTE', newPlayer('ec', 'Ecaz', 'ecaz'), false, ['ecaz']);
|
||||
g.players.push(newPlayer('at', 'Atreides', 'atreides'), newPlayer('ha', 'Harkonnen', 'harkonnen'));
|
||||
g.order = g.players.map(p => p.id);
|
||||
g.status = 'playing';
|
||||
g.turn = 2;
|
||||
g.phase = options.phase ?? 1;
|
||||
g.active = 'at';
|
||||
g.movementRemaining = [...g.order];
|
||||
g.deck = baseDeck();
|
||||
g.discard = [];
|
||||
for (const player of g.players) {
|
||||
player.hand = [];
|
||||
player.spice = 10;
|
||||
player.ally = null;
|
||||
player.reserves = 20;
|
||||
player.tanks = 0;
|
||||
player.forces = {};
|
||||
}
|
||||
const ecaz = g.players[0], harkonnen = g.players[2];
|
||||
if (options.ally) {
|
||||
ecaz.ally = 'ha';
|
||||
harkonnen.ally = 'ec';
|
||||
}
|
||||
if (options.spice !== undefined) ecaz.spice = options.spice;
|
||||
if (options.fullHand) ecaz.hand = g.deck.splice(0, handLimit(ecaz));
|
||||
if (options.supply !== undefined) g.deck = g.deck.slice(0, options.supply);
|
||||
const cards = createNexusCards(g.players, () => 0);
|
||||
if ((options.holder ?? true) && !options.ally) {
|
||||
cards.deck = ['emperor', ...cards.deck.filter(card => card !== 'emperor')];
|
||||
g.nexusCards = { cards: drawNexusCard(cards, 'ec', g.players, () => 0), phase: null };
|
||||
} else g.nexusCards = { cards, phase: null };
|
||||
let state = createAmbassadors(() => 0.2);
|
||||
const effect = options.copy ? 'beneGesserit' : 'richese';
|
||||
const token = state.tokens.find(t => t.effect === effect)!;
|
||||
state.cohort = [
|
||||
token.id,
|
||||
...state.tokens.filter(t => t.effect !== 'ecaz' && t.id !== token.id).slice(0, 4).map(t => t.id),
|
||||
];
|
||||
for (const candidate of state.tokens) {
|
||||
candidate.zone = candidate.effect === 'ecaz' || state.cohort.includes(candidate.id) ? 'supply' : 'pool';
|
||||
candidate.location = null;
|
||||
}
|
||||
state = placeAmbassador(state, token.id, {
|
||||
turn: 1,
|
||||
availableSpice: 20,
|
||||
destination: { id: 'arrakeen', stronghold: true, inStorm: false, allowed: true },
|
||||
}).state;
|
||||
if (options.consumed ?? true) state = triggerAmbassador(state, token.id);
|
||||
validateAmbassadors(state);
|
||||
g.ecazAmbassadors = state;
|
||||
g.pendingAmbassador = {
|
||||
event: ENTRY,
|
||||
owner: 'ec',
|
||||
entrant: options.entrant ?? 'at',
|
||||
token: token.id,
|
||||
territory: 'arrakeen',
|
||||
sector: 10,
|
||||
turn: options.turn ?? g.turn,
|
||||
phase: g.phase,
|
||||
stage: 'purchase',
|
||||
resume: 'none',
|
||||
copyChoices: options.copyChoices ?? (options.copy ? ['richese'] : []),
|
||||
effect: options.effect ?? 'richese',
|
||||
beneficiary: options.beneficiary ?? (options.ally ? 'ha' : 'ec'),
|
||||
};
|
||||
return { g, ecaz };
|
||||
}
|
||||
|
||||
function lobby(factions: Parameters<typeof newPlayer>[2][], expansions: string[]): Game {
|
||||
const g = createGame('AMBMODE', newPlayer(factions[0], factions[0], factions[0]), false, expansions);
|
||||
for (const faction of factions.slice(1)) g.players.push(newPlayer(faction, faction, faction));
|
||||
g.order = g.players.map(p => p.id);
|
||||
return g;
|
||||
}
|
||||
|
||||
|
||||
void test('private room, spice, supply and the concealed Nexus face only disable Use, never the Pay confirmation', () => {
|
||||
const cases: [string, FixtureOptions, string][] = [
|
||||
['an allied buyer', { ally: true, beneficiary: 'ec' }, 'ec'],
|
||||
['an allied beneficiary', { ally: true, beneficiary: 'ha' }, 'ha'],
|
||||
['a buyer without the real card', { holder: false }, 'ec'],
|
||||
['two spice', { spice: 2 }, 'ec'],
|
||||
['a full hand', { fullHand: true }, 'ec'],
|
||||
['an empty supply', { supply: 0 }, 'ec'],
|
||||
];
|
||||
for (const [label, options, owner] of cases) {
|
||||
const { g } = fixture(options), before = structuredClone(g);
|
||||
const quote = quoteEmperorNexusAmbassadorPurchase(g, owner);
|
||||
assert.ok(quote.blocked, label);
|
||||
assert.deepEqual(g, before, label);
|
||||
if (options.supply !== 0) assert.throws(() => createEmperorNexusAmbassadorPurchase(g, owner, 'drawn-card'),
|
||||
EmperorNexusPurchaseError, label);
|
||||
}
|
||||
const { g } = fixture();
|
||||
g.players.push(newPlayer('em', 'Emperor', 'emperor'));
|
||||
g.order.push('em');
|
||||
assert.throws(() => quoteEmperorNexusAmbassadorPurchase(g, 'ec'), EmperorNexusPurchaseError);
|
||||
});
|
||||
|
||||
void test('malformed original source or stale entry cannot be used to retain a purchase price', () => {
|
||||
const cases: [string, FixtureOptions, string][] = [
|
||||
['an unconsumed token', { consumed: false }, 'ec'],
|
||||
['a copied effect outside this cohort', { copy: true, copyChoices: [] }, 'ec'],
|
||||
['another copied effect', { copy: true, copyChoices: ['atreides'] }, 'ec'],
|
||||
['a different effect', { effect: 'atreides' }, 'ec'],
|
||||
['another beneficiary', {}, 'ha'],
|
||||
['a stale turn', { turn: 1 }, 'ec'],
|
||||
['the buyer entering its own Ambassador', { entrant: 'ec' }, 'ec'],
|
||||
];
|
||||
for (const [label, options, owner] of cases) {
|
||||
const { g } = fixture(options);
|
||||
assert.throws(() => quoteEmperorNexusAmbassadorPurchase(g, owner), EmperorNexusPurchaseError, label);
|
||||
assert.throws(() => createEmperorNexusAmbassadorPurchase(g, owner, 'drawn-card'), EmperorNexusPurchaseError, label);
|
||||
}
|
||||
// A copied Bene Gesserit token is a legal original source for the same price.
|
||||
assert.equal(quoteEmperorNexusAmbassadorPurchase(fixture({ copy: true }).g, 'ec').blocked, null);
|
||||
});
|
||||
|
||||
|
||||
void test('the offer keeps its supply proof before the draw and accepts the last drawn card afterwards', () => {
|
||||
const { g } = fixture({ supply: 1 });
|
||||
assert.equal(quoteEmperorNexusAmbassadorPurchase(g, 'ec').blocked, null);
|
||||
const last = g.deck[0];
|
||||
g.deck = [];
|
||||
const receipt = createEmperorNexusAmbassadorPurchase(g, 'ec', last.id);
|
||||
validateEmperorNexusPurchase(g, receipt);
|
||||
const duplicated = fixture();
|
||||
const shared = duplicated.g.deck[0];
|
||||
duplicated.g.discard.push(shared);
|
||||
assert.throws(() => createEmperorNexusAmbassadorPurchase(duplicated.g, 'ec', shared.id),
|
||||
/single physically drawn Treachery Card/);
|
||||
const undrawn = fixture();
|
||||
assert.throws(() => createEmperorNexusAmbassadorPurchase(undrawn.g, 'ec', undrawn.g.deck[0].id),
|
||||
/single physically drawn Treachery Card/);
|
||||
const later = fixture();
|
||||
later.ecaz.hand.push(later.g.deck.shift()!);
|
||||
assert.throws(() => createEmperorNexusAmbassadorPurchase(later.g, 'ec', later.ecaz.hand.at(-1)!.id),
|
||||
EmperorNexusPurchaseError);
|
||||
});
|
||||
|
||||
void test('version three history rejects a changed trigger, price or retained balance even after re-signing', () => {
|
||||
const { g } = fixture();
|
||||
const card = g.deck[0];
|
||||
g.deck = g.deck.slice(1);
|
||||
const receipt = createEmperorNexusAmbassadorPurchase(g, 'ec', card.id);
|
||||
const invalid = (patch: Partial<EmperorNexusAmbassadorPurchase>, resign = false) => {
|
||||
const changed = { ...receipt, ...patch };
|
||||
if (resign) changed.signature = signEmperorNexusPurchase(changed);
|
||||
assert.throws(() => validateEmperorNexusPurchase(g, changed), EmperorNexusPurchaseError,
|
||||
JSON.stringify(patch));
|
||||
};
|
||||
// Every recorded field is inside the fixed signature tuple.
|
||||
for (const patch of [
|
||||
{ entry: 'other-entry' }, { token: 'ambassador-1' }, { entrant: 'ha' },
|
||||
{ card: 'other-card' }, { owner: 'ha' }, { price: 2 as never }, { sequence: 1 },
|
||||
{ origin: 'cache' } as never, { phase: 5 as never }, { turn: 1 },
|
||||
]) invalid(patch);
|
||||
for (const patch of [
|
||||
{ version: 2 as never }, { price: 2 as never }, { price: 4 as never },
|
||||
{ phase: 0 as never }, { phase: 9 as never }, { turn: 0 }, { turn: 3 },
|
||||
{ beforeSpice: 2, afterSpice: 2 }, { afterSpice: 9 },
|
||||
{ entrant: 'ec' }, { entry: ' ' }, { token: ' ' }, { entrant: ' ' },
|
||||
{ card: ' ' }, { advanced: true },
|
||||
{ round: 'round' } as never, { lot: 'lot' } as never, { seller: 'ha' } as never,
|
||||
{ auctionIndex: 0 } as never, { bankSubsidy: 3 } as never,
|
||||
]) invalid(patch, true);
|
||||
});
|
||||
|
||||
|
||||
void test('the public Ecaz envelope reuses original E3 Nexus and Skills profiles without an Emperor', () => {
|
||||
const standalone = lobby(['ecaz', 'atreides', 'harkonnen'], ['ecaz']);
|
||||
standalone.nexusCards = { cards: null, phase: null };
|
||||
assert.equal(emperorNexusAmbassadorPurchaseModeSupported(standalone), true);
|
||||
// An undealt, concealed Nexus face is not part of the public mode proof.
|
||||
const skills = lobby(['ecaz', 'atreides', 'harkonnen'], ['ecaz']);
|
||||
skills.nexusCards = { cards: null, phase: null };
|
||||
skills.leaderSkills = {} as NonNullable<Game['leaderSkills']>;
|
||||
assert.equal(emperorNexusAmbassadorPurchaseModeSupported(skills), true);
|
||||
const paired = lobby(['ecaz', 'moritani', 'atreides'], ['ecaz']);
|
||||
paired.nexusCards = { cards: null, phase: null };
|
||||
assert.equal(emperorNexusAmbassadorPurchaseModeSupported(paired), true);
|
||||
const mixed = lobby(['ecaz', 'ixians', 'atreides'], ['ecaz', 'ix']);
|
||||
mixed.nexusCards = { cards: null, phase: null };
|
||||
assert.equal(emperorNexusAmbassadorPurchaseModeSupported(mixed), true);
|
||||
const withoutNexus = lobby(['ecaz', 'atreides', 'harkonnen'], ['ecaz']);
|
||||
const withEmperor = lobby(['ecaz', 'emperor', 'harkonnen'], ['ecaz']);
|
||||
withEmperor.nexusCards = { cards: null, phase: null };
|
||||
const classicOnly = lobby(['atreides', 'harkonnen'], []);
|
||||
classicOnly.nexusCards = { cards: null, phase: null };
|
||||
const sandtrout = lobby(['ecaz', 'atreides', 'harkonnen'], ['ecaz']);
|
||||
sandtrout.nexusCards = { cards: null, phase: null };
|
||||
sandtrout.sandtrout = true;
|
||||
const treachery = lobby(['ecaz', 'atreides', 'harkonnen'], ['ecaz']);
|
||||
treachery.nexusCards = { cards: null, phase: null };
|
||||
treachery.ecazTreachery = true;
|
||||
for (const unsupported of [withoutNexus, withEmperor, classicOnly, sandtrout, treachery])
|
||||
assert.equal(emperorNexusAmbassadorPurchaseModeSupported(unsupported), false);
|
||||
});
|
||||
Reference in new issue
Block a user