333 lines
23 KiB
TypeScript
333 lines
23 KiB
TypeScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
applyAction, createGame, initializeFactionExpansionsGameForAudit,
|
|
initializeStrongholdFactionsGameForAudit, joinGame, newPlayer, viewGame, type Game,
|
|
} from '../game/engine';
|
|
import type { FactionId } from '../game/catalog';
|
|
import { treacheryDeck } from '../game/cards';
|
|
import { createTechTokens, ownedTech } from '../game/tech-tokens';
|
|
import { quoteBattleResolution, type ResolutionCombatant } from '../game/battle-resolution-quote';
|
|
import { quoteSpiceCollection } from '../game/board-resolution-quote';
|
|
import { strongholdControllers } from '../game/stronghold-cards';
|
|
import { finishEcazOccupySetup } from './fixture-ecaz-occupy';
|
|
import { advanceEcazStronghold, ecazStrongholdSeat as player, finishEcazStronghold } from './fixture-ecaz-strongholds';
|
|
import {
|
|
advanceMoritaniStrongholds, holdMoritaniStrongholdsTraitor, nextMoritaniStrongholdsStep,
|
|
resolveMoritaniStrongholdsBattle, stageMoritaniStrongholdsBattle,
|
|
} from './fixture-moritani-strongholds';
|
|
import { quoteStrongholdFactionsBattle } from './fixture-stronghold-factions';
|
|
import {
|
|
createEcazNativeTechFixture, createMoritaniNativeTechFixture,
|
|
initializeE3NativeTechSetup, revealEcazNativeTechBattle,
|
|
} from './fixture-e3-native-tech';
|
|
|
|
function lobby(roster: FactionId[], advanced = true, expansions: Game['expansions'] = ['ecaz']): Game {
|
|
let game = createGame('E3TECHGUARD', newPlayer(`auth-${roster[0]}`, roster[0], roster[0]), advanced, expansions);
|
|
for (const faction of roster.slice(1)) joinGame(game, newPlayer(`auth-${faction}`, faction, faction));
|
|
game.techTokens = createTechTokens();
|
|
for (const p of game.players) game = applyAction(game, p.id, { type: 'ready' });
|
|
return game;
|
|
}
|
|
function physical(game: Game): void {
|
|
const cards = [...game.deck, ...game.discard, ...(game.auction?.cards.slice(game.auction.index) ?? []),
|
|
...game.players.flatMap(p => p.hand)].map(c => c.id).sort();
|
|
assert.deepEqual(cards, treacheryDeck(['ecaz']).map(c => c.id).sort(), 'Every original selected physical card retains one custodian.');
|
|
assert.equal(new Set(cards).size, cards.length);
|
|
for (const p of game.players) {
|
|
assert.equal(p.reserves + p.tanks + Object.values(p.forces).reduce((sum, n) => sum + n, 0), 20);
|
|
if (p.elites) assert.equal(p.elites.reserves + p.elites.tanks + Object.values(p.elites.forces).reduce((sum, n) => sum + n, 0),
|
|
p.faction === 'emperor' ? 5 : 3);
|
|
}
|
|
assert.equal(Object.keys(game.techTokens!).length, 3);
|
|
for (const token of Object.values(game.techTokens!))
|
|
assert.ok(token.owner === null || game.players.some(p => p.id === token.owner));
|
|
const moritani = game.players.find(p => p.faction === 'moritani');
|
|
if (moritani) {
|
|
assert.equal(moritani.leaders.length, 5, 'The five original Moritani leader discs remain physically present.');
|
|
assert.equal(new Set(moritani.leaders.map(l => l.id)).size, 5);
|
|
assert.equal(game.moritaniTerror!.tokens.length, 6);
|
|
assert.equal(new Set(game.moritaniTerror!.tokens.map(t => t.id)).size, 6);
|
|
const traitors = [...game.players.flatMap(p => p.traitors), ...(game.traitorReserve ?? []),
|
|
...(game.ecazLoyalty?.card ? [game.ecazLoyalty.card] : []),
|
|
...(game.moritaniAssassinate?.opportunities.flatMap(o => o.stage === 'replaced' && o.card ? [o.card] : []) ?? [])];
|
|
assert.equal(new Set(traitors).size, traitors.length, 'Held, replacement-reserve and revealed spent Traitors have distinct physical custody.');
|
|
}
|
|
}
|
|
|
|
for (const native of ['ecaz', 'moritani'] as const) for (const advanced of [false, true])
|
|
for (const seats of [3, 6]) void test(`${advanced ? 'Advanced' : 'Basic'} standalone ${native} plain Tech: ${seats} original seats complete real setup and receive three first-Storm tokens`, () => {
|
|
const roster: FactionId[] = [native, 'guild', 'emperor', 'atreides', 'fremen', 'beneGesserit'].slice(0, seats) as FactionId[];
|
|
const admitted = lobby(roster, advanced);
|
|
const setup = initializeE3NativeTechSetup({ initial: admitted, native, advanced });
|
|
let game = finishEcazOccupySetup(setup);
|
|
const actor = game.players.find(p => p.faction === native)!;
|
|
assert.equal(actor.id, `auth-${native}`);
|
|
physical(game);
|
|
game = advanceMoritaniStrongholds(game, g => g.phase === 2 && !g.phaseOpening && !g.response && !g.decision);
|
|
const owners = Object.values(game.techTokens!).map(token => token.owner);
|
|
assert.ok(owners.every(owner => typeof owner === 'string' && game.players.some(p => p.id === owner)));
|
|
assert.equal(new Set(owners).size, 3, 'Actual first-Storm order supplies unassigned tokens to three distinct seats.');
|
|
physical(game);
|
|
});
|
|
|
|
|
|
for (const strongholds of [false, true]) for (const lead of ['ecaz', 'ally'] as const)
|
|
void test(`Advanced standalone Ecaz ${strongholds ? 'Stronghold+Tech' : 'plain Tech'}: selected ${lead} earns only the enemy token after original holder reward and typed owner casualties`, () => {
|
|
const f = createEcazNativeTechFixture({ strongholds });
|
|
const result = revealEcazNativeTechBattle(f, lead, true);
|
|
const { before, revealed, pending, actor } = result;
|
|
const battle = revealed.battle!, publicBattle = viewGame(revealed, actor).battle!;
|
|
const side = (id: string): ResolutionCombatant => {
|
|
const p = player(revealed, id), view = viewGame(revealed, id).battle!;
|
|
assert.ok(view.ownForces);
|
|
return { id, faction: p.faction, ally: p.ally, spice: p.spice, hand: p.hand,
|
|
plan: battle.plans[id], leader: p.leaders.find(l => l.id === battle.plans[id].leader),
|
|
forces: view.ownForces, stronghold: view.strongholdEffects[id] };
|
|
};
|
|
const quote = quoteBattleResolution({ advanced: true, turn: revealed.turn, territory: f.territory,
|
|
ecazOccupy: publicBattle.ecazOccupy!.profile!, aggressor: publicBattle.aggressor,
|
|
attacker: side(battle.attacker), defender: side(battle.defender),
|
|
voters: publicBattle.traitorVoters.map(id => ({ id, called: false, traitors: player(revealed, id).traitors,
|
|
beneficiary: [battle.attacker, battle.defender].includes(id) ? id : actor })),
|
|
participants: revealed.players, physicalCards: [...revealed.deck, ...revealed.discard, ...revealed.players.flatMap(p => p.hand)],
|
|
pendingAuditorPresent: false, pendingRetentionPresent: false });
|
|
assert.deepEqual(quote.fixedLosses, [{ owner: f.ecaz, normal: 3, elite: 0 }]);
|
|
assert.equal(quote.casualties!.owner, f.ally, 'The Guild variable army owns its losses even when Ecaz seals the winning plan.');
|
|
assert.deepEqual(quote.casualties!.options, [{ normal: 3, elite: 0,
|
|
paidNormal: battle.plans[actor].support, paidElite: 0 }]);
|
|
const income = strongholds && lead === 'ecaz' ? 2 : 0;
|
|
assert.deepEqual(quote.strongholdIncome, income ? [{ player: actor, amount: income }] : []);
|
|
const payment = quote.payments.find(p => p.player === actor)!;
|
|
assert.equal(player(pending, actor).spice, player(before, actor).spice - payment.ownPayment + income);
|
|
assert.equal(pending.decision?.player, actor);
|
|
const enemyToken = ownedTech(before.techTokens, f.opponent);
|
|
assert.equal(enemyToken.length, 1);
|
|
assert.equal(pending.techTokens![enemyToken[0]].owner, f.opponent,
|
|
'Stronghold reward is already paid while actual winner-card cleanup still precedes Tech custody.');
|
|
const game = finishEcazStronghold(pending), nonLead = lead === 'ecaz' ? f.ally : f.ecaz;
|
|
assert.equal(game.lastBattleContext!.winner, actor);
|
|
assert.equal(game.techTokens![enemyToken[0]].owner, actor);
|
|
assert.equal(ownedTech(game.techTokens, actor).length, 2);
|
|
assert.equal(ownedTech(game.techTokens, nonLead).length, 1);
|
|
assert.equal(ownedTech(game.techTokens, f.opponent).length, 0);
|
|
assert.equal(player(game, f.ecaz).tanks - player(before, f.ecaz).tanks, 3);
|
|
assert.equal(player(game, f.ally).tanks - player(before, f.ally).tanks, 3);
|
|
assert.equal(player(game, f.opponent).tanks - player(before, f.opponent).tanks, 8);
|
|
assert.equal(player(game, f.ecaz).forces[f.location], 2);
|
|
assert.equal(player(game, f.ally).forces[f.location], 1);
|
|
const progress = viewGame(game, actor).victoryProgress.find(p => p.player === actor)!;
|
|
assert.equal(progress.strongholds.length, 3);
|
|
assert.equal(progress.jointlyOccupied.length, 1);
|
|
assert.equal(progress.techStronghold, false, 'Two plus one allied tokens do not produce a joint third-token stronghold.');
|
|
assert.equal(progress.qualifies, false);
|
|
physical(game);
|
|
const collection = quoteSpiceCollection(game).receipts.find(p => p.player === actor)!;
|
|
const nextTurn = advanceEcazStronghold(game, g => g.turn === 4 && g.phase === 0);
|
|
assert.equal(nextTurn.status, 'playing', 'Original end-Mentat does not infer an allied three-token victory.');
|
|
assert.deepEqual(nextTurn.winner, []);
|
|
assert.equal(player(nextTurn, actor).spice, player(pending, actor).spice + collection.strongholds + collection.collected,
|
|
'Only actual native Collection follows the completed reward; the earlier Stronghold battle income does not replay.');
|
|
});
|
|
|
|
for (const lead of ['ecaz', 'ally'] as const)
|
|
void test(`Basic plain Tech Ecaz ${lead}: even original coalition pays no support and attributes the token to its actual selected lead`, () => {
|
|
const f = createEcazNativeTechFixture({ advanced: false });
|
|
const result = revealEcazNativeTechBattle(f, lead);
|
|
const token = ownedTech(result.before.techTokens, f.opponent)[0];
|
|
assert.equal(player(result.pending, result.actor).spice, player(result.before, result.actor).spice);
|
|
const game = finishEcazStronghold(result.pending);
|
|
assert.equal(game.techTokens![token].owner, result.actor);
|
|
assert.equal(player(game, f.ecaz).forces[f.location], 2);
|
|
assert.equal(player(game, f.ally).forces[f.location], 1);
|
|
assert.equal(player(game, f.ecaz).tanks - player(result.before, f.ecaz).tanks, 2);
|
|
assert.equal(player(game, f.ally).tanks - player(result.before, f.ally).tanks, 3);
|
|
physical(game);
|
|
});
|
|
|
|
void test('Basic native Tech Ecaz admits odd forces with provisional ceiling losses and floor survivors', () => {
|
|
const f = createEcazNativeTechFixture({ advanced: false, ecazForces: 3, chooseBattle: false });
|
|
const admitted = applyAction(f.game, f.battleAction.actor, f.battleAction.action);
|
|
assert.ok(admitted.battle);
|
|
assert.equal(admitted.decision?.kind, 'ecazBattleLead');
|
|
physical(admitted);
|
|
for (const lead of ['ecaz', 'ally'] as const) {
|
|
const result = revealEcazNativeTechBattle({ ...f, game: admitted }, lead);
|
|
const { before, revealed, pending, actor } = result;
|
|
const battle = revealed.battle!, publicBattle = viewGame(revealed, actor).battle!;
|
|
const profile = publicBattle.ecazOccupy!.profile!;
|
|
assert.equal(profile.ecazForces.normal, 3);
|
|
assert.equal(profile.fixedEcazDial, Math.ceil(3 / 2));
|
|
assert.equal(profile.planOwner, actor);
|
|
assert.equal(profile.payer, actor);
|
|
assert.equal(profile.forceOwner, f.ally);
|
|
const side = (id: string): ResolutionCombatant => {
|
|
const p = player(revealed, id), view = viewGame(revealed, id).battle!;
|
|
assert.ok(view.ownForces);
|
|
return { id, faction: p.faction, ally: p.ally, spice: p.spice, hand: p.hand,
|
|
plan: battle.plans[id], leader: p.leaders.find(l => l.id === battle.plans[id].leader),
|
|
forces: view.ownForces, stronghold: view.strongholdEffects[id] };
|
|
};
|
|
const quote = quoteBattleResolution({ advanced: false, turn: revealed.turn, territory: f.territory,
|
|
ecazOccupy: profile, aggressor: publicBattle.aggressor,
|
|
attacker: side(battle.attacker), defender: side(battle.defender),
|
|
voters: publicBattle.traitorVoters.map(id => ({ id, called: false, traitors: player(revealed, id).traitors,
|
|
beneficiary: [battle.attacker, battle.defender].includes(id) ? id : actor })),
|
|
participants: revealed.players, physicalCards: [...revealed.deck, ...revealed.discard, ...revealed.players.flatMap(p => p.hand)],
|
|
pendingAuditorPresent: false, pendingRetentionPresent: false });
|
|
assert.equal(quote.winner, actor);
|
|
assert.deepEqual(quote.fixedLosses, [{ owner: f.ecaz, normal: Math.ceil(3 / 2), elite: 0 }]);
|
|
assert.equal(quote.casualties!.owner, f.ally);
|
|
assert.deepEqual(quote.casualties!.options, [{ normal: 3, elite: 0, paidNormal: 0, paidElite: 0 }]);
|
|
assert.ok(quote.payments.every(payment => payment.ownPayment === 0));
|
|
assert.deepEqual(quote.strongholdIncome, []);
|
|
assert.equal(player(pending, actor).spice, player(before, actor).spice);
|
|
const token = ownedTech(before.techTokens, f.opponent)[0]; assert.ok(token);
|
|
assert.equal(pending.techTokens![token].owner, f.opponent, 'Winner-card cleanup still precedes Tech transfer.');
|
|
const game = finishEcazStronghold(pending), nonLead = actor === f.ecaz ? f.ally : f.ecaz;
|
|
assert.equal(game.lastBattleContext!.winner, actor);
|
|
assert.equal(game.techTokens![token].owner, actor);
|
|
assert.equal(ownedTech(game.techTokens, actor).length, 2);
|
|
assert.equal(ownedTech(game.techTokens, nonLead).length, 1);
|
|
assert.equal(ownedTech(game.techTokens, f.opponent).length, 0);
|
|
assert.equal(player(game, f.ecaz).tanks - player(before, f.ecaz).tanks, Math.ceil(3 / 2));
|
|
assert.equal(player(game, f.ecaz).forces[f.location], Math.floor(3 / 2));
|
|
assert.equal(player(game, f.ally).tanks - player(before, f.ally).tanks, 3);
|
|
assert.equal(player(game, f.ally).forces[f.location], 1);
|
|
assert.equal(player(game, f.opponent).tanks - player(before, f.opponent).tanks, 8);
|
|
physical(game);
|
|
}
|
|
});
|
|
|
|
for (const strongholds of [false, true])
|
|
void test(`Advanced Moritani ${strongholds ? 'Stronghold+Tech' : 'plain Tech'}: loss retains original effects, assassination pays one bounty, actual winner earns Tech, and Mentat replaces one held Traitor`, () => {
|
|
const f = createMoritaniNativeTechFixture({ strongholds });
|
|
assert.equal(f.afterSetup.players.find(p => p.id === f.moritani)!.leaders.length, 5);
|
|
assert.equal(f.afterPlacement.moritaniTerror!.tokens.filter(t => t.status === 'available').length, 5);
|
|
assert.equal(f.afterPlacement.moritaniTerror!.tokens.filter(t => t.status === 'placed').length, 1);
|
|
const discs = f.afterPlacement.moritaniTerror!.tokens.map(t => ({ ...t }));
|
|
const pending = f.pending, quote = quoteStrongholdFactionsBattle(f.revealed);
|
|
assert.equal(pending.decision?.kind, 'moritaniAssassinate');
|
|
assert.equal(pending.lastBattleContext!.winner, f.opponent);
|
|
const income = strongholds ? 4 : 0;
|
|
assert.deepEqual(quote.strongholdIncome, income ? [{ player: f.moritani, amount: income }] : []);
|
|
assert.equal(player(pending, f.moritani).spice, player(f.revealed, f.moritani).spice - 1 + income);
|
|
assert.equal(player(pending, f.opponent).spice, player(f.revealed, f.opponent).spice - 3);
|
|
if (strongholds) {
|
|
assert.equal(pending.strongholdCards!.owners.tueks_sietch, f.moritani);
|
|
assert.equal(strongholdControllers(pending.players, false).tueks_sietch, f.opponent);
|
|
}
|
|
const token = ownedTech(pending.techTokens, f.moritani)[0];
|
|
assert.ok(token);
|
|
const target = player(pending, f.opponent).leaders.find(l => l.id === f.target)!;
|
|
const held = [...player(pending, f.moritani).traitors], reserve = [...pending.traitorReserve!];
|
|
const decision = pending.decision;
|
|
assert.ok(decision?.kind === 'moritaniAssassinate');
|
|
let game = applyAction(pending, f.moritani, { type: 'decision', event: decision.event, card: f.target });
|
|
const paid = player(game, f.moritani).spice;
|
|
assert.equal(paid, player(pending, f.moritani).spice + target.strength);
|
|
assert.equal(player(game, f.opponent).leaders.find(l => l.id === f.target)!.deaths, target.deaths + 1);
|
|
assert.deepEqual(player(game, f.moritani).traitors, held, 'Revealed original physical Traitor remains held until Mentat.');
|
|
assert.equal(game.techTokens![token].owner, f.moritani);
|
|
assert.equal(game.decision?.kind, 'battleCards');
|
|
game = applyAction(game, f.opponent, { type: 'decision', discard: f.opponentCards });
|
|
game = advanceMoritaniStrongholds(game, g => !g.battle && !g.response && !g.decision && !g.pendingTreacheryDiscard);
|
|
assert.equal(game.techTokens![token].owner, f.opponent);
|
|
assert.equal(ownedTech(game.techTokens, f.opponent).length, 2);
|
|
assert.equal(ownedTech(game.techTokens, f.moritani).length, 0);
|
|
assert.equal(player(game, f.moritani).tanks - player(f.revealed, f.moritani).tanks, 6);
|
|
assert.equal(player(game, f.opponent).tanks - player(f.revealed, f.opponent).tanks, 3);
|
|
assert.equal(player(game, f.moritani).spice, paid);
|
|
assert.deepEqual(game.moritaniTerror!.tokens, discs, 'Original assassination does not consume a Terror disc.');
|
|
for (const card of [...f.moritaniCards, ...f.opponentCards]) assert.equal(game.discard.filter(c => c.id === card).length, 1);
|
|
physical(game);
|
|
game = advanceMoritaniStrongholds(game, g => g.phase === 8);
|
|
const receipt = game.moritaniAssassinate!.opportunities.at(-1)!;
|
|
assert.equal(receipt.stage, 'replaced'); assert.equal(receipt.bounty, target.strength);
|
|
assert.equal(receipt.replacement, reserve[0]);
|
|
assert.deepEqual(game.traitorReserve, reserve.slice(1));
|
|
assert.deepEqual(player(game, f.moritani).traitors, [...held.filter(id => id !== f.target), reserve[0]]);
|
|
assert.equal(player(game, f.moritani).spice, paid, 'Neither Stronghold income nor bounty replays at Mentat.');
|
|
const rival = viewGame(game, f.opponent).moritaniAssassinate!.history.at(-1)!;
|
|
assert.equal(rival.card, f.target); assert.equal('replacement' in rival, false);
|
|
game = advanceMoritaniStrongholds(game, g => g.turn === 3 && g.phase === 0);
|
|
assert.equal(game.traitorReserve!.length, reserve.length - 1);
|
|
assert.equal(player(game, f.moritani).spice, paid);
|
|
assert.equal(game.techTokens![token].owner, f.opponent);
|
|
if (strongholds) assert.equal(game.strongholdCards!.owners.tueks_sietch, f.opponent);
|
|
physical(game);
|
|
});
|
|
|
|
for (const strongholds of [false, true])
|
|
void test(`Advanced Moritani ${strongholds ? 'Stronghold+Tech' : 'plain Tech'}: genuine normal Traitor call forfeits the later original loss assassination across turns`, () => {
|
|
const f = createMoritaniNativeTechFixture({ strongholds, normalCall: true });
|
|
assert.equal(f.pending.lastBattleContext!.winner, f.moritani);
|
|
assert.equal(f.pending.moritaniAssassinate!.normalTraitorCall, true);
|
|
assert.equal(f.pending.moritaniAssassinate!.opportunities.length, 0);
|
|
assert.equal(player(f.pending, f.opponent).leaders.find(l => l.id === f.opponentLeader)!.dead, true);
|
|
assert.equal(ownedTech(f.pending.techTokens, f.moritani).length, 2);
|
|
let game = advanceMoritaniStrongholds(f.pending, g => g.turn === 3 && g.phase === 5 && !g.response && !g.phaseOpening && !g.decision);
|
|
const emperor = game.players.find(p => p.faction === 'emperor')!.id;
|
|
stageMoritaniStrongholdsBattle(game, f.moritani, emperor, 'tueks_sietch');
|
|
const loser = player(game, f.moritani).leaders.filter(l => !l.dead).sort((a, b) => a.strength - b.strength)[0];
|
|
const winner = player(game, emperor).leaders.filter(l => !l.dead).sort((a, b) => b.strength - a.strength)[0];
|
|
const target = player(game, emperor).leaders.find(l => !l.dead && l.id !== winner.id)!;
|
|
holdMoritaniStrongholdsTraitor(game, f.moritani, target.id);
|
|
const tokens = ownedTech(game.techTokens, f.moritani), reserve = [...game.traitorReserve!];
|
|
game = advanceMoritaniStrongholds(game, g => g.phase === 6 && !g.response && !g.phaseOpening && !g.decision);
|
|
const actor = game.active!;
|
|
assert.ok([f.moritani, emperor].includes(actor));
|
|
game = applyAction(game, actor, { type: 'chooseBattle', territory: 'tueks_sietch', target: actor === f.moritani ? emperor : f.moritani });
|
|
game = advanceMoritaniStrongholds(game, g => !!g.battle && !g.battle.revealed && !nextMoritaniStrongholdsStep(g));
|
|
game = applyAction(game, f.moritani, { type: 'battlePlan', leader: loser.id, dial: 0, support: 0 });
|
|
game = applyAction(game, emperor, { type: 'battlePlan', leader: winner.id, dial: 2, support: 2 });
|
|
game = resolveMoritaniStrongholdsBattle(game, f.moritani);
|
|
assert.equal(game.lastBattleContext!.winner, emperor);
|
|
assert.equal(game.moritaniAssassinate!.normalTraitorCall, true);
|
|
assert.equal(game.moritaniAssassinate!.opportunities.length, 0);
|
|
assert.equal(player(game, emperor).leaders.find(l => l.id === target.id)!.dead, false);
|
|
assert.deepEqual(game.traitorReserve, reserve, 'No assassination means no hidden replacement draw.');
|
|
assert.equal(tokens.filter(token => game.techTokens![token].owner === emperor).length, 1,
|
|
'A real victory selects one loser token, not both allied or held tokens.');
|
|
assert.equal(ownedTech(game.techTokens, emperor).length, 2);
|
|
physical(game);
|
|
});
|
|
|
|
for (const strongholds of [false, true]) {
|
|
const initialize = strongholds ? initializeStrongholdFactionsGameForAudit : initializeFactionExpansionsGameForAudit;
|
|
void test(`${strongholds ? 'Stronghold+Tech' : 'plain Tech'} initializer admits selected mixed families while excluding unrelated overlays and used inventory`, () => {
|
|
for (const admitted of [lobby(['ecaz', 'moritani', 'guild']),
|
|
lobby(['ecaz', 'ixians', 'guild'], true, ['ecaz', 'ix']),
|
|
lobby(['moritani', 'choam', 'guild'], true, ['ecaz', 'choam']),
|
|
lobby(['moritani', 'harkonnen', 'guild'])]) {
|
|
const setup = initialize(admitted);
|
|
assert.equal(setup.status, 'setup');
|
|
assert.deepEqual(setup.expansions, admitted.expansions);
|
|
assert.equal(!!setup.strongholdCards, strongholds);
|
|
assert.equal(!!setup.moritaniAssassinate, admitted.players.some(p => p.faction === 'moritani'));
|
|
}
|
|
assert.throws(() => initialize(lobby(['ecaz', 'guild'])));
|
|
if (strongholds) assert.throws(() => initialize(lobby(['ecaz', 'guild', 'emperor'], false)));
|
|
for (const overlay of ['leaderSkills', 'homeworlds', 'nexusCards', 'discoveryEnabled', 'ecazTreachery',
|
|
'semutaPreview', 'advancedPreview', 'kullPreview', 'nexusKullPreview', 'guildBetrayalPreview',
|
|
'richeseBetrayalPreview', 'nexusIxianReplacementPreview', 'nexusIxianBetrayalPreview', 'nexusHarkonnenBetrayalPreview']) {
|
|
const game = lobby(['ecaz', 'guild', 'emperor']); Object.assign(game, { [overlay]: true });
|
|
assert.throws(() => initialize(game), `${overlay} remains excluded from the bounded native Tech family.`);
|
|
}
|
|
for (const stale of ['owner', 'spice', 'triggeredTurn'] as const) {
|
|
const game = lobby(['ecaz', 'guild', 'emperor']);
|
|
Object.assign(game.techTokens!.axlotl, { [stale]: stale === 'owner' ? game.host : 1 });
|
|
assert.throws(() => initialize(game));
|
|
}
|
|
});
|
|
}
|
|
|
|
void test('Basic standalone Moritani Tech retains its original Harkonnen-compatible setup boundary', () => {
|
|
const game = finishEcazOccupySetup(initializeE3NativeTechSetup({
|
|
initial: lobby(['moritani', 'harkonnen', 'guild'], false), native: 'moritani', advanced: false,
|
|
}));
|
|
assert.equal(player(game, 'auth-moritani').reserves, 14);
|
|
assert.equal(player(game, 'auth-harkonnen').traitors.length, 4);
|
|
physical(game);
|
|
});
|