249 lines
15 KiB
TypeScript
249 lines
15 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { applyAction, viewGame, type Game } from '../game/engine';
|
|
import { homeworldShipmentActions, homeworldShipmentChoice, richeseHomeworldMarkerChoice } from '../game/homeworld-shipment-options';
|
|
import { finishHarassPreparation } from './fixture-harass-withdraw';
|
|
import { homeworldContext, homeworldGameIntegrity } from '../game/homeworld-game';
|
|
import { homeworldForceGroups } from '../game/homeworld-custody';
|
|
import { currentHomeworldOccupationSnapshot, homeworldOccupationMarker,
|
|
homeworldOccupationSnapshotPresence } from '../game/homeworld-occupation-history';
|
|
import {
|
|
createRicheseHomeworldShipmentFixture as fixture,
|
|
passRicheseHomeworldShipment as pass,
|
|
richeseHomeworldShipmentInventory as inventory,
|
|
richeseHomeworldShipmentPlayer as player,
|
|
} from './fixture-richese-homeworld-shipment';
|
|
|
|
const owner = 'richese', foreign = 'homeworld:emperor', native = 'homeworld:richese';
|
|
function group(game: Game, location: string) {
|
|
const world = homeworldForceGroups(homeworldContext(game), game.homeworlds!.custody!)
|
|
.find(item => item.id === location); assert.ok(world);
|
|
return world.forces[owner] ?? {normal:0, elite:0};
|
|
}
|
|
|
|
/** Start from real public Advanced setup and native phase actions. Only a later
|
|
* fresh shipment opportunity and wallet are staged after the real first entry;
|
|
* the intervening battle is intentionally skipped, so this is not a full game. */
|
|
function stageNewTurn(game: Game) {
|
|
game.turn++;
|
|
Object.assign(game, { phase:5, phaseOpening:null, response:null, decision:null,
|
|
active:owner, order:game.players.map(p=>p.id),
|
|
movementRemaining:game.players.map(p=>p.id), ready:[] });
|
|
for (const p of game.players) { p.shipped=false; p.moved=0; }
|
|
player(game, owner).spice = 8;
|
|
homeworldGameIntegrity(game);
|
|
}
|
|
|
|
for (const value of [0,3,5] as const) void test(`Advanced concealed ${value} marker returns to its native World without materializing reserves`, () => {
|
|
const f = fixture({advanced:true, companions:2, value});
|
|
let game = f.game;
|
|
const initialInventory = inventory(game), original = structuredClone(game);
|
|
const view = viewGame(game,owner), token = view.richeseNoField!.private!.tokens.find(row=>row.value===value);
|
|
assert.ok(token);
|
|
const fresh = richeseHomeworldMarkerChoice(view, foreign, token.id, 0, undefined, {normal:2, elite:0});
|
|
assert.ok(fresh.action, fresh.blocked ?? 'The actual foreign entry must be available');
|
|
assert.equal(fresh.cost,3);
|
|
game = pass(applyAction(game,owner,fresh.action));
|
|
assert.ok(!game.pendingHomeworldShipment && player(game,owner).shipped);
|
|
assert.deepEqual(player(game,owner).noField!.deployed!.location,{homeworld:foreign});
|
|
assert.deepEqual(group(game,foreign),{normal:2,elite:0});
|
|
assert.equal(player(game,owner).reserves,player(original,owner).reserves-2);
|
|
assert.deepEqual(inventory(game),initialInventory);
|
|
stageNewTurn(game);
|
|
const before = structuredClone(game), beforeOwner = viewGame(game,owner);
|
|
const returning = richeseHomeworldMarkerChoice(beforeOwner,native,token.id,0,foreign,{normal:1,elite:0});
|
|
assert.ok(returning.action,returning.blocked ?? 'A distinct foreign-to-native return must be offered');
|
|
assert.equal(returning.amount,2);
|
|
assert.equal(returning.cost,2);
|
|
let returned = pass(applyAction(game,owner,returning.action));
|
|
assert.deepEqual(game,before);
|
|
assert.equal(player(returned,owner).spice,player(before,owner).spice-2);
|
|
assert.equal(player(returned,owner).reserves,player(before,owner).reserves+1);
|
|
assert.deepEqual(group(returned,foreign),{normal:1,elite:0});
|
|
assert.equal(player(returned,owner).noField!.deployed!.tokenId,token.id);
|
|
assert.deepEqual(player(returned,owner).noField!.deployed!.location,{homeworld:native});
|
|
assert.equal(player(returned,owner).noField!.lastShipped,token.id);
|
|
const observer = viewGame(returned,'emperor').richeseNoField!;
|
|
assert.equal(observer.private,null);
|
|
assert.deepEqual(observer.public.deployed!.location,{homeworld:native});
|
|
assert.equal(observer.public.deployed!.effectiveForces,1);
|
|
assert.equal(JSON.stringify(observer.public).includes(token.id),false);
|
|
assert.deepEqual(inventory(returned),initialInventory);
|
|
homeworldGameIntegrity(returned);
|
|
// A later ordinary shipment can move the same still-concealed marker back
|
|
// out of its native World with another physically paid companion.
|
|
let outgoing = structuredClone(returned);
|
|
stageNewTurn(outgoing);
|
|
const departure = richeseHomeworldMarkerChoice(viewGame(outgoing,owner),foreign,token.id,0,native,
|
|
{normal:1,elite:0});
|
|
assert.ok(departure.action, departure.blocked ?? 'The marker can depart its own World');
|
|
assert.equal(departure.cost,2);
|
|
const nativeBeforeDeparture = player(outgoing,owner).reserves;
|
|
outgoing = pass(applyAction(outgoing,owner,departure.action));
|
|
assert.deepEqual(player(outgoing,owner).noField!.deployed!.location,{homeworld:foreign});
|
|
assert.equal(player(outgoing,owner).reserves,nativeBeforeDeparture-1);
|
|
assert.deepEqual(group(outgoing,foreign),{normal:2,elite:0});
|
|
assert.deepEqual(inventory(outgoing),initialInventory);
|
|
homeworldGameIntegrity(outgoing);
|
|
const reserves = player(returned,owner).reserves, own = player(returned,owner);
|
|
returned = pass(applyAction(returned,owner,{type:'revealNoField',token:token.id,event:own.noFieldEvent}));
|
|
assert.equal(player(returned,owner).noField!.deployed,null);
|
|
assert.equal(player(returned,owner).reserves,reserves,
|
|
'Revealing at home does not withdraw or duplicate the native reserve pool.');
|
|
assert.deepEqual(group(returned,foreign),{normal:1,elite:0});
|
|
assert.deepEqual(inventory(returned),initialInventory);
|
|
homeworldGameIntegrity(returned);
|
|
});
|
|
|
|
/** Stages the later phase opportunities, but uses real native shipments,
|
|
* battle selection, preparation and plan actions. The native reserves and the
|
|
* invading group remain the original physical counters. */
|
|
for (const value of [0,3,5] as const) void test(`Advanced native battle counts a home No-Field ${value} without duplicating reserves`, () => {
|
|
const f = fixture({advanced:true, companions:2, value});
|
|
let game = f.game;
|
|
const originalInventory = inventory(game), own = viewGame(game,owner);
|
|
const token = own.richeseNoField!.private!.tokens.find(row=>row.value===value); assert.ok(token);
|
|
const first = richeseHomeworldMarkerChoice(own,foreign,token.id,0,undefined,{normal:2,elite:0});
|
|
assert.ok(first.action,first.blocked ?? 'The original marker deployment must be legal');
|
|
game = pass(applyAction(game,owner,first.action));
|
|
stageNewTurn(game);
|
|
const back = richeseHomeworldMarkerChoice(viewGame(game,owner),native,token.id,0,foreign,{normal:1,elite:0});
|
|
assert.ok(back.action,back.blocked ?? 'The native return must be legal');
|
|
game = pass(applyAction(game,owner,back.action));
|
|
const nativeReserves = player(game,owner).reserves;
|
|
const nativePhysical = group(game,native);
|
|
assert.equal(nativePhysical.normal,nativeReserves);
|
|
// Stage Emperor's next real World shipment from its original reserve pool.
|
|
game.turn++;
|
|
Object.assign(game,{phase:5,phaseOpening:null,response:null,decision:null,
|
|
active:'emperor',order:game.players.map(p=>p.id),
|
|
movementRemaining:game.players.map(p=>p.id),ready:[]});
|
|
for (const p of game.players) {p.shipped=false;p.moved=0;}
|
|
player(game,'emperor').spice = 10;
|
|
const invasion = homeworldShipmentChoice(viewGame(game,'emperor'),native,
|
|
{'homeworld:emperor':{normal:1,elite:0}});
|
|
assert.ok(invasion.action,invasion.blocked ?? 'An actual native World invasion must be legal');
|
|
game = pass(applyAction(game,'emperor',invasion.action));
|
|
assert.deepEqual(player(game,owner).noField!.deployed!.location,{homeworld:native});
|
|
homeworldGameIntegrity(game);
|
|
// The Battle phase is staged, then its ordinary chooser and simultaneous
|
|
// plans execute natively rather than constructing a saved battle object.
|
|
Object.assign(game,{phase:6,active:owner,ready:[],response:null,decision:null,phaseOpening:null});
|
|
const choice = viewGame(game,owner).battleChoices.find(row=>row.territory===native);
|
|
assert.ok(choice, 'The public home marker and invader create a native battle');
|
|
const target = choice.attacker === owner ? choice.defender : choice.attacker;
|
|
game = applyAction(game,owner,{type:'chooseBattle',territory:native,target});
|
|
const preview = viewGame(game,owner).battle!.ownForces!;
|
|
assert.equal(preview.normal,nativePhysical.normal,
|
|
'The native army is its existing physical pool, regardless of hidden marker value.');
|
|
assert.equal(preview.elite,nativePhysical.elite);
|
|
game = finishHarassPreparation(game);
|
|
for (const actor of [owner,'emperor']) {
|
|
const leader = player(game,actor).leaders.find(row=>!row.dead && (!row.usedAt || row.usedAt===native));
|
|
assert.ok(leader);
|
|
game = applyAction(game,actor,{type:'battlePlan',dial:0,support:0,leader:leader.id,weapon:null,defense:null});
|
|
}
|
|
assert.equal(game.battle!.revealed,true);
|
|
assert.equal(player(game,owner).noField!.deployed,null);
|
|
assert.equal(player(game,owner).reserves,nativeReserves);
|
|
assert.deepEqual(group(game,native),nativePhysical);
|
|
assert.deepEqual(inventory(game),originalInventory);
|
|
homeworldGameIntegrity(game);
|
|
});
|
|
|
|
void test('a concealed native zero marker with no reserves creates public battle presence but no phantom force', () => {
|
|
const f = fixture({advanced:true, companions:2, value:0});
|
|
let game = f.game;
|
|
const originalInventory = inventory(game), own = viewGame(game,owner);
|
|
const token = own.richeseNoField!.private!.tokens.find(row=>row.value===0); assert.ok(token);
|
|
const first = richeseHomeworldMarkerChoice(own,foreign,token.id,0,undefined,{normal:2,elite:0});
|
|
assert.ok(first.action, first.blocked ?? 'The initial deployment must be legal');
|
|
game = pass(applyAction(game,owner,first.action));
|
|
stageNewTurn(game);
|
|
const back = richeseHomeworldMarkerChoice(viewGame(game,owner),native,token.id,0,foreign,{normal:1,elite:0});
|
|
assert.ok(back.action, back.blocked ?? 'The native return must be legal');
|
|
game = pass(applyAction(game,owner,back.action));
|
|
// Explicit physical staging: move all native reserves into the Tanks while
|
|
// preserving the real returned marker and the one foreign garrison counter.
|
|
const richese = player(game,owner);
|
|
richese.tanks += richese.reserves;
|
|
richese.reserves = 0;
|
|
assert.deepEqual(group(game,native),{normal:0,elite:0});
|
|
assert.deepEqual(inventory(game),originalInventory);
|
|
homeworldGameIntegrity(game);
|
|
game.turn++;
|
|
Object.assign(game,{phase:5,phaseOpening:null,response:null,decision:null,
|
|
active:'emperor',order:game.players.map(p=>p.id),
|
|
movementRemaining:game.players.map(p=>p.id),ready:[]});
|
|
for (const p of game.players) {p.shipped=false;p.moved=0;}
|
|
player(game,'emperor').spice = 10;
|
|
const invasion = homeworldShipmentChoice(viewGame(game,'emperor'),native,
|
|
{'homeworld:emperor':{normal:1,elite:0}});
|
|
assert.ok(invasion.action,invasion.blocked ?? 'The real invading force must be legal');
|
|
game = pass(applyAction(game,'emperor',invasion.action));
|
|
assert.deepEqual(group(game,native),{normal:0,elite:0});
|
|
assert.equal(viewGame(game,'emperor').richeseNoField!.public.deployed!.effectiveForces,1);
|
|
const withMarker = currentHomeworldOccupationSnapshot(homeworldContext(game), game.homeworlds!.custody!,
|
|
homeworldOccupationMarker(game.players));
|
|
assert.deepEqual(homeworldOccupationSnapshotPresence(withMarker,native),['emperor','richese'],
|
|
'The native marker keeps the invading force from being alone before reveal.');
|
|
Object.assign(game,{phase:6,active:owner,ready:[],response:null,decision:null,phaseOpening:null});
|
|
const choice = viewGame(game,owner).battleChoices.find(row=>row.territory===native);
|
|
assert.ok(choice, 'The concealed marker remains a public battle participant even with zero native reserves');
|
|
const target = choice.attacker === owner ? choice.defender : choice.attacker;
|
|
game = applyAction(game,owner,{type:'chooseBattle',territory:native,target});
|
|
assert.equal(viewGame(game,owner).battle!.ownForces!.normal,0);
|
|
assert.equal(viewGame(game,owner).battle!.ownForces!.elite,0);
|
|
game = finishHarassPreparation(game);
|
|
for (const actor of [owner,'emperor']) {
|
|
const leader = player(game,actor).leaders.find(row=>!row.dead && (!row.usedAt || row.usedAt===native));
|
|
assert.ok(leader);
|
|
game = applyAction(game,actor,{type:'battlePlan',dial:0,support:0,leader:leader.id,weapon:null,defense:null});
|
|
}
|
|
assert.equal(game.battle!.revealed,true);
|
|
assert.equal(player(game,owner).noField!.deployed,null);
|
|
assert.equal(player(game,owner).reserves,0);
|
|
assert.deepEqual(group(game,native),{normal:0,elite:0});
|
|
const afterReveal = currentHomeworldOccupationSnapshot(homeworldContext(game), game.homeworlds!.custody!,
|
|
homeworldOccupationMarker(game.players));
|
|
assert.deepEqual(homeworldOccupationSnapshotPresence(afterReveal,native),['emperor'],
|
|
'The removed zero marker creates no physical native presence after reveal.');
|
|
assert.deepEqual(inventory(game),originalInventory);
|
|
homeworldGameIntegrity(game);
|
|
|
|
// Resolve the native Homeworld's actual Traitor decision and shared final
|
|
// opportunity, rather than stopping when the zero marker is revealed.
|
|
game = applyAction(game,owner,{type:'traitorCall',call:false});
|
|
while (game.battle?.outcomeWindow && !game.battle.outcomeWindow.closed) {
|
|
const window = game.battle.outcomeWindow;
|
|
const actor = [window.attacker,window.defender].find(id=>!window.ready.includes(id));
|
|
assert.ok(actor, 'The final battle opportunity must have an unfinished combatant');
|
|
game = applyAction(game,actor,{type:'battleOutcomeReady',event:window.event});
|
|
}
|
|
assert.equal(game.battle,null, 'The zero-reserve native battle must finish');
|
|
assert.equal(game.lastBattleContext!.territory,native);
|
|
assert.equal(player(game,owner).noField!.deployed,null);
|
|
assert.equal(player(game,owner).reserves,0);
|
|
assert.deepEqual(group(game,native),{normal:0,elite:0});
|
|
assert.deepEqual(inventory(game),originalInventory);
|
|
homeworldGameIntegrity(game);
|
|
});
|
|
|
|
void test('all four legal bot profiles offer a foreign-to-native concealed marker return', () => {
|
|
const f = fixture({advanced:true, companions:2, value:3});
|
|
let game = f.game;
|
|
const own = viewGame(game,owner), token = own.richeseNoField!.private!.tokens.find(row=>row.value===3);
|
|
assert.ok(token);
|
|
const first = richeseHomeworldMarkerChoice(own,foreign,token.id,0,undefined,{normal:2,elite:0});
|
|
assert.ok(first.action, first.blocked ?? 'The original marker deployment must be legal');
|
|
game = pass(applyAction(game,owner,first.action));
|
|
stageNewTurn(game);
|
|
for (let level=0; level<4; level++) {
|
|
const view = viewGame(game,owner);
|
|
const action = homeworldShipmentActions(view,level).find(candidate => candidate.type === 'homeworldShip' &&
|
|
candidate.destination === native && candidate.noFieldFrom === foreign && candidate.noField === token.id);
|
|
assert.ok(action, `Profile ${level} should offer the legal marker return`);
|
|
assert.doesNotThrow(() => applyAction(game,owner,action));
|
|
}
|
|
});
|