Quintine
7e3bec2721
The user answered five recorded questions; each ruling is indexed in RULE_DECISIONS.md and implemented with a focused regression. - CHOAM opening income counts as a qualifying collection, so low-population Tupile adds its bank increment under the Inflation multiplier. The engine guard is removed and the projection/notice expose the added bonus. - An exhausted Richese cache is legal and restores one ordinary lot; the canceled/prevented compulsory cache auction branch restores the reduction before the ordinary pool runs and the cache offer is skipped when no cache lot can run. The pure continuation quote mirrors the count. - Suk-rescued casualties count toward Advanced Atreides' seven Kwisatz Haderach losses: the battle-loss counter gains the full dialed allocation in both rescue paths, and the earlier Suk availability restriction is removed. - The Guild Nexus Secret Ally reserve return overrides the Arrakis-to-native- Homeworld restriction for the holder's own reserves and deposits through the shared native-reserve pipeline (generalized from the revival deposit). - Interior passengers count as entering the territories a relocated Ixian HMS points into, so Sandmaster collects there before the native collection. Full offline suite 7804/7804, types and lint pass. Historical evidence and superseded test expectations are updated to the ruled behaviour; preserved combined Homeworld/Nexus, occupation and Richese captures are unblocked but not re-run here. No existing game, seat or saved state was changed.
543 lines
19 KiB
TypeScript
543 lines
19 KiB
TypeScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
applyAction,
|
|
createGame,
|
|
joinGame,
|
|
newPlayer,
|
|
normalizeAutomaticGame,
|
|
viewGame,
|
|
type Game,
|
|
} from '../game/engine';
|
|
import { baseDeck } from '../game/cards';
|
|
import { richeseCards } from '../game/richese-cards';
|
|
import { submitRicheseBid } from '../game/richese-auction';
|
|
|
|
const player = (g: Game, id: string) => g.players.find((p) => p.id === id)!;
|
|
const reload = (g: Game): Game => JSON.parse(JSON.stringify(g));
|
|
|
|
function hold(g: Game, id: string, form: 'printed' | 'worthless') {
|
|
const index = g.deck.findIndex((c) =>
|
|
form === 'printed' ? c.effect === 'karama' : c.kind === 'worthless',
|
|
);
|
|
assert.ok(index >= 0);
|
|
const card = g.deck.splice(index, 1)[0];
|
|
player(g, id).hand.push(card);
|
|
return card.id;
|
|
}
|
|
|
|
function inventory(g: Game) {
|
|
const ids = [
|
|
...g.deck,
|
|
...g.discard,
|
|
...g.players.flatMap((p) => p.hand),
|
|
...(g.richeseCache ?? []),
|
|
...(g.richeseRemoved ?? []),
|
|
...(g.auction?.cards.slice(g.auction.index) ?? []),
|
|
]
|
|
.map((c) => c.id)
|
|
.sort();
|
|
assert.equal(new Set(ids).size, ids.length);
|
|
return ids;
|
|
}
|
|
|
|
/** Construct only the pre-Bidding scenario. The count opportunity itself is
|
|
* generated through real all-ready and Richese declaration actions. */
|
|
function countOpportunity(position: 'first' | 'last' = 'first') {
|
|
let g = createGame(
|
|
'KARAMAPREFLIGHT',
|
|
newPlayer('r', 'Richese', 'richese'),
|
|
true,
|
|
['choam'],
|
|
);
|
|
joinGame(g, newPlayer('b', 'Bene Gesserit', 'beneGesserit'));
|
|
joinGame(g, newPlayer('e', 'Emperor', 'emperor'));
|
|
Object.assign(g, {
|
|
status: 'playing',
|
|
phase: 2,
|
|
turn: 2,
|
|
order: ['r', 'b', 'e'],
|
|
ready: [],
|
|
deck: baseDeck(),
|
|
richeseCache: richeseCards(),
|
|
richeseRemoved: [],
|
|
});
|
|
for (const p of g.players) {
|
|
p.hand = [];
|
|
p.spice = 20;
|
|
}
|
|
const worthless = hold(g, 'b', 'worthless');
|
|
const printed = hold(g, 'e', 'printed');
|
|
const spare = hold(g, 'e', 'printed');
|
|
const physical = inventory(g);
|
|
for (const p of g.players) g = applyAction(g, p.id, { type: 'ready' });
|
|
assert.equal(g.phase, 3);
|
|
assert.equal(g.decision?.kind, 'richeseDeclaration');
|
|
assert.equal(g.richeseBidding?.normalCount, 2);
|
|
g = applyAction(g, 'r', {
|
|
type: 'decision',
|
|
event: g.richeseBidding!.event,
|
|
position,
|
|
});
|
|
assert.equal(g.response?.kind, 'richeseAuction');
|
|
assert.equal(g.response.owner, 'r');
|
|
assert.equal(g.auction, null);
|
|
assert.deepEqual(inventory(g), physical);
|
|
return { g, worthless, printed, spare };
|
|
}
|
|
|
|
for (const form of ['printed', 'worthless'] as const)
|
|
for (const position of ['first', 'last'] as const)
|
|
void test(`${form} cancellation of the real ${position} Richese count rejects before cost or conversion, without randomness`, (t) => {
|
|
const { g, worthless, printed } = countOpportunity(position);
|
|
const before = structuredClone(g);
|
|
const physical = inventory(g);
|
|
const random = t.mock.method(crypto, 'getRandomValues', () => {
|
|
throw Error('Rejected preflight must not draw randomness.');
|
|
});
|
|
const uuid = t.mock.method(crypto, 'randomUUID', () => {
|
|
throw Error('Rejected preflight must not allocate an event.');
|
|
});
|
|
for (let attempt = 0; attempt < 2; attempt++)
|
|
assert.throws(
|
|
() =>
|
|
applyAction(g, form === 'printed' ? 'e' : 'b', {
|
|
type: 'card',
|
|
card: form === 'printed' ? printed : worthless,
|
|
mode: 'cancel',
|
|
}),
|
|
/canceled Richese auction count.*ruling/i,
|
|
);
|
|
assert.deepEqual(g, before);
|
|
assert.deepEqual(inventory(g), physical);
|
|
assert.equal(g.pendingKarama, undefined);
|
|
assert.equal(g.discard.length, 0);
|
|
assert.equal(random.mock.callCount(), 0);
|
|
assert.equal(uuid.mock.callCount(), 0);
|
|
});
|
|
|
|
void test('printed cancellation of a legacy BG conversion restores the original Richese count instead of executing its unsupported cancellation', () => {
|
|
const { g: initial, worthless, printed, spare } = countOpportunity();
|
|
const physical = inventory(initial);
|
|
const original = structuredClone(initial.response!);
|
|
const legacy = reload(initial);
|
|
const bg = player(legacy, 'b');
|
|
// Historical saves accepted this conversion before checking the eventual
|
|
// unsupported count cancellation. Preserve its real parent and spent card;
|
|
// do not use the newly rejected declaration to manufacture a legacy save.
|
|
const index = bg.hand.findIndex((c) => c.id === worthless);
|
|
legacy.discard.push(bg.hand.splice(index, 1)[0]);
|
|
legacy.pendingKarama = {
|
|
owner: 'b',
|
|
use: { kind: 'cancel', response: original },
|
|
};
|
|
legacy.response = {
|
|
kind: 'worthlessKarama',
|
|
owner: 'b',
|
|
passed: [],
|
|
intent: 'Cancel a power used by Richese.',
|
|
};
|
|
const saved = reload(legacy);
|
|
const before = structuredClone(saved);
|
|
for (const p of saved.players)
|
|
assert.equal(viewGame(saved, p.id).response?.kind, 'worthlessKarama');
|
|
assert.deepEqual(reload(normalizeAutomaticGame(saved)), saved);
|
|
let done = applyAction(saved, 'e', {
|
|
type: 'card',
|
|
card: printed,
|
|
mode: 'cancel',
|
|
});
|
|
assert.deepEqual(saved, before);
|
|
assert.equal(done.pendingKarama, null);
|
|
assert.deepEqual(done.response, original);
|
|
assert.deepEqual(done.richeseBidding, initial.richeseBidding);
|
|
assert.equal(done.auction, null);
|
|
assert.equal(done.discard.filter((c) => c.id === worthless).length, 1);
|
|
assert.equal(done.discard.filter((c) => c.id === printed).length, 1);
|
|
assert.ok(player(done, 'e').hand.some((c) => c.id === spare));
|
|
assert.deepEqual(inventory(done), physical);
|
|
assert.deepEqual(reload(normalizeAutomaticGame(reload(done))), reload(done));
|
|
|
|
// Actual passes now allow the original count once. The spare printed card
|
|
// kept restoration observable instead of allowing automatic advancement.
|
|
while (done.response?.kind === 'richeseAuction') {
|
|
const next = done.players.find(
|
|
(p) => !done.response!.passed.includes(p.id),
|
|
);
|
|
assert.ok(next);
|
|
done = applyAction(done, next.id, { type: 'passResponse' });
|
|
}
|
|
assert.equal(done.decision?.kind, 'richeseCache');
|
|
assert.equal(done.richeseBidding?.normalCount, 2);
|
|
assert.equal(done.richeseBidding?.stage, 'cacheOffer');
|
|
assert.equal(done.discard.length, 2);
|
|
assert.deepEqual(inventory(done), physical);
|
|
});
|
|
|
|
function blackMarketOpportunity(winner: 'a' | 'b' | 'e' = 'a') {
|
|
let g = createGame(
|
|
'KARAMAMARKET',
|
|
newPlayer('r', 'Richese', 'richese'),
|
|
true,
|
|
['choam'],
|
|
);
|
|
joinGame(g, newPlayer('b', 'Bene Gesserit', 'beneGesserit'));
|
|
joinGame(g, newPlayer('e', 'Emperor', 'emperor'));
|
|
joinGame(g, newPlayer('a', 'Atreides', 'atreides'));
|
|
Object.assign(g, {
|
|
status: 'playing',
|
|
phase: 2,
|
|
turn: 2,
|
|
order: ['r', 'b', 'e', 'a'],
|
|
ready: [],
|
|
deck: baseDeck(),
|
|
richeseCache: richeseCards(),
|
|
richeseRemoved: [],
|
|
});
|
|
for (const p of g.players) {
|
|
p.hand = [];
|
|
p.spice = 20;
|
|
}
|
|
const donor = winner === 'a' ? 'b' : 'a';
|
|
player(g, winner).ally = donor;
|
|
player(g, donor).ally = winner;
|
|
const worthless = hold(g, 'b', 'worthless');
|
|
const printed = hold(g, 'e', 'printed');
|
|
hold(g, 'e', 'printed');
|
|
const offered = g.deck.splice(
|
|
g.deck.findIndex((c) => c.kind === 'projectile'),
|
|
1,
|
|
)[0];
|
|
player(g, 'r').hand.push(offered);
|
|
for (const p of g.players) g = applyAction(g, p.id, { type: 'ready' });
|
|
assert.equal(g.decision?.kind, 'richeseBlackMarket');
|
|
g = applyAction(g, 'r', {
|
|
type: 'decision',
|
|
event: g.richeseBidding!.event,
|
|
card: offered.id,
|
|
method: 'silent',
|
|
direction: 'clockwise',
|
|
});
|
|
assert.equal(g.response?.kind, 'richeseBlackMarket');
|
|
assert.equal(g.richeseAuction?.cardId, offered.id);
|
|
return { g, worthless, printed, offered };
|
|
}
|
|
|
|
for (const form of ['printed', 'worthless'] as const)
|
|
void test(`${form} Black Market cancellation with an exhausted cache continues and restores the ordinary lot`, () => {
|
|
// User ruling 7 October 2026: an exhausted cache is legal, so a canceled
|
|
// Black Market settles and the round declares the ordinary pool with the
|
|
// cache's one-lot reduction restored.
|
|
const counts: number[] = [];
|
|
for (const exhausted of [false, true]) {
|
|
const { g: initial, worthless, printed } = blackMarketOpportunity();
|
|
const g = reload(initial);
|
|
// A real offered Black Market keeps its response while its cache is
|
|
// exhausted; every physical card ID is preserved.
|
|
if (exhausted) {
|
|
g.richeseRemoved!.push(...g.richeseCache!);
|
|
g.richeseCache = [];
|
|
}
|
|
const physical = inventory(g);
|
|
let canceled = applyAction(g, form === 'printed' ? 'e' : 'b', {
|
|
type: 'card',
|
|
card: form === 'printed' ? printed : worthless,
|
|
mode: 'cancel',
|
|
});
|
|
// The Worthless card opens its own conversion response before settling.
|
|
canceled = passKind(canceled, 'worthlessKarama');
|
|
assert.equal(canceled.decision?.kind, 'richeseDeclaration');
|
|
assert.ok(!canceled.pendingKarama);
|
|
assert.deepEqual(inventory(canceled), physical);
|
|
counts.push(canceled.richeseBidding!.normalCount!);
|
|
}
|
|
assert.equal(
|
|
counts[1],
|
|
counts[0] + 1,
|
|
'The exhausted cache restores exactly one ordinary lot',
|
|
);
|
|
});
|
|
|
|
function passKind(initial: Game, kind: NonNullable<Game['response']>['kind']) {
|
|
let g = initial;
|
|
while (g.response?.kind === kind) {
|
|
const next = g.players.find((p) => !g.response!.passed.includes(p.id));
|
|
assert.ok(next);
|
|
g = applyAction(g, next.id, { type: 'passResponse' });
|
|
}
|
|
return g;
|
|
}
|
|
|
|
function savedSoldPeek(winner: 'a' | 'b' | 'e' = 'a') {
|
|
const f = blackMarketOpportunity(winner);
|
|
let g = passKind(f.g, 'richeseBlackMarket');
|
|
assert.equal(g.response?.kind, 'atreidesAuction');
|
|
const peek = structuredClone(g.response);
|
|
g = passKind(g, 'atreidesAuction');
|
|
assert.equal(g.response, null);
|
|
const donor = winner === 'a' ? 'b' : 'a';
|
|
g = applyAction(g, donor, { type: 'pledgeAid', amount: 2 });
|
|
// Saved-state coverage, not a claimed reachable public pause: today's final
|
|
// bid immediately settles. Derive a coherent terminal outcome using the
|
|
// real pure bidding reducer, retaining the earlier genuine peek control.
|
|
// The cancellation dispatcher must safely handle or reject this snapshot.
|
|
for (const id of g.richeseAuction!.eligible) {
|
|
const amount = id === winner ? 5 : 0;
|
|
g.richeseAuction = submitRicheseBid(
|
|
g.richeseAuction!,
|
|
{ event: g.richeseAuction!.event, actor: id, amount },
|
|
20,
|
|
);
|
|
g.richeseFunding![id] = {
|
|
amount,
|
|
allyPayment: id === winner ? 2 : 0,
|
|
donor: id === winner ? donor : null,
|
|
};
|
|
}
|
|
assert.deepEqual(g.richeseAuction!.outcome, {
|
|
kind: 'sold',
|
|
winner,
|
|
amount: 5,
|
|
});
|
|
g.response = peek;
|
|
g.active = g.richeseAuction!.active;
|
|
return { ...f, g: reload(g) };
|
|
}
|
|
|
|
const invalidSettlement: [string, (g: Game) => void, RegExp][] = [
|
|
[
|
|
'reserved card missing from its actual source',
|
|
(g) => {
|
|
const owner = player(g, 'r');
|
|
const i = owner.hand.findIndex((c) => c.id === g.richeseAuction!.cardId);
|
|
g.deck.push(owner.hand.splice(i, 1)[0]);
|
|
},
|
|
/reserved auction card.*available/i,
|
|
],
|
|
[
|
|
'winning hand at capacity',
|
|
(g) => {
|
|
const winner = player(g, 'a');
|
|
while (winner.hand.length < 4) winner.hand.push(g.deck.shift()!);
|
|
},
|
|
/winning hand.*room/i,
|
|
],
|
|
[
|
|
'missing exact funding',
|
|
(g) => delete g.richeseFunding!.a,
|
|
/exact funding/i,
|
|
],
|
|
[
|
|
'funding amount differs from the winning bid',
|
|
(g) => {
|
|
g.richeseFunding!.a.amount = 4;
|
|
},
|
|
/exact funding/i,
|
|
],
|
|
[
|
|
'ally split exceeds the actual pledged credit',
|
|
(g) => {
|
|
g.richeseFunding!.a.allyPayment = 3;
|
|
},
|
|
/payment.*funded/i,
|
|
],
|
|
[
|
|
'own part of the declared split is unfunded',
|
|
(g) => {
|
|
player(g, 'a').spice = 2;
|
|
},
|
|
/payment.*funded/i,
|
|
],
|
|
];
|
|
|
|
for (const form of ['printed', 'worthless'] as const)
|
|
for (const [name, corrupt, error] of invalidSettlement)
|
|
void test(`${form} Atreides peek cancellation preflights ${name} before spending`, (t) => {
|
|
const { g, worthless, printed } = savedSoldPeek();
|
|
corrupt(g);
|
|
const before = structuredClone(g);
|
|
const physical = inventory(g);
|
|
const random = t.mock.method(crypto, 'getRandomValues', () => {
|
|
throw Error('Rejected settlement preflight must not draw.');
|
|
});
|
|
const uuid = t.mock.method(crypto, 'randomUUID', () => {
|
|
throw Error('Rejected settlement preflight must not advance its lot.');
|
|
});
|
|
assert.throws(
|
|
() =>
|
|
applyAction(g, form === 'printed' ? 'e' : 'b', {
|
|
type: 'card',
|
|
card: form === 'printed' ? printed : worthless,
|
|
mode: 'cancel',
|
|
}),
|
|
error,
|
|
);
|
|
assert.deepEqual(g, before);
|
|
assert.deepEqual(inventory(g), physical);
|
|
assert.equal(g.pendingKarama, undefined);
|
|
assert.equal(g.discard.length, 0);
|
|
assert.equal(random.mock.callCount(), 0);
|
|
assert.equal(uuid.mock.callCount(), 0);
|
|
});
|
|
|
|
for (const form of ['printed', 'worthless'] as const)
|
|
void test(`${form} Atreides peek cancellation preserves a valid exact split and settles the original card once`, () => {
|
|
const { g, worthless, printed, offered } = savedSoldPeek();
|
|
const before = structuredClone(g);
|
|
const physical = inventory(g);
|
|
let done = applyAction(g, form === 'printed' ? 'e' : 'b', {
|
|
type: 'card',
|
|
card: form === 'printed' ? printed : worthless,
|
|
mode: 'cancel',
|
|
});
|
|
assert.deepEqual(g, before);
|
|
if (form === 'worthless') {
|
|
assert.equal(done.response?.kind, 'worthlessKarama');
|
|
assert.equal(player(done, 'a').spice, 20);
|
|
assert.equal(done.aid.b.amount, 2);
|
|
assert.ok(player(done, 'r').hand.some((c) => c.id === offered.id));
|
|
done = passKind(reload(done), 'worthlessKarama');
|
|
}
|
|
assert.equal(player(done, 'a').spice, 17);
|
|
assert.equal(done.aid.b.amount, 0);
|
|
assert.equal(player(done, 'b').spice, 18);
|
|
assert.equal(player(done, 'r').spice, 25);
|
|
assert.equal(
|
|
player(done, 'a').hand.filter((c) => c.id === offered.id).length,
|
|
1,
|
|
);
|
|
assert.ok(!player(done, 'r').hand.some((c) => c.id === offered.id));
|
|
assert.equal(done.decision?.kind, 'richeseDeclaration');
|
|
assert.equal(done.richeseAuction, null);
|
|
assert.equal(done.discard.length, 1);
|
|
assert.deepEqual(inventory(done), physical);
|
|
assert.deepEqual(
|
|
reload(normalizeAutomaticGame(reload(done))),
|
|
reload(done),
|
|
);
|
|
});
|
|
|
|
for (const form of ['printed', 'worthless'] as const)
|
|
void test(`${form} winning buyer at capacity frees its own slot before the saved Atreides settlement quote`, () => {
|
|
const winner = form === 'printed' ? 'e' : 'b';
|
|
const { g, worthless, printed, offered } = savedSoldPeek(winner);
|
|
// The same documented constructed sold-peek boundary, with the winning
|
|
// buyer also paying for cancellation. Its pre-cost hand is exactly full.
|
|
const buyer = player(g, winner);
|
|
while (buyer.hand.length < 4) buyer.hand.push(g.deck.shift()!);
|
|
assert.equal(buyer.hand.length, 4);
|
|
const spent = form === 'printed' ? printed : worthless;
|
|
const before = structuredClone(g);
|
|
const physical = inventory(g);
|
|
let done = applyAction(g, winner, {
|
|
type: 'card',
|
|
card: spent,
|
|
mode: 'cancel',
|
|
});
|
|
assert.deepEqual(g, before);
|
|
if (form === 'worthless') {
|
|
assert.equal(done.response?.kind, 'worthlessKarama');
|
|
assert.equal(player(done, winner).hand.length, 3);
|
|
assert.equal(player(done, winner).spice, 20);
|
|
assert.equal(done.aid.a.amount, 2);
|
|
assert.ok(player(done, 'r').hand.some((c) => c.id === offered.id));
|
|
done = passKind(reload(done), 'worthlessKarama');
|
|
}
|
|
assert.equal(player(done, winner).hand.length, 4);
|
|
assert.equal(
|
|
player(done, winner).hand.filter((c) => c.id === offered.id).length,
|
|
1,
|
|
);
|
|
assert.equal(
|
|
player(done, winner).hand.some((c) => c.id === spent),
|
|
false,
|
|
);
|
|
assert.equal(done.discard.filter((c) => c.id === spent).length, 1);
|
|
assert.equal(player(done, winner).spice, 17);
|
|
assert.equal(player(done, 'a').spice, 18);
|
|
assert.equal(done.aid.a.amount, 0);
|
|
assert.equal(player(done, 'r').spice, 25);
|
|
assert.equal(done.richeseAuction, null);
|
|
assert.equal(done.decision?.kind, 'richeseDeclaration');
|
|
assert.deepEqual(inventory(done), physical);
|
|
assert.deepEqual(
|
|
reload(normalizeAutomaticGame(reload(done))),
|
|
reload(done),
|
|
);
|
|
});
|
|
|
|
for (const form of ['printed', 'worthless'] as const)
|
|
void test(`${form} original normal-auction winner can pay from a full saved hand by freeing its Karama slot`, () => {
|
|
const winner = form === 'printed' ? 'e' : 'b';
|
|
let g = createGame(
|
|
'KARAMAFULLPAY',
|
|
newPlayer('b', 'Bene Gesserit', 'beneGesserit'),
|
|
true,
|
|
);
|
|
joinGame(g, newPlayer('e', 'Emperor', 'emperor'));
|
|
joinGame(g, newPlayer('g', 'Guild', 'guild'));
|
|
Object.assign(g, {
|
|
status: 'playing',
|
|
phase: 3,
|
|
turn: 2,
|
|
order: [
|
|
winner,
|
|
...g.players.map((p) => p.id).filter((id) => id !== winner),
|
|
],
|
|
active: winner,
|
|
deck: baseDeck(),
|
|
});
|
|
for (const p of g.players) {
|
|
p.hand = [];
|
|
p.spice = 20;
|
|
}
|
|
const card = hold(g, winner, form);
|
|
hold(g, 'g', 'printed');
|
|
const sold = g.deck.shift()!;
|
|
g.auction = {
|
|
cards: [sold],
|
|
index: 0,
|
|
bid: 0,
|
|
bidder: null,
|
|
active: winner,
|
|
passed: [],
|
|
opener: 0,
|
|
peekKnown: false,
|
|
};
|
|
g = applyAction(g, winner, { type: 'bid', amount: 3 });
|
|
while (!g.decision)
|
|
g = applyAction(g, g.auction!.active, { type: 'passBid' });
|
|
assert.equal(g.decision.kind, 'auctionPayment');
|
|
assert.equal(g.decision.player, winner);
|
|
assert.equal(g.auction!.bidder, winner);
|
|
// A saved payment-stage capacity boundary; actual bidding above establishes
|
|
// the winner. Keep card custody unique while filling the remaining slots.
|
|
while (player(g, winner).hand.length < 4)
|
|
player(g, winner).hand.push(g.deck.shift()!);
|
|
const before = structuredClone(g);
|
|
const physical = inventory(g);
|
|
let done = applyAction(reload(g), winner, {
|
|
type: 'decision',
|
|
karama: true,
|
|
card,
|
|
});
|
|
assert.deepEqual(g, before);
|
|
if (form === 'worthless') {
|
|
assert.equal(player(done, winner).hand.length, 3);
|
|
done = passKind(reload(done), 'worthlessKarama');
|
|
}
|
|
assert.equal(player(done, winner).hand.length, 4);
|
|
assert.equal(
|
|
player(done, winner).hand.filter((c) => c.id === sold.id).length,
|
|
1,
|
|
);
|
|
assert.equal(player(done, winner).spice, 20);
|
|
assert.equal(done.discard.filter((c) => c.id === card).length, 1);
|
|
assert.equal(done.auction, null);
|
|
assert.deepEqual(inventory(done), physical);
|
|
assert.deepEqual(
|
|
reload(normalizeAutomaticGame(reload(done))),
|
|
reload(done),
|
|
);
|
|
});
|