Initial commit
This commit is contained in:
commit
8c709fb52f
771 files changed
+222983
No files matched your search
@@ -0,0 +1,673 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
quoteCompletedMovementArrival,
|
||||
MovementArrivalError,
|
||||
type CompletedMovementArrivalInput,
|
||||
} from '../game/karama-movement-preflight';
|
||||
import {
|
||||
applyAction,
|
||||
createGame,
|
||||
joinGame,
|
||||
newPlayer,
|
||||
normalizeAutomaticGame,
|
||||
type Game,
|
||||
} from '../game/engine';
|
||||
import { baseDeck } from '../game/cards';
|
||||
import { richeseCards } from '../game/richese-cards';
|
||||
import { createAmbassadors, placeAmbassador } from '../game/ecaz-ambassadors';
|
||||
import { createTerrorState, placeTerror } from '../game/moritani-terror';
|
||||
|
||||
function fixture(): CompletedMovementArrivalInput {
|
||||
return {
|
||||
advanced: true,
|
||||
players: [
|
||||
{ id: 'p', faction: 'emperor', ally: null, forces: {} },
|
||||
{ id: 'b', faction: 'beneGesserit', ally: null, forces: {} },
|
||||
{ id: 'e', faction: 'ecaz', ally: null, forces: {} },
|
||||
{ id: 'm', faction: 'moritani', ally: null, forces: {} },
|
||||
],
|
||||
order: {
|
||||
player: 'p',
|
||||
origin: 'red_chasm',
|
||||
to: 'broken_land',
|
||||
advisors: false,
|
||||
wantsFighters: false,
|
||||
},
|
||||
ambassadors: [],
|
||||
terror: [],
|
||||
controls: {
|
||||
response: false,
|
||||
decision: false,
|
||||
pendingTerror: false,
|
||||
pendingAmbassador: false,
|
||||
paidBox: false,
|
||||
},
|
||||
flight: null,
|
||||
};
|
||||
}
|
||||
const ambassador = {
|
||||
zone: 'placed' as const,
|
||||
location: 'broken_land',
|
||||
effect: 'atreides' as const,
|
||||
};
|
||||
const terror = { status: 'placed' as const, location: 'broken_land' };
|
||||
|
||||
void test('a plain movement has no arrival reaction, and an eligible token opens only its own opportunity', () => {
|
||||
const input = fixture();
|
||||
assert.deepEqual(quoteCompletedMovementArrival(input), {
|
||||
intrusion: false,
|
||||
reaction: null,
|
||||
retiresOrnithopter: false,
|
||||
});
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({ ...input, ambassadors: [ambassador] })
|
||||
.reaction,
|
||||
'ambassador',
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({ ...input, terror: [terror] }).reaction,
|
||||
'terror',
|
||||
);
|
||||
assert.throws(
|
||||
() =>
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
ambassadors: [ambassador],
|
||||
terror: [terror],
|
||||
}),
|
||||
MovementArrivalError,
|
||||
);
|
||||
});
|
||||
|
||||
for (const exclusion of [
|
||||
'owner',
|
||||
'ally',
|
||||
'matchingFaction',
|
||||
'advisor',
|
||||
] as const)
|
||||
void test(`Ambassador ${exclusion} exclusion still permits the independent Terror opportunity`, () => {
|
||||
const input = fixture();
|
||||
const players = input.players.map((p) => ({ ...p }));
|
||||
let order = { ...input.order };
|
||||
if (exclusion === 'owner') order.player = 'e';
|
||||
if (exclusion === 'ally') players.find((p) => p.id === 'e')!.ally = 'p';
|
||||
if (exclusion === 'matchingFaction')
|
||||
players.find((p) => p.id === 'p')!.faction = 'atreides';
|
||||
if (exclusion === 'advisor') {
|
||||
order = { ...order, player: 'b', advisors: true };
|
||||
}
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
players,
|
||||
order,
|
||||
ambassadors: [ambassador],
|
||||
terror: [terror],
|
||||
}).reaction,
|
||||
'terror',
|
||||
);
|
||||
});
|
||||
|
||||
for (const entrant of ['m', 'p'])
|
||||
void test(`Terror exempts its ${entrant === 'm' ? 'owner' : 'ally'} while independent Ambassador entry stays eligible`, () => {
|
||||
const input = fixture();
|
||||
const players = input.players.map((p) =>
|
||||
p.id === 'm' ? { ...p, ally: 'p' } : p,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
players,
|
||||
order: { ...input.order, player: entrant },
|
||||
ambassadors: [ambassador],
|
||||
terror: [terror],
|
||||
}).reaction,
|
||||
'ambassador',
|
||||
);
|
||||
});
|
||||
|
||||
void test('BG intrusion uses current opposing fighters, requires Advanced rules and excludes the mover itself', () => {
|
||||
const input = fixture();
|
||||
const players = input.players.map((p) =>
|
||||
p.id === 'b' ? { ...p, forces: { 'broken_land:9': 2 } } : p,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({ ...input, players }).intrusion,
|
||||
true,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({ ...input, players, advanced: false })
|
||||
.intrusion,
|
||||
false,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
players,
|
||||
order: { ...input.order, player: 'b' },
|
||||
}).intrusion,
|
||||
false,
|
||||
);
|
||||
const advisors = players.map((p) =>
|
||||
p.id === 'b' ? { ...p, advisors: { broken_land: {} } } : p,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({ ...input, players: advisors }).intrusion,
|
||||
false,
|
||||
);
|
||||
for (const tokens of [{ ambassadors: [ambassador] }, { terror: [terror] }])
|
||||
assert.throws(
|
||||
() => quoteCompletedMovementArrival({ ...input, players, ...tokens }),
|
||||
/another arrival reaction/,
|
||||
);
|
||||
});
|
||||
|
||||
void test('mover advisor stance is the declared resulting stance, not its stale destination map', () => {
|
||||
const input = fixture();
|
||||
const players = input.players.map((p) =>
|
||||
p.id === 'b' ? { ...p, advisors: { broken_land: {} } } : p,
|
||||
);
|
||||
const base = {
|
||||
...input,
|
||||
players,
|
||||
ambassadors: [ambassador],
|
||||
order: { ...input.order, player: 'b' },
|
||||
};
|
||||
assert.equal(quoteCompletedMovementArrival(base).reaction, 'ambassador');
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...base,
|
||||
order: { ...base.order, advisors: true },
|
||||
}).reaction,
|
||||
null,
|
||||
);
|
||||
// A pending fighter flip leaves the advisor stance in place until allowed.
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...base,
|
||||
order: { ...base.order, advisors: true, wantsFighters: true },
|
||||
}).reaction,
|
||||
null,
|
||||
);
|
||||
assert.throws(
|
||||
() =>
|
||||
quoteCompletedMovementArrival({
|
||||
...base,
|
||||
terror: [terror],
|
||||
order: { ...base.order, advisors: true, wantsFighters: true },
|
||||
}),
|
||||
/Terror combined/,
|
||||
);
|
||||
});
|
||||
|
||||
void test('same-territory movement still reports intrusion but does not reopen Ambassador or Terror entry', () => {
|
||||
const input = fixture();
|
||||
const players = input.players.map((p) =>
|
||||
p.id === 'b' ? { ...p, forces: { 'broken_land:9': 1 } } : p,
|
||||
);
|
||||
assert.deepEqual(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
players,
|
||||
order: { ...input.order, origin: 'broken_land', wantsFighters: true },
|
||||
ambassadors: [ambassador],
|
||||
terror: [terror],
|
||||
controls: {
|
||||
...input.controls,
|
||||
response: true,
|
||||
decision: true,
|
||||
pendingTerror: true,
|
||||
pendingAmbassador: true,
|
||||
},
|
||||
}),
|
||||
{ intrusion: true, reaction: null, retiresOrnithopter: false },
|
||||
);
|
||||
});
|
||||
|
||||
void test('current controls and the move-created fighter response are checked without inventing a global pending-parent ban', () => {
|
||||
const input = fixture();
|
||||
for (const flag of [
|
||||
'response',
|
||||
'decision',
|
||||
'pendingTerror',
|
||||
'pendingAmbassador',
|
||||
] as const)
|
||||
assert.throws(
|
||||
() =>
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
ambassadors: [ambassador],
|
||||
controls: { ...input.controls, [flag]: true },
|
||||
}),
|
||||
/Ambassadors combined/,
|
||||
);
|
||||
for (const flag of ['response', 'decision'] as const)
|
||||
assert.throws(
|
||||
() =>
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
terror: [terror],
|
||||
controls: { ...input.controls, [flag]: true },
|
||||
}),
|
||||
/Terror combined/,
|
||||
);
|
||||
assert.throws(
|
||||
() =>
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
terror: [terror],
|
||||
controls: { ...input.controls, response: true, pendingTerror: true },
|
||||
}),
|
||||
/Resolve the pending Terror entry first/,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
terror: [terror],
|
||||
controls: { ...input.controls, pendingAmbassador: true },
|
||||
}).reaction,
|
||||
'terror',
|
||||
);
|
||||
assert.throws(
|
||||
() =>
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
ambassadors: [ambassador],
|
||||
order: { ...input.order, wantsFighters: true },
|
||||
}),
|
||||
/Ambassadors combined/,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
controls: {
|
||||
...input.controls,
|
||||
response: true,
|
||||
decision: true,
|
||||
pendingTerror: true,
|
||||
pendingAmbassador: true,
|
||||
},
|
||||
}).reaction,
|
||||
null,
|
||||
);
|
||||
});
|
||||
|
||||
void test('unplaced, removed, wrong-territory or unowned markers create no arrival opportunity', () => {
|
||||
const input = fixture();
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
ambassadors: [
|
||||
{ ...ambassador, zone: 'supply', location: null },
|
||||
{ ...ambassador, location: 'red_chasm' },
|
||||
],
|
||||
terror: [
|
||||
{ ...terror, status: 'removed' },
|
||||
{ ...terror, location: 'red_chasm' },
|
||||
],
|
||||
}).reaction,
|
||||
null,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
players: input.players.filter((p) => p.id !== 'e' && p.id !== 'm'),
|
||||
ambassadors: [ambassador],
|
||||
terror: [terror],
|
||||
}).reaction,
|
||||
null,
|
||||
);
|
||||
});
|
||||
|
||||
void test('paid Box prevents only actual Ornithopter retirement: first two-groups move remains distinct from its final move', () => {
|
||||
const input = fixture();
|
||||
const controls = { ...input.controls, paidBox: true };
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({ ...input, controls }).retiresOrnithopter,
|
||||
false,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
controls,
|
||||
flight: { player: 'p', mode: 'twoGroups', completed: 0 },
|
||||
}).retiresOrnithopter,
|
||||
false,
|
||||
);
|
||||
assert.throws(
|
||||
() =>
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
controls,
|
||||
flight: { player: 'p', mode: 'twoGroups', completed: 1 },
|
||||
}),
|
||||
/Finish the paid search/,
|
||||
);
|
||||
assert.throws(
|
||||
() =>
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
controls,
|
||||
flight: { player: 'p', mode: 'range3', completed: 0 },
|
||||
}),
|
||||
/Finish the paid search/,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
controls,
|
||||
flight: { player: 'b', mode: 'range3', completed: 0 },
|
||||
}).retiresOrnithopter,
|
||||
false,
|
||||
);
|
||||
assert.equal(
|
||||
quoteCompletedMovementArrival({
|
||||
...input,
|
||||
flight: { player: 'p', mode: 'twoGroups', completed: 1 },
|
||||
}).retiresOrnithopter,
|
||||
true,
|
||||
);
|
||||
});
|
||||
|
||||
void test('arrival quotes are repeatable and immutable without RNG, events, or reading private cards and marker value', (t) => {
|
||||
const input = fixture();
|
||||
const before = structuredClone(input);
|
||||
for (const p of input.players)
|
||||
Object.defineProperty(p, 'hand', {
|
||||
get() {
|
||||
throw Error('Private hand read.');
|
||||
},
|
||||
});
|
||||
Object.defineProperty(input.players[0], 'noField', {
|
||||
get() {
|
||||
throw Error(
|
||||
'The mover marker value is irrelevant to arrival eligibility.',
|
||||
);
|
||||
},
|
||||
});
|
||||
const random = t.mock.method(crypto, 'getRandomValues', () => {
|
||||
throw Error('Randomness in pure quote.');
|
||||
});
|
||||
const uuid = t.mock.method(crypto, 'randomUUID', () => {
|
||||
throw Error('Event creation in pure quote.');
|
||||
});
|
||||
const first = quoteCompletedMovementArrival(input);
|
||||
assert.deepEqual(quoteCompletedMovementArrival(input), first);
|
||||
assert.deepEqual(JSON.parse(JSON.stringify(input)), before);
|
||||
assert.equal(random.mock.callCount(), 0);
|
||||
assert.equal(uuid.mock.callCount(), 0);
|
||||
});
|
||||
|
||||
const seat = (g: Game, id: string) => g.players.find((p) => p.id === id)!;
|
||||
const reload = (g: Game): Game => JSON.parse(JSON.stringify(g));
|
||||
const source = 'imperial_basin:10';
|
||||
|
||||
function holdCard(g: Game, id: string, name: string) {
|
||||
const pile = g.richeseCache?.some((c) => c.name === name)
|
||||
? g.richeseCache
|
||||
: g.deck;
|
||||
const index = pile!.findIndex((c) => c.name === name);
|
||||
assert.ok(index >= 0, name);
|
||||
const card = pile!.splice(index, 1)[0];
|
||||
seat(g, id).hand.push(card);
|
||||
return card.id;
|
||||
}
|
||||
function physical(g: Game) {
|
||||
const ids = [
|
||||
...g.deck,
|
||||
...g.discard,
|
||||
...g.players.flatMap((p) => p.hand),
|
||||
...(g.richeseCache ?? []),
|
||||
...(g.ornithopter ? [g.ornithopter.card] : []),
|
||||
]
|
||||
.map((c) => c.id)
|
||||
.sort();
|
||||
assert.equal(new Set(ids).size, ids.length);
|
||||
for (const p of g.players)
|
||||
assert.equal(
|
||||
p.reserves + p.tanks + Object.values(p.forces).reduce((a, n) => a + n, 0),
|
||||
20,
|
||||
);
|
||||
return ids;
|
||||
}
|
||||
|
||||
/** Only initial board/card supply is staged. Movement card selection, the
|
||||
* CHOAM opportunity, and Baliset declaration are all actual public actions. */
|
||||
function balisetFlight(mode: 'range3' | 'twoGroups', conflict = false) {
|
||||
let g = createGame('KARAMAARRIVAL', newPlayer('c', 'CHOAM', 'choam'), true, [
|
||||
'choam',
|
||||
'ecaz',
|
||||
]);
|
||||
joinGame(g, newPlayer('p', 'Emperor', 'emperor'));
|
||||
joinGame(g, newPlayer('b', 'Bene Gesserit', 'beneGesserit'));
|
||||
joinGame(g, newPlayer('e', 'Ecaz', 'ecaz'));
|
||||
joinGame(g, newPlayer('m', 'Moritani', 'moritani'));
|
||||
Object.assign(g, {
|
||||
status: 'playing',
|
||||
phase: 5,
|
||||
turn: 2,
|
||||
storm: 18,
|
||||
order: ['p', 'c', 'b', 'e', 'm'],
|
||||
active: 'p',
|
||||
movementRemaining: ['p', 'c', 'b', 'e', 'm'],
|
||||
deck: baseDeck(),
|
||||
richeseCache: richeseCards(),
|
||||
});
|
||||
for (const p of g.players) {
|
||||
p.hand = [];
|
||||
p.spice = 10;
|
||||
p.forces = {};
|
||||
p.reserves = 20;
|
||||
}
|
||||
seat(g, 'p').forces[source] = 3;
|
||||
seat(g, 'p').reserves = 17;
|
||||
const territory = mode === 'range3' ? 'arrakeen' : 'carthag';
|
||||
const sector = mode === 'range3' ? 10 : 11;
|
||||
const destination = `${territory}:${sector}`;
|
||||
seat(g, 'c').forces[destination] = 1;
|
||||
seat(g, 'c').reserves = 19;
|
||||
const orni = holdCard(g, 'p', 'Ornithopter');
|
||||
const baliset = holdCard(g, 'c', 'Baliset');
|
||||
const printed = holdCard(g, 'p', 'Karama');
|
||||
const worthless = holdCard(g, 'b', 'Jubba Cloak');
|
||||
if (conflict) {
|
||||
g.ecazAmbassadors = createAmbassadors(() => 0);
|
||||
g.ecazAmbassadors = placeAmbassador(
|
||||
g.ecazAmbassadors,
|
||||
g.ecazAmbassadors.tokens.find((t) => t.effect === 'ecaz')!.id,
|
||||
{
|
||||
turn: 1,
|
||||
availableSpice: 10,
|
||||
destination: {
|
||||
id: territory,
|
||||
stronghold: true,
|
||||
allowed: true,
|
||||
inStorm: false,
|
||||
},
|
||||
},
|
||||
).state;
|
||||
g.moritaniTerror = createTerrorState(() => 0);
|
||||
g.moritaniTerror = placeTerror(
|
||||
g.moritaniTerror,
|
||||
g.moritaniTerror.tokens.find((t) => t.kind === 'sabotage')!.id,
|
||||
territory,
|
||||
1,
|
||||
);
|
||||
}
|
||||
const inventory = physical(g);
|
||||
if (mode === 'twoGroups') {
|
||||
g = applyAction(g, 'p', {
|
||||
type: 'move',
|
||||
movementCard: orni,
|
||||
ornithopter: mode,
|
||||
forces: { [source]: 1 },
|
||||
territory: 'arrakeen',
|
||||
sector: 10,
|
||||
});
|
||||
assert.equal(g.ornithopter?.completed, 1);
|
||||
assert.equal(g.decision, null);
|
||||
g = applyAction(g, 'p', {
|
||||
type: 'move',
|
||||
ornithopterEvent: g.ornithopter!.event,
|
||||
forces: { [source]: 1 },
|
||||
territory,
|
||||
sector,
|
||||
});
|
||||
} else {
|
||||
g = applyAction(g, 'p', {
|
||||
type: 'move',
|
||||
movementCard: orni,
|
||||
ornithopter: mode,
|
||||
forces: { [source]: 1 },
|
||||
territory,
|
||||
sector,
|
||||
});
|
||||
}
|
||||
assert.equal(g.decision?.kind, 'choamMovement');
|
||||
assert.equal(seat(g, 'p').moved, mode === 'twoGroups' ? 1 : 0);
|
||||
g = applyAction(g, 'c', {
|
||||
type: 'card',
|
||||
card: baliset,
|
||||
mode: 'choam',
|
||||
target: 'p',
|
||||
territory,
|
||||
});
|
||||
assert.equal(g.response?.kind, 'choamWorthless');
|
||||
assert.equal(g.pendingChoamWorthless?.movement, true);
|
||||
assert.deepEqual(physical(g), inventory);
|
||||
return { g, orni, baliset, printed, worthless, destination };
|
||||
}
|
||||
|
||||
function allowConversion(initial: Game) {
|
||||
let g = initial;
|
||||
while (g.response?.kind === 'worthlessKarama') {
|
||||
const p = g.players.find((p) => !g.response!.passed.includes(p.id));
|
||||
assert.ok(p);
|
||||
g = applyAction(g, p.id, { type: 'passResponse' });
|
||||
}
|
||||
return g;
|
||||
}
|
||||
|
||||
for (const form of ['printed', 'worthless'] as const)
|
||||
for (const mode of ['range3', 'twoGroups'] as const)
|
||||
void test(`${form} cancellation of real Baliset rejects competing Ambassador and Terror arrival before cost (${mode})`, (t) => {
|
||||
const { g, printed, worthless, orni, baliset } = balisetFlight(
|
||||
mode,
|
||||
true,
|
||||
);
|
||||
const before = structuredClone(g);
|
||||
const inventory = physical(g);
|
||||
const random = t.mock.method(crypto, 'getRandomValues', () => {
|
||||
throw Error('Rejected arrival preflight drew randomness.');
|
||||
});
|
||||
const uuid = t.mock.method(crypto, 'randomUUID', () => {
|
||||
throw Error('Rejected arrival preflight created an event.');
|
||||
});
|
||||
assert.throws(
|
||||
() =>
|
||||
applyAction(g, form === 'printed' ? 'p' : 'b', {
|
||||
type: 'card',
|
||||
mode: 'cancel',
|
||||
card: form === 'printed' ? printed : worthless,
|
||||
}),
|
||||
/Ambassadors combined with another arrival reaction/,
|
||||
);
|
||||
assert.deepEqual(g, before);
|
||||
assert.deepEqual(physical(g), inventory);
|
||||
assert.equal(g.pendingKarama ?? null, null);
|
||||
assert.equal(g.ornithopter?.card.id, orni);
|
||||
assert.equal(
|
||||
g.discard.some((c) =>
|
||||
[printed, worthless, baliset, orni].includes(c.id),
|
||||
),
|
||||
false,
|
||||
);
|
||||
assert.equal(random.mock.callCount(), 0);
|
||||
assert.equal(uuid.mock.callCount(), 0);
|
||||
});
|
||||
|
||||
for (const form of ['printed', 'worthless'] as const)
|
||||
for (const mode of ['range3', 'twoGroups'] as const)
|
||||
void test(`${form} cancellation of real Baliset completes the exact final ${mode} flight and retires escrow once`, () => {
|
||||
const { g, printed, worthless, orni, baliset, destination } =
|
||||
balisetFlight(mode);
|
||||
const before = structuredClone(g);
|
||||
const inventory = physical(g);
|
||||
const spent = form === 'printed' ? printed : worthless;
|
||||
let done = applyAction(g, form === 'printed' ? 'p' : 'b', {
|
||||
type: 'card',
|
||||
mode: 'cancel',
|
||||
card: spent,
|
||||
});
|
||||
assert.deepEqual(g, before);
|
||||
if (form === 'worthless') {
|
||||
assert.equal(done.response?.kind, 'worthlessKarama');
|
||||
assert.equal(done.ornithopter?.completed, mode === 'twoGroups' ? 1 : 0);
|
||||
assert.equal(seat(done, 'p').forces[destination] ?? 0, 0);
|
||||
done = allowConversion(reload(done));
|
||||
}
|
||||
assert.equal(seat(done, 'p').forces[destination], 1);
|
||||
assert.equal(
|
||||
seat(done, 'p').forces[source],
|
||||
mode === 'twoGroups' ? 1 : 2,
|
||||
);
|
||||
assert.equal(seat(done, 'p').moved, mode === 'twoGroups' ? 2 : 1);
|
||||
assert.equal(done.ornithopter, null);
|
||||
assert.equal(done.pendingChoamMove, null);
|
||||
assert.equal(done.pendingTreacheryDiscard, null);
|
||||
assert.equal(done.discard.filter((c) => c.id === orni).length, 1);
|
||||
assert.equal(done.discard.filter((c) => c.id === spent).length, 1);
|
||||
assert.ok(seat(done, 'c').hand.some((c) => c.id === baliset));
|
||||
assert.deepEqual(physical(done), inventory);
|
||||
assert.deepEqual(
|
||||
reload(normalizeAutomaticGame(reload(done))),
|
||||
reload(done),
|
||||
);
|
||||
});
|
||||
|
||||
for (const form of ['printed', 'worthless'] as const)
|
||||
void test(`${form} cancellation still accepts a real Baliset order that became illegal, without moving or retiring the unused flight`, () => {
|
||||
const {
|
||||
g: original,
|
||||
printed,
|
||||
worthless,
|
||||
orni,
|
||||
baliset,
|
||||
destination,
|
||||
} = balisetFlight('range3');
|
||||
const g = reload(original);
|
||||
// Saved-state perturbation, not a claimed legal action during the response:
|
||||
// source units have returned to reserves. The current flight remains valid,
|
||||
// but its declared group is unavailable and must take the existing fizzle.
|
||||
seat(g, 'p').reserves += seat(g, 'p').forces[source];
|
||||
delete seat(g, 'p').forces[source];
|
||||
const before = structuredClone(g);
|
||||
const inventory = physical(g);
|
||||
const spent = form === 'printed' ? printed : worthless;
|
||||
let done = applyAction(g, form === 'printed' ? 'p' : 'b', {
|
||||
type: 'card',
|
||||
mode: 'cancel',
|
||||
card: spent,
|
||||
});
|
||||
assert.deepEqual(g, before);
|
||||
if (form === 'worthless') done = allowConversion(reload(done));
|
||||
assert.equal(seat(done, 'p').moved, 0);
|
||||
assert.equal(seat(done, 'p').forces[destination] ?? 0, 0);
|
||||
assert.equal(seat(done, 'p').reserves, 20);
|
||||
assert.equal(done.ornithopter?.completed, 0);
|
||||
assert.equal(done.ornithopter?.card.id, orni);
|
||||
assert.equal(done.pendingChoamMove, null);
|
||||
assert.equal(done.pendingChoamWorthless, null);
|
||||
assert.equal(done.discard.filter((c) => c.id === spent).length, 1);
|
||||
assert.equal(
|
||||
done.discard.some((c) => c.id === orni),
|
||||
false,
|
||||
);
|
||||
assert.ok(seat(done, 'c').hand.some((c) => c.id === baliset));
|
||||
assert.deepEqual(physical(done), inventory);
|
||||
assert.deepEqual(
|
||||
reload(normalizeAutomaticGame(reload(done))),
|
||||
reload(done),
|
||||
);
|
||||
});
|
||||
Reference in new issue
Block a user