211 lines
13 KiB
TypeScript
211 lines
13 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { applyAction, viewGame, type Action, type Game } from '../game/engine';
|
|
import { combatArmy, homeworldBattleLocation } from '../game/combat-location';
|
|
import {
|
|
HARASS_HOMEWORLD_CARD, advanceHarassHomeworld,
|
|
assertHarassHomeworldCustody, chooseHarassHomeworldReturn, createHarassHomeworldFixture,
|
|
finishHarassHomeworldBattle, harassHomeworldClean, harassHomeworldPlayer as player,
|
|
harassHomeworldPool, revealHarassHomeworldBattle, sealHarassHomeworldPlan,
|
|
type HarassHomeworldStep,
|
|
} from './fixture-harass-homeworld';
|
|
|
|
function rejectsUnchanged(game: Game, actor: string, action: Action, reason?: RegExp): void {
|
|
const before = JSON.stringify(game);
|
|
if (reason) assert.throws(() => applyAction(game, actor, action), reason);
|
|
else assert.throws(() => applyAction(game, actor, action));
|
|
assert.equal(JSON.stringify(game), before, 'An illegal action must not mutate original custody or sealed plans');
|
|
}
|
|
function assertFinished(game: Game, owner: string, location: string): void {
|
|
assert.equal(game.battle, null);
|
|
assert.ok(!game.homeworldBattleLoss && !game.pendingTreacheryDiscard && harassHomeworldClean(game));
|
|
assert.equal(game.lastBattleContext!.territory, location);
|
|
assert.equal(game.discard.filter(c => c.id === HARASS_HOMEWORLD_CARD).length, 1);
|
|
assert.ok(!player(game, owner).hand.some(c => c.id === HARASS_HOMEWORLD_CARD));
|
|
assertHarassHomeworldCustody(game);
|
|
}
|
|
|
|
for (const sample of [
|
|
{ advanced: false, slot: 'weapon' as const },
|
|
{ advanced: true, slot: 'defense' as const },
|
|
]) void test(`${sample.advanced ? 'Advanced' : 'Basic'} native visitor ${sample.slot} returns actual typed counters, then loses only its original commitment`, () => {
|
|
const f = createHarassHomeworldFixture(sample);
|
|
for (const state of [f.afterSetup, f.beforeShipment, f.afterShipment, f.beforeBattle, f.game])
|
|
assertHarassHomeworldCustody(state);
|
|
assert.equal(f.shipmentStep.action.type, 'homeworldShip');
|
|
assert.equal(f.battleStep.action.type, 'chooseBattle');
|
|
assert.deepEqual(combatArmy(f.beforeShipment, f.visitor, f.location), { normal: 0, elite: 0 });
|
|
assert.deepEqual(combatArmy(f.afterShipment, f.visitor, f.location), { normal: 3, elite: 4 });
|
|
assert.equal(player(f.afterShipment, f.visitor).reserves, player(f.beforeShipment, f.visitor).reserves - 7);
|
|
assert.equal(player(f.afterShipment, f.visitor).elites!.reserves, player(f.beforeShipment, f.visitor).elites!.reserves - 4);
|
|
assert.equal(f.game.battle!.harassAllocationVersion, 1);
|
|
let game = sealHarassHomeworldPlan(f.game, f.planActions[0]);
|
|
assert.ok(!game.battle!.revealed);
|
|
assert.equal(game.battle!.harassAllocation, undefined);
|
|
assert.equal(viewGame(game, f.opponent).battle!.plans[f.owner], undefined);
|
|
const sealedPlan = structuredClone(game.battle!.plans[f.owner]);
|
|
assert.equal(sealedPlan[sample.slot], HARASS_HOMEWORLD_CARD);
|
|
game = sealHarassHomeworldPlan(game, f.planActions[1]);
|
|
assert.equal(game.battle!.revealed, true);
|
|
assert.equal(game.decision?.kind, 'harassWithdraw');
|
|
assert.deepEqual(game.battle!.plans[f.owner], sealedPlan);
|
|
const offer = viewGame(game, f.owner).battle!.harassAllocation!;
|
|
assert.deepEqual(offer.context.locations, { [f.location]: { normal: 3, elite: 4 } });
|
|
assert.deepEqual(offer.context.forces.normal, 3);
|
|
assert.deepEqual(offer.context.forces.elite, 4);
|
|
assert.equal(viewGame(game, f.opponent).battle!.harassAllocation, null);
|
|
const beforeSelection = structuredClone(game);
|
|
game = chooseHarassHomeworldReturn(game, f.returns);
|
|
assert.deepEqual(game.battle!.plans[f.owner], sealedPlan);
|
|
assert.deepEqual(game.homeworlds, beforeSelection.homeworlds, 'Allocation selection is not a premature withdrawal');
|
|
for (const p of game.players) {
|
|
assert.equal(p.reserves, player(beforeSelection, p.id).reserves);
|
|
assert.equal(p.tanks, player(beforeSelection, p.id).tanks);
|
|
}
|
|
assert.deepEqual(viewGame(game, f.owner).battle!.traitorVoters, [f.native]);
|
|
rejectsUnchanged(game, f.visitor, { type: 'traitorCall', call: false });
|
|
const actions: HarassHomeworldStep[] = [];
|
|
const done = finishHarassHomeworldBattle(game, { actions });
|
|
const returned = f.returns[f.location], amount = returned.normal + returned.elite;
|
|
const before = player(f.game, f.owner), after = player(done, f.owner);
|
|
assert.equal(done.lastBattleContext!.winner, f.native);
|
|
assert.equal(done.lastBattleContext!.result, 'normal');
|
|
assert.equal(after.reserves, before.reserves + amount);
|
|
assert.equal(after.elites!.reserves, before.elites!.reserves + returned.elite);
|
|
assert.equal(after.tanks, before.tanks + 7 - amount);
|
|
assert.equal(after.elites!.tanks, before.elites!.tanks + 4 - returned.elite);
|
|
assert.equal(after.battleLosses, before.battleLosses + 7 - amount);
|
|
assert.equal(after.revived, before.revived);
|
|
assert.equal(after.freeForcesRevived, before.freeForcesRevived);
|
|
assert.equal(after.elites!.revived, before.elites!.revived);
|
|
assert.deepEqual(combatArmy(done, f.owner, f.location), { normal: 0, elite: 0 });
|
|
const primary = 'homeworld:emperor';
|
|
const homeBefore = harassHomeworldPool(f.game, f.owner, primary);
|
|
assert.deepEqual(harassHomeworldPool(done, f.owner, primary), sample.advanced
|
|
? { normal: homeBefore.normal + returned.normal, elite: homeBefore.elite }
|
|
: { normal: homeBefore.normal + returned.normal, elite: homeBefore.elite + returned.elite });
|
|
if (sample.advanced) {
|
|
const salusa = harassHomeworldPool(f.game, f.owner, 'homeworld:emperor:salusa');
|
|
assert.deepEqual(harassHomeworldPool(done, f.owner, 'homeworld:emperor:salusa'),
|
|
{ normal: salusa.normal, elite: salusa.elite + returned.elite });
|
|
}
|
|
assert.equal(player(done, f.native).tanks - player(f.game, f.native).tanks, 3);
|
|
assert.deepEqual(actions.filter(s => s.action.type === 'traitorCall').map(s => s.actor), [f.native]);
|
|
assert.equal(after.leaders.find(l => l.id === sealedPlan.leader)!.dead, false, 'Ordinary leader resolution is unchanged');
|
|
assertFinished(done, f.owner, f.location);
|
|
const continued = advanceHarassHomeworld(done, g => g.phase === 7 && harassHomeworldClean(g));
|
|
assert.equal(continued.turn, f.game.turn);
|
|
assertFinished(continued, f.owner, f.location);
|
|
});
|
|
|
|
void test('Advanced visitor winner pays its fixed original support and discards Harass instead of retaining it', () => {
|
|
const f = createHarassHomeworldFixture({ advanced: true, slot: 'weapon', outcome: 'win' });
|
|
let game = revealHarassHomeworldBattle(f);
|
|
const sealedPlan = structuredClone(game.battle!.plans[f.owner]);
|
|
game = chooseHarassHomeworldReturn(game, f.returns);
|
|
assert.deepEqual(game.battle!.plans[f.owner], sealedPlan);
|
|
const before = player(f.game, f.owner);
|
|
const done = finishHarassHomeworldBattle(game);
|
|
const after = player(done, f.owner);
|
|
assert.equal(done.lastBattleContext!.winner, f.owner);
|
|
assert.equal(after.reserves, before.reserves + 5);
|
|
assert.equal(after.tanks, before.tanks + 2);
|
|
assert.equal(after.elites!.tanks, before.elites!.tanks + 1);
|
|
assert.equal(after.battleLosses, before.battleLosses + 2);
|
|
assert.equal(after.spice, before.spice - 1, 'No leader dies here; original one-spice support is charged exactly once');
|
|
assert.deepEqual(combatArmy(done, f.owner, f.location), { normal: 0, elite: 0 });
|
|
assertFinished(done, f.owner, f.location);
|
|
});
|
|
|
|
for (const sample of [
|
|
{ advanced: false, secondary: false, slot: 'weapon' as const },
|
|
{ advanced: true, secondary: false, slot: 'defense' as const },
|
|
{ advanced: true, secondary: true, slot: 'weapon' as const },
|
|
]) void test(`${sample.advanced ? 'Advanced' : 'Basic'} own ${sample.secondary ? 'Salusa' : 'Kaitain'} forbids Harass immutably but accepts the plain original plan`, () => {
|
|
const f = createHarassHomeworldFixture({ ...sample, role: 'native' });
|
|
assert.equal(homeworldBattleLocation(f.game, f.location)!.native, f.owner);
|
|
const preview = viewGame(f.game, f.owner).battle!.harassWithdraw!;
|
|
assert.match(preview.blocked!, /own.*Homeworld/i);
|
|
rejectsUnchanged(f.game, f.owner, f.planActions[0].action, /own.*Homeworld/i);
|
|
assert.equal(Object.keys(f.game.battle!.plans).length, 0);
|
|
assert.ok(player(f.game, f.owner).hand.some(c => c.id === HARASS_HOMEWORLD_CARD));
|
|
const plain: HarassHomeworldStep = { actor: f.owner, action: { ...f.planActions[0].action, weapon: null, defense: null } };
|
|
let game = sealHarassHomeworldPlan(f.game, plain);
|
|
game = sealHarassHomeworldPlan(game, f.planActions[1]);
|
|
assert.equal(game.battle!.revealed, true);
|
|
assert.deepEqual(viewGame(game, f.owner).battle!.traitorVoters, [f.owner]);
|
|
const actions: HarassHomeworldStep[] = [];
|
|
game = finishHarassHomeworldBattle(game, { actions });
|
|
assert.equal(game.battle, null);
|
|
assert.ok(harassHomeworldClean(game));
|
|
assert.equal(game.lastBattleContext!.territory, f.location);
|
|
assert.equal(game.lastBattleContext!.result, 'normal');
|
|
assert.ok(player(game, f.owner).hand.some(c => c.id === HARASS_HOMEWORLD_CARD), 'Rejected card was never used');
|
|
assert.equal(game.discard.filter(c => c.id === HARASS_HOMEWORLD_CARD).length, 0);
|
|
assert.ok(actions.filter(s => s.action.type === 'traitorCall').every(s => s.actor === f.owner));
|
|
assertHarassHomeworldCustody(game);
|
|
});
|
|
|
|
void test('the real opposing native Traitor cancels a selected typed withdrawal; no invader vote is invented', () => {
|
|
const f = createHarassHomeworldFixture({ advanced: true, slot: 'defense', outcome: 'traitor' });
|
|
let game = revealHarassHomeworldBattle(f);
|
|
assert.ok(player(game, f.native).traitors.includes(game.battle!.plans[f.owner].leader!));
|
|
game = chooseHarassHomeworldReturn(game, f.returns);
|
|
assert.deepEqual(viewGame(game, f.owner).battle!.traitorVoters, [f.native]);
|
|
rejectsUnchanged(game, f.visitor, { type: 'traitorCall', call: true });
|
|
const actions: HarassHomeworldStep[] = [];
|
|
const done = finishHarassHomeworldBattle(game, { callers: [f.native], actions });
|
|
const before = player(f.game, f.owner), after = player(done, f.owner);
|
|
assert.equal(done.lastBattleContext!.result, 'traitor');
|
|
assert.equal(done.lastBattleContext!.winner, f.native);
|
|
assert.equal(after.reserves, before.reserves);
|
|
assert.equal(after.elites!.reserves, before.elites!.reserves);
|
|
assert.equal(after.tanks, before.tanks + 7);
|
|
assert.equal(after.elites!.tanks, before.elites!.tanks + 4);
|
|
assert.equal(after.battleLosses, before.battleLosses + 7);
|
|
assert.equal(after.revived, before.revived);
|
|
assert.equal(after.elites!.revived, before.elites!.revived);
|
|
assert.deepEqual(combatArmy(done, f.owner, f.location), { normal: 0, elite: 0 });
|
|
assert.equal(player(done, f.native).tanks, player(f.game, f.native).tanks);
|
|
assert.equal(after.leaders.find(l => l.id === f.planActions[0].action.leader)!.dead, true);
|
|
assertFinished(done, f.owner, f.location);
|
|
});
|
|
|
|
void test('Harass precedes Lasgun/Shield: returned visitors survive while native losses retain the printed Homeworld exception', () => {
|
|
const f = createHarassHomeworldFixture({ advanced: true, slot: 'defense', outcome: 'explosion' });
|
|
let game = revealHarassHomeworldBattle(f);
|
|
const nativeBefore = combatArmy(f.game, f.native, f.location);
|
|
const printed = homeworldBattleLocation(f.game, f.location)!.nativeBattleStrength;
|
|
assert.ok(nativeBefore.normal > printed);
|
|
const ownPlan = structuredClone(game.battle!.plans[f.owner]);
|
|
const enemyPlan = structuredClone(game.battle!.plans[f.opponent]);
|
|
assert.equal(player(game, f.owner).hand.find(c => c.id === ownPlan.weapon)!.kind, 'lasgun');
|
|
assert.equal(player(game, f.opponent).hand.find(c => c.id === enemyPlan.defense)!.kind, 'shield');
|
|
game = chooseHarassHomeworldReturn(game, f.returns);
|
|
assert.deepEqual(game.battle!.plans[f.owner], ownPlan);
|
|
const actions: HarassHomeworldStep[] = [];
|
|
const done = finishHarassHomeworldBattle(game, { actions });
|
|
const before = player(f.game, f.owner), after = player(done, f.owner);
|
|
assert.equal(done.lastBattleContext!.result, 'explosion');
|
|
assert.equal(done.lastBattleContext!.winner, null);
|
|
assert.equal(after.reserves, before.reserves + 5);
|
|
assert.equal(after.elites!.reserves, before.elites!.reserves + 3);
|
|
assert.equal(after.tanks, before.tanks + 2);
|
|
assert.equal(after.elites!.tanks, before.elites!.tanks + 1);
|
|
assert.equal(after.battleLosses, before.battleLosses + 2);
|
|
assert.equal(after.revived, before.revived);
|
|
assert.equal(after.freeForcesRevived, before.freeForcesRevived);
|
|
assert.equal(after.elites!.revived, before.elites!.revived);
|
|
assert.deepEqual(combatArmy(done, f.owner, f.location), { normal: 0, elite: 0 });
|
|
assert.deepEqual(combatArmy(done, f.native, f.location), { normal: nativeBefore.normal - printed, elite: nativeBefore.elite });
|
|
assert.equal(player(done, f.native).reserves, player(f.game, f.native).reserves - printed);
|
|
assert.equal(player(done, f.native).tanks, player(f.game, f.native).tanks + printed);
|
|
assert.equal(player(done, f.native).battleLosses, player(f.game, f.native).battleLosses + printed);
|
|
assert.equal(after.leaders.find(l => l.id === ownPlan.leader)!.dead, true);
|
|
assert.equal(player(done, f.opponent).leaders.find(l => l.id === enemyPlan.leader)!.dead, true);
|
|
for (const id of [HARASS_HOMEWORLD_CARD, ownPlan.weapon, enemyPlan.defense])
|
|
assert.equal(done.discard.filter(c => c.id === id).length, 1);
|
|
assert.deepEqual(actions.filter(s => s.action.type === 'traitorCall').map(s => s.actor), [f.native]);
|
|
assertFinished(done, f.owner, f.location);
|
|
});
|