Guard Duke grants using public capture uncertainty
Verify and publish checkpoint container / container (push) Successful in 11m21s
Verify and publish checkpoint container / container (push) Successful in 11m21s
This commit is contained in:
1 parent
5f4eeee4f1
commit
57e7611468
15 files changed
+500
-19
No files matched your search
@@ -0,0 +1,132 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { applyAction, viewGame, type Game } from '../game/engine';
|
||||
import { acquireDuke, captureDuke, DUKE_VIDAL_ID } from '../game/duke-vidal';
|
||||
import { createNexusDukeCaptureFixture } from './fixture-nexus-duke-capture';
|
||||
|
||||
/** The Ambassador placement and offer are reached by real actions. We stage
|
||||
* two alternate custody outcomes for the same physical disc and parent event:
|
||||
* a living third-party Duke and its legal concealed Harkonnen capture. */
|
||||
function paired() {
|
||||
const source = createNexusDukeCaptureFixture();
|
||||
const free = structuredClone(source.arrival.before);
|
||||
const priorController = source.others.find(id => id !== source.captor && id !== source.entrant);
|
||||
assert.ok(priorController, 'A third party owns the staged prior Duke');
|
||||
const prior = acquireDuke(free.dukeVidal!, priorController, free.turn, 'ecaz');
|
||||
free.dukeVidal = prior;
|
||||
const captured: Game = structuredClone(free);
|
||||
captured.dukeVidal = captureDuke(prior, source.captor, priorController, free.turn, 'carthag');
|
||||
// Public history records a possible hidden Duke capture, regardless of
|
||||
// whether this physical disc was the captive actually selected.
|
||||
Object.assign(free, { dukeCaptureUncertain: true });
|
||||
Object.assign(captured, { dukeCaptureUncertain: true });
|
||||
assert.equal(captured.pendingAmbassador?.event, free.pendingAmbassador?.event);
|
||||
const freeView = viewGame(free, source.owner), capturedView = viewGame(captured, source.owner);
|
||||
for (const key of Object.keys(freeView) as (keyof typeof freeView)[]) {
|
||||
if (key !== 'ambassadorEntry') assert.deepEqual(capturedView[key], freeView[key], `Public-equivalent ${key}`);
|
||||
}
|
||||
return { source, free, captured };
|
||||
}
|
||||
|
||||
void test('Ecaz Ambassador availability must not reveal a concealed Duke captured from another controller', () => {
|
||||
const {source, free, captured} = paired();
|
||||
const freeEntry = viewGame(free, source.owner).ambassadorEntry;
|
||||
const hiddenEntry = viewGame(captured, source.owner).ambassadorEntry;
|
||||
assert.ok(freeEntry && hiddenEntry);
|
||||
const action = {type:'decision', event:free.pendingAmbassador!.event, trigger:true, beneficiary:source.owner, choice:'duke'};
|
||||
for (const game of [free, captured]) {
|
||||
const before = structuredClone(game);
|
||||
assert.throws(() => applyAction(game, source.owner, action));
|
||||
assert.deepEqual(game, before, 'The unavailable action preserves the physical Ambassador and Duke');
|
||||
}
|
||||
assert.deepEqual(hiddenEntry, freeEntry, 'The same public Duke and parent event must offer identical controls');
|
||||
assert.ok(freeEntry.dukeAcquisition?.blocked, 'The same public uncertainty uniformly blocks the acquisition');
|
||||
});
|
||||
|
||||
void test('an actual fresh Ambassador grant stays available before public capture uncertainty', () => {
|
||||
const source = createNexusDukeCaptureFixture(), game = structuredClone(source.arrival.before);
|
||||
assert.equal(viewGame(game, source.owner).ambassadorEntry?.dukeAcquisition?.blocked, null);
|
||||
const after = applyAction(game, source.owner, source.arrival.step.action);
|
||||
assert.equal(after.dukeVidal?.controller, source.owner);
|
||||
assert.equal(after.dukeVidal?.source, 'ecaz');
|
||||
});
|
||||
|
||||
void test('a fresh Advanced Ecaz alliance grants the unambiguous Duke without another choice', () => {
|
||||
const source = createNexusDukeCaptureFixture(), game = structuredClone(source.arrival.before);
|
||||
const event = game.pendingAmbassador!.event;
|
||||
const offered = applyAction(game, source.owner, {type:'decision', event, trigger:true,
|
||||
beneficiary:source.owner, choice:'alliance'});
|
||||
assert.equal(offered.pendingAmbassador?.stage, 'allianceReply');
|
||||
const accepted = applyAction(offered, source.entrant, {type:'decision', event, accept:true});
|
||||
assert.equal(accepted.players.find(player => player.id === source.owner)?.ally, source.entrant);
|
||||
assert.equal(accepted.dukeVidal?.controller, source.entrant);
|
||||
assert.equal(accepted.dukeVidal?.source, 'ally');
|
||||
assert.notEqual(accepted.pendingAmbassador?.stage, 'loan');
|
||||
});
|
||||
|
||||
void test('an Advanced alliance does not reveal uncertain Duke custody through its automatic grant', () => {
|
||||
const {source, free, captured} = paired();
|
||||
const results: Game[] = [];
|
||||
for (const game of [free, captured]) {
|
||||
const originalDuke = structuredClone(game.dukeVidal);
|
||||
const event = game.pendingAmbassador!.event;
|
||||
const offered = applyAction(game, source.owner, {type:'decision', event, trigger:true,
|
||||
beneficiary:source.owner, choice:'alliance'});
|
||||
const accepted = applyAction(offered, source.entrant, {type:'decision', event, accept:true});
|
||||
assert.equal(accepted.players.find(player => player.id === source.owner)?.ally, source.entrant);
|
||||
assert.deepEqual(accepted.dukeVidal, originalDuke, 'No automatic grant changes either actual custody');
|
||||
assert.notEqual(accepted.pendingAmbassador?.stage, 'loan');
|
||||
results.push(accepted);
|
||||
}
|
||||
assert.deepEqual(viewGame(results[0], source.owner), viewGame(results[1], source.owner));
|
||||
assert.deepEqual(viewGame(results[0], source.entrant), viewGame(results[1], source.entrant));
|
||||
});
|
||||
|
||||
void test('a real Duke-possible capture marks uncertainty for either concealed selection', () => {
|
||||
const source = createNexusDukeCaptureFixture({variant:'used'});
|
||||
assert.ok(source.offer);
|
||||
assert.ok(source.candidates.some(leader => leader.id === DUKE_VIDAL_ID));
|
||||
assert.ok(source.candidates.some(leader => leader.id !== DUKE_VIDAL_ID));
|
||||
assert.equal(source.offer.before.dukeCaptureUncertain, false);
|
||||
assert.equal(source.offer.after.decision?.kind, 'capturedLeader');
|
||||
if (source.offer.after.decision?.kind !== 'capturedLeader') throw Error('Missing capture selection');
|
||||
assert.equal(source.offer.after.decision.leader, DUKE_VIDAL_ID);
|
||||
assert.equal(source.offer.after.dukeCaptureUncertain, true);
|
||||
assert.equal(source.game.dukeCaptureUncertain, true);
|
||||
|
||||
// Select a different original candidate solely by controlled shuffle entropy,
|
||||
// replaying the same real public capture and preserving all physical discs.
|
||||
const saved = Object.getOwnPropertyDescriptor(crypto, 'getRandomValues');
|
||||
const native = crypto.getRandomValues.bind(crypto);
|
||||
try {
|
||||
crypto.getRandomValues = <V extends ArrayBufferView | null>(array: V): V => {
|
||||
if (array instanceof Uint32Array) { array.fill(0); return array; }
|
||||
return Reflect.apply(native, crypto, [array]);
|
||||
};
|
||||
const different = applyAction(structuredClone(source.offer.before), source.offer.step.actor, source.offer.step.action);
|
||||
assert.equal(different.decision?.kind, 'capturedLeader');
|
||||
if (different.decision?.kind !== 'capturedLeader') throw Error('Missing capture selection');
|
||||
assert.notEqual(different.decision.leader, DUKE_VIDAL_ID);
|
||||
assert.equal(different.dukeCaptureUncertain, true, 'The public marker cannot depend on hidden selection');
|
||||
} finally {
|
||||
if (saved) Object.defineProperty(crypto, 'getRandomValues', saved);
|
||||
else Reflect.deleteProperty(crypto, 'getRandomValues');
|
||||
}
|
||||
});
|
||||
|
||||
void test('legacy games without the capture marker uniformly guard equivalent Duke custody', () => {
|
||||
const {source, free, captured} = paired();
|
||||
delete free.dukeCaptureUncertain;
|
||||
delete captured.dukeCaptureUncertain;
|
||||
const freeEntry = viewGame(free, source.owner).ambassadorEntry;
|
||||
const hiddenEntry = viewGame(captured, source.owner).ambassadorEntry;
|
||||
assert.ok(freeEntry && hiddenEntry);
|
||||
assert.deepEqual(hiddenEntry, freeEntry);
|
||||
assert.ok(freeEntry.dukeAcquisition?.blocked, 'Unknown legacy capture history must not be assumed safe');
|
||||
const action = {type:'decision', event:free.pendingAmbassador!.event, trigger:true, beneficiary:source.owner, choice:'duke'};
|
||||
for (const game of [free, captured]) {
|
||||
const before = structuredClone(game);
|
||||
assert.throws(() => applyAction(game, source.owner, action));
|
||||
assert.deepEqual(game, before);
|
||||
}
|
||||
});
|
||||
Reference in new issue
Block a user