875 lines
59 KiB
TypeScript
875 lines
59 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import {
|
|
compileMixedActionExpression,
|
|
type MixedActionExpression,
|
|
} from '../game/mixed-action-question';
|
|
import {
|
|
TURN_ACTION_MAX_DEPTH,
|
|
TURN_ACTION_MAX_LEAVES,
|
|
TurnActionError,
|
|
closeTurnActionBidding,
|
|
closeTurnActionCombat,
|
|
closeTurnActionRevival,
|
|
closeTurnActionTransport,
|
|
finishTurnActionTurn,
|
|
liveTurnActionPromises,
|
|
parseTurnActionLeaf,
|
|
recordTurnActionBid,
|
|
recordTurnActionPlan,
|
|
recordTurnActionTraitor,
|
|
recordTurnActionMovement,
|
|
recordTurnActionPayment,
|
|
recordTurnActionShipment,
|
|
recordTurnActionRevival,
|
|
settleTurnActionAlliance,
|
|
turnActionBranches,
|
|
turnActionHasPayments,
|
|
turnActionValue,
|
|
validateTurnActionPromises,
|
|
type TurnActionBranchLeaf,
|
|
type TurnActionLeaf,
|
|
type TurnActionPromise,
|
|
type TurnActionPlanValue,
|
|
} from '../game/turn-action-promises';
|
|
|
|
type Expression = MixedActionExpression<TurnActionLeaf>;
|
|
const seats = ['respondent', 'asker', 'recipient', 'other', 'second-recipient'];
|
|
const travel = (kind: 'ship' | 'move', territory = 'carthag', minimum = 3): Expression =>
|
|
({ kind: 'action', action: { kind, territory, minimum } });
|
|
const pay = (recipient = 'recipient', minimum = 3): Expression =>
|
|
({ kind: 'action', action: { kind: 'payment', recipient, minimum } });
|
|
const bid = (minimum = 3, lot = 1): Expression => ({ kind: 'action', action: { kind: 'bid', lot, minimum } });
|
|
const forces = (minimum = 3, counter: 'total' | 'normal' | 'elite' = 'total'): Expression =>
|
|
({ kind: 'action', action: { kind: 'forces', counter, minimum } });
|
|
const leader = (leader = 'atreides-0'): Expression => ({ kind: 'action', action: { kind: 'leader', leader } });
|
|
const alliance = (partner = 'recipient'): Expression => ({ kind: 'action', action: { kind: 'alliance', partner } });
|
|
const plan = (claim: TurnActionPlanValue['claim'] = { kind: 'dial', compare: 'gte', value: 2 }, battle = 'battle:1'): Expression =>
|
|
({ kind: 'action', action: { kind: 'battlePlan', battle, territory: 'carthag', claim } });
|
|
const call = (call = true, battle = 'battle:1'): Expression =>
|
|
({ kind: 'action', action: { kind: 'traitorCall', battle, territory: 'carthag', call } });
|
|
const fact = (): Expression => ({ kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 5 } });
|
|
const group = (kind: 'and' | 'or', ...terms: Expression[]): Expression => ({ kind, terms });
|
|
const signedTravel = (kind: 'ship' | 'move', territory = 'carthag', minimum = 3,
|
|
answer = true): TurnActionBranchLeaf => ({ kind, territory, minimum, answer });
|
|
const signedPay = (recipient = 'recipient', minimum = 3, progress = 0,
|
|
answer = true): TurnActionBranchLeaf => ({ kind: 'payment', recipient, minimum, progress, answer });
|
|
const event = (territory = 'carthag', amount = 3) => ({ territory, amount });
|
|
const payment = (recipient = 'recipient', amount = 3) => ({ recipient, amount });
|
|
function promise(mixed: Expression, answer = true, id = 'turn-action:1'): TurnActionPromise {
|
|
return {
|
|
turn: 1, mixed, event: id, player: 'respondent', asker: 'asker', answer,
|
|
compiled: compileMixedActionExpression(mixed, () => 'yes', answer),
|
|
shipment: { pending: true, event: null }, progress: [], payments: [],
|
|
transportClosed: false, paymentClosed: false, fulfilled: false, released: false,
|
|
};
|
|
}
|
|
const branches = (record: TurnActionPromise) => [...turnActionBranches(record)];
|
|
function prepared(mixed: Expression, answer = true, id = 'turn-action:1'): TurnActionPromise {
|
|
return { ...promise(mixed, answer, id), preparation: {
|
|
bid: { lot: 1, source: 'original-lot:1', maximum: 0, closed: false },
|
|
revival: { total: 0, normal: 0, elite: 0, leaders: [], closed: false },
|
|
} };
|
|
}
|
|
function nexus(mixed: Expression, answer = true, id = 'turn-action:1'): TurnActionPromise {
|
|
return { ...promise(mixed, answer, id), alliance: { source: 'nexus:1', partner: null, closed: false } };
|
|
}
|
|
function combat(mixed: Expression, answer = true, id = 'turn-action:1'): TurnActionPromise {
|
|
return { ...promise(mixed, answer, id), combat: { event: 'battle:1', territory: 'carthag',
|
|
plan: { closed: false, values: null }, traitor: { beneficiary: 'respondent', target: 'other',
|
|
leader: 'other-0', closed: false, call: null } } };
|
|
}
|
|
const dial = (value = true): TurnActionPlanValue => ({ claim: { kind: 'dial', compare: 'gte', value: 2 }, value });
|
|
|
|
void test('turn-action leaves retain exact native fields, safe payment minima and no payment twenty-force cap', () => {
|
|
for (const kind of ['ship', 'move'] as const) {
|
|
const leaf = { kind, territory: 'carthag', minimum: 3 };
|
|
assert.deepEqual(parseTurnActionLeaf(leaf), leaf);
|
|
assert.notEqual(parseTurnActionLeaf(leaf), leaf);
|
|
for (const invalid of [{ ...leaf, minimum: 0 }, { ...leaf, minimum: 21 },
|
|
{ ...leaf, territory: 'not-a-territory' }, { ...leaf, amount: 3 },
|
|
{ ...leaf, answer: true }, { ...leaf, recipient: 'recipient' }])
|
|
assert.throws(() => parseTurnActionLeaf(invalid), TurnActionError);
|
|
}
|
|
for (const minimum of [1, 21, 1001, Number.MAX_SAFE_INTEGER]) {
|
|
const leaf = { kind: 'payment', recipient: 'recipient', minimum };
|
|
assert.deepEqual(parseTurnActionLeaf(leaf), leaf);
|
|
assert.notEqual(parseTurnActionLeaf(leaf), leaf);
|
|
}
|
|
const leaf = { kind: 'payment', recipient: 'recipient', minimum: 3 };
|
|
for (const invalid of [null, [], {}, { ...leaf, kind: 'gift' }, { ...leaf, recipient: '' },
|
|
{ ...leaf, recipient: ' recipient' }, { ...leaf, progress: 0 }, { ...leaf, turn: 1 },
|
|
{ ...leaf, territory: 'carthag' }, { ...leaf, answer: true },
|
|
...[0, -1, 1.5, NaN, Infinity, Number.MAX_SAFE_INTEGER + 1, '3'].map(minimum => ({ ...leaf, minimum }))])
|
|
assert.throws(() => parseTurnActionLeaf(invalid), TurnActionError);
|
|
});
|
|
|
|
void test('one whole AND requires actual shipment, physical movement and ordinary payment while OR retains choices', () => {
|
|
const and = promise(group('and', travel('ship'), travel('move', 'arrakeen', 2), pay()));
|
|
const or = promise(group('or', travel('ship'), travel('move', 'arrakeen', 2), pay()), true, 'turn-action:2');
|
|
assert.deepEqual(branches(and), [[signedTravel('ship'), signedTravel('move', 'arrakeen', 2), signedPay()]]);
|
|
assert.deepEqual(branches(or), [[signedTravel('ship')], [signedTravel('move', 'arrakeen', 2)], [signedPay()]]);
|
|
const shipped = recordTurnActionShipment([and, or], 'respondent', 1, event());
|
|
assert.equal(shipped[0].fulfilled, false);
|
|
assert.equal(shipped[1].fulfilled, true);
|
|
assert.deepEqual(branches(shipped[0]), [[signedTravel('move', 'arrakeen', 2), signedPay()]]);
|
|
const moved = recordTurnActionMovement(shipped, 'respondent', 1, event('arrakeen', 2));
|
|
assert.equal(moved[0].fulfilled, false);
|
|
assert.deepEqual(branches(moved[0]), [[signedPay()]]);
|
|
const paid = recordTurnActionPayment(moved, 'respondent', 1, payment());
|
|
assert.equal(paid[0].fulfilled, true);
|
|
assert.equal(turnActionValue(paid[0]), true);
|
|
assert.deepEqual(branches(paid[0]), [[]]);
|
|
assert.equal(liveTurnActionPromises(paid, 'respondent', 1).length, 0);
|
|
assert.equal(paid[1], shipped[1], 'A terminal alternative never receives later movement or payments');
|
|
assert.deepEqual(and.progress, []);
|
|
assert.deepEqual(and.payments, []);
|
|
assert.equal(and.shipment.pending, true);
|
|
validateTurnActionPromises(paid, seats);
|
|
});
|
|
|
|
void test('whole No negates the entire AND/OR tree and actual actions may change its remaining branch', () => {
|
|
const andNo = promise(group('and', travel('ship'), group('or', travel('move', 'arrakeen', 2), pay())), false);
|
|
assert.deepEqual(branches(andNo), [[signedTravel('ship', 'carthag', 3, false)],
|
|
[signedTravel('move', 'arrakeen', 2, false), signedPay('recipient', 3, 0, false)]]);
|
|
const shipped = recordTurnActionShipment([andNo], 'respondent', 1, event());
|
|
assert.deepEqual(branches(shipped[0]), [[signedTravel('move', 'arrakeen', 2, false),
|
|
signedPay('recipient', 3, 0, false)]]);
|
|
const before = structuredClone(shipped);
|
|
assert.throws(() => recordTurnActionMovement(shipped, 'respondent', 1, event('arrakeen', 2)), TurnActionError);
|
|
assert.throws(() => recordTurnActionPayment(shipped, 'respondent', 1, payment()), TurnActionError);
|
|
assert.deepEqual(shipped, before);
|
|
const orNo = promise(group('or', travel('ship'), pay()), false);
|
|
assert.deepEqual(branches(orNo), [[signedTravel('ship', 'carthag', 3, false),
|
|
signedPay('recipient', 3, 0, false)]]);
|
|
assert.throws(() => recordTurnActionShipment([orNo], 'respondent', 1, event()), TurnActionError);
|
|
assert.throws(() => recordTurnActionPayment([orNo], 'respondent', 1, payment()), TurnActionError);
|
|
const skipped = recordTurnActionShipment([andNo], 'respondent', 1, null);
|
|
assert.ok(branches(skipped[0]).some(branch => branch.length === 0));
|
|
assert.equal(skipped[0].fulfilled, false, 'Other relevant opportunities remain open even with a decisive absent shipment');
|
|
const paid = recordTurnActionPayment(skipped, 'respondent', 1, payment());
|
|
assert.equal(paid[0].fulfilled, false);
|
|
assert.equal(finishTurnActionTurn(paid, 'respondent', 1)[0].fulfilled, true);
|
|
});
|
|
|
|
void test('payment progress sums actual payer events while movement progress retains only one maximum group', () => {
|
|
const original = promise(group('and', travel('move', 'carthag', 5), pay('recipient', 5)));
|
|
const moved = recordTurnActionMovement([original], 'respondent', 1, event('carthag', 3));
|
|
const movedAgain = recordTurnActionMovement(moved, 'respondent', 1, event('carthag', 3));
|
|
assert.equal(movedAgain[0], moved[0]);
|
|
assert.deepEqual(movedAgain[0].progress, [{ territory: 'carthag', maximum: 3 }]);
|
|
const paid = recordTurnActionPayment(movedAgain, 'respondent', 1, payment('recipient', 3));
|
|
const paidAgain = recordTurnActionPayment(paid, 'respondent', 1, payment('recipient', 2));
|
|
assert.deepEqual(paidAgain[0].payments, [payment('recipient', 5)]);
|
|
assert.equal(turnActionValue(paidAgain[0]), false);
|
|
assert.deepEqual(branches(paidAgain[0]), [[signedTravel('move', 'carthag', 5)]]);
|
|
assert.equal(recordTurnActionMovement(paidAgain, 'respondent', 1, event('carthag', 5))[0].fulfilled, true);
|
|
assert.equal(recordTurnActionMovement(paidAgain, 'respondent', 1, event('arrakeen', 20))[0], paidAgain[0]);
|
|
assert.equal(recordTurnActionPayment(paidAgain, 'respondent', 1, payment('other', 20))[0], paidAgain[0]);
|
|
});
|
|
|
|
void test('answer intervals retain separate payment receipts, movement maxima and one shared original shipment', () => {
|
|
const mixed = group('and', group('or', travel('ship', 'carthag', 5), travel('move', 'arrakeen', 5)), pay('recipient', 7));
|
|
const old = promise(mixed);
|
|
const once = recordTurnActionPayment([old], 'respondent', 1, payment('recipient', 3));
|
|
const shipped = recordTurnActionShipment(once, 'respondent', 1, event('carthag', 4));
|
|
const moved = recordTurnActionMovement(shipped, 'respondent', 1, event('arrakeen', 4));
|
|
const fresh = promise(mixed, true, 'turn-action:2');
|
|
fresh.shipment.pending = false;
|
|
const otherPlayer = { ...promise(mixed, true, 'turn-action:3'), player: 'other' };
|
|
const otherTurn = { ...promise(mixed, true, 'turn-action:4'), turn: 2 };
|
|
const list = [moved[0], fresh, otherPlayer, otherTurn];
|
|
const paid = recordTurnActionPayment(list, 'respondent', 1, payment('recipient', 2));
|
|
assert.deepEqual(paid[0].payments, [payment('recipient', 5)]);
|
|
assert.deepEqual(paid[1].payments, [payment('recipient', 2)]);
|
|
assert.deepEqual(branches(paid[0]), [[signedTravel('move', 'arrakeen', 5), signedPay('recipient', 7, 5)]]);
|
|
assert.deepEqual(branches(paid[1]), [[signedTravel('move', 'arrakeen', 5), signedPay('recipient', 7, 2)]]);
|
|
const again = recordTurnActionShipment(paid, 'respondent', 1, event('arrakeen', 20));
|
|
assert.equal(again[0].shipment.event?.amount, 4);
|
|
assert.equal(again[1].shipment.event, null);
|
|
assert.equal(again[2], otherPlayer);
|
|
assert.equal(again[3], otherTurn);
|
|
const small = recordTurnActionMovement(again, 'respondent', 1, event('arrakeen', 2));
|
|
assert.deepEqual(small[0].progress, [{ territory: 'arrakeen', maximum: 4 }]);
|
|
assert.deepEqual(small[1].progress, [{ territory: 'arrakeen', maximum: 2 }]);
|
|
});
|
|
|
|
void test('signed DNF merges only same-kind bounds within a record and prunes incompatible positive shipment destinations', () => {
|
|
const same = promise(group('and', travel('ship', 'carthag', 2), travel('ship', 'carthag', 5),
|
|
travel('move', 'carthag', 3), travel('move', 'carthag', 4), pay('recipient', 3), pay('recipient', 6)));
|
|
const partial = recordTurnActionPayment([same], 'respondent', 1, payment('recipient', 2));
|
|
assert.deepEqual(branches(partial[0]), [[signedTravel('ship', 'carthag', 5), signedTravel('move', 'carthag', 4),
|
|
signedPay('recipient', 6, 2)]]);
|
|
const no = promise(group('or', pay('recipient', 3), pay('recipient', 6), travel('move', 'carthag', 2),
|
|
travel('move', 'carthag', 5)), false);
|
|
assert.deepEqual(branches(no), [[signedPay('recipient', 3, 0, false), signedTravel('move', 'carthag', 2, false)]]);
|
|
const impossible = promise(group('and', travel('ship'), travel('ship', 'arrakeen'), pay()));
|
|
assert.deepEqual(branches(impossible), []);
|
|
const choices = promise(group('and', group('or', travel('ship'), pay()),
|
|
group('or', travel('ship', 'arrakeen', 2), travel('move', 'arrakeen', 4))));
|
|
assert.deepEqual(branches(choices), [
|
|
[signedTravel('ship'), signedTravel('move', 'arrakeen', 4)],
|
|
[signedPay(), signedTravel('ship', 'arrakeen', 2)],
|
|
[signedPay(), signedTravel('move', 'arrakeen', 4)],
|
|
]);
|
|
});
|
|
|
|
void test('transport closure preserves actual shipment and unfinished Yes payment alternatives without inventing a release', () => {
|
|
const original = promise(group('and', travel('ship'), group('or', travel('move', 'arrakeen', 2), pay())));
|
|
const shipped = recordTurnActionShipment([original], 'respondent', 1, event());
|
|
const closed = closeTurnActionTransport(shipped, 'respondent', 1);
|
|
assert.equal(closed[0].transportClosed, true);
|
|
assert.equal(closed[0].paymentClosed, false);
|
|
assert.deepEqual(closed[0].shipment, { pending: false, event: event() });
|
|
assert.deepEqual(branches(closed[0]), [[signedPay()]]);
|
|
assert.equal(closed[0].fulfilled, false);
|
|
assert.equal(closed[0].released, false);
|
|
validateTurnActionPromises(closed, seats);
|
|
assert.equal(recordTurnActionMovement(closed, 'respondent', 1, event('arrakeen', 2))[0], closed[0]);
|
|
assert.equal(recordTurnActionPayment(closed, 'respondent', 1, payment())[0].fulfilled, true);
|
|
const impossible = closeTurnActionTransport([promise(travel('move'))], 'respondent', 1);
|
|
assert.deepEqual(branches(impossible[0]), []);
|
|
assert.equal(impossible[0].released, false, 'Native closure preflight decides whether the respondent may close');
|
|
validateTurnActionPromises(impossible, seats);
|
|
});
|
|
|
|
void test('whole No remains binding after transport closes through a later ordinary payment window', () => {
|
|
const original = promise(group('or', travel('move'), pay('recipient', 5)), false);
|
|
const closed = closeTurnActionTransport([original], 'respondent', 1);
|
|
assert.equal(closed[0].fulfilled, false);
|
|
assert.deepEqual(branches(closed[0]), [[signedPay('recipient', 5, 0, false)]]);
|
|
const partial = recordTurnActionPayment(closed, 'respondent', 1, payment('recipient', 4));
|
|
assert.equal(partial[0].fulfilled, false);
|
|
assert.deepEqual(branches(partial[0]), [[signedPay('recipient', 5, 4, false)]]);
|
|
assert.throws(() => recordTurnActionPayment(partial, 'respondent', 1, payment('recipient', 1)), TurnActionError);
|
|
validateTurnActionPromises(partial, seats);
|
|
const finished = finishTurnActionTurn(partial, 'respondent', 1);
|
|
assert.equal(finished[0].fulfilled, true);
|
|
assert.equal(finished[0].paymentClosed, true);
|
|
assert.equal(finished[0].released, false);
|
|
validateTurnActionPromises(finished, seats);
|
|
const transportOnly = closeTurnActionTransport([promise(travel('move'), false)], 'respondent', 1);
|
|
assert.equal(transportOnly[0].fulfilled, true);
|
|
const shipmentOnly = recordTurnActionShipment([promise(travel('ship'), false)], 'respondent', 1, null);
|
|
assert.equal(shipmentOnly[0].fulfilled, true);
|
|
});
|
|
|
|
void test('closed payment opportunities fold false while achieved payments fold true in remaining transport branches', () => {
|
|
const mixed = group('or', travel('move'), pay());
|
|
const closedPayment = { ...promise(mixed), paymentClosed: true };
|
|
assert.deepEqual(branches(closedPayment), [[signedTravel('move')]]);
|
|
assert.equal(recordTurnActionPayment([closedPayment], 'respondent', 1, payment())[0], closedPayment);
|
|
const achievedPayment = { ...promise(group('and', travel('move'), pay())), payments: [payment()] };
|
|
assert.deepEqual(branches(achievedPayment), [[signedTravel('move')]]);
|
|
const impossible = { ...promise(pay()), paymentClosed: true };
|
|
assert.deepEqual(branches(impossible), []);
|
|
validateTurnActionPromises([closedPayment], seats);
|
|
});
|
|
|
|
void test('actual turn expiry fulfills the aggregate answer or releases it and terminal rows never update', () => {
|
|
const yes = promise(group('and', travel('ship'), pay()));
|
|
const no = promise(group('and', travel('ship'), pay()), false, 'turn-action:2');
|
|
const externallyReleased = { ...promise(pay(), true, 'turn-action:3'), released: true };
|
|
const fulfilled = recordTurnActionPayment([promise(pay(), true, 'turn-action:4')], 'respondent', 1, payment())[0];
|
|
const finished = finishTurnActionTurn([yes, no, externallyReleased, fulfilled], 'respondent', 1);
|
|
assert.equal(finished[0].released, true);
|
|
assert.equal(finished[0].fulfilled, false);
|
|
assert.equal(finished[1].fulfilled, true);
|
|
assert.equal(finished[1].released, false);
|
|
assert.equal(finished[2], externallyReleased);
|
|
assert.equal(finished[3], fulfilled);
|
|
for (const record of finished.slice(0, 2)) {
|
|
assert.equal(record.transportClosed, true);
|
|
assert.equal(record.paymentClosed, true);
|
|
assert.equal(record.shipment.pending, false);
|
|
}
|
|
for (const transform of [
|
|
(list: TurnActionPromise[]) => recordTurnActionShipment(list, 'respondent', 1, event()),
|
|
(list: TurnActionPromise[]) => recordTurnActionMovement(list, 'respondent', 1, event()),
|
|
(list: TurnActionPromise[]) => recordTurnActionPayment(list, 'respondent', 1, payment()),
|
|
(list: TurnActionPromise[]) => closeTurnActionTransport(list, 'respondent', 1),
|
|
(list: TurnActionPromise[]) => finishTurnActionTurn(list, 'respondent', 1),
|
|
]) assert.ok(transform(finished).every((record, index) => record === finished[index]));
|
|
validateTurnActionPromises(finished, seats);
|
|
});
|
|
|
|
void test('frozen known and unknown facts retain whole-answer constants and original payment scope', () => {
|
|
for (const answer of [true, false]) {
|
|
for (const factAnswer of ['yes', 'no', 'unknown'] as const) {
|
|
for (const kind of ['and', 'or'] as const) {
|
|
const mixed = group(kind, fact(), pay());
|
|
const record = promise(mixed, answer);
|
|
record.compiled = compileMixedActionExpression(mixed, () => factAnswer, answer);
|
|
assert.deepEqual(record.mixed, mixed);
|
|
assert.equal(turnActionHasPayments(record), true);
|
|
if (record.compiled.kind === 'constant') {
|
|
assert.equal(turnActionValue(record), record.compiled.value);
|
|
assert.deepEqual(branches(record), record.compiled.value === answer ? [[]] : []);
|
|
if (record.compiled.value === answer) {
|
|
record.fulfilled = true;
|
|
validateTurnActionPromises([record], seats);
|
|
}
|
|
} else assert.deepEqual(branches(record), [[signedPay('recipient', 3, 0, answer)]]);
|
|
}
|
|
}
|
|
}
|
|
assert.equal(turnActionHasPayments(promise(travel('move'))), false);
|
|
});
|
|
|
|
void test('original and private turn-action expressions enforce sixteen total leaves and four group levels', () => {
|
|
assert.equal(TURN_ACTION_MAX_LEAVES, 16);
|
|
assert.equal(TURN_ACTION_MAX_DEPTH, 4);
|
|
const sixteen = group('and', ...Array.from({ length: 16 }, () => pay()));
|
|
assert.doesNotThrow(() => turnActionValue(promise(sixteen)));
|
|
const nested = (depth: number): Expression => depth === 0 ? pay() : group('or', travel('move'), nested(depth - 1));
|
|
assert.doesNotThrow(() => turnActionValue(promise(nested(4))));
|
|
for (const mixed of [nested(5), group('or', ...Array.from({ length: 17 }, () => pay())),
|
|
group('and', group('or', ...Array.from({ length: 9 }, () => pay())),
|
|
group('or', ...Array.from({ length: 8 }, () => travel('move'))))])
|
|
assert.throws(() => turnActionValue(promise(mixed)), TurnActionError);
|
|
const manyFacts: Expression = { kind: 'fact', fact: { kind: 'and', terms: Array.from({ length: 16 }, () =>
|
|
({ kind: 'spice', compare: 'gte', value: 5 })) } };
|
|
assert.throws(() => turnActionValue(promise(group('and', manyFacts, pay()))), TurnActionError,
|
|
'The fact wrapper shares the original logical budget');
|
|
const original = promise(pay());
|
|
const compiled = { kind: 'and', terms: Array.from({ length: 17 }, () => original.compiled) };
|
|
assert.throws(() => turnActionValue({ ...original, compiled } as TurnActionPromise), TurnActionError);
|
|
const nestedPrivate = (depth: number): TurnActionPromise['compiled'] => depth === 0 ? original.compiled :
|
|
{ kind: 'or', terms: [{ kind: 'constant', value: true }, nestedPrivate(depth - 1)] };
|
|
assert.throws(() => turnActionValue({ ...original, compiled: nestedPrivate(5) }), TurnActionError,
|
|
'A decisive private constant cannot skip an over-depth later clause');
|
|
});
|
|
|
|
void test('safe payment accumulation is immutable and rejects overflow even in a nonselected alternative', () => {
|
|
const original = promise(group('or', pay('recipient', Number.MAX_SAFE_INTEGER), travel('move')));
|
|
const partial = recordTurnActionPayment([original], 'respondent', 1,
|
|
payment('recipient', Number.MAX_SAFE_INTEGER - 1));
|
|
const before = structuredClone(partial);
|
|
assert.throws(() => recordTurnActionPayment(partial, 'respondent', 1, payment('recipient', 2)), TurnActionError);
|
|
assert.deepEqual(partial, before);
|
|
const ordinary = promise(group('and', pay('recipient', 5), travel('move')), true, 'turn-action:2');
|
|
const list = [ordinary, partial[0]];
|
|
assert.throws(() => recordTurnActionPayment(list, 'respondent', 1, payment('recipient', 2)), TurnActionError);
|
|
assert.deepEqual(ordinary.payments, []);
|
|
const complete = recordTurnActionPayment(partial, 'respondent', 1, payment('recipient', 1));
|
|
assert.equal(complete[0].fulfilled, true);
|
|
assert.deepEqual(complete[0].payments, [payment('recipient', Number.MAX_SAFE_INTEGER)]);
|
|
});
|
|
|
|
void test('stored rows reject missing or extra metadata, foreign private leaves and malformed native receipts', () => {
|
|
const original = promise(group('and', travel('ship'), travel('move'), pay()));
|
|
validateTurnActionPromises([original], seats);
|
|
const corruptions: unknown[] = [
|
|
{ ...original, turn: 0 }, { ...original, event: '' }, { ...original, player: ' respondent' },
|
|
{ ...original, order: 1 }, { ...original, answer: 'yes' }, { ...original, fulfilled: undefined },
|
|
{ ...original, paymentClosed: undefined }, { ...original, transportClosed: 'yes' },
|
|
{ ...original, fulfilled: true, released: true },
|
|
{ ...original, shipment: { pending: true, event: event() } },
|
|
{ ...original, shipment: { pending: false, event: { ...event(), elite: 1 } } },
|
|
{ ...original, shipment: { pending: true, event: null }, transportClosed: true },
|
|
{ ...original, progress: [{ territory: 'carthag', maximum: 21 }] },
|
|
{ ...original, progress: [{ territory: 'arrakeen', maximum: 3 }] },
|
|
{ ...original, progress: [{ territory: 'carthag', maximum: 3, amount: 3 }] },
|
|
{ ...original, progress: [{ territory: 'carthag', maximum: 1 }, { territory: 'carthag', maximum: 2 }] },
|
|
{ ...original, payments: [payment('other')] },
|
|
{ ...original, payments: [payment(), payment()] },
|
|
{ ...original, payments: [payment('recipient', Number.MAX_SAFE_INTEGER + 1)] },
|
|
{ ...original, payments: [{ ...payment(), received: true }] },
|
|
{ ...original, compiled: { kind: 'constant', value: 'unknown' } },
|
|
{ ...original, compiled: { kind: 'constant', value: true, answer: true } },
|
|
{ ...original, compiled: { kind: 'action', action: { kind: 'payment', recipient: 'other', minimum: 3 } } },
|
|
{ ...original, compiled: { kind: 'action', action: { kind: 'move', territory: 'carthag', minimum: 4 } } },
|
|
{ ...original, compiled: { kind: 'and', terms: [] } },
|
|
{ ...original, mixed: { kind: 'constant', value: true } },
|
|
{ ...original, mixed: { kind: 'action', action: { kind: 'payment', recipient: 'recipient', minimum: 3, progress: 0 } } },
|
|
{ ...original, mixed: fact() },
|
|
];
|
|
for (const field of Object.keys(original)) {
|
|
const missing: Record<string, unknown> = { ...original };
|
|
delete missing[field];
|
|
corruptions.push(missing);
|
|
}
|
|
for (const corrupted of corruptions)
|
|
assert.throws(() => turnActionValue(corrupted as TurnActionPromise), TurnActionError);
|
|
for (const corrupted of [{ ...original, asker: 'respondent' }, { ...original, player: 'missing' },
|
|
{ ...original, fulfilled: true }, { ...original, mixed: pay('missing'), compiled: promise(pay('missing')).compiled },
|
|
{ ...original, mixed: pay('respondent'), compiled: promise(pay('respondent')).compiled },
|
|
{ ...original, answer: false, shipment: { pending: false, event: event() },
|
|
progress: [{ territory: 'carthag', maximum: 3 }], payments: [payment()] },
|
|
{ ...original, answer: false, fulfilled: true }])
|
|
assert.throws(() => validateTurnActionPromises([corrupted], seats), TurnActionError);
|
|
assert.throws(() => validateTurnActionPromises([original, original], seats), TurnActionError);
|
|
for (const invalid of [{ ...event(), amount: 21 }, { ...event(), amount: -1 },
|
|
{ ...event(), amount: 2.5 }, { ...event(), amount: '3' },
|
|
{ ...event(), territory: 'missing' }, { ...event(), elite: 1 }]) {
|
|
assert.throws(() => recordTurnActionMovement([original], 'respondent', 1, invalid as never), TurnActionError);
|
|
assert.throws(() => recordTurnActionShipment([original], 'respondent', 1, invalid as never), TurnActionError);
|
|
}
|
|
for (const invalid of [{ ...payment(), amount: 0 }, { ...payment(), amount: -1 },
|
|
{ ...payment(), amount: 1.5 }, { ...payment(), amount: Number.MAX_SAFE_INTEGER + 1 },
|
|
{ ...payment(), recipient: '' }, { ...payment(), received: true }])
|
|
assert.throws(() => recordTurnActionPayment([original], 'respondent', 1, invalid as never), TurnActionError);
|
|
});
|
|
|
|
void test('new preparation leaves reuse strict native bid and typed Revival parsers without changing old rows', () => {
|
|
for (const leaf of [{ kind: 'bid', lot: 1, minimum: Number.MAX_SAFE_INTEGER },
|
|
{ kind: 'forces', counter: 'elite', minimum: 20 }, { kind: 'leader', leader: 'atreides-0' }]) {
|
|
assert.deepEqual(parseTurnActionLeaf(leaf), leaf);
|
|
assert.notEqual(parseTurnActionLeaf(leaf), leaf);
|
|
}
|
|
for (const leaf of [{ kind: 'bid', lot: 0, minimum: 1 }, { kind: 'bid', lot: 1, minimum: 0 },
|
|
{ kind: 'bid', lot: 1, minimum: 1, source: 'hidden' }, { kind: 'bid', lot: 1, minimum: 1, progress: 0 },
|
|
{ kind: 'forces', counter: 'normal', minimum: 21 }, { kind: 'forces', counter: 'other', minimum: 1 },
|
|
{ kind: 'forces', counter: 'normal', minimum: 1, amount: 1 },
|
|
{ kind: 'leader', leader: '' }, { kind: 'leader', leader: 'atreides-0', answer: true }])
|
|
assert.throws(() => parseTurnActionLeaf(leaf), TurnActionError);
|
|
const old = promise(group('and', pay(), travel('move')));
|
|
validateTurnActionPromises([old], seats);
|
|
assert.equal('preparation' in recordTurnActionPayment([old], 'respondent', 1, payment())[0], false);
|
|
for (const mixed of [bid(), forces(), leader()])
|
|
assert.throws(() => turnActionValue(promise(mixed)), TurnActionError);
|
|
const folded = prepared(group('or', fact(), bid()));
|
|
delete folded.preparation;
|
|
assert.throws(() => turnActionValue(folded), TurnActionError, 'Folded original bid leaves still retain their physical source');
|
|
});
|
|
|
|
void test('bid progress retains a maximum accepted declaration from one future original lot and answer interval', () => {
|
|
const original = prepared(group('and', bid(7), pay()));
|
|
const once = recordTurnActionBid([original], 'respondent', 1, { lot: 1, source: 'original-lot:1', amount: 3 });
|
|
const twice = recordTurnActionBid(once, 'respondent', 1, { lot: 1, source: 'original-lot:1', amount: 5 });
|
|
assert.equal(twice[0].preparation!.bid!.maximum, 5);
|
|
assert.equal(turnActionValue(twice[0]), false, 'Three and five never combine into an eight-spice bid');
|
|
assert.deepEqual(branches(twice[0]), [[{ kind: 'bid', lot: 1, source: 'original-lot:1', minimum: 7, answer: true }, signedPay()]]);
|
|
for (const event of [{ lot: 1, source: 'other-lot', amount: 9 }, { lot: 2, source: 'original-lot:1', amount: 9 },
|
|
{ lot: 1, source: 'original-lot:1', amount: 4 }])
|
|
assert.equal(recordTurnActionBid(twice, 'respondent', 1, event)[0], twice[0]);
|
|
const fresh = prepared(group('and', bid(7), pay()), true, 'turn-action:2');
|
|
const combined = recordTurnActionBid([twice[0], fresh], 'respondent', 1, { lot: 1, source: 'original-lot:1', amount: 4 });
|
|
assert.equal(combined[0].preparation!.bid!.maximum, 5);
|
|
assert.equal(combined[1].preparation!.bid!.maximum, 4);
|
|
const accepted = recordTurnActionBid(combined, 'respondent', 1, { lot: 1, source: 'original-lot:1', amount: 7 });
|
|
assert.deepEqual(branches(accepted[0]), [[signedPay()]]);
|
|
assert.equal(original.preparation!.bid!.maximum, 0);
|
|
assert.equal(recordTurnActionBid(accepted, 'other', 1, { lot: 1, source: 'original-lot:1', amount: 20 })[0], accepted[0]);
|
|
assert.equal(recordTurnActionBid(accepted, 'respondent', 2, { lot: 1, source: 'original-lot:1', amount: 20 })[0], accepted[0]);
|
|
});
|
|
|
|
void test('ordinary Revival accumulates typed physical returns and records each personal leader identity once', () => {
|
|
const original = prepared(group('and', forces(5), forces(3, 'normal'), forces(2, 'elite'), leader(), pay()));
|
|
const once = recordTurnActionRevival([original], 'respondent', 1, { kind: 'forces', amount: 3, elite: 1 });
|
|
assert.deepEqual(once[0].preparation!.revival, { total: 3, normal: 2, elite: 1, leaders: [], closed: false });
|
|
assert.deepEqual(branches(once[0]), [[
|
|
{ kind: 'forces', counter: 'total', minimum: 5, progress: 3, answer: true },
|
|
{ kind: 'forces', counter: 'normal', minimum: 3, progress: 2, answer: true },
|
|
{ kind: 'forces', counter: 'elite', minimum: 2, progress: 1, answer: true },
|
|
{ kind: 'leader', leader: 'atreides-0', answer: true }, signedPay(),
|
|
]]);
|
|
const twice = recordTurnActionRevival(once, 'respondent', 1, { kind: 'forces', amount: 2, elite: 1 });
|
|
const returned = recordTurnActionRevival(twice, 'respondent', 1, { kind: 'leader', leader: 'atreides-0' });
|
|
assert.deepEqual(returned[0].preparation!.revival, { total: 5, normal: 3, elite: 2, leaders: ['atreides-0'], closed: false });
|
|
assert.equal(recordTurnActionRevival(returned, 'respondent', 1, { kind: 'leader', leader: 'atreides-0' })[0], returned[0]);
|
|
assert.deepEqual(branches(returned[0]), [[signedPay()]]);
|
|
assert.equal(recordTurnActionPayment(returned, 'respondent', 1, payment())[0].fulfilled, true);
|
|
assert.equal(original.preparation!.revival!.total, 0);
|
|
const fresh = prepared(group('and', forces(5), pay()), true, 'turn-action:2');
|
|
const intervals = recordTurnActionRevival([returned[0], fresh], 'respondent', 1, { kind: 'forces', amount: 1, elite: 0 });
|
|
assert.equal(intervals[0].preparation!.revival!.total, 6);
|
|
assert.equal(intervals[1].preparation!.revival!.total, 1);
|
|
});
|
|
|
|
void test('cross-preparation whole No uses De Morgan and rejects the actual event completing its aggregate', () => {
|
|
const original = prepared(group('and', bid(4), group('or', forces(2), leader())), false);
|
|
assert.deepEqual(branches(original), [[{ kind: 'bid', lot: 1, source: 'original-lot:1', minimum: 4, answer: false }],
|
|
[{ kind: 'forces', counter: 'total', minimum: 2, progress: 0, answer: false },
|
|
{ kind: 'leader', leader: 'atreides-0', answer: false }]]);
|
|
const accepted = recordTurnActionBid([original], 'respondent', 1, { lot: 1, source: 'original-lot:1', amount: 4 });
|
|
const before = structuredClone(accepted);
|
|
assert.throws(() => recordTurnActionRevival(accepted, 'respondent', 1, { kind: 'forces', amount: 2, elite: 0 }), TurnActionError);
|
|
assert.throws(() => recordTurnActionRevival(accepted, 'respondent', 1, { kind: 'leader', leader: 'atreides-0' }), TurnActionError);
|
|
assert.deepEqual(accepted, before);
|
|
const orNo = prepared(group('or', bid(4), leader()), false);
|
|
assert.throws(() => recordTurnActionBid([orNo], 'respondent', 1, { lot: 1, source: 'original-lot:1', amount: 4 }), TurnActionError);
|
|
assert.throws(() => recordTurnActionRevival([orNo], 'respondent', 1, { kind: 'leader', leader: 'atreides-0' }), TurnActionError);
|
|
});
|
|
|
|
void test('Bidding and Revival close independently while transport closure preserves both preparation alternatives', () => {
|
|
const original = prepared(group('or', bid(), forces(), pay()));
|
|
const transport = closeTurnActionTransport([original], 'respondent', 1);
|
|
assert.equal(transport[0].preparation!.bid!.closed, false);
|
|
assert.equal(transport[0].preparation!.revival!.closed, false);
|
|
const wrong = closeTurnActionBidding(transport, 1, 'other-lot');
|
|
assert.equal(wrong[0], transport[0]);
|
|
assert.equal(closeTurnActionBidding(transport, 1, 'original-lot:1', 'other')[0], transport[0]);
|
|
const bidding = closeTurnActionBidding(transport, 1, 'original-lot:1', 'respondent');
|
|
assert.equal(bidding[0].preparation!.bid!.closed, true);
|
|
assert.equal(bidding[0].preparation!.revival!.closed, false);
|
|
const revival = closeTurnActionRevival(bidding, 'respondent', 1);
|
|
assert.deepEqual(branches(revival[0]), [[signedPay()]]);
|
|
assert.equal(revival[0].released, false);
|
|
assert.equal(recordTurnActionBid(revival, 'respondent', 1, { lot: 1, source: 'original-lot:1', amount: 20 })[0], revival[0]);
|
|
assert.equal(recordTurnActionRevival(revival, 'respondent', 1, { kind: 'forces', amount: 20, elite: 0 })[0], revival[0]);
|
|
const no = prepared(group('and', bid(), leader()), false);
|
|
const bidClosed = closeTurnActionBidding([no], 1, 'original-lot:1');
|
|
assert.equal(bidClosed[0].fulfilled, false);
|
|
assert.equal(closeTurnActionRevival(bidClosed, 'respondent', 1)[0].fulfilled, true);
|
|
const paidOnlyClosed = { ...original, transportClosed: true, paymentClosed: true,
|
|
shipment: { pending: false, event: null } };
|
|
validateTurnActionPromises([paidOnlyClosed], seats);
|
|
});
|
|
|
|
void test('same-source bid and force bounds merge strongest thresholds without combining distinct typed counters', () => {
|
|
const mixed = group('and', bid(3), bid(5), forces(2, 'normal'), forces(4, 'normal'), forces(1, 'elite'), leader(), leader());
|
|
assert.deepEqual(branches(prepared(mixed)), [[
|
|
{ kind: 'bid', lot: 1, source: 'original-lot:1', minimum: 5, answer: true },
|
|
{ kind: 'forces', counter: 'normal', minimum: 4, progress: 0, answer: true },
|
|
{ kind: 'forces', counter: 'elite', minimum: 1, progress: 0, answer: true },
|
|
{ kind: 'leader', leader: 'atreides-0', answer: true },
|
|
]]);
|
|
const no = prepared(group('or', bid(3), bid(5), forces(2), forces(4)), false);
|
|
assert.deepEqual(branches(no), [[
|
|
{ kind: 'bid', lot: 1, source: 'original-lot:1', minimum: 3, answer: false },
|
|
{ kind: 'forces', counter: 'total', minimum: 2, progress: 0, answer: false },
|
|
]]);
|
|
});
|
|
|
|
void test('full expiry closes every preparation stage while terminal rows preserve their original progress and deadlines', () => {
|
|
const original = prepared(group('and', bid(), forces(), leader(), pay()));
|
|
const no = prepared(group('and', bid(), forces(), leader(), pay()), false, 'turn-action:2');
|
|
const finished = finishTurnActionTurn([original, no], 'respondent', 1);
|
|
assert.equal(finished[0].released, true);
|
|
assert.equal(finished[1].fulfilled, true);
|
|
for (const row of finished) {
|
|
assert.equal(row.preparation!.bid!.closed, true);
|
|
assert.equal(row.preparation!.revival!.closed, true);
|
|
}
|
|
for (const transform of [
|
|
(rows: TurnActionPromise[]) => recordTurnActionBid(rows, 'respondent', 1, { lot: 1, source: 'original-lot:1', amount: 20 }),
|
|
(rows: TurnActionPromise[]) => recordTurnActionRevival(rows, 'respondent', 1, { kind: 'forces', amount: 20, elite: 0 }),
|
|
(rows: TurnActionPromise[]) => closeTurnActionBidding(rows, 1, 'original-lot:1'),
|
|
(rows: TurnActionPromise[]) => closeTurnActionRevival(rows, 'respondent', 1),
|
|
]) assert.ok(transform(finished).every((row, index) => row === finished[index]));
|
|
validateTurnActionPromises(finished, seats);
|
|
});
|
|
|
|
void test('preparation metadata and actual events reject foreign sources, mismatched stages and impossible typed totals', () => {
|
|
const original = prepared(group('and', bid(), forces(), leader()));
|
|
for (const preparation of [undefined, null, {}, { bid: null, revival: null },
|
|
{ ...original.preparation, hidden: true },
|
|
{ ...original.preparation, bid: { ...original.preparation!.bid!, lot: 2 } },
|
|
{ ...original.preparation, bid: { ...original.preparation!.bid!, source: '' } },
|
|
{ ...original.preparation, bid: { ...original.preparation!.bid!, maximum: -1 } },
|
|
{ ...original.preparation, bid: { ...original.preparation!.bid!, maximum: Number.MAX_SAFE_INTEGER + 1 } },
|
|
{ ...original.preparation, revival: { ...original.preparation!.revival!, total: 2, normal: 1 } },
|
|
{ ...original.preparation, revival: { ...original.preparation!.revival!, leaders: ['atreides-0', 'atreides-0'] } },
|
|
{ ...original.preparation, revival: { ...original.preparation!.revival!, closed: 'yes' } }])
|
|
assert.throws(() => turnActionValue({ ...original, preparation } as TurnActionPromise), TurnActionError);
|
|
assert.throws(() => turnActionValue(prepared(group('or', bid(1, 1), bid(1, 2)))), TurnActionError);
|
|
for (const invalid of [{ lot: 0, source: 'original-lot:1', amount: 1 }, { lot: 1, source: '', amount: 1 },
|
|
{ lot: 1, source: 'original-lot:1', amount: 0 }, { lot: 1, source: 'original-lot:1', amount: 1, answer: true }])
|
|
assert.throws(() => recordTurnActionBid([original], 'respondent', 1, invalid), TurnActionError);
|
|
for (const invalid of [{ kind: 'forces', amount: 2, elite: 3 }, { kind: 'forces', amount: 21, elite: 0 },
|
|
{ kind: 'forces', amount: 2, elite: 0, source: 'ghola' }, { kind: 'leader', leader: 'atreides-0', card: 'ghola' }])
|
|
assert.throws(() => recordTurnActionRevival([original], 'respondent', 1, invalid as never), TurnActionError);
|
|
const full = { ...original, preparation: { ...original.preparation!,
|
|
revival: { total: 20, normal: 20, elite: 0, leaders: [], closed: false } } };
|
|
const before = structuredClone(full);
|
|
assert.throws(() => recordTurnActionRevival([full], 'respondent', 1, { kind: 'forces', amount: 1, elite: 0 }), TurnActionError);
|
|
assert.deepEqual(full, before);
|
|
});
|
|
|
|
void test('final-alliance leaves use exact public partner fields and require a private original Nexus stage', () => {
|
|
const leaf = { kind: 'alliance', partner: 'recipient' };
|
|
assert.deepEqual(parseTurnActionLeaf(leaf), leaf);
|
|
assert.notEqual(parseTurnActionLeaf(leaf), leaf);
|
|
for (const invalid of [{ ...leaf, partner: '' }, { ...leaf, partner: ' recipient' },
|
|
{ ...leaf, source: 'nexus:1' }, { ...leaf, closed: true }, { ...leaf, answer: true },
|
|
{ ...leaf, turn: 1 }, { ...leaf, minimum: 1 }])
|
|
assert.throws(() => parseTurnActionLeaf(invalid), TurnActionError);
|
|
assert.throws(() => turnActionValue(promise(alliance())), TurnActionError);
|
|
const folded = promise(group('or', fact(), alliance()));
|
|
assert.equal(folded.compiled.kind, 'constant');
|
|
assert.throws(() => turnActionValue(folded), TurnActionError, 'Original alliance clauses require their source even after folding');
|
|
validateTurnActionPromises([nexus(group('and', alliance(), pay()))], seats);
|
|
validateTurnActionPromises([{ ...prepared(group('and', bid(), forces())),
|
|
alliance: { source: 'nexus:1', partner: null, closed: false } }], seats);
|
|
assert.equal('alliance' in closeTurnActionTransport([promise(pay())], 'respondent', 1)[0], false);
|
|
});
|
|
|
|
void test('open final membership remains unresolved and lazy branches retain whole AND OR and No meaning', () => {
|
|
const original = nexus(group('or', alliance(), pay()));
|
|
assert.equal(turnActionValue(original), false);
|
|
assert.deepEqual(branches(original), [[{ kind: 'alliance', partner: 'recipient', source: 'nexus:1', answer: true }], [signedPay()]]);
|
|
assert.deepEqual(branches(nexus(group('and', alliance(), pay()), false)), [
|
|
[{ kind: 'alliance', partner: 'recipient', source: 'nexus:1', answer: false }],
|
|
[signedPay('recipient', 3, 0, false)],
|
|
]);
|
|
assert.deepEqual(branches(nexus(group('or', alliance(), pay()), false)), [[
|
|
{ kind: 'alliance', partner: 'recipient', source: 'nexus:1', answer: false }, signedPay('recipient', 3, 0, false),
|
|
]]);
|
|
assert.deepEqual(branches(nexus(group('and', alliance(), alliance()))), [[
|
|
{ kind: 'alliance', partner: 'recipient', source: 'nexus:1', answer: true },
|
|
]]);
|
|
assert.deepEqual(branches(nexus(group('and', alliance(), alliance('other')))), [],
|
|
'One final source has only one final partner');
|
|
assert.deepEqual(branches(nexus(group('or', alliance(), alliance('other')))), [
|
|
[{ kind: 'alliance', partner: 'recipient', source: 'nexus:1', answer: true }],
|
|
[{ kind: 'alliance', partner: 'other', source: 'nexus:1', answer: true }],
|
|
]);
|
|
});
|
|
|
|
void test('exact Nexus closure snapshots final membership once and preserves later payment alternatives', () => {
|
|
const original = nexus(group('and', alliance(), pay()));
|
|
assert.equal(settleTurnActionAlliance([original], 1, 'other-nexus', { respondent: 'recipient' })[0], original);
|
|
assert.equal(settleTurnActionAlliance([original], 2, 'nexus:1', { respondent: 'recipient' })[0], original);
|
|
const closed = settleTurnActionAlliance([original], 1, 'nexus:1', { respondent: 'recipient' });
|
|
assert.deepEqual(closed[0].alliance, { source: 'nexus:1', partner: 'recipient', closed: true });
|
|
assert.equal(closed[0].fulfilled, false);
|
|
assert.deepEqual(branches(closed[0]), [[signedPay()]]);
|
|
assert.equal(settleTurnActionAlliance(closed, 1, 'nexus:1', { respondent: 'other' })[0], closed[0]);
|
|
assert.equal(recordTurnActionPayment(closed, 'respondent', 1, payment())[0].fulfilled, true);
|
|
assert.deepEqual(original.alliance, { source: 'nexus:1', partner: null, closed: false });
|
|
const alternative = settleTurnActionAlliance([nexus(group('or', alliance(), pay()))], 1, 'nexus:1', { respondent: null });
|
|
assert.equal(alternative[0].fulfilled, false);
|
|
assert.equal(alternative[0].released, false);
|
|
assert.deepEqual(branches(alternative[0]), [[signedPay()]]);
|
|
assert.equal(recordTurnActionPayment(alternative, 'respondent', 1, payment())[0].fulfilled, true);
|
|
validateTurnActionPromises(alternative, seats);
|
|
});
|
|
|
|
void test('a whole No made true by final membership releases while later actual payments still reject live No violations', () => {
|
|
const no = nexus(alliance(), false);
|
|
const conflict = settleTurnActionAlliance([no], 1, 'nexus:1', { respondent: 'recipient' });
|
|
assert.equal(conflict[0].released, true);
|
|
assert.equal(conflict[0].fulfilled, false);
|
|
assert.equal(turnActionValue(conflict[0]), true);
|
|
validateTurnActionPromises(conflict, seats);
|
|
const beforePayment = nexus(group('and', alliance(), pay()), false);
|
|
const matching = settleTurnActionAlliance([beforePayment], 1, 'nexus:1', { respondent: 'recipient' });
|
|
assert.equal(matching[0].released, false);
|
|
assert.equal(matching[0].fulfilled, false);
|
|
assert.deepEqual(branches(matching[0]), [[signedPay('recipient', 3, 0, false)]]);
|
|
assert.throws(() => recordTurnActionPayment(matching, 'respondent', 1, payment()), TurnActionError);
|
|
const paidFirst = recordTurnActionPayment([beforePayment], 'respondent', 1, payment());
|
|
assert.equal(paidFirst[0].released, false);
|
|
const conflictAfterPayment = settleTurnActionAlliance(paidFirst, 1, 'nexus:1', { respondent: 'recipient' });
|
|
assert.equal(conflictAfterPayment[0].released, true);
|
|
const nonmatching = settleTurnActionAlliance([beforePayment], 1, 'nexus:1', { respondent: null });
|
|
assert.equal(nonmatching[0].fulfilled, false, 'Whole No still waits for its remaining payment opportunity');
|
|
const finished = finishTurnActionTurn(nonmatching, 'respondent', 1);
|
|
assert.equal(finished[0].fulfilled, true);
|
|
const plainNo = settleTurnActionAlliance([no], 1, 'nexus:1', { respondent: 'other' });
|
|
assert.equal(plainNo[0].fulfilled, true);
|
|
assert.equal(plainNo[0].released, false);
|
|
});
|
|
|
|
void test('expiry releases an unresolved original Nexus without inventing membership and preserves every terminal row', () => {
|
|
const originals = [nexus(alliance()), nexus(alliance(), false, 'turn-action:2')];
|
|
const finished = finishTurnActionTurn(originals, 'respondent', 1);
|
|
for (const record of finished) {
|
|
assert.equal(record.released, true);
|
|
assert.equal(record.fulfilled, false);
|
|
assert.deepEqual(record.alliance, { source: 'nexus:1', partner: null, closed: false });
|
|
}
|
|
const paid = recordTurnActionPayment([nexus(group('or', alliance(), pay()), true, 'turn-action:3')],
|
|
'respondent', 1, payment())[0];
|
|
assert.equal(paid.fulfilled, true);
|
|
assert.equal(finishTurnActionTurn([paid], 'respondent', 1)[0], paid);
|
|
const terminal = [...finished, paid];
|
|
assert.ok(settleTurnActionAlliance(terminal, 1, 'nexus:1', { respondent: 'recipient' })
|
|
.every((row, index) => row === terminal[index]));
|
|
assert.ok(recordTurnActionPayment(terminal, 'respondent', 1, payment())
|
|
.every((row, index) => row === terminal[index]));
|
|
validateTurnActionPromises(terminal, seats);
|
|
});
|
|
|
|
void test('final-membership stages reject temporary pairs, extra metadata, missing snapshot players and foreign partner clauses', () => {
|
|
const original = nexus(group('and', alliance(), pay()));
|
|
for (const stage of [undefined, null, {}, { source: '', partner: null, closed: false },
|
|
{ source: 'nexus:1', partner: 'recipient', closed: false }, { source: 'nexus:1', partner: 'respondent', closed: true },
|
|
{ source: 'nexus:1', partner: null, closed: 'yes' }, { source: 'nexus:1', partner: null, closed: false, offers: {} }])
|
|
assert.throws(() => turnActionValue({ ...original, alliance: stage } as TurnActionPromise), TurnActionError);
|
|
assert.throws(() => settleTurnActionAlliance([original], 1, 'nexus:1', {}), TurnActionError);
|
|
assert.throws(() => settleTurnActionAlliance([original], 1, 'nexus:1', { respondent: 'respondent' }), TurnActionError);
|
|
for (const partner of ['missing', 'respondent'])
|
|
assert.throws(() => validateTurnActionPromises([nexus(alliance(partner))], seats), TurnActionError);
|
|
const foreignSnapshot = { ...original, alliance: { source: 'nexus:1', partner: 'missing', closed: true } };
|
|
assert.throws(() => validateTurnActionPromises([foreignSnapshot], seats), TurnActionError);
|
|
const foreignCompiled = { ...original, compiled: { kind: 'action', action: { kind: 'alliance', partner: 'other' } } };
|
|
assert.throws(() => turnActionValue(foreignCompiled as TurnActionPromise), TurnActionError);
|
|
});
|
|
|
|
void test('combat leaves accept only one original native plan atom or actual declaration in the original battle', () => {
|
|
const claims: TurnActionPlanValue['claim'][] = [{ kind: 'dial', compare: 'eq', value: 1.5 },
|
|
{ kind: 'support', compare: 'gte', value: 2 }, { kind: 'weapon', name: null },
|
|
{ kind: 'defense', name: null }, { kind: 'leader', leader: 'structural-leader-id' }, { kind: 'kwisatz', use: false }];
|
|
for (const claim of claims) {
|
|
const leaf = { kind: 'battlePlan', battle: 'battle:1', territory: 'carthag', claim };
|
|
assert.deepEqual(parseTurnActionLeaf(leaf), leaf);
|
|
assert.notEqual(parseTurnActionLeaf(leaf), leaf);
|
|
}
|
|
for (const choice of [true, false]) assert.deepEqual(parseTurnActionLeaf({ kind: 'traitorCall', battle: 'battle:1',
|
|
territory: 'carthag', call: choice }), { kind: 'traitorCall', battle: 'battle:1', territory: 'carthag', call: choice });
|
|
const original = { kind: 'battlePlan', battle: 'battle:1', territory: 'carthag', claim: dial().claim };
|
|
for (const leaf of [{ ...original, battle: '' }, { ...original, territory: '' }, { ...original, answer: true },
|
|
{ ...original, claim: { kind: 'and', terms: [dial().claim, dial().claim] } },
|
|
{ ...original, claim: { kind: 'dial', compare: 'eq', value: 1.25 } },
|
|
{ ...original, claim: { kind: 'leader', leader: ' untrimmed' } },
|
|
{ kind: 'traitorCall', battle: 'battle:1', territory: 'carthag', call: 'yes' },
|
|
{ kind: 'traitorCall', battle: 'battle:1', territory: 'carthag', call: true, canReveal: true }])
|
|
assert.throws(() => parseTurnActionLeaf(leaf), TurnActionError);
|
|
for (const mixed of [plan(), call(), group('or', fact(), plan()), group('or', fact(), call())])
|
|
assert.throws(() => turnActionValue(promise(mixed)), TurnActionError);
|
|
});
|
|
|
|
void test('combat whole AND OR and No branches retain original plan atoms and actual declaration polarity', () => {
|
|
const planLeaf = { kind: 'battlePlan', battle: 'battle:1', territory: 'carthag', claim: dial().claim, answer: true };
|
|
const traitorLeaf = { kind: 'traitorCall', battle: 'battle:1', territory: 'carthag', call: true, answer: true,
|
|
beneficiary: 'respondent', target: 'other', leader: 'other-0' };
|
|
assert.deepEqual(branches(combat(group('and', plan(), call(), pay()))), [[planLeaf, traitorLeaf, signedPay()]]);
|
|
assert.deepEqual(branches(combat(group('or', plan(), call(), pay()))), [[planLeaf], [traitorLeaf], [signedPay()]]);
|
|
assert.deepEqual(branches(combat(group('and', plan(), call()), false)), [
|
|
[{ ...planLeaf, answer: false }], [{ ...traitorLeaf, answer: false }],
|
|
]);
|
|
assert.deepEqual(branches(combat(group('or', call(true), call(false)), false)), [],
|
|
'No declaration satisfies No to the OR of actual Reveal and actual Decline');
|
|
assert.deepEqual(branches(combat(group('and', call(true), call(false)))), [],
|
|
'One original native declaration cannot both Reveal and Decline');
|
|
assert.deepEqual(branches(combat(group('and', plan(), plan()))), [[planLeaf]]);
|
|
});
|
|
|
|
void test('one actual plan receipt projects exact original predicates into distinct answer intervals and then permits later payment', () => {
|
|
const weapon: TurnActionPlanValue = { claim: { kind: 'weapon', name: null }, value: true };
|
|
const first = combat(group('and', plan(), pay()));
|
|
const second = combat(group('and', plan(weapon.claim), plan(weapon.claim), pay()), true, 'turn-action:2');
|
|
const rows = recordTurnActionPlan([first, second], 'respondent', 1, 'battle:1', 'carthag', [dial(), weapon]);
|
|
assert.deepEqual(rows[0].combat!.plan, { closed: true, values: [dial()] });
|
|
assert.deepEqual(rows[1].combat!.plan, { closed: true, values: [weapon] });
|
|
assert.deepEqual(branches(rows[0]), [[signedPay()]]);
|
|
assert.equal(rows[0].fulfilled, false);
|
|
assert.equal(recordTurnActionPayment(rows, 'respondent', 1, payment())[0].fulfilled, true);
|
|
const fresh = combat(group('and', plan(), pay()), true, 'turn-action:3');
|
|
assert.equal(fresh.combat!.plan!.values, null);
|
|
assert.equal(recordTurnActionPlan(rows, 'respondent', 1, 'battle:1', 'carthag', [dial(false), weapon])[0], rows[0]);
|
|
assert.equal(recordTurnActionPlan([fresh], 'respondent', 1, 'other-battle', 'carthag', [dial()])[0], fresh);
|
|
assert.equal(recordTurnActionPlan([fresh], 'respondent', 1, 'battle:1', 'arrakeen', [dial()])[0], fresh);
|
|
assert.equal(recordTurnActionPlan([fresh], 'respondent', 2, 'battle:1', 'carthag', [dial()])[0], fresh);
|
|
assert.equal(recordTurnActionPlan([fresh], 'other', 1, 'battle:1', 'carthag', [dial()])[0], fresh);
|
|
assert.equal(first.combat!.plan!.values, null);
|
|
validateTurnActionPromises(rows, seats);
|
|
});
|
|
|
|
void test('actual plan and declaration events reject whole No violations atomically and retain dynamic alternatives', () => {
|
|
const no = combat(group('and', plan(), call()), false);
|
|
const planned = recordTurnActionPlan([no], 'respondent', 1, 'battle:1', 'carthag', [dial()]);
|
|
const before = structuredClone(planned);
|
|
assert.throws(() => recordTurnActionTraitor(planned, 'respondent', 1, 'battle:1', 'carthag', true), TurnActionError);
|
|
assert.deepEqual(planned, before);
|
|
const declined = recordTurnActionTraitor(planned, 'respondent', 1, 'battle:1', 'carthag', false);
|
|
assert.equal(declined[0].fulfilled, true);
|
|
const yes = combat(group('and', plan(), pay()), true, 'turn-action:2');
|
|
const planNo = combat(plan(), false, 'turn-action:3');
|
|
assert.throws(() => recordTurnActionPlan([yes, planNo], 'respondent', 1, 'battle:1', 'carthag', [dial()]), TurnActionError);
|
|
assert.equal(yes.combat!.plan!.values, null);
|
|
const declineNo = combat(call(false), false);
|
|
assert.throws(() => recordTurnActionTraitor([declineNo], 'respondent', 1, 'battle:1', 'carthag', false), TurnActionError);
|
|
const revealed = recordTurnActionTraitor([combat(group('and', call(), pay()))], 'respondent', 1, 'battle:1', 'carthag', true);
|
|
assert.equal(revealed[0].combat!.traitor!.call, true);
|
|
assert.equal(recordTurnActionTraitor(revealed, 'respondent', 1, 'battle:1', 'carthag', false)[0], revealed[0],
|
|
'Later prevention/effect handling cannot retract the original declaration');
|
|
});
|
|
|
|
void test('combat closure without a receipt makes every plan and both declaration predicates false', () => {
|
|
const zero = plan({ kind: 'dial', compare: 'eq', value: 0 });
|
|
const yes = combat(group('or', zero, call(false)));
|
|
const no = combat(group('or', zero, call(false)), false, 'turn-action:2');
|
|
const closed = closeTurnActionCombat([yes, no], 1, 'battle:1');
|
|
assert.equal(turnActionValue(closed[0]), false);
|
|
assert.deepEqual(closed[0].combat!.plan, { closed: true, values: null });
|
|
assert.equal(closed[0].combat!.traitor!.closed, true);
|
|
assert.equal(closed[0].combat!.traitor!.call, null);
|
|
assert.equal(closed[0].fulfilled, false);
|
|
assert.equal(closed[1].fulfilled, true);
|
|
assert.equal(closeTurnActionCombat([yes], 1, 'other-battle')[0], yes);
|
|
const finished = finishTurnActionTurn(closed, 'respondent', 1);
|
|
assert.equal(finished[0].released, true);
|
|
const received = recordTurnActionPlan([combat(group('and', plan(), pay()))], 'respondent', 1, 'battle:1', 'carthag', [dial()]);
|
|
const preserved = closeTurnActionCombat(received, 1, 'battle:1');
|
|
assert.deepEqual(preserved[0].combat!.plan, { closed: true, values: [dial()] });
|
|
assert.deepEqual(branches(preserved[0]), [[signedPay()]]);
|
|
});
|
|
|
|
void test('combat expiry releases unresolved original stages without inventing a plan or declaration and preserves terminal rows', () => {
|
|
const yes = combat(plan()), no = combat(call(false), false, 'turn-action:2');
|
|
const expired = finishTurnActionTurn([yes, no], 'respondent', 1);
|
|
for (const row of expired) {
|
|
assert.equal(row.released, true);
|
|
assert.equal(row.fulfilled, false);
|
|
assert.deepEqual(row.combat, yes.combat);
|
|
}
|
|
const terminal = recordTurnActionPlan([combat(plan(), true, 'turn-action:3')], 'respondent', 1, 'battle:1', 'carthag', [dial()])[0];
|
|
assert.equal(terminal.fulfilled, true);
|
|
assert.equal(finishTurnActionTurn([terminal], 'respondent', 1)[0], terminal);
|
|
for (const transform of [
|
|
(rows: TurnActionPromise[]) => closeTurnActionCombat(rows, 1, 'battle:1'),
|
|
(rows: TurnActionPromise[]) => recordTurnActionPlan(rows, 'respondent', 1, 'battle:1', 'carthag', [dial()]),
|
|
(rows: TurnActionPromise[]) => recordTurnActionTraitor(rows, 'respondent', 1, 'battle:1', 'carthag', true),
|
|
]) assert.ok(transform([...expired, terminal]).every((row, index) => row === [...expired, terminal][index]));
|
|
validateTurnActionPromises([...expired, terminal], seats);
|
|
});
|
|
|
|
void test('combat metadata rejects missing original stages, mismatched source, premature values and incomplete or foreign receipts', () => {
|
|
const original = combat(group('and', plan(), call(), pay()));
|
|
const stage = original.combat!;
|
|
for (const value of [undefined, null, {}, { ...stage, event: 'other-battle' }, { ...stage, territory: 'arrakeen' },
|
|
{ ...stage, plan: null }, { ...stage, traitor: null }, { ...stage, canReveal: true },
|
|
{ ...stage, plan: { closed: false, values: [dial()] } },
|
|
{ ...stage, plan: { closed: true, values: [] } },
|
|
{ ...stage, plan: { closed: true, values: [dial(), dial()] } },
|
|
{ ...stage, plan: { closed: true, values: [{ claim: { kind: 'weapon', name: null }, value: true }] } },
|
|
{ ...stage, traitor: { ...stage.traitor!, call: false } },
|
|
{ ...stage, traitor: { ...stage.traitor!, beneficiary: 'other', target: 'other' } }])
|
|
assert.throws(() => turnActionValue({ ...original, combat: value } as TurnActionPromise), TurnActionError);
|
|
assert.throws(() => recordTurnActionPlan([original], 'respondent', 1, 'battle:1', 'carthag', []), TurnActionError);
|
|
assert.throws(() => recordTurnActionPlan([original], 'respondent', 1, 'battle:1', 'carthag', [dial(), dial()]), TurnActionError);
|
|
assert.throws(() => recordTurnActionPlan([original], 'respondent', 1, 'battle:1', 'carthag',
|
|
[{ ...dial(), value: 'yes' }] as never), TurnActionError);
|
|
assert.throws(() => recordTurnActionTraitor([original], 'respondent', 1, 'battle:1', 'carthag', null as never), TurnActionError);
|
|
const foreign = { ...original, combat: { ...stage, traitor: { ...stage.traitor!, target: 'missing' } } };
|
|
assert.throws(() => validateTurnActionPromises([foreign], seats), TurnActionError);
|
|
});
|
|
|
|
void test('combat clauses share the outer logical budget and can coexist with strict earlier optional stages', () => {
|
|
const sixteen = combat(group('or', ...Array.from({ length: 16 }, () => plan())));
|
|
assert.doesNotThrow(() => turnActionValue(sixteen));
|
|
assert.throws(() => turnActionValue(combat(group('or', ...Array.from({ length: 17 }, () => plan())))), TurnActionError);
|
|
const mixed = group('and', plan(), call(), bid(), forces(), alliance(), pay());
|
|
const row = { ...prepared(mixed), alliance: { source: 'nexus:1', partner: null, closed: false }, combat: combat(mixed).combat };
|
|
validateTurnActionPromises([row], seats);
|
|
const old = prepared(group('and', bid(), forces(), pay()));
|
|
assert.equal('combat' in closeTurnActionCombat([old], 1, 'battle:1')[0], false);
|
|
});
|
|
|
|
void test('native off-board combat locations retain exact event and location bindings without widening travel destinations', () => {
|
|
const territory = 'homeworld:guild';
|
|
const mixed: Expression = { kind: 'and', terms: [
|
|
{ kind: 'action', action: { kind: 'battlePlan', battle: 'battle:1', territory, claim: dial().claim } },
|
|
{ kind: 'action', action: { kind: 'traitorCall', battle: 'battle:1', territory, call: false } },
|
|
pay(),
|
|
] };
|
|
const original = combat(mixed);
|
|
original.combat!.territory = territory;
|
|
validateTurnActionPromises([original], seats);
|
|
assert.equal(recordTurnActionPlan([original], 'respondent', 1, 'other-battle', territory, [dial()])[0], original);
|
|
assert.equal(recordTurnActionPlan([original], 'respondent', 1, 'battle:1', 'homeworld:emperor', [dial()])[0], original);
|
|
const planned = recordTurnActionPlan([original], 'respondent', 1, 'battle:1', territory, [dial()]);
|
|
assert.equal(recordTurnActionTraitor(planned, 'respondent', 1, 'other-battle', territory, false)[0], planned[0]);
|
|
assert.equal(recordTurnActionTraitor(planned, 'respondent', 1, 'battle:1', 'homeworld:emperor', false)[0], planned[0]);
|
|
const declared = recordTurnActionTraitor(planned, 'respondent', 1, 'battle:1', territory, false);
|
|
assert.deepEqual(branches(declared[0]), [[signedPay()]]);
|
|
assert.equal(recordTurnActionPayment(declared, 'respondent', 1, payment())[0].fulfilled, true);
|
|
assert.equal(closeTurnActionCombat([original], 1, 'other-battle')[0], original);
|
|
assert.equal(closeTurnActionCombat([original], 1, 'battle:1')[0].combat!.plan!.closed, true);
|
|
for (const kind of ['ship', 'move'])
|
|
assert.throws(() => parseTurnActionLeaf({ kind, territory, minimum: 1 }), TurnActionError);
|
|
});
|