112 lines
6.0 KiB
TypeScript
112 lines
6.0 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { viewGame, type Action, type Game } from '../game/engine';
|
|
import {
|
|
actFremenRevivalGrant as actBattle, advanceFremenRevivalGrant as advanceBattle,
|
|
createFremenRevivalGrantFixture, fremenRevivalGrantClean,
|
|
fremenRevivalGrantInventory as battleInventory, fremenRevivalGrantPlayer as battlePlayer,
|
|
} from './fixture-fremen-revival-grant';
|
|
import {
|
|
actSemutaDisasterWorm as actWorm, advanceSemutaDisasterWorm as advanceWorm,
|
|
allowSemutaDisasterWorm, createSemutaDisasterWormFixture,
|
|
semutaDisasterWormPlayer as wormPlayer,
|
|
} from './fixture-semuta-disaster-worm';
|
|
|
|
function rejected(game: Game, act: (game: Game, actor: string, action: Action) => Game,
|
|
actor: string, action: Action) {
|
|
const original = structuredClone(game);
|
|
assert.throws(() => act(game, actor, action));
|
|
assert.deepEqual(game, original, 'A rejected bribe preserves its native parent and resources');
|
|
}
|
|
|
|
/** Actual public Basic selected-deck setup, purchase and original Fremen
|
|
* shipment; the natural second-turn worm and survival response create this
|
|
* ride. No decision, army, spice balance or phase is assigned by this test. */
|
|
function wormRideSource() {
|
|
const fixture = createSemutaDisasterWormFixture({ advanced: false });
|
|
let game = allowSemutaDisasterWorm(fixture.game);
|
|
game = advanceWorm(game, state => state.decision?.kind === 'wormRide' &&
|
|
!state.response && !state.phaseOpening && !state.pendingTreacheryDiscard);
|
|
assert.equal(game.decision?.player, fixture.owner);
|
|
assert.equal(game.decision?.kind === 'wormRide' && game.decision.territory, 'funeral_plain');
|
|
return {fixture, game};
|
|
}
|
|
|
|
void test('a Basic worm rider and another seat can negotiate while the original unpaid ride waits', () => {
|
|
const {fixture:f, game} = wormRideSource();
|
|
const actor = f.spender, target = f.guild, originalDecision = structuredClone(game.decision);
|
|
const oldPurse = wormPlayer(game, actor).spice, oldCash = wormPlayer(game, target).spice;
|
|
const oldEscrow = wormPlayer(game, target).bribes;
|
|
assert.ok(oldPurse >= 4); assert.notEqual(wormPlayer(game, actor).ally, target);
|
|
assert.equal(viewGame(game, actor).bribeOptions.blocked, null);
|
|
rejected(game, actWorm, actor, {type:'bribe', target, amount:oldPurse + 1});
|
|
rejected(game, actWorm, actor, {type:'bribe', target:actor, amount:1});
|
|
const paid = actWorm(game, actor, {type:'bribe', target, amount:4});
|
|
assert.deepEqual(paid.decision, originalDecision);
|
|
assert.deepEqual(paid.wormRides, game.wormRides);
|
|
assert.deepEqual(paid.spiceSequence, game.spiceSequence);
|
|
assert.equal(wormPlayer(paid, actor).spice, oldPurse - 4);
|
|
assert.equal(wormPlayer(paid, target).spice, oldCash);
|
|
assert.equal(wormPlayer(paid, target).bribes, oldEscrow + 4);
|
|
const decline: Action = {type:'decision', accept:false};
|
|
const control = actWorm(game, f.owner, decline);
|
|
const continued = actWorm(paid, f.owner, decline);
|
|
assert.deepEqual(continued.decision, control.decision);
|
|
assert.deepEqual(continued.wormRides, control.wormRides);
|
|
assert.equal(wormPlayer(continued, target).bribes, oldEscrow + 4);
|
|
});
|
|
|
|
/** The original public Basic Fremen/Atreides invasion and real battle produce
|
|
* the winner's optional card disposal. One actually dealt Fremen card is
|
|
* exchanged with an original shield in another hand or the deck before battle
|
|
* when needed, conserving the physical cards and hand sizes. */
|
|
function battleCardsSource() {
|
|
const f = createFremenRevivalGrantFixture();
|
|
let game = structuredClone(f.beforeBattle);
|
|
const hand = battlePlayer(game, f.fremen).hand;
|
|
assert.ok(hand.length);
|
|
let shield = hand.find(card => card.kind === 'shield');
|
|
if (!shield) {
|
|
const zone = [game.deck, ...game.players.filter(seat => seat.id !== f.fremen).map(seat => seat.hand)]
|
|
.find(cards => cards.some(card => card.kind === 'shield'));
|
|
assert.ok(zone);
|
|
const index = zone.findIndex(card => card.kind === 'shield');
|
|
[hand[0], zone[index]] = [zone[index], hand[0]];
|
|
shield = hand[0];
|
|
}
|
|
const shieldId = shield.id, original = battleInventory(game);
|
|
game = actBattle(game, f.battleStep.actor, f.battleStep.action);
|
|
for (const step of f.plans) {
|
|
game = advanceBattle(game, state => !!state.battle && fremenRevivalGrantClean(state) &&
|
|
!state.battle.preparation && (!state.battle.preLeader || state.battle.preLeader.closed));
|
|
game = actBattle(game, step.actor, step.actor === f.fremen
|
|
? {...step.action, defense:shieldId} : step.action);
|
|
}
|
|
game = advanceBattle(game, state => !state.response && !state.phaseOpening &&
|
|
state.decision?.kind === 'battleCards');
|
|
assert.equal(game.decision?.player, f.fremen);
|
|
assert.ok(game.decision?.kind === 'battleCards' && game.decision.cards.includes(shieldId));
|
|
return {f, game, shield:shieldId, original};
|
|
}
|
|
|
|
void test('a Basic winner can retain the same played card after an out-of-turn bribe', () => {
|
|
const {f, game, shield, original} = battleCardsSource();
|
|
const actor = f.observer, target = f.ally, decision = structuredClone(game.decision);
|
|
const purse = battlePlayer(game, actor).spice, cash = battlePlayer(game, target).spice;
|
|
const escrow = battlePlayer(game, target).bribes;
|
|
assert.ok(purse >= 1); assert.notEqual(battlePlayer(game, actor).ally, target);
|
|
assert.equal(viewGame(game, actor).bribeOptions.blocked, null);
|
|
rejected(game, actBattle, actor, {type:'bribe', target, amount:purse + 1});
|
|
const paid = actBattle(game, actor, {type:'bribe', target, amount:1});
|
|
assert.deepEqual(paid.decision, decision);
|
|
assert.deepEqual(paid.lastBattleContext, game.lastBattleContext);
|
|
assert.equal(battlePlayer(paid, actor).spice, purse - 1);
|
|
assert.equal(battlePlayer(paid, target).spice, cash);
|
|
assert.equal(battlePlayer(paid, target).bribes, escrow + 1);
|
|
assert.deepEqual(battleInventory(paid), original);
|
|
const retained = actBattle(paid, f.fremen, {type:'decision', discard:[]});
|
|
assert.ok(battlePlayer(retained, f.fremen).hand.some(card => card.id === shield));
|
|
assert.equal(battlePlayer(retained, target).bribes, escrow + 1);
|
|
assert.deepEqual(battleInventory(retained), original);
|
|
});
|