Connect mixed No-Field armies to native Occupy battles
This commit is contained in:
1 parent
a58b8bc92c
commit
0dfdeb9578
14 files changed
+778
-43
No files matched your search
@@ -0,0 +1,267 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { applyAction, viewGame, RuleError, type Game } from '../game/engine';
|
||||
import { occupyRicheseSeat } from './fixture-ecaz-occupy-richese';
|
||||
import { NO_FIELD_HARASS, NO_FIELD_REINFORCEMENTS } from './fixture-no-field-reinforcements';
|
||||
import {
|
||||
ecazOccupyMixedNoFieldFixture, sealEcazOccupyMixedNoField, finishEcazOccupyMixedNoField,
|
||||
type EcazOccupyMixedNoFieldFixture,
|
||||
} from './fixture-ecaz-occupy-mixed-no-field';
|
||||
|
||||
function assertCustody(fixture: EcazOccupyMixedNoFieldFixture, game: Game): void {
|
||||
const cards = (state: Game) => [...state.deck, ...state.discard,
|
||||
...(state.richeseCache ?? []), ...(state.richeseRemoved ?? []),
|
||||
...state.players.flatMap(player => player.hand)].map(card => card.id).sort();
|
||||
assert.deepEqual(cards(game), cards(fixture.initial), 'Every original physical card retains custody.');
|
||||
const traitors = (state: Game) => [...(state.traitorReserve ?? []),
|
||||
...(state.ecazLoyalty?.card ? [state.ecazLoyalty.card] : []),
|
||||
...state.players.flatMap(player => player.traitors)].sort();
|
||||
assert.deepEqual(traitors(game), traitors(fixture.afterSetup));
|
||||
for (const player of game.players) {
|
||||
const counters = [player.reserves, player.tanks, ...Object.values(player.forces)];
|
||||
assert.equal(counters.reduce((sum, count) => sum + count, 0), 20,
|
||||
`${player.faction} keeps its own twenty physical counters.`);
|
||||
assert.ok(counters.every(count => Number.isSafeInteger(count) && count >= 0));
|
||||
assert.ok(player.hand.length <= 4, 'Conserved staging must not leave a native hand over its limit.');
|
||||
}
|
||||
}
|
||||
function assertFirstSeal(fixture: EcazOccupyMixedNoFieldFixture, first: Game): void {
|
||||
const before = occupyRicheseSeat(fixture.preplan, fixture.richese);
|
||||
const sealed = occupyRicheseSeat(first, fixture.richese);
|
||||
assert.equal(first.battle!.revealed, false);
|
||||
assert.deepEqual(sealed.noField, fixture.noField);
|
||||
assert.equal(sealed.noFieldEvent, before.noFieldEvent);
|
||||
assert.equal(sealed.reserves, before.reserves);
|
||||
assert.equal(sealed.forces[fixture.location], fixture.ordinary);
|
||||
assert.equal(sealed.tanks, before.tanks);
|
||||
assert.equal(viewGame(first, fixture.opponent).battle!.plans[fixture.owner], undefined);
|
||||
assertCustody(fixture, first);
|
||||
}
|
||||
function assertReveal(fixture: EcazOccupyMixedNoFieldFixture, revealed: Game): void {
|
||||
const richese = occupyRicheseSeat(revealed, fixture.richese);
|
||||
const original = occupyRicheseSeat(fixture.preplan, fixture.richese);
|
||||
assert.equal(revealed.battle!.revealed, true);
|
||||
assert.equal(richese.noField!.deployed, null);
|
||||
assert.equal(richese.noField!.lastShipped, fixture.noField.deployed!.tokenId);
|
||||
assert.deepEqual(richese.noField!.tokens, fixture.noField.tokens);
|
||||
assert.notEqual(richese.noFieldEvent, original.noFieldEvent);
|
||||
assert.equal(richese.forces[fixture.location], fixture.ordinary + fixture.materializes,
|
||||
'Both actual seals add native marker counters to, rather than replace, ordinary counters.');
|
||||
assert.equal(richese.reserves, original.reserves - fixture.materializes);
|
||||
assert.equal(richese.tanks, original.tanks);
|
||||
assertCustody(fixture, revealed);
|
||||
}
|
||||
function assertHistory(fixture: EcazOccupyMixedNoFieldFixture, revealed: Game, done: Game): void {
|
||||
const richese = occupyRicheseSeat(done, fixture.richese);
|
||||
assert.equal(richese.noField!.deployed, null);
|
||||
assert.deepEqual(richese.noField!.tokens, fixture.noField.tokens);
|
||||
assert.equal(richese.noField!.lastShipped, fixture.noField.lastShipped);
|
||||
assert.equal(richese.noFieldEvent, occupyRicheseSeat(revealed, fixture.richese).noFieldEvent,
|
||||
'Withdrawal, losses and aftermath must not perform a second marker revelation.');
|
||||
for (const actor of [fixture.ecaz, fixture.richese, fixture.opponent]) {
|
||||
const history = viewGame(done, actor).players.find(player => player.id === fixture.richese)!.noField!;
|
||||
assert.equal(history.deployed, null);
|
||||
assert.equal(history.lastUsed, fixture.marker, 'The actual shipped denomination becomes native public history.');
|
||||
}
|
||||
assert.equal(done.battle, null);
|
||||
assert.equal(done.decision, null);
|
||||
assertCustody(fixture, done);
|
||||
}
|
||||
function assertUtilities(game: Game, used: readonly string[]): void {
|
||||
for (const id of [NO_FIELD_HARASS, NO_FIELD_REINFORCEMENTS]) {
|
||||
assert.equal(game.discard.filter(card => card.id === id).length, used.includes(id) ? 1 : 0);
|
||||
assert.equal(game.players.flatMap(player => player.hand).filter(card => card.id === id).length,
|
||||
used.includes(id) ? 0 : 1);
|
||||
}
|
||||
}
|
||||
|
||||
// Three denominations, one reserve-capped positive marker, and both selected
|
||||
// plan actors. Every case retains positive ordinary Richese physical presence.
|
||||
for (const lead of ['ecaz', 'ally'] as const)
|
||||
for (const [marker, reserves] of [[0, 0], [3, 6], [5, 2]] as const)
|
||||
void test(`Mixed Richese variable ally: marker ${marker}, reserves ${reserves}, ${lead} lead seals and resolves native counters`, () => {
|
||||
const fixture = ecazOccupyMixedNoFieldFixture({ lead, marker, richeseReserves: reserves });
|
||||
const actorView = viewGame(fixture.preplan, fixture.owner).battle!;
|
||||
const profile = actorView.ecazOccupy!.profile!;
|
||||
assert.equal(profile.forceOwner, fixture.richese);
|
||||
assert.equal(profile.payer, fixture.owner);
|
||||
assert.equal(profile.fixedEcazDial, 3);
|
||||
assert.equal(profile.maxDial, 3 + fixture.ordinary + fixture.materializes);
|
||||
assert.equal(actorView.ownForces!.normal, fixture.ordinary + fixture.materializes);
|
||||
assert.equal(actorView.mixedNoField, true,
|
||||
'The selected Ecaz plan also uses its physical Richese variable owner, not the Ecaz counter pool.');
|
||||
const rivalView = viewGame(fixture.preplan, fixture.opponent).battle!;
|
||||
assert.equal(rivalView.opponentForces, null);
|
||||
assert.equal(rivalView.ecazOccupy!.profile, null,
|
||||
'Ordinary presence must not disclose the prospective concealed increment.');
|
||||
assert.equal(rivalView.mixedNoField, undefined);
|
||||
const first = applyAction(fixture.preplan, fixture.owner, fixture.plans.plain);
|
||||
assertFirstSeal(fixture, first);
|
||||
const revealed = applyAction(first, fixture.opponent, fixture.plans.opponent);
|
||||
assertReveal(fixture, revealed);
|
||||
const { game: done } = finishEcazOccupyMixedNoField(fixture, revealed);
|
||||
assert.equal(done.lastBattleContext!.result, 'normal');
|
||||
assert.equal(done.lastBattleContext!.winner, fixture.owner);
|
||||
const richese = occupyRicheseSeat(done, fixture.richese);
|
||||
assert.equal(richese.forces[fixture.location] ?? 0, fixture.ordinary + fixture.materializes - fixture.variableDial);
|
||||
assert.equal(richese.tanks - occupyRicheseSeat(fixture.preplan, fixture.richese).tanks, fixture.variableDial);
|
||||
assert.equal(richese.reserves, reserves - fixture.materializes);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.ecaz).forces[fixture.location], 2);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.ecaz).tanks - occupyRicheseSeat(fixture.preplan, fixture.ecaz).tanks, 3);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.opponent).tanks - occupyRicheseSeat(fixture.preplan, fixture.opponent).tanks, 8);
|
||||
for (const actor of [fixture.ecaz, fixture.richese])
|
||||
assert.equal(occupyRicheseSeat(done, actor).spice,
|
||||
occupyRicheseSeat(fixture.preplan, actor).spice - (actor === fixture.owner ? fixture.support : 0) +
|
||||
((occupyRicheseSeat(done, actor).forces[fixture.location] ?? 0) > 0 ? 2 : 0));
|
||||
assertUtilities(done, []);
|
||||
assertHistory(fixture, revealed, done);
|
||||
});
|
||||
|
||||
void test('Mixed capped ally uses actual unsupported physical losses, while the original Ecaz fixed commitment stays free', () => {
|
||||
const fixture = ecazOccupyMixedNoFieldFixture({ lead: 'ecaz', marker: 5, richeseReserves: 2,
|
||||
variableDial: 2, support: 0 });
|
||||
const revealed = sealEcazOccupyMixedNoField(fixture);
|
||||
assertReveal(fixture, revealed);
|
||||
const { game: done } = finishEcazOccupyMixedNoField(fixture, revealed);
|
||||
assert.equal(done.lastBattleContext!.winner, fixture.ecaz);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.richese).tanks - occupyRicheseSeat(fixture.preplan, fixture.richese).tanks, 4,
|
||||
'Two unsupported strength consumes all four real ordinary-plus-revealed counters.');
|
||||
assert.equal(occupyRicheseSeat(done, fixture.richese).forces[fixture.location] ?? 0, 0);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.ecaz).tanks - occupyRicheseSeat(fixture.preplan, fixture.ecaz).tanks, 3);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.ecaz).spice,
|
||||
occupyRicheseSeat(fixture.preplan, fixture.ecaz).spice + 2);
|
||||
assertHistory(fixture, revealed, done);
|
||||
});
|
||||
|
||||
for (const lead of ['ecaz', 'ally'] as const)
|
||||
void test(`Mixed positive marker with ${lead}-held H/R returns only that card user's actual undialed army`, () => {
|
||||
const fixture = ecazOccupyMixedNoFieldFixture({ lead });
|
||||
const before = fixture.preplan;
|
||||
const offer = viewGame(before, fixture.owner).battle!;
|
||||
assert.equal(offer.harassWithdraw!.blocked, null);
|
||||
assert.equal(offer.reinforcements!.blocked, null);
|
||||
assert.equal(offer.reinforcements!.normal, 3);
|
||||
if (lead === 'ally') {
|
||||
assert.equal(offer.harassWithdraw!.forces.normal, fixture.ordinary + fixture.materializes);
|
||||
assert.equal(offer.harassWithdraw!.locations[fixture.location].normal, fixture.ordinary + fixture.materializes);
|
||||
assert.equal(offer.reinforcements!.noField!.reservesAfterReveal, 3);
|
||||
} else assert.equal(offer.reinforcements!.noField, undefined);
|
||||
const first = applyAction(before, fixture.owner, fixture.plans.both);
|
||||
assertFirstSeal(fixture, first);
|
||||
const revealed = applyAction(first, fixture.opponent, fixture.plans.opponent);
|
||||
assertReveal(fixture, revealed);
|
||||
const { game: done } = finishEcazOccupyMixedNoField(fixture, revealed);
|
||||
assert.equal(done.lastBattleContext!.result, 'normal');
|
||||
assert.equal(done.lastBattleContext!.winner, fixture.owner);
|
||||
const ecaz = occupyRicheseSeat(done, fixture.ecaz);
|
||||
const richese = occupyRicheseSeat(done, fixture.richese);
|
||||
const returned = lead === 'ecaz' ? 2 : fixture.ordinary + fixture.materializes - fixture.variableDial;
|
||||
assert.ok(returned > 0);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.owner).reserves,
|
||||
occupyRicheseSeat(before, fixture.owner).reserves - (lead === 'ally' ? fixture.materializes : 0) - 3 + returned,
|
||||
'Three original reserves are spent before, and cannot be funded by, the future H return.');
|
||||
assert.equal(ecaz.tanks - occupyRicheseSeat(before, fixture.ecaz).tanks, 3 + (lead === 'ecaz' ? 3 : 0),
|
||||
'Returning Ecaz undialed counters never reduces or recalculates ceil(original five / two).');
|
||||
assert.equal(richese.tanks - occupyRicheseSeat(before, fixture.richese).tanks,
|
||||
fixture.variableDial + (lead === 'ally' ? 3 : 0));
|
||||
assert.equal(ecaz.forces[fixture.location] ?? 0, lead === 'ecaz' ? 0 : 2);
|
||||
assert.equal(richese.forces[fixture.location] ?? 0, lead === 'ally' ? 0 : fixture.ordinary + fixture.materializes - fixture.variableDial);
|
||||
const other = lead === 'ecaz' ? fixture.richese : fixture.ecaz;
|
||||
assert.equal(occupyRicheseSeat(done, other).reserves,
|
||||
occupyRicheseSeat(before, other).reserves - (other === fixture.richese ? fixture.materializes : 0));
|
||||
assert.equal(occupyRicheseSeat(done, fixture.owner).spice,
|
||||
occupyRicheseSeat(before, fixture.owner).spice - fixture.support);
|
||||
assertUtilities(done, [NO_FIELD_HARASS, NO_FIELD_REINFORCEMENTS]);
|
||||
assertHistory(fixture, revealed, done);
|
||||
});
|
||||
|
||||
void test('Mixed Richese Reinforcements alone spends post-reveal reserves without returning undialed board counters', () => {
|
||||
const fixture = ecazOccupyMixedNoFieldFixture();
|
||||
const revealed = sealEcazOccupyMixedNoField(fixture, 'reinforcements');
|
||||
assertReveal(fixture, revealed);
|
||||
const { game: done } = finishEcazOccupyMixedNoField(fixture, revealed);
|
||||
assert.equal(done.lastBattleContext!.winner, fixture.richese);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.richese).reserves, 0);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.richese).forces[fixture.location], 2);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.richese).tanks - occupyRicheseSeat(fixture.preplan, fixture.richese).tanks, 6);
|
||||
assertUtilities(done, [NO_FIELD_REINFORCEMENTS]);
|
||||
assertHistory(fixture, revealed, done);
|
||||
});
|
||||
|
||||
void test('Mixed Richese unfunded FIRST R and H/R plans reject immutably; a real H-only fallback remains legal', () => {
|
||||
const fixture = ecazOccupyMixedNoFieldFixture({ marker: 5, richeseReserves: 7 });
|
||||
const before = fixture.preplan;
|
||||
const saved = structuredClone(before);
|
||||
const offer = viewGame(before, fixture.owner).battle!;
|
||||
assert.equal(offer.reinforcements!.normal, 2);
|
||||
assert.equal(offer.reinforcements!.noField!.reservesAfterReveal, 2);
|
||||
assert.ok(offer.reinforcements!.blocked);
|
||||
assert.equal(offer.harassWithdraw!.blocked, null);
|
||||
for (const plan of [fixture.plans.reinforcements, fixture.plans.both]) {
|
||||
assert.throws(() => applyAction(before, fixture.owner, plan), RuleError);
|
||||
assert.deepEqual(before, saved, 'No first seal, card custody, reserve debit or marker reveal survives rejection.');
|
||||
assert.equal(before.battle!.plans[fixture.owner], undefined);
|
||||
}
|
||||
const first = applyAction(before, fixture.owner, fixture.plans.harass);
|
||||
assertFirstSeal(fixture, first);
|
||||
const revealed = applyAction(first, fixture.opponent, fixture.plans.opponent);
|
||||
assertReveal(fixture, revealed);
|
||||
const { game: done } = finishEcazOccupyMixedNoField(fixture, revealed);
|
||||
assert.equal(done.lastBattleContext!.winner, fixture.richese);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.richese).reserves, 7 + fixture.ordinary - fixture.variableDial);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.richese).forces[fixture.location] ?? 0, 0);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.richese).tanks - occupyRicheseSeat(before, fixture.richese).tanks, fixture.variableDial);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.ecaz).forces[fixture.location], 2);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.ecaz).tanks - occupyRicheseSeat(before, fixture.ecaz).tanks, 3);
|
||||
assertUtilities(done, [NO_FIELD_HARASS]);
|
||||
assertHistory(fixture, revealed, done);
|
||||
});
|
||||
|
||||
void test('Ecaz-held mixed H/R cannot spend its ally reserves or its own future Harass return', () => {
|
||||
const fixture = ecazOccupyMixedNoFieldFixture({ lead: 'ecaz', richeseReserves: 8, ecazReserves: 2 });
|
||||
const before = fixture.preplan;
|
||||
const saved = structuredClone(before);
|
||||
const offer = viewGame(before, fixture.ecaz).battle!.reinforcements!;
|
||||
assert.equal(offer.normal, 2);
|
||||
assert.equal(offer.noField, undefined);
|
||||
assert.ok(offer.blocked);
|
||||
assert.throws(() => applyAction(before, fixture.ecaz, fixture.plans.both), RuleError);
|
||||
assert.deepEqual(before, saved);
|
||||
const revealed = sealEcazOccupyMixedNoField(fixture, 'harass');
|
||||
assertReveal(fixture, revealed);
|
||||
const { game: done } = finishEcazOccupyMixedNoField(fixture, revealed);
|
||||
assert.equal(done.lastBattleContext!.winner, fixture.ecaz);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.ecaz).reserves, 4);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.ecaz).tanks - occupyRicheseSeat(before, fixture.ecaz).tanks, 3);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.richese).reserves, 5);
|
||||
assertUtilities(done, [NO_FIELD_HARASS]);
|
||||
assertHistory(fixture, revealed, done);
|
||||
});
|
||||
|
||||
for (const lead of ['ecaz', 'ally'] as const)
|
||||
void test(`Real opposing Traitor cancels ${lead}-held mixed Harass, but preserves native reveal and the original R cost`, () => {
|
||||
const fixture = ecazOccupyMixedNoFieldFixture({ lead, opposingTraitor: true });
|
||||
const before = fixture.preplan;
|
||||
const leader = fixture.plans.both.leader;
|
||||
assert.ok(typeof leader === 'string');
|
||||
assert.ok(occupyRicheseSeat(before, fixture.opponent).traitors.includes(leader));
|
||||
const revealed = sealEcazOccupyMixedNoField(fixture, 'both');
|
||||
assertReveal(fixture, revealed);
|
||||
const { game: done } = finishEcazOccupyMixedNoField(fixture, revealed);
|
||||
assert.equal(done.lastBattleContext!.result, 'traitor');
|
||||
assert.equal(done.lastBattleContext!.winner, fixture.opponent);
|
||||
assert.equal(occupyRicheseSeat(done, fixture.owner).leaders.find(face => face.id === leader)!.dead, true);
|
||||
for (const actor of [fixture.ecaz, fixture.richese]) {
|
||||
const original = occupyRicheseSeat(before, actor);
|
||||
const player = occupyRicheseSeat(done, actor);
|
||||
const materialized = actor === fixture.richese ? fixture.materializes : 0;
|
||||
const reserveCost = actor === fixture.owner ? 3 : 0;
|
||||
const destroyed = actor === fixture.ecaz ? 5 : fixture.ordinary + materialized;
|
||||
assert.equal(player.forces[fixture.location] ?? 0, 0);
|
||||
assert.equal(player.reserves, original.reserves - materialized - reserveCost,
|
||||
'An opposing real Traitor prevents every promised H return, including ordinary counters.');
|
||||
assert.equal(player.tanks - original.tanks, destroyed + reserveCost);
|
||||
}
|
||||
assertUtilities(done, [NO_FIELD_HARASS, NO_FIELD_REINFORCEMENTS]);
|
||||
assertHistory(fixture, revealed, done);
|
||||
});
|
||||
Reference in new issue
Block a user