Connect staged Advanced classic group alliances
Verify and publish checkpoint container / container (push) Successful in 10m53s

This commit is contained in:
Quintine committed 2026-10-29 02:37:23 +11:00
1 parent ef92ddf2b9
commit 3ba9087405
22 files changed
+561 -44

No files matched your search

+120
View File
@@ -0,0 +1,120 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import { coalitionOf, emptyCoalitionState } from '../game/coalition-alliance';
import { applyAction, viewGame, type Action, type Game } from '../game/engine';
import { advanceTruthAlliance, createTruthAllianceFixture, truthAllianceClean } from './fixture-truth-alliance';
const act = (game: Game, id: string, action: Action) => applyAction(game, id, action);
const seat = (game: Game, id: string) => game.players.find(player => player.id === id)!;
const remaining = (game: Game, donor: string, recipient: string) =>
game.coalitionEscrow!.pledges.find(row => row.donor === donor && row.recipient === recipient)?.amount ?? 0;
const allSpice = (game: Game) => game.players.reduce((sum, p) => sum + p.spice, 0) +
(game.coalitionEscrow?.pledges.reduce((sum, row) => sum + row.amount, 0) ?? 0);
/** Genuine Advanced preview and normal Nexus. Only an empty group ledger is
* added there; the base fixture selects unopened deal/lot/Spice positions and
* scalar lotteries. Pair, invitation, consent and later phases use native
* actions. Tests explicitly stage wallets or one conserved Tank force. */
function group() {
const source = createTruthAllianceFixture({advanced:true, consent:'none'});
let game = structuredClone(source.game);
game.coalitionState = emptyCoalitionState('three-short');
game = act(game, source.asker, {type:'alliance', target:source.opponent});
game = act(game, source.opponent, {type:'alliance', target:source.asker});
const pair = coalitionOf(game.players, game.coalitionState, source.asker); assert.ok(pair);
game = act(game, source.asker, {type:'coalitionPropose', groupId:pair.id, entrant:source.target,
expectedRevision:game.coalitionState!.revision});
for (const id of [source.opponent, source.target]) {
const offer = game.coalitionState!.proposal; assert.ok(offer);
game = act(game, id, {type:'coalitionAnswer', event:offer.event, nexus:offer.nexus, turn:offer.turn,
accept:true, expectedRevision:game.coalitionState!.revision});
}
assert.equal(coalitionOf(game.players, game.coalitionState, source.asker)!.members.length, 3);
assert.ok(game.coalitionEscrow);
return {game, source};
}
function stageWallets(game: Game, payer: string, donor1: string, donor2: string) {
seat(game, payer).spice = 2;
seat(game, donor1).spice = 10;
seat(game, donor2).spice = 10;
}
function pledge(game: Game, payer: string, donor1: string, donor2: string): Game {
game = act(game, donor1, {type:'coalitionPledge', recipient:payer, amount:4});
return act(game, donor2, {type:'coalitionPledge', recipient:payer, amount:3});
}
function responses(game: Game): Game {
for (let i = 0; game.response && i < 30; i++) {
const player = game.players.find(p => !game.response!.passed.includes(p.id)); assert.ok(player);
game = act(game, player.id, {type:'passResponse'});
}
assert.equal(game.response, null);
return game;
}
void test('Advanced group bid settles both donors once and pays the Emperor', () => {
const {game: initial, source} = group();
const payer = source.asker, donor1 = source.opponent, donor2 = source.target;
let game = advanceTruthAlliance(initial, state => state.phase === 3 && !!state.auction && truthAllianceClean(state));
for (let count = 0; game.auction && game.auction.active !== payer && count < game.players.length; count++)
game = act(game, game.auction.active, {type:'passBid'});
assert.equal(game.auction?.active, payer);
stageWallets(game, payer, donor1, donor2);
const beforeSpice = allSpice(game), hand = seat(game, payer).hand.length;
game = pledge(game, payer, donor1, donor2);
assert.equal(viewGame(game, payer).coalitionFunding?.incoming.length, 2);
game = act(game, payer, {type:'bid', amount:6, allyPayment:0,
coalitionContributions:[{donor:donor1, amount:3}, {donor:donor2, amount:2}]});
for (let count = 0; !game.response && !game.decision && game.auction?.bidder === payer && count < 10; count++)
game = act(game, game.auction.active, {type:'passBid'});
if (game.decision?.kind === 'auctionPayment') game = act(game, payer, {type:'decision', karama:false});
if (game.response) {
assert.equal(game.response.kind, 'emperorIncome');
game = responses(game);
}
assert.ok(seat(game, payer).hand.length > hand);
assert.equal(seat(game, payer).spice, 1);
assert.equal(seat(game, donor1).spice, 6);
assert.equal(seat(game, donor2).spice, 13, 'Emperor receives the six-spice winning price.');
assert.equal(remaining(game, donor1, payer), 1);
assert.equal(remaining(game, donor2, payer), 1);
assert.equal(allSpice(game), beforeSpice);
});
void test('Advanced group shipment spends the actual donor pledges and bank invoice', () => {
const {game: initial, source} = group();
const payer = source.asker, donor1 = source.opponent, donor2 = source.target;
let game = advanceTruthAlliance(initial, state => state.phase === 5 && state.active === payer && truthAllianceClean(state));
stageWallets(game, payer, donor1, donor2);
// Select a safe sector without moving any force or changing its inventory.
game.storm = 18;
const beforeSpice = allSpice(game), reserves = seat(game, payer).reserves;
game = pledge(game, payer, donor1, donor2);
game = act(game, payer, {type:'ship', territory:'imperial_basin', sector:9, amount:3, elite:0, allyPayment:0,
coalitionContributions:[{donor:donor1, amount:3}, {donor:donor2, amount:2}]});
game = responses(game);
assert.equal(seat(game, payer).forces['imperial_basin:9'], 3);
assert.equal(seat(game, payer).reserves, reserves - 3);
assert.equal(seat(game, payer).spice, 1);
assert.equal(remaining(game, donor1, payer), 1);
assert.equal(remaining(game, donor2, payer), 1);
assert.equal(allSpice(game), beforeSpice - 6, 'There is no Guild seat; the invoice goes to the bank.');
});
void test('Advanced Emperor pays a group ally for one extra revival on that ally’s actual Revival turn', () => {
const {game: initial, source} = group();
let game = advanceTruthAlliance(initial, state => state.phase === 4 && truthAllianceClean(state) &&
!!state.revivalOrder?.remaining[0] && state.revivalOrder.remaining[0] !== source.target);
const target = game.revivalOrder!.remaining[0], recipient = seat(game, target), emperor = seat(game, source.target);
// Move one original ordinary reserve to Tanks and supply a test-bank wallet.
assert.ok(recipient.reserves > 0);
recipient.reserves--; recipient.tanks++;
emperor.spice = 10;
const reserves = recipient.reserves, tanks = recipient.tanks;
game = act(game, source.target, {type:'emperorRevival', target, amount:1, elite:0});
if (game.response) assert.equal(game.response.kind, 'emperorRevival');
game = responses(game);
assert.equal(seat(game, source.target).spice, 8);
assert.equal(seat(game, target).reserves, reserves + 1);
assert.equal(seat(game, target).tanks, tanks - 1);
assert.equal(game.emperorExtra[target], 1);
});