125 lines
8.0 KiB
TypeScript
125 lines
8.0 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { applyAction, viewGame, type Action, type Game } from '../game/engine';
|
|
import { botActions } from '../game/bots';
|
|
import type { Difficulty } from '../game/bot-profiles';
|
|
import { actNoFieldAlliedSeparation as act, createNoFieldAlliedSeparationFixture as fixture,
|
|
noFieldAlliedSeparationInventory as inventory, noFieldAlliedSeparationPlayer as p,
|
|
noFieldAlliedSeparationReload as reload, finishNoFieldAlliedSeparationMovement as finish,
|
|
noFieldAlliedSeparationClean as clean, nextNoFieldAlliedSeparation as next } from './fixture-no-field-allied-separation';
|
|
|
|
function reject(game: Game, actor: string, action: Action) {
|
|
const before = reload(game); assert.throws(() => applyAction(game, actor, action)); assert.deepEqual(game, before);
|
|
}
|
|
function assertDueLoss(f: ReturnType<typeof fixture>, game: Game) {
|
|
const before = p(f.game, f.actor), after = p(game, f.actor), amount = Math.min(f.value, before.reserves);
|
|
assert.equal(after.noField!.deployed, null); assert.notEqual(after.noFieldEvent, f.event);
|
|
assert.deepEqual(after.noField!.tokens, f.marker!.tokens); assert.equal(after.noField!.lastShipped, f.token);
|
|
assert.equal(after.reserves, before.reserves - amount); assert.equal(after.tanks, before.tanks + amount);
|
|
assert.deepEqual(after.forces, {});
|
|
assert.equal(p(game, f.ally).forces['imperial_basin:11'], 2); assert.equal(p(game, f.ally).tanks, 0);
|
|
assert.equal(p(game, f.ally).ally, f.actor); assert.equal(after.ally, f.ally);
|
|
assert.equal((game.movementRemaining ?? []).includes(f.actor), false);
|
|
assert.deepEqual(inventory(game), f.original);
|
|
}
|
|
|
|
void test('genuine protected Basin marker and army form a real next-worm alliance without premature revelation', () => {
|
|
const f = fixture();
|
|
assert.equal(f.initial.status, 'lobby'); assert.equal(f.setup.status, 'setup');
|
|
assert.equal(f.sourceCounts.setup, f.setupActions.length); assert.equal(f.sourceCounts.source, f.sourceActions.length);
|
|
assert.equal(f.sourceCounts.markerShipment, f.markerShipment.steps.length);
|
|
assert.equal(f.sourceCounts.allyShipment, f.allyShipment.steps.length);
|
|
assert.equal(f.sourceCounts.alliance, f.alliance.steps.length);
|
|
assert.deepEqual(f.firstDials.steps.map(step => step.action.amount), [4, 5]);
|
|
assert.equal(p(f.markerShipment.before, f.actor).spice - p(f.markerShipment.after, f.actor).spice, 2);
|
|
assert.equal(p(f.allyShipment.before, f.ally).spice - p(f.allyShipment.after, f.ally).spice, 4);
|
|
assert.deepEqual(f.alliance.steps.map(step => [step.actor, step.action.type, step.action.target]),
|
|
[[f.actor, 'alliance', f.ally], [f.ally, 'alliance', f.actor]]);
|
|
assert.equal(f.alliance.before.turn, 2); assert.equal(f.alliance.before.phase, 1); assert.equal(f.alliance.before.nexus, true);
|
|
assert.equal(viewGame(f.alliance.after, f.actor).advancedAllySeparation, null);
|
|
assert.deepEqual(p(f.game, f.actor).forces, {}); assert.equal(p(f.game, f.actor).noFieldEvent, f.event);
|
|
assert.equal(f.game.active, f.actor);
|
|
assert.deepEqual(viewGame(f.game, f.actor).advancedAllySeparation, { territories: ['Imperial Basin'], noField: true });
|
|
assert.equal(viewGame(f.game, f.ally).advancedAllySeparation, null);
|
|
assert.equal(viewGame(f.game, f.actor).basicAllySeparation, null);
|
|
assert.deepEqual(inventory(f.game), f.original);
|
|
});
|
|
|
|
void test('Advanced due ends reveal zero three and five once and lose only the ending player materialized group', () => {
|
|
for (const value of [0, 3, 5] as const) {
|
|
const f = fixture({ value }); let game = act(reload(f.game), f.actor, f.action);
|
|
assertDueLoss(f, game);
|
|
const revealedEvent = p(game, f.actor).noFieldEvent;
|
|
reject(game, f.actor, f.action);
|
|
assert.equal(viewGame(game, f.actor).advancedAllySeparation, null);
|
|
game = finish(game); assert.equal(game.phase, 7);
|
|
assert.equal(p(game, f.actor).tanks, value); assert.equal(p(game, f.actor).noFieldEvent, revealedEvent);
|
|
assert.equal(p(game, f.ally).forces['imperial_basin:11'], 2);
|
|
assert.deepEqual(inventory(game), f.original);
|
|
}
|
|
});
|
|
|
|
void test('Basic actual new-alliance turn ends preserve the concealed marker and its ally formation grace', () => {
|
|
const f = fixture({ advanced: false, value: 5 }); assert.ok(f.formationEnds);
|
|
const before = f.formationMovement;
|
|
assert.equal(before.turn, 2); assert.equal(before.active, f.ally);
|
|
assert.equal(viewGame(before, f.ally).basicAllySeparation, null);
|
|
assert.equal(viewGame(before, f.actor).basicAllySeparation, null);
|
|
const game = finish(reload(before));
|
|
assert.equal(game.phase, 7); assert.deepEqual(p(game, f.actor).noField, p(before, f.actor).noField);
|
|
assert.equal(p(game, f.actor).noFieldEvent, f.event); assert.equal(p(game, f.actor).tanks, 0);
|
|
assert.equal(p(game, f.ally).forces['imperial_basin:11'], 2); assert.equal(p(game, f.ally).tanks, 0);
|
|
assert.equal(f.formationEnds.after.phase, 7); assert.deepEqual(inventory(game), f.original);
|
|
});
|
|
|
|
void test('Basic later-player deadline follows an actual earlier ally end and then destroys only the due marker group', () => {
|
|
for (const value of [0, 3, 5] as const) {
|
|
const f = fixture({ advanced: false, value });
|
|
assert.equal(f.beforeEarlierEnd.turn, 3); assert.equal(f.beforeEarlierEnd.active, f.ally);
|
|
assert.equal(viewGame(f.beforeEarlierEnd, f.ally).basicAllySeparation, null);
|
|
assert.ok(f.earlierEnds.some(step => step.actor === f.ally && step.action.type === 'endMovement'));
|
|
assert.equal(p(f.game, f.actor).noFieldEvent, f.event); assert.equal(p(f.game, f.ally).forces['imperial_basin:11'], 2);
|
|
assert.equal((f.game.movementRemaining ?? []).includes(f.ally), false);
|
|
assert.deepEqual(viewGame(f.game, f.actor).basicAllySeparation, { territories: ['Imperial Basin'], noField: true });
|
|
assert.equal(viewGame(f.game, f.actor).advancedAllySeparation, null);
|
|
const game = act(reload(f.game), f.actor, f.action); assertDueLoss(f, game);
|
|
assert.equal(viewGame(game, f.actor).basicAllySeparation, null);
|
|
}
|
|
});
|
|
|
|
void test('native voluntary reveal remains an alternative before the same due physical separation without a second reveal', () => {
|
|
const f = fixture({ value: 3 });
|
|
let game = act(reload(f.game), f.actor, { type: 'revealNoField', event: f.event, token: f.token });
|
|
const event = p(game, f.actor).noFieldEvent;
|
|
assert.notEqual(event, f.event); assert.equal(p(game, f.actor).noField!.deployed, null);
|
|
assert.equal(p(game, f.actor).forces['imperial_basin:9'], 3); assert.equal(p(game, f.actor).tanks, 0);
|
|
assert.deepEqual(viewGame(game, f.actor).advancedAllySeparation, { territories: ['Imperial Basin'] });
|
|
game = act(game, f.actor, f.action);
|
|
assertDueLoss(f, game); assert.equal(p(game, f.actor).noFieldEvent, event);
|
|
assert.equal(p(game, f.actor).tanks, 3);
|
|
});
|
|
|
|
void test('all four minimal profiles legally complete the native deadline by departure, revelation or ending', () => {
|
|
const f = fixture({ value: 3 });
|
|
for (const difficulty of ['Easy', 'Medium', 'Hard', 'Brutal'] satisfies Difficulty[]) {
|
|
let game = reload(f.game);
|
|
for (let count = 0; game.phase === 5 && (game.movementRemaining ?? []).includes(f.actor) && count < 60; count++) {
|
|
if (game.active === f.actor && clean(game)) {
|
|
const view = viewGame(game, f.actor); view.players.find(player => player.id === f.actor)!.bot = difficulty;
|
|
const choice = botActions(view)[0]; assert.ok(choice, `${difficulty} has a legal current continuation`);
|
|
game = act(game, f.actor, choice);
|
|
} else {
|
|
const step = next(game); assert.ok(step); game = act(game, step.actor, step.action);
|
|
}
|
|
}
|
|
assert.equal((game.movementRemaining ?? []).includes(f.actor), false,
|
|
`${difficulty} completes instead of stalling on concealed custody`);
|
|
assert.equal(p(game, f.ally).forces['imperial_basin:11'], 2);
|
|
assert.equal(p(game, f.ally).tanks, 0);
|
|
assert.deepEqual(inventory(game), f.original);
|
|
game = finish(game); assert.ok(game.phase === 6 || game.phase === 7);
|
|
assert.equal(p(game, f.ally).forces['imperial_basin:11'], 2);
|
|
assert.deepEqual(inventory(game), f.original);
|
|
}
|
|
});
|