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); });