Complete Advanced Revival suspension and solo win ranking
This commit is contained in:
1 parent
812657bb35
commit
3c62c284a7
17 files changed
+598
-47
No files matched your search
@@ -0,0 +1,70 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import {
|
||||
createRevivalOrder, finishRevivalOrder, reorderSaphoRevivalOrder,
|
||||
saphoRevivalOrderEvent, startRevivalOrder, validateRevivalOrder,
|
||||
type RevivalOrder, type RevivalOrderContext,
|
||||
} from '../game/revival-order';
|
||||
|
||||
const context = (ready: string[] = []): RevivalOrderContext => ({ turn: 4,
|
||||
order: ['a', 'b', 'c', 'd'], ready });
|
||||
function reorder(ctx: RevivalOrderContext, order: RevivalOrder, player: string, mode: 'first' | 'last') {
|
||||
return reorderSaphoRevivalOrder(ctx, order, { event: saphoRevivalOrderEvent(ctx, order), player, mode });
|
||||
}
|
||||
|
||||
void test('started Revival suspends last and resumes the same started opportunity after intervening turns', () => {
|
||||
const ctx = context(), original = startRevivalOrder(ctx, createRevivalOrder(ctx), 'a');
|
||||
const choice = reorder(ctx, original, 'a', 'last');
|
||||
assert.equal(choice.suspended, 'a'); assert.equal(choice.afterCurrent, undefined);
|
||||
assert.equal(choice.order.version, 3); assert.ok(choice.order.version === 3);
|
||||
assert.deepEqual(choice.order.remaining, ['b', 'c', 'd', 'a']);
|
||||
assert.deepEqual(choice.order.paused, ['a']); assert.equal(choice.order.started, false);
|
||||
assert.equal(original.version, 1); assert.equal(original.started, true);
|
||||
let order: RevivalOrder = choice.order;
|
||||
for (const [index, player] of ['b', 'c', 'd'].entries()) {
|
||||
const before = context(['b', 'c', 'd'].slice(0, index));
|
||||
order = finishRevivalOrder(before, startRevivalOrder(before, order, player), player);
|
||||
}
|
||||
assert.equal(order.version, 3); assert.ok(order.version === 3);
|
||||
assert.deepEqual(order.remaining, ['a']); assert.deepEqual(order.paused, ['a']);
|
||||
assert.equal(order.started, true);
|
||||
const finished = finishRevivalOrder(context(['b', 'c', 'd']), order, 'a');
|
||||
validateRevivalOrder(context(['b', 'c', 'd', 'a']), finished);
|
||||
assert.ok(finished.version === 3); assert.deepEqual(finished.paused, []);
|
||||
assert.equal(finished.started, false);
|
||||
});
|
||||
|
||||
void test('suspension preserves earlier version-two uses and a later reordered paused turn retains its started lock', () => {
|
||||
const ctx = context();
|
||||
const first = reorder(ctx, createRevivalOrder(ctx), 'd', 'first').order;
|
||||
assert.equal(first.version, 2);
|
||||
const active = startRevivalOrder(ctx, first, 'd');
|
||||
const suspended = reorder(ctx, active, 'd', 'last').order;
|
||||
assert.ok(first.version === 2 && suspended.version === 3);
|
||||
assert.deepEqual(suspended.uses[0], first.uses[0]);
|
||||
assert.deepEqual(suspended.paused, ['d']);
|
||||
const resumed = reorder(ctx, suspended, 'd', 'first').order;
|
||||
assert.ok(resumed.version === 3); assert.equal(resumed.started, true);
|
||||
assert.equal(resumed.remaining[0], 'd'); assert.deepEqual(resumed.paused, ['d']);
|
||||
const restored = JSON.parse(JSON.stringify(resumed)) as RevivalOrder;
|
||||
validateRevivalOrder(ctx, restored);
|
||||
const done = finishRevivalOrder(ctx, restored, 'd');
|
||||
assert.ok(done.version === 3); assert.deepEqual(done.paused, []);
|
||||
validateRevivalOrder(context(['d']), done);
|
||||
});
|
||||
|
||||
void test('suspension rejects stale, no-op and forged receipts without changing either input', () => {
|
||||
const ctx = context(), fresh = createRevivalOrder(ctx);
|
||||
const old = saphoRevivalOrderEvent(ctx, fresh), active = startRevivalOrder(ctx, fresh, 'a');
|
||||
const before = structuredClone(active);
|
||||
assert.throws(() => reorderSaphoRevivalOrder(ctx, active, { event: old, player: 'a', mode: 'last' }));
|
||||
assert.throws(() => reorder(ctx, active, 'a', 'first'));
|
||||
assert.deepEqual(active, before);
|
||||
const frame = reorder(ctx, active, 'a', 'last').order; assert.ok(frame.version === 3);
|
||||
for (const bad of [
|
||||
{ ...frame, paused: [] }, { ...frame, paused: ['a', 'a'] },
|
||||
{ ...frame, paused: ['foreign'] }, { ...frame, remaining: ['a', 'b', 'c', 'd'] },
|
||||
{ ...frame, uses: frame.uses.map(use => ({ ...use, suspended: undefined })) },
|
||||
]) assert.throws(() => validateRevivalOrder(ctx, bad as RevivalOrder));
|
||||
assert.deepEqual(active, before);
|
||||
});
|
||||
Reference in new issue
Block a user