208 lines
13 KiB
TypeScript
208 lines
13 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { applyAction, initializeHomeworldOccupationGameForAudit, viewGame, type Action, type Game } from '../game/engine';
|
|
import { botActions } from '../game/bots';
|
|
import { DIFFICULTIES } from '../game/bot-profiles';
|
|
import { assertClassicHomeworldSkillsCustody } from './fixture-homeworld-classic-skills';
|
|
import {
|
|
advanceHomeworldFunding, allowHomeworldFundingResponses as allow, chooseHomeworldFunding as choose,
|
|
createHomeworldFundingFixture as fixture, holdHomeworldFundingKarama,
|
|
homeworldFundingCards, homeworldFundingClean, homeworldFundingPlayer as player,
|
|
payHomeworldFunding as pay, type HomeworldFundingFixture,
|
|
} from './fixture-bureaucrat-homeworld-funding';
|
|
|
|
const wallets = (game: Game) => Object.fromEntries(game.players.map(p => [p.id, p.spice]));
|
|
const armies = (game: Game) => game.players.map(p => ({ id: p.id, forces: p.forces, reserves: p.reserves,
|
|
tanks: p.tanks, elites: p.elites }));
|
|
function reject(game: Game, actor: string, action: Action): void {
|
|
const before = structuredClone(game); assert.throws(() => applyAction(game, actor, action)); assert.deepEqual(game, before);
|
|
}
|
|
|
|
/** Exact wallet conservation proves the flat Bank diversion, not just the
|
|
* recipient's reduced receipt. Homeworld native custody remains real. */
|
|
function outcome(f: HomeworldFundingFixture, done: Game, diverted: number, canceled = false): void {
|
|
const expected = wallets(f.beforePledge);
|
|
expected[f.payer] -= f.payerShare; expected[f.donor] -= f.donorShare;
|
|
if (!canceled) expected[f.payee] += f.gross - diverted;
|
|
assert.deepEqual(wallets(done), expected);
|
|
assert.equal(Object.values(wallets(f.beforePledge)).reduce((a, b) => a + b, 0) -
|
|
Object.values(wallets(done)).reduce((a, b) => a + b, 0), canceled ? f.gross : diverted,
|
|
'Only the original canceled gross or exactly two diverted spice leaves the seated wallets for the Bank');
|
|
assert.equal(done.aid[f.donor]?.amount ?? 0, 0);
|
|
assert.deepEqual(homeworldFundingCards(done), f.physical);
|
|
assert.equal(done.bureaucratPayments?.used.length ?? 0, diverted ? 1 : 0);
|
|
assert.equal(viewGame(done, f.trainer).bureaucrat.usedThisPhase, diverted === 2);
|
|
if (f.kind === 'auction') {
|
|
assert.deepEqual(player(done, f.payer).hand.map(c => c.id),
|
|
[...player(f.beforeAction, f.payer).hand.map(c => c.id), f.card, f.beforeAction.deck[0].id]);
|
|
assert.equal(done.auction!.index, f.beforeAction.auction!.index + 1);
|
|
assert.equal(done.currentAuctionSale, null);
|
|
assert.deepEqual(armies(done), armies(f.beforePledge));
|
|
assert.deepEqual(done.homeworlds!.custody, f.beforePledge.homeworlds!.custody);
|
|
} else {
|
|
assert.equal(player(done, f.payer).reserves, player(f.beforePledge, f.payer).reserves - f.gross);
|
|
assert.deepEqual(player(done, f.payer).forces,
|
|
{ ...player(f.beforePledge, f.payer).forces, [`${f.target}:${f.sector}`]: f.gross });
|
|
assert.equal(player(done, f.payer).shipped, true);
|
|
for (const actor of done.players.filter(p => p.id !== f.payer)) {
|
|
assert.deepEqual(actor.forces, player(f.beforePledge, actor.id).forces);
|
|
assert.equal(actor.reserves, player(f.beforePledge, actor.id).reserves);
|
|
}
|
|
assert.equal(done.phase, 5); assert.equal(done.active, f.payer);
|
|
const moved = applyAction(done, f.payer, { type: 'endMovement' });
|
|
assert.notEqual(moved.active, f.payer); assert.deepEqual(armies(moved), armies(done));
|
|
}
|
|
assertClassicHomeworldSkillsCustody(done);
|
|
}
|
|
|
|
for (const advanced of [false, true]) for (const kind of ['auction', 'shipment'] as const) {
|
|
for (const [payerShare, donorShare] of [[5, 3], [3, 5], [5, 5], [0, 5]]) for (const redirect of [false, true]) {
|
|
void test(`${advanced ? 'Advanced' : 'Basic'} Homeworld ${kind} ${payerShare}+${donorShare} ${redirect ? 'redirects two' : 'declines'} with full debits and original continuation`, () => {
|
|
const f = fixture({ kind, advanced, payerShare, donorShare });
|
|
assert.equal(player(f.alliance, f.payer).ally, f.donor);
|
|
assert.equal(player(f.alliance, f.donor).ally, f.payer);
|
|
assert.equal(player(f.beforeAction, f.donor).spice, player(f.beforePledge, f.donor).spice - donorShare);
|
|
assert.deepEqual(armies(f.beforeAction), armies(f.beforePledge));
|
|
const paid = pay(f), pending = allow(paid);
|
|
assert.equal(pending.decision?.kind, 'bureaucratPayment'); assert.equal(pending.decision?.player, f.trainer);
|
|
assert.equal(player(pending, f.payer).spice, player(f.beforePledge, f.payer).spice - payerShare);
|
|
assert.equal(player(pending, f.donor).spice, player(f.beforePledge, f.donor).spice - donorShare);
|
|
assert.equal(player(pending, f.payee).spice, player(f.beforePledge, f.payee).spice);
|
|
assert.deepEqual(armies(pending), armies(paid));
|
|
const done = allow(choose(pending, redirect)); outcome(f, done, redirect ? 2 : 0);
|
|
reject(done, f.trainer, { type: 'decision', event: pending.bureaucratPaymentEvent, redirect: true });
|
|
});
|
|
}
|
|
|
|
void test(`${advanced ? 'Advanced' : 'Basic'} Homeworld ${kind} cannot pool two sub-five contributions`, () => {
|
|
const f = fixture({ kind, advanced, payerShare: 3, donorShare: 3 });
|
|
const done = allow(pay(f)); assert.notEqual(done.decision?.kind, 'bureaucratPayment'); outcome(f, done, 0);
|
|
});
|
|
|
|
void test(`${advanced ? 'Advanced' : 'Basic'} Homeworld ${kind} excludes trainer and payee without masking an eligible third party`, () => {
|
|
for (const donor of kind === 'auction' ? ['atreides', 'emperor'] : ['atreides']) {
|
|
const eligible = fixture({ kind, advanced, donor, payerShare: 5, donorShare: 5 });
|
|
const pending = allow(pay(eligible)); assert.equal(pending.decision?.kind, 'bureaucratPayment');
|
|
outcome(eligible, allow(choose(pending, true)), 2);
|
|
const excluded = fixture({ kind, advanced, donor, payerShare: 3, donorShare: 5 });
|
|
const done = allow(pay(excluded)); assert.notEqual(done.decision?.kind, 'bureaucratPayment'); outcome(excluded, done, 0);
|
|
}
|
|
if (kind === 'shipment') {
|
|
// Guild alliance invokes the original half-price native transport. Its
|
|
// contribution to its own income cannot qualify as a third-party payer.
|
|
const f = fixture({ kind, advanced, donor: 'guild', payerShare: 5, donorShare: 5 });
|
|
const done = allow(pay(f)); assert.notEqual(done.decision?.kind, 'bureaucratPayment');
|
|
assert.equal(player(done, f.payer).spice, player(f.beforePledge, f.payer).spice);
|
|
assert.equal(player(done, f.donor).spice, player(f.beforePledge, f.donor).spice - 5);
|
|
assert.equal(player(done, f.payer).reserves, player(f.beforePledge, f.payer).reserves - 10);
|
|
assert.equal(player(done, f.payer).forces[`${f.target}:${f.sector}`], 10);
|
|
assert.equal(done.bureaucratPayments?.used.length ?? 0, 0);
|
|
assert.notEqual(applyAction(done, f.payer, { type: 'endMovement' }).active, f.payer);
|
|
assertClassicHomeworldSkillsCustody(done);
|
|
}
|
|
});
|
|
|
|
void test(`${advanced ? 'Advanced' : 'Basic'} Homeworld ${kind} publishes gross only, rejects stale/cross-actor choices, and supports all four owner bots`, () => {
|
|
for (const [payerShare, donorShare] of [[5, 3], [3, 5]]) {
|
|
const f = fixture({ kind, advanced, payerShare, donorShare }), pending = allow(pay(f));
|
|
for (const viewer of pending.players) {
|
|
const view = viewGame(pending, viewer.id), invoice = view.bureaucrat.pending!;
|
|
assert.equal(invoice.payer, null); assert.equal(invoice.payee, f.payee); assert.equal(invoice.amount, 8);
|
|
for (const field of ['contributions', 'shares', 'qualifyingPayer', 'signature', 'source', 'privateFunding'])
|
|
assert.equal(field in invoice, false, `${field} is private funding evidence, not a public invoice`);
|
|
assert.equal('bureaucratPayments' in view, false); assert.equal('bureaucratUseEvents' in view, false);
|
|
}
|
|
reject(pending, f.donor, { type: 'decision', event: pending.bureaucratPaymentEvent, redirect: true });
|
|
reject(pending, f.trainer, { type: 'decision', event: 'expired-funding-event', redirect: true });
|
|
reject(pending, f.payer, kind === 'shipment' ? { type: 'endMovement' } : f.action);
|
|
reject(pending, f.donor, { type: 'pledgeAid', amount: 1 });
|
|
for (const bot of DIFFICULTIES) {
|
|
const view = viewGame(pending, f.trainer); view.players.find(p => p.id === f.trainer)!.bot = bot;
|
|
const actions = botActions(view); assert.equal(actions.length, 1);
|
|
outcome(f, allow(applyAction(pending, f.trainer, actions[0])), 2);
|
|
}
|
|
}
|
|
});
|
|
|
|
void test(`${advanced ? 'Advanced' : 'Basic'} Homeworld ${kind} original Karama cancels gross after full payment, without an offer/use`, () => {
|
|
const f = fixture({ kind, advanced, payerShare: 5, donorShare: 5 });
|
|
const card = holdHomeworldFundingKarama(f), paid = pay(f);
|
|
assert.equal(paid.response?.kind, kind === 'auction' ? 'emperorIncome' : 'guildIncome');
|
|
assert.ok(viewGame(paid, f.trainer).responseControls?.cancelCards.includes(card));
|
|
const done = allow(applyAction(paid, f.trainer, { type: 'card', mode: 'cancel', card }));
|
|
assert.notEqual(done.decision?.kind, 'bureaucratPayment'); outcome(f, done, 0, true);
|
|
assert.equal(done.discard.filter(c => c.id === card).length, 1);
|
|
assert.ok(!player(done, f.trainer).hand.some(c => c.id === card));
|
|
reject(done, f.trainer, { type: 'card', mode: 'cancel', card });
|
|
});
|
|
}
|
|
|
|
for (const advanced of [false, true]) void test(`${advanced ? 'Advanced' : 'Basic'} Homeworld auction decline retains the physical use for the next genuine lot, redirect spends it only once`, () => {
|
|
for (const redirect of [false, true]) {
|
|
const f = fixture({ kind: 'auction', advanced, payerShare: 3, donorShare: 5 });
|
|
const first = allow(choose(allow(pay(f)), redirect));
|
|
const next = advanceHomeworldFunding(first, g => !!g.auction && g.auction.active === f.payer && homeworldFundingClean(g));
|
|
const before = structuredClone(next), card = next.auction!.cards[next.auction!.index].id;
|
|
const second = { ...f, game: next, action: { type: 'bid', amount: 5 } as Action };
|
|
let done = allow(pay(second));
|
|
if (redirect) {
|
|
assert.notEqual(done.decision?.kind, 'bureaucratPayment');
|
|
assert.equal(player(done, f.payee).spice, player(before, f.payee).spice + 5);
|
|
} else {
|
|
assert.equal(done.decision?.kind, 'bureaucratPayment');
|
|
done = allow(choose(done, true));
|
|
assert.equal(player(done, f.payee).spice, player(before, f.payee).spice + 3);
|
|
}
|
|
assert.equal(player(done, f.payer).spice, player(before, f.payer).spice - 5);
|
|
assert.deepEqual(player(done, f.payer).hand.map(c => c.id),
|
|
[...player(before, f.payer).hand.map(c => c.id), card, before.deck[0].id]);
|
|
assert.equal(done.auction!.index, before.auction!.index + 1);
|
|
assert.equal(done.bureaucratPayments!.used.length, 1);
|
|
assert.deepEqual(homeworldFundingCards(done), f.physical);
|
|
assert.deepEqual(armies(done), armies(before));
|
|
assertClassicHomeworldSkillsCustody(done);
|
|
}
|
|
});
|
|
|
|
for (const advanced of [false, true]) void test(`${advanced ? 'Advanced' : 'Basic'} Homeworld physical use is once per phase; decline does not spend it and next phase renews it`, () => {
|
|
for (const redirect of [false, true]) {
|
|
const f = fixture({ kind: 'shipment', advanced, payerShare: 3, donorShare: 5 });
|
|
const pending = allow(pay(f)), settled = allow(choose(pending, redirect));
|
|
const following = applyAction(settled, f.payer, { type: 'bribe', target: 'guild', amount: 5 });
|
|
let used: Game;
|
|
if (redirect) {
|
|
assert.notEqual(following.decision?.kind, 'bureaucratPayment');
|
|
assert.equal(player(following, 'guild').bribes, player(settled, 'guild').bribes + 5); used = following;
|
|
} else {
|
|
assert.equal(following.decision?.kind, 'bureaucratPayment');
|
|
reject(following, f.trainer, { type: 'decision', event: pending.bureaucratPaymentEvent, redirect: true });
|
|
used = allow(choose(following, true));
|
|
assert.equal(player(used, 'guild').bribes, player(settled, 'guild').bribes + 3);
|
|
}
|
|
assert.equal(used.bureaucratPayments!.used.length, 1);
|
|
const ended = applyAction(used, f.payer, { type: 'endMovement' });
|
|
const next = advanceHomeworldFunding(ended, g => g.turn === 3 && g.phase === 1 && homeworldFundingClean(g));
|
|
assert.equal(viewGame(next, f.trainer).bureaucrat.usedThisPhase, false);
|
|
// The Guild's actual shipment receipts fund a later genuine third-party bribe.
|
|
const renewed = allow(choose(applyAction(next, 'guild', { type: 'bribe', target: 'emperor', amount: 5 }), true));
|
|
assert.equal(renewed.bureaucratPayments!.used.length, 2);
|
|
assert.deepEqual(renewed.bureaucratPayments!.used.map(use => [use.turn, use.phase]), [[2, 5], [3, 1]]);
|
|
assert.equal(viewGame(renewed, f.trainer).bureaucrat.usedThisPhase, true);
|
|
assertClassicHomeworldSkillsCustody(renewed);
|
|
}
|
|
});
|
|
|
|
void test('played Homeworld skills rooms cannot be converted and incomplete occupation saves reject immutably', () => {
|
|
const f = fixture({ kind: 'shipment' });
|
|
assert.equal(f.game.homeworldOccupationPreview, undefined);
|
|
const original = structuredClone(f.game);
|
|
assert.throws(() => initializeHomeworldOccupationGameForAudit(f.game));
|
|
assert.deepEqual(f.game, original);
|
|
// Negative malformed-save input only: never claimed as a reachable occupation
|
|
// fixture. No wallet, army, occupation history or skill custody is fabricated.
|
|
const rejectedSave = structuredClone(f.game); rejectedSave.homeworldOccupationPreview = true;
|
|
const before = structuredClone(rejectedSave);
|
|
assert.throws(() => applyAction(rejectedSave, f.payer, f.action));
|
|
assert.deepEqual(rejectedSave, before);
|
|
});
|