180 lines
11 KiB
TypeScript
180 lines
11 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { botActions } from '../game/bots';
|
|
import { viewGame, type Action, type Game } from '../game/engine';
|
|
import type { PublicDeal } from '../game/public-deals';
|
|
import {
|
|
actMentatBribe as act, createMentatBribeFixture as fixture,
|
|
mentatBribeInventory as inventory, mentatBribePlayer as player,
|
|
} from './fixture-mentat-bribes';
|
|
import {
|
|
actTruthTravel, createTruthTravelFixture, settleTruthTravel,
|
|
truthTravelInventory, truthTravelPlayer,
|
|
} from './fixture-truth-travel';
|
|
|
|
type Deferred = { kind:'deferredBribe'; payer:string; recipient:string; amount:number; dueTurn:number };
|
|
type Line = { payment:Deferred; paymentStatus?:'pending'|'paid'|'void'|'released' };
|
|
type MultiDeal = PublicDeal & { additionalPayments?:Line[] };
|
|
|
|
const term = (payer:string, recipient:string, amount:number, dueTurn:number): Deferred =>
|
|
({kind:'deferredBribe',payer,recipient,amount,dueTurn});
|
|
const key = (deal:string, index:number) => `${deal}:payment:${index}`;
|
|
function deal(game: Game, id: string): MultiDeal {
|
|
const found = game.deals?.find(row => row.id === id); assert.ok(found); return found as MultiDeal;
|
|
}
|
|
function reject(game: Game, actor: string, action: Action) {
|
|
const before = structuredClone(game);
|
|
assert.throws(() => act(game,actor,action));
|
|
assert.deepEqual(game,before,'Rejected actions leave the original state unchanged');
|
|
}
|
|
function offer(game: Game, from: string, to: string, additionalPayments: Deferred[], payment?: object) {
|
|
game = act(game,from,{type:'dealOffer',target:to,terms:'Pay the agreed separate amounts.',additionalPayments,
|
|
...(payment ? {payment} : {})});
|
|
const id = game.deals?.at(-1)?.id; assert.ok(id);
|
|
return {game,id};
|
|
}
|
|
const accept = (game: Game, actor:string, id:string) => act(game,actor,{type:'dealRespond',deal:id,accept:true});
|
|
const pay = (game: Game, actor:string, id:string, paymentIndex:number) =>
|
|
act(game,actor,{type:'dealPay',deal:id,paymentIndex});
|
|
|
|
/** Public Basic H/A/E start, real auction and first Mentat. The inherited
|
|
* fixture orders only unopened original cards and Spice; no purse or deal is
|
|
* fabricated. Every term's consent and transfer uses native player actions. */
|
|
void test('identical deferred terms have separate indices and each exact payment settles once', () => {
|
|
const f = fixture(), start = f.game, original = inventory(start);
|
|
const terms = [term(f.target,f.asker,3,start.turn),term(f.target,f.asker,3,start.turn)];
|
|
const proposed = offer(start,f.asker,f.target,terms);
|
|
assert.deepEqual(deal(proposed.game,proposed.id).additionalPayments?.map(line => line.payment),terms);
|
|
assert.equal(player(proposed.game,f.target).spice,10);
|
|
let game = accept(proposed.game,f.target,proposed.id);
|
|
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['pending','pending']);
|
|
assert.equal(viewGame(game,f.target).deferredDealPaymentOptions[key(proposed.id,0)]?.blocked,null);
|
|
assert.equal(viewGame(game,f.target).deferredDealPaymentOptions[key(proposed.id,1)]?.blocked,null);
|
|
reject(game,f.asker,{type:'dealPay',deal:proposed.id,paymentIndex:0});
|
|
reject(game,f.target,{type:'dealPay',deal:proposed.id,paymentIndex:2});
|
|
reject(game,f.target,{type:'dealPay',deal:proposed.id});
|
|
game = pay(game,f.target,proposed.id,1);
|
|
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['pending','paid']);
|
|
assert.equal(player(game,f.target).spice,7); assert.equal(player(game,f.asker).bribes,3);
|
|
reject(game,f.target,{type:'dealPay',deal:proposed.id,paymentIndex:1});
|
|
game = pay(game,f.target,proposed.id,0);
|
|
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['paid','paid']);
|
|
assert.equal(player(game,f.target).spice,4); assert.equal(player(game,f.asker).bribes,6);
|
|
assert.deepEqual(inventory(game),original);
|
|
});
|
|
|
|
void test('final consent rolls back when separate due terms overcommit the same purse', () => {
|
|
const f = fixture(), terms = [term(f.target,f.asker,6,f.game.turn),term(f.target,f.asker,5,f.game.turn)];
|
|
const proposed = offer(f.game,f.asker,f.target,terms), before = structuredClone(proposed.game);
|
|
reject(proposed.game,f.target,{type:'dealRespond',deal:proposed.id,accept:true});
|
|
assert.deepEqual(proposed.game,before);
|
|
assert.equal(deal(proposed.game,proposed.id).status,'offered');
|
|
assert.deepEqual(deal(proposed.game,proposed.id).additionalPayments?.map(line => line.paymentStatus),[undefined,undefined]);
|
|
assert.equal(player(proposed.game,f.target).spice,10);
|
|
assert.deepEqual(inventory(proposed.game),f.originalCards);
|
|
});
|
|
|
|
void test('current and future terms reserve only the current due amount and keep distinct payment receipts', () => {
|
|
const f = fixture(), due = f.game.turn;
|
|
const proposed = offer(f.game,f.asker,f.target,[term(f.target,f.asker,3,due),term(f.target,f.asker,8,due+1)]);
|
|
let game = accept(proposed.game,f.target,proposed.id);
|
|
assert.equal(viewGame(game,f.target).deferredDealPaymentOptions[key(proposed.id,0)]?.blocked,null);
|
|
assert.ok(viewGame(game,f.target).deferredDealPaymentOptions[key(proposed.id,1)]?.blocked);
|
|
reject(game,f.target,{type:'dealPay',deal:proposed.id,paymentIndex:1});
|
|
game = pay(game,f.target,proposed.id,0);
|
|
assert.equal(player(game,f.target).spice,7);
|
|
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['paid','pending']);
|
|
assert.deepEqual(inventory(game),f.originalCards);
|
|
});
|
|
|
|
void test('unanimous release cancels only unpaid terms and does not refund paid spice', () => {
|
|
const f = fixture(), proposed = offer(f.game,f.asker,f.target,
|
|
[term(f.target,f.asker,2,f.game.turn),term(f.target,f.asker,3,f.game.turn)]);
|
|
let game = accept(proposed.game,f.target,proposed.id);
|
|
game = pay(game,f.target,proposed.id,0);
|
|
game = act(game,f.asker,{type:'dealRelease',deal:proposed.id,agree:true});
|
|
assert.equal(deal(game,proposed.id).status,'active');
|
|
game = act(game,f.target,{type:'dealRelease',deal:proposed.id,agree:true});
|
|
assert.equal(deal(game,proposed.id).status,'released');
|
|
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['paid','released']);
|
|
assert.equal(player(game,f.target).spice,8); assert.equal(player(game,f.asker).bribes,2);
|
|
reject(game,f.target,{type:'dealPay',deal:proposed.id,paymentIndex:1});
|
|
assert.deepEqual(inventory(game),f.originalCards);
|
|
});
|
|
|
|
void test('a group can accept distinct payer terms without settling before all consent', () => {
|
|
const f = fixture(), start = f.game;
|
|
assert.ok(player(start,f.opponent).spice >= 1);
|
|
const terms = [term(f.target,f.asker,2,start.turn),term(f.opponent,f.asker,1,start.turn)];
|
|
let game = act(start,f.asker,{type:'dealOffer',targets:[f.target,f.opponent],terms:'Both pay agreed spice.',additionalPayments:terms});
|
|
const id = game.deals?.at(-1)?.id; assert.ok(id);
|
|
game = accept(game,f.target,id);
|
|
assert.equal(deal(game,id).status,'offered');
|
|
assert.equal(player(game,f.target).spice,player(start,f.target).spice);
|
|
game = accept(game,f.opponent,id);
|
|
assert.equal(deal(game,id).status,'active');
|
|
reject(game,f.target,{type:'dealPay',deal:id,paymentIndex:1});
|
|
game = pay(game,f.opponent,id,1);
|
|
game = pay(game,f.target,id,0);
|
|
assert.equal(player(game,f.asker).bribes,3);
|
|
assert.deepEqual(deal(game,id).additionalPayments?.map(line => line.paymentStatus),['paid','paid']);
|
|
assert.deepEqual(inventory(game),f.originalCards);
|
|
});
|
|
|
|
void test('the original immediate payment and extra deferred payments use separate native transfers', () => {
|
|
const f = fixture(), start = f.game;
|
|
const immediate = {kind:'immediateBribe',payer:f.target,recipient:f.asker,amount:2};
|
|
const proposed = offer(start,f.asker,f.target,[term(f.target,f.asker,3,start.turn)],immediate);
|
|
assert.equal(player(proposed.game,f.target).spice,10);
|
|
let game = accept(proposed.game,f.target,proposed.id);
|
|
assert.equal(player(game,f.target).spice,8); assert.equal(player(game,f.asker).bribes,2);
|
|
assert.equal(deal(game,proposed.id).additionalPayments?.[0].paymentStatus,'pending');
|
|
game = pay(game,f.target,proposed.id,0);
|
|
assert.equal(player(game,f.target).spice,5); assert.equal(player(game,f.asker).bribes,5);
|
|
assert.equal(deal(game,proposed.id).additionalPayments?.[0].paymentStatus,'paid');
|
|
assert.deepEqual(inventory(game),f.originalCards);
|
|
});
|
|
|
|
void test('autopilot uses a legal indexed action for each payment that is due', () => {
|
|
const f = fixture(), proposed = offer(f.game,f.asker,f.target,
|
|
[term(f.target,f.asker,2,f.game.turn),term(f.target,f.asker,3,f.game.turn)]);
|
|
let game = accept(proposed.game,f.target,proposed.id);
|
|
game = act(game,f.target,{type:'setAutopilot',difficulty:'Easy'});
|
|
for (let count = 0; count < 2; count++) {
|
|
const action = botActions(viewGame(game,f.target))[0]; assert.ok(action);
|
|
assert.equal(action.type,'dealPay'); assert.equal(action.deal,proposed.id);
|
|
assert.ok(action.paymentIndex === 0 || action.paymentIndex === 1);
|
|
game = act(game,f.target,action);
|
|
}
|
|
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['paid','paid']);
|
|
assert.equal(player(game,f.target).spice,5); assert.equal(player(game,f.asker).bribes,5);
|
|
assert.deepEqual(inventory(game),f.originalCards);
|
|
});
|
|
|
|
void test('multiple deferred payments can accompany an actual current-turn shipment', () => {
|
|
const f = createTruthTravelFixture(), initial = f.game, original = truthTravelInventory(initial);
|
|
const terms = [term(f.target,f.asker,1,initial.turn),term(f.target,f.asker,1,initial.turn)];
|
|
let game = actTruthTravel(initial,f.asker,{type:'dealOffer',target:f.target,terms:'Two payments and a shipment.',
|
|
additionalPayments:terms,travel:{kind:'ship',territory:f.shipmentTerritory,minimum:1,answer:true}});
|
|
const id = game.deals?.at(-1)?.id; assert.ok(id);
|
|
game = actTruthTravel(game,f.target,{type:'dealRespond',deal:id,accept:true});
|
|
assert.equal(viewGame(game,f.target).dealTravelStatus[id],'pending');
|
|
game = actTruthTravel(game,f.target,{type:'dealPay',deal:id,paymentIndex:0});
|
|
game = settleTruthTravel(actTruthTravel(game,f.target,f.shipmentAction));
|
|
game = actTruthTravel(game,f.target,{type:'dealPay',deal:id,paymentIndex:1});
|
|
assert.equal(viewGame(game,f.target).dealTravelStatus[id],'fulfilled');
|
|
assert.deepEqual(deal(game,id).additionalPayments?.map(line => line.paymentStatus),['paid','paid']);
|
|
assert.equal(truthTravelPlayer(game,f.target).forces['polar_sink:0'],1);
|
|
assert.deepEqual(truthTravelInventory(game),original);
|
|
});
|
|
|
|
void test('malformed additional payment packets are rejected without opening a deal', () => {
|
|
const f = fixture(), due = f.game.turn, valid = term(f.target,f.asker,1,due);
|
|
const packet = {type:'dealOffer',target:f.target,terms:'Invalid payment terms.'};
|
|
for (const additionalPayments of [
|
|
[{...valid,amount:0}], [{...valid,payer:f.asker,recipient:f.asker}],
|
|
[{...valid,dueTurn:due-1}], [{...valid,kind:'immediateBribe'}],
|
|
[{...valid,extra:true}], Array.from({length:13},() => valid),
|
|
]) reject(f.game,f.asker,{...packet,additionalPayments});
|
|
});
|