Allow Sapho order behind a started turn
This commit is contained in:
1 parent
3bf7d26e80
commit
8e6602633d
17 files changed
+1121
-62
No files matched your search
@@ -0,0 +1,164 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { protectOrderedOpportunityLast, reorderOrderedOpportunity } from '../game/ordered-opportunity';
|
||||
import {
|
||||
reorderSaphoMovementOrder, saphoMovementOrderEvent, SaphoMovementOrderError,
|
||||
type SaphoMovementOrderContext,
|
||||
} from '../game/sapho-movement-order';
|
||||
|
||||
function context(started = false): SaphoMovementOrderContext {
|
||||
return {
|
||||
queue: {
|
||||
event: 'movement:3', eligible: ['done', 'active', 'later', 'holder', 'guild'],
|
||||
remaining: ['active', 'later', 'holder', 'guild'], completed: ['done'],
|
||||
current: 'active', currentStarted: started, protectedLast: null,
|
||||
},
|
||||
started: started ? ['done', 'active'] : ['done'],
|
||||
guild: { player: 'guild', granted: false, locked: false },
|
||||
};
|
||||
}
|
||||
function reorder(input: SaphoMovementOrderContext, player: string, mode: 'first' | 'last') {
|
||||
return reorderSaphoMovementOrder(input, { event: saphoMovementOrderEvent(input), player, mode });
|
||||
}
|
||||
function reject(input: SaphoMovementOrderContext, player: string, mode: 'first' | 'last', event?: string) {
|
||||
const before = structuredClone(input);
|
||||
assert.throws(() => reorderSaphoMovementOrder(input, {
|
||||
event: event ?? saphoMovementOrderEvent(input), player, mode,
|
||||
}), SaphoMovementOrderError);
|
||||
assert.deepEqual(input, before);
|
||||
}
|
||||
|
||||
void test('clean first and last retain the existing immutable ordered-opportunity semantics', () => {
|
||||
for (const mode of ['first', 'last'] as const) {
|
||||
const input = context(), before = structuredClone(input);
|
||||
const quote = reorder(input, 'holder', mode);
|
||||
const expected = mode === 'first'
|
||||
? reorderOrderedOpportunity(input.queue, { event: input.queue.event, player: 'holder', position: 'first' })
|
||||
: protectOrderedOpportunityLast(input.queue, { event: input.queue.event, player: 'holder' });
|
||||
assert.equal(quote.event, input.queue.event);
|
||||
assert.equal(quote.afterCurrent, null);
|
||||
assert.deepEqual(quote.next, expected);
|
||||
assert.deepEqual(input, before);
|
||||
assert.notEqual(quote.next.remaining, input.queue.remaining);
|
||||
assert.notEqual(quote.next.eligible, input.queue.eligible);
|
||||
assert.notEqual(quote.next.completed, input.queue.completed);
|
||||
}
|
||||
const ownCleanTurn = reorder(context(), 'active', 'last');
|
||||
assert.deepEqual(ownCleanTurn.next.remaining, ['later', 'holder', 'guild', 'active']);
|
||||
assert.equal(ownCleanTurn.next.protectedLast, 'active');
|
||||
});
|
||||
|
||||
void test('started-tail first preserves the active combined turn and all other relative positions', () => {
|
||||
const input = context(true), before = structuredClone(input);
|
||||
const quote = reorder(input, 'holder', 'first');
|
||||
assert.equal(quote.afterCurrent, 'active');
|
||||
assert.deepEqual(quote.next.remaining, ['active', 'holder', 'later', 'guild']);
|
||||
assert.equal(quote.next.current, 'active');
|
||||
assert.equal(quote.next.currentStarted, true);
|
||||
assert.equal(quote.next.event, 'movement:3');
|
||||
assert.notEqual(quote.event, quote.next.event);
|
||||
assert.ok(quote.event.startsWith('sapho-after:'));
|
||||
assert.deepEqual(input, before);
|
||||
});
|
||||
|
||||
void test('started-tail last includes Guild while retaining the active turn and base protection event', () => {
|
||||
const input = context(true), before = structuredClone(input);
|
||||
const quote = reorder(input, 'holder', 'last');
|
||||
assert.deepEqual(quote.next.remaining, ['active', 'later', 'guild', 'holder']);
|
||||
assert.equal(quote.next.current, 'active');
|
||||
assert.equal(quote.afterCurrent, 'active');
|
||||
assert.equal(quote.next.protectedLast, 'holder');
|
||||
assert.equal(quote.next.event, input.queue.event);
|
||||
assert.deepEqual(input, before);
|
||||
assert.throws(() => saphoMovementOrderEvent({ ...input, queue: quote.next }), SaphoMovementOrderError);
|
||||
});
|
||||
|
||||
void test('an already started actor cannot use either mode to split its combined turn', () => {
|
||||
reject(context(true), 'active', 'first');
|
||||
reject(context(true), 'active', 'last');
|
||||
const anotherStarted = context(true);
|
||||
anotherStarted.started = ['active', 'holder'];
|
||||
reject(anotherStarted, 'later', 'last', 'movement:3');
|
||||
const inconsistentCurrent = context();
|
||||
inconsistentCurrent.started = ['active'];
|
||||
reject(inconsistentCurrent, 'holder', 'first', 'movement:3');
|
||||
const missingCurrent = context(true);
|
||||
missingCurrent.started = ['done'];
|
||||
reject(missingCurrent, 'holder', 'first', 'movement:3');
|
||||
});
|
||||
|
||||
void test('granted Guild priority blocks clean displacement but a started Guild turn stays first during tail reorder', () => {
|
||||
const input = context();
|
||||
input.queue = { ...input.queue, remaining: ['guild', 'later', 'holder', 'active'], current: 'guild' };
|
||||
input.guild = { player: 'guild', granted: true, locked: false };
|
||||
reject(input, 'holder', 'first');
|
||||
assert.deepEqual(reorder(input, 'holder', 'last').next.remaining, ['guild', 'later', 'active', 'holder']);
|
||||
input.queue = { ...input.queue, currentStarted: true };
|
||||
input.started = ['done', 'guild'];
|
||||
const before = structuredClone(input), quote = reorder(input, 'holder', 'first');
|
||||
assert.deepEqual(quote.next.remaining, ['guild', 'holder', 'later', 'active']);
|
||||
assert.equal(quote.next.current, 'guild');
|
||||
assert.equal(quote.afterCurrent, 'guild');
|
||||
assert.deepEqual(input, before);
|
||||
});
|
||||
|
||||
void test('ordinary Guild timing flags and Basic null timing retain their own later native opportunities', () => {
|
||||
const input = context(), before = structuredClone(input);
|
||||
assert.deepEqual(reorder(input, 'holder', 'first').next.remaining, ['holder', 'active', 'later', 'guild']);
|
||||
assert.deepEqual(input.guild, { player: 'guild', granted: false, locked: false });
|
||||
assert.deepEqual(input, before);
|
||||
const basic = { ...context(), guild: null };
|
||||
assert.deepEqual(reorder(basic, 'holder', 'last').next.remaining, ['active', 'later', 'guild', 'holder']);
|
||||
const locked = context();
|
||||
locked.queue = { ...locked.queue, remaining: ['guild', 'later', 'holder', 'active'], current: 'guild' };
|
||||
locked.guild = { player: 'guild', granted: true, locked: true };
|
||||
assert.equal(reorder(locked, 'holder', 'first').next.current, 'holder');
|
||||
});
|
||||
|
||||
void test('started event binds the base phase, active actor and complete public tail with encoded identities', () => {
|
||||
const input = context(true), event = saphoMovementOrderEvent(input);
|
||||
assert.equal(saphoMovementOrderEvent(structuredClone(input)), event);
|
||||
assert.equal(saphoMovementOrderEvent({ ...input, started: ['active'] }), event);
|
||||
reject(input, 'holder', 'first', input.queue.event);
|
||||
const reordered = context(true);
|
||||
reordered.queue = { ...reordered.queue, remaining: ['active', 'later', 'guild', 'holder'] };
|
||||
reject(reordered, 'holder', 'first', event);
|
||||
const nextPhase = context(true);
|
||||
nextPhase.queue = { ...nextPhase.queue, event: 'movement:4' };
|
||||
reject(nextPhase, 'holder', 'first', event);
|
||||
const differentCurrent = context(true);
|
||||
differentCurrent.queue = { ...differentCurrent.queue, remaining: ['later', 'active', 'holder', 'guild'], current: 'later' };
|
||||
differentCurrent.started = ['later'];
|
||||
reject(differentCurrent, 'holder', 'last', event);
|
||||
const encoded = context(true);
|
||||
const rename = (id: string) => id === 'active' ? 'actor:/"[]' : id;
|
||||
encoded.queue = { ...encoded.queue, eligible: encoded.queue.eligible.map(rename),
|
||||
remaining: encoded.queue.remaining.map(rename), current: rename('active') };
|
||||
encoded.started = [rename('active')];
|
||||
assert.notEqual(saphoMovementOrderEvent(encoded), event);
|
||||
assert.ok(saphoMovementOrderEvent(encoded).includes('%22'));
|
||||
});
|
||||
|
||||
void test('no-op, completed, foreign, protected and malformed requests cannot consume Sapho', () => {
|
||||
reject(context(), 'active', 'first');
|
||||
reject(context(), 'guild', 'last');
|
||||
reject(context(true), 'later', 'first');
|
||||
reject(context(true), 'guild', 'last');
|
||||
reject(context(), 'done', 'last');
|
||||
reject(context(), 'foreign', 'first');
|
||||
const protectedLast = context();
|
||||
protectedLast.queue = { ...protectedLast.queue, protectedLast: 'guild' };
|
||||
reject(protectedLast, 'holder', 'first', 'movement:3');
|
||||
const unknownStarted = context();
|
||||
unknownStarted.started = ['foreign'];
|
||||
reject(unknownStarted, 'holder', 'first', 'movement:3');
|
||||
const duplicateStarted = context(true);
|
||||
duplicateStarted.started = ['active', 'active'];
|
||||
reject(duplicateStarted, 'holder', 'last', 'movement:3');
|
||||
const malformed = context();
|
||||
malformed.queue = { ...malformed.queue, current: 'holder' };
|
||||
reject(malformed, 'holder', 'first', 'movement:3');
|
||||
const finished = context();
|
||||
finished.queue = { ...finished.queue, remaining: [], completed: finished.queue.eligible, current: null };
|
||||
reject(finished, 'holder', 'first', 'movement:3');
|
||||
});
|
||||
Reference in new issue
Block a user