235 lines
14 KiB
TypeScript
235 lines
14 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { viewGame, type Action, type Game } from '../game/engine';
|
|
import { botActions } from '../game/bots';
|
|
import { DIFFICULTIES } from '../game/bot-profiles';
|
|
import {
|
|
actBoxShipmentPrice, allowBoxShipmentPrice, boxShipmentPriceInventory,
|
|
boxShipmentPricePhysical, boxShipmentPricePlayer as player, createBoxShipmentPriceFixture,
|
|
declareBoxShipmentPrice, finishBoxShipmentPrice, payBoxShipmentPrice,
|
|
selectBoxShipmentPrice, stopBoxShipmentPrice, type BoxShipmentPriceFixture,
|
|
} from './fixture-box-shipment-price';
|
|
|
|
function rejected(game: Game, actor: string, action: Action) {
|
|
const before = structuredClone(game);
|
|
assert.throws(() => actBoxShipmentPrice(game, actor, action));
|
|
assert.deepEqual(game, before);
|
|
}
|
|
function originalSource(f: BoxShipmentPriceFixture) {
|
|
assert.equal(f.game.status, 'playing');
|
|
assert.equal(f.game.phase, 5);
|
|
assert.equal(f.game.active, f.beneficiary);
|
|
assert.equal(f.game.response ?? null, null);
|
|
assert.equal(f.game.decision ?? null, null);
|
|
assert.equal(f.game.pendingNullentropy ?? null, null);
|
|
assert.equal(f.game.pendingTreacheryDiscard ?? null, null);
|
|
assert.deepEqual(f.game.karamaShipping, f.originalGrant);
|
|
assert.equal(f.game.karamaShipping!.card, f.karama);
|
|
assert.equal(f.game.karamaShipping!.owner, f.creator);
|
|
assert.equal(f.game.karamaShipping!.player, f.beneficiary);
|
|
assert.equal(Object.hasOwn(f.game.karamaShipping!, 'costClaimed'), false);
|
|
assert.notEqual(f.karama, f.stopKarama);
|
|
assert.ok(player(f.game, f.holder).hand.some(card => card.id === f.box));
|
|
assert.ok(player(f.game, f.holder).hand.some(card => card.id === f.stopKarama));
|
|
assert.ok(player(f.afterSetup, f.creator).hand.some(card => card.id === f.karama));
|
|
assert.ok(f.acquisition.actions.some(step => step.actor === f.holder && step.action.type === 'richeseBid' && step.action.amount === 1));
|
|
assert.equal(f.priceAction.card, f.karama);
|
|
assert.equal(f.priceAction.mode, 'shipment');
|
|
assert.equal(f.game.discard.filter(card => card.id === f.karama).length, 1);
|
|
assert.equal(f.game.discard.filter(card => card.id === f.alternative).length, f.otherCandidate ? 1 : 0);
|
|
if (f.otherCandidate) {
|
|
assert.ok(f.weather);
|
|
assert.equal(f.weather.action.card, f.alternative);
|
|
assert.equal(f.weather.action.amount, 0);
|
|
} else assert.equal(f.weather, null);
|
|
assert.equal(f.sourceActionCount, f.actions.length);
|
|
assert.deepEqual(boxShipmentPriceInventory(f.game), f.originalInventory);
|
|
}
|
|
function recovered(f: BoxShipmentPriceFixture, selected: string) {
|
|
const paid = payBoxShipmentPrice(f);
|
|
assert.equal(player(paid, f.holder).spice, player(f.game, f.holder).spice - f.boxFee);
|
|
assert.deepEqual(paid.karamaShipping, f.originalGrant, 'Payment alone does not claim the original price cost');
|
|
assert.ok(paid.pendingNullentropy);
|
|
const search = viewGame(paid, f.holder).nullentropy!.search;
|
|
assert.ok(search);
|
|
assert.deepEqual(search.cards.map(card => card.id).sort(), [f.karama, f.alternative].sort());
|
|
let game = selectBoxShipmentPrice(f, paid, selected);
|
|
game = finishBoxShipmentPrice(f, game);
|
|
assert.equal(player(game, f.holder).spice, player(f.game, f.holder).spice - f.boxFee);
|
|
assert.ok(player(game, f.holder).hand.some(card => card.id === selected));
|
|
assert.equal(game.discard.filter(card => card.id === f.box).length, 1);
|
|
assert.equal(game.discard.at(-1)!.id, f.box);
|
|
assert.equal(game.pendingNullentropy ?? null, null);
|
|
assert.deepEqual(game.karamaShipping, { ...f.originalGrant, ...(selected === f.karama ? { costClaimed: true } : {}) });
|
|
assert.deepEqual(boxShipmentPriceInventory(game), f.originalInventory);
|
|
return { paid, game };
|
|
}
|
|
|
|
for (const advanced of [false, true]) {
|
|
for (const selectedCost of [true, false]) {
|
|
void test(`${advanced ? 'Advanced' : 'Basic'} genuine Box selects ${selectedCost ? 'active price cost' : 'other discard'} and preserves the real bank-paid shipment`, () => {
|
|
const f = createBoxShipmentPriceFixture({ advanced });
|
|
originalSource(f);
|
|
if (!advanced) rejected(f.game, f.guild, { type: 'card', card: f.stopKarama, mode: 'special' });
|
|
const selected = selectedCost ? f.karama : f.alternative;
|
|
let { game } = recovered(f, selected);
|
|
const before = structuredClone(player(game, f.beneficiary)), guildSpice = player(game, f.guild).spice;
|
|
game = declareBoxShipmentPrice(f, game);
|
|
if (advanced) {
|
|
assert.equal(game.decision?.kind, 'guildShipment');
|
|
assert.equal(player(game, f.beneficiary).spice, before.spice);
|
|
assert.equal(player(game, f.beneficiary).reserves, before.reserves);
|
|
}
|
|
game = allowBoxShipmentPrice(f, game);
|
|
game = finishBoxShipmentPrice(f, game);
|
|
assert.equal(player(game, f.beneficiary).spice, before.spice - f.shipmentCost);
|
|
assert.equal(player(game, f.beneficiary).reserves, before.reserves - f.amount);
|
|
assert.equal(player(game, f.beneficiary).forces[f.target], f.amount);
|
|
assert.equal(player(game, f.beneficiary).shipped, true);
|
|
assert.equal(player(game, f.beneficiary).moved, 0);
|
|
assert.equal(player(game, f.guild).spice, guildSpice, 'The purchased price pays the bank, without Guild income');
|
|
assert.equal(game.karamaShipping, null);
|
|
assert.equal(player(game, f.holder).hand.filter(card => card.id === selected).length, 1);
|
|
rejected(game, f.beneficiary, f.shipment);
|
|
assert.deepEqual(boxShipmentPriceInventory(game), f.originalInventory);
|
|
});
|
|
}
|
|
|
|
if (advanced) void test('Advanced genuine Box recovery can spend the same price card for a Guild stop without a second refund', () => {
|
|
const f = createBoxShipmentPriceFixture({ advanced });
|
|
originalSource(f);
|
|
let { game } = recovered(f, f.karama);
|
|
const before = structuredClone(player(game, f.beneficiary)), guildSpice = player(game, f.guild).spice;
|
|
game = declareBoxShipmentPrice(f, game);
|
|
game = stopBoxShipmentPrice(f, game, f.karama);
|
|
game = finishBoxShipmentPrice(f, game);
|
|
assert.equal(player(game, f.beneficiary).spice, before.spice);
|
|
assert.equal(player(game, f.beneficiary).reserves, before.reserves);
|
|
assert.deepEqual(player(game, f.beneficiary).forces, before.forces);
|
|
assert.equal(player(game, f.beneficiary).shipped, true);
|
|
assert.equal(player(game, f.beneficiary).moved, 0);
|
|
assert.equal(player(game, f.guild).spice, guildSpice);
|
|
assert.equal(player(game, f.guild).specialKaramaUsed, true);
|
|
assert.equal(player(game, f.creator).hand.some(card => card.id === f.karama), false);
|
|
assert.equal(player(game, f.guild).hand.some(card => card.id === f.karama), false);
|
|
assert.ok(player(game, f.guild).hand.some(card => card.id === f.stopKarama));
|
|
assert.equal(game.discard.filter(card => card.id === f.karama).length, 1);
|
|
assert.equal(game.discard.filter(card => card.id === f.box).length, 1);
|
|
assert.equal(game.karamaShipping, null);
|
|
rejected(game, f.guild, { type: 'card', card: f.karama, mode: 'special' });
|
|
game = actBoxShipmentPrice(game, f.beneficiary, { type: 'endMovement' });
|
|
assert.notEqual(game.active, f.beneficiary);
|
|
assert.deepEqual(boxShipmentPriceInventory(game), f.originalInventory);
|
|
});
|
|
|
|
if (advanced) void test('Advanced genuine Box search during Guild interception restores the original shipment before a same-card stop', () => {
|
|
const f = createBoxShipmentPriceFixture({ advanced });
|
|
originalSource(f);
|
|
const declared = declareBoxShipmentPrice(f, structuredClone(f.game));
|
|
assert.equal(declared.decision?.kind, 'guildShipment');
|
|
const originalDecision = structuredClone(declared.decision), originalShipment = structuredClone(declared.pendingShipment);
|
|
assert.ok(originalShipment);
|
|
const originalShipper = structuredClone(player(declared, f.beneficiary));
|
|
const paid = payBoxShipmentPrice(f, declared);
|
|
assert.ok(paid.pendingNullentropy);
|
|
assert.deepEqual(paid.pendingNullentropy.resume.decision, originalDecision);
|
|
assert.deepEqual(paid.pendingShipment, originalShipment);
|
|
assert.deepEqual(paid.karamaShipping, f.originalGrant);
|
|
let game = selectBoxShipmentPrice(f, paid, f.karama);
|
|
assert.deepEqual(game.decision, originalDecision);
|
|
assert.deepEqual(game.pendingShipment, originalShipment);
|
|
assert.deepEqual(game.karamaShipping, { ...f.originalGrant, costClaimed: true });
|
|
assert.equal(player(game, f.holder).spice, player(f.game, f.holder).spice - f.boxFee);
|
|
game = stopBoxShipmentPrice(f, game, f.karama);
|
|
game = finishBoxShipmentPrice(f, game);
|
|
assert.deepEqual(player(game, f.beneficiary).forces, originalShipper.forces);
|
|
assert.equal(player(game, f.beneficiary).reserves, originalShipper.reserves);
|
|
assert.equal(player(game, f.beneficiary).spice, originalShipper.spice);
|
|
assert.equal(player(game, f.beneficiary).shipped, true);
|
|
assert.equal(player(game, f.beneficiary).moved, 0);
|
|
assert.equal(game.pendingShipment ?? null, null);
|
|
assert.equal(game.karamaShipping, null);
|
|
assert.equal(player(game, f.creator).hand.some(card => card.id === f.karama), false);
|
|
assert.equal(game.discard.filter(card => card.id === f.karama).length, 1);
|
|
assert.equal(game.discard.filter(card => card.id === f.box).length, 1);
|
|
assert.deepEqual(boxShipmentPriceInventory(game), f.originalInventory);
|
|
});
|
|
|
|
if (advanced) void test('Advanced genuine Box other-card selection leaves the unclaimed price cost refundable exactly once', () => {
|
|
const f = createBoxShipmentPriceFixture({ advanced });
|
|
originalSource(f);
|
|
let { game } = recovered(f, f.alternative);
|
|
const before = structuredClone(player(game, f.beneficiary));
|
|
game = declareBoxShipmentPrice(f, game);
|
|
game = stopBoxShipmentPrice(f, game, f.stopKarama);
|
|
game = finishBoxShipmentPrice(f, game);
|
|
assert.equal(player(game, f.beneficiary).spice, before.spice);
|
|
assert.equal(player(game, f.beneficiary).reserves, before.reserves);
|
|
assert.deepEqual(player(game, f.beneficiary).forces, before.forces);
|
|
assert.equal(player(game, f.beneficiary).shipped, true);
|
|
assert.equal(player(game, f.creator).hand.filter(card => card.id === f.karama).length, 1);
|
|
assert.equal(game.discard.some(card => card.id === f.karama), false);
|
|
assert.equal(game.discard.filter(card => card.id === f.stopKarama).length, 1);
|
|
assert.equal(player(game, f.guild).hand.filter(card => card.id === f.alternative).length, 1);
|
|
assert.equal(game.karamaShipping, null);
|
|
rejected(game, f.guild, { type: 'card', card: f.stopKarama, mode: 'special' });
|
|
assert.equal(player(game, f.creator).hand.filter(card => card.id === f.karama).length, 1);
|
|
assert.deepEqual(boxShipmentPriceInventory(game), f.originalInventory);
|
|
});
|
|
|
|
void test(`${advanced ? 'Advanced' : 'Basic'} genuine sole-candidate Box automatically recovers and marks the original price cost`, () => {
|
|
const f = createBoxShipmentPriceFixture({ advanced, otherCandidate: false });
|
|
originalSource(f);
|
|
assert.deepEqual(f.game.discard.map(card => card.id), [f.karama]);
|
|
const game = finishBoxShipmentPrice(f, payBoxShipmentPrice(f));
|
|
assert.equal(game.pendingNullentropy ?? null, null);
|
|
assert.equal(game.decision ?? null, null);
|
|
assert.equal(player(game, f.holder).spice, player(f.game, f.holder).spice - f.boxFee);
|
|
assert.equal(player(game, f.holder).hand.filter(card => card.id === f.karama).length, 1);
|
|
assert.deepEqual(game.karamaShipping, { ...f.originalGrant, costClaimed: true });
|
|
assert.deepEqual(game.discard.map(card => card.id), [f.box]);
|
|
assert.deepEqual(boxShipmentPriceInventory(game), f.originalInventory);
|
|
});
|
|
|
|
void test(`${advanced ? 'Advanced' : 'Basic'} genuine Box stale and foreign choices retain the paid search and charge its fee once`, () => {
|
|
const f = createBoxShipmentPriceFixture({ advanced });
|
|
originalSource(f);
|
|
const paid = payBoxShipmentPrice(f), event = paid.pendingNullentropy!.event;
|
|
rejected(paid, f.creator, { type: 'decision', event, card: f.karama });
|
|
rejected(paid, f.holder, { type: 'decision', event: 'stale', card: f.karama });
|
|
rejected(paid, f.holder, { type: 'decision', event, card: f.stopKarama });
|
|
rejected(paid, f.holder, f.action);
|
|
assert.deepEqual(paid.karamaShipping, f.originalGrant);
|
|
assert.equal(player(paid, f.holder).spice, player(f.game, f.holder).spice - f.boxFee);
|
|
const done = selectBoxShipmentPrice(f, paid, f.karama);
|
|
rejected(done, f.holder, { type: 'decision', event, card: f.alternative });
|
|
assert.equal(player(done, f.holder).spice, player(f.game, f.holder).spice - f.boxFee);
|
|
assert.deepEqual(boxShipmentPriceInventory(done), f.originalInventory);
|
|
});
|
|
}
|
|
|
|
void test('four existing profiles make a legal paid native Box selection while preserving the original purchased price', () => {
|
|
for (const advanced of [false, true]) {
|
|
const f = createBoxShipmentPriceFixture({ advanced }), paid = payBoxShipmentPrice(f);
|
|
for (const difficulty of DIFFICULTIES) {
|
|
const view = viewGame(paid, f.holder);
|
|
view.players.find(seat => seat.id === f.holder)!.bot = difficulty;
|
|
const candidates = view.nullentropy!.search!.cards.map(card => card.id), action = botActions(view)[0];
|
|
assert.ok(action, `${advanced}/${difficulty}`);
|
|
assert.equal(action.type, 'decision');
|
|
assert.equal(action.event, paid.pendingNullentropy!.event);
|
|
assert.ok(candidates.includes(String(action.card)));
|
|
const done = actBoxShipmentPrice(structuredClone(paid), f.holder, action);
|
|
assert.equal(player(done, f.holder).spice, player(f.game, f.holder).spice - f.boxFee);
|
|
assert.equal(done.karamaShipping!.owner, f.creator);
|
|
assert.equal(done.karamaShipping!.player, f.beneficiary);
|
|
assert.equal(done.karamaShipping!.costClaimed ?? false, action.card === f.karama);
|
|
assert.deepEqual(boxShipmentPriceInventory(done), f.originalInventory);
|
|
const before = boxShipmentPricePhysical(f.game), after = boxShipmentPricePhysical(done);
|
|
assert.equal(after.active, before.active);
|
|
assert.deepEqual(after.players.map(seat => ({ ...seat, spice: 0 })),
|
|
before.players.map(seat => ({ ...seat, spice: 0 })));
|
|
}
|
|
}
|
|
});
|