549 lines
21 KiB
TypeScript
549 lines
21 KiB
TypeScript
import test from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import {
|
||
applyAction,
|
||
createGame,
|
||
newPlayer,
|
||
viewGame,
|
||
RuleError,
|
||
type Game,
|
||
type Action,
|
||
} from '../game/engine';
|
||
import { baseDeck } from '../game/cards';
|
||
import { botActions, runBots } from '../game/bots';
|
||
import { DIFFICULTIES } from '../game/bot-profiles';
|
||
import {
|
||
truthFactAnswer,
|
||
truthQuestionText,
|
||
validateTruthQuestionReceipt,
|
||
type TruthFact,
|
||
type TruthQuestion,
|
||
} from '../game/truthtrance';
|
||
import { CHEAP_HERO_TRAITOR } from '../game/traitors';
|
||
|
||
void test('whole card questions name Amal, Thumper and the actual printed Karama role and shipment beneficiary', () => {
|
||
const question = (effect: 'amal' | 'thumper' | 'karamaAuction' | 'karamaShipment', source: string) =>
|
||
truthQuestionText({ kind: 'turnActions', target: 'emperor', turn: 2, mixed: { kind: 'action', action: {
|
||
kind: 'windowCardPlay', effect, source,
|
||
} } }, id => id, id => id, id => id === 'emperor' ? 'Emperor' : id);
|
||
assert.match(question('thumper', 'first-spice-reveal:2'), /Thumper.*original first Spice reveal.*ignored or suppressed/);
|
||
assert.match(question('amal', 'phase-opening:2:8'), /Amal.*original phase opening.*before ordinary payments/);
|
||
assert.match(question('karamaAuction', 'ordinary-auction:2:1'), /Karama.*original ordinary auction lot.*winning invoice/);
|
||
assert.match(question('karamaShipment', '["karamaShipment",2,"emperor","original"]'), /Karama.*Emperor’s original unused shipment price/);
|
||
});
|
||
|
||
void test('whole Box questions describe future printed activation and its search payment without choosing the recovered card', () => {
|
||
const question: TruthQuestion = { kind: 'turnActions', target: 'e', turn: 2,
|
||
mixed: { kind: 'action', action: { kind: 'cardPlay', effect: 'nullentropyBox' } } };
|
||
const text = truthQuestionText(question, id => id, id => id);
|
||
assert.match(text, /activate Nullentropy Box.*printed role.*pay its 2-spice search cost after this answer this turn/);
|
||
assert.doesNotMatch(text, /Ghola|selected|recover.*Shield/);
|
||
});
|
||
|
||
void test('Box raw question parsing needs no hidden possession and eagerly rejects extra selected-card data in folded clauses', () => {
|
||
const game = fixture();
|
||
assert.ok(!game.players.find(player => player.id === 'e')!.hand.some(card => card.effect === 'nullentropyBox'));
|
||
const action = { kind: 'cardPlay' as const, effect: 'nullentropyBox' as const };
|
||
const question: TruthQuestion = { kind: 'turnActions', target: 'e', turn: 2,
|
||
mixed: { kind: 'or', terms: [{ kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 0 } },
|
||
{ kind: 'action', action }] } };
|
||
assert.doesNotThrow(() => validateTruthQuestionReceipt(game, 'a', question));
|
||
for (const extra of [{ selected: 'Shield' }, { card: 'physical-box' }, { cost: 2 }, { recipient: 'h' }]) {
|
||
const invalid = { ...question, mixed: { kind: 'or', terms: [{ kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 0 } },
|
||
{ kind: 'action', action: { ...action, ...extra } }] } };
|
||
assert.throws(() => validateTruthQuestionReceipt(game, 'a', invalid as TruthQuestion));
|
||
}
|
||
});
|
||
|
||
void test('Distrans and Sapho questions name only actual printed use this turn without transfer or order choices', () => {
|
||
const game = fixture();
|
||
for (const effect of ['distrans', 'juiceOfSapho'] as const) {
|
||
assert.ok(!game.players.find(player => player.id === 'e')!.hand.some(card => card.effect === effect));
|
||
const action = { kind: 'cardPlay' as const, effect };
|
||
const question: TruthQuestion = { kind: 'turnActions', target: 'e', turn: 2,
|
||
mixed: { kind: 'or', terms: [{ kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 0 } },
|
||
{ kind: 'action', action }] } };
|
||
assert.doesNotThrow(() => validateTruthQuestionReceipt(game, 'a', question));
|
||
const text = truthQuestionText(question, id => id, id => id);
|
||
assert.match(text, effect === 'distrans' ? /complete a printed Distrans transfer and discard Distrans after this answer this turn/ :
|
||
/play Juice of Sapho in its printed role after this answer this turn/);
|
||
assert.doesNotMatch(text, /Ghola|first|last|aggressor|private-card|recipient/);
|
||
for (const extra of [{ recipient: 'h' }, { give: 'private-card' }, { scope: 'movement' }, { mode: 'first' }, { outcome: true }]) {
|
||
const invalid = { ...question, mixed: { kind: 'or', terms: [{ kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 0 } },
|
||
{ kind: 'action', action: { ...action, ...extra } }] } } as TruthQuestion;
|
||
assert.throws(() => validateTruthQuestionReceipt(game, 'a', invalid));
|
||
}
|
||
}
|
||
});
|
||
|
||
void test('Semuta future-use questions require completed physical exchange without naming a fresh target or inspection', () => {
|
||
const game = fixture();
|
||
assert.ok(!game.players.find(player => player.id === 'e')!.hand.some(card => card.effect === 'semutaDrug'));
|
||
const action = { kind: 'cardPlay' as const, effect: 'semutaDrug' as const };
|
||
const question: TruthQuestion = { kind: 'turnActions', target: 'e', turn: 2,
|
||
mixed: { kind: 'or', terms: [{ kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 0 } },
|
||
{ kind: 'action', action }] } };
|
||
assert.doesNotThrow(() => validateTruthQuestionReceipt(game, 'a', question));
|
||
const text = truthQuestionText(question, id => id, id => id);
|
||
assert.match(text, /complete a printed Semuta Drug exchange and discard Semuta Drug after this answer this turn/);
|
||
assert.doesNotMatch(text, /inspect|commit|private-fresh-card|Ghola|Sapho/);
|
||
for (const extra of [{ selected: 'private-fresh-card' }, { committed: true }, { stage: 'select' }, { event: 'discard:2:4:1' }]) {
|
||
const invalid = { ...question, mixed: { kind: 'or', terms: [{ kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 0 } },
|
||
{ kind: 'action', action: { ...action, ...extra } }] } } as TruthQuestion;
|
||
assert.throws(() => validateTruthQuestionReceipt(game, 'a', invalid));
|
||
}
|
||
});
|
||
|
||
void test('Ornithopter and Residual Poison questions name actual native play and the proper deadline without chosen details', () => {
|
||
const game = fixture();
|
||
for (const effect of ['ornithopter', 'residualPoison'] as const) {
|
||
const action = { kind: 'cardPlay' as const, effect };
|
||
const question: TruthQuestion = { kind: 'turnActions', target: 'e', turn: 2,
|
||
mixed: { kind: 'or', terms: [{ kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 0 } },
|
||
{ kind: 'action', action }] } };
|
||
assert.doesNotThrow(() => validateTruthQuestionReceipt(game, 'a', question));
|
||
const text = truthQuestionText(question, id => id, id => id);
|
||
assert.match(text, effect === 'ornithopter' ? /play Ornithopter into a native flight after this answer before your Shipment and Movement turn ends/ :
|
||
/play Residual Poison in its printed role after this answer this turn/);
|
||
assert.doesNotMatch(text, /twoGroups|private-leader|killed|Semuta|Ghola/);
|
||
for (const extra of [{ mode: 'twoGroups' }, { group: 2 }, { victim: 'private-leader' }, { outcome: 'killed' }]) {
|
||
const invalid = { ...question, mixed: { kind: 'or', terms: [{ kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 0 } },
|
||
{ kind: 'action', action: { ...action, ...extra } }] } } as TruthQuestion;
|
||
assert.throws(() => validateTruthQuestionReceipt(game, 'a', invalid));
|
||
}
|
||
}
|
||
});
|
||
|
||
function fixture() {
|
||
const g = createGame('TRUTH22', newPlayer('a', 'Atreides', 'atreides'));
|
||
g.players.push(
|
||
newPlayer('e', 'Emperor', 'emperor'),
|
||
newPlayer('h', 'Harkonnen', 'harkonnen'),
|
||
);
|
||
g.status = 'playing';
|
||
g.phase = 4;
|
||
g.turn = 2;
|
||
g.order = ['e', 'h', 'a'];
|
||
g.deck = baseDeck();
|
||
g.players.forEach((p) => {
|
||
p.hand = [];
|
||
p.traitorChoices = [];
|
||
p.traitors = [p.leaders[0].id];
|
||
});
|
||
hold(g, 'a', 'Truthtrance');
|
||
hold(g, 'h', 'Truthtrance');
|
||
hold(g, 'e', 'Shield');
|
||
return g;
|
||
}
|
||
function hold(g: Game, id: string, name: string) {
|
||
const index = g.deck.findIndex((c) => c.name === name);
|
||
assert.ok(index >= 0);
|
||
const card = g.deck.splice(index, 1)[0];
|
||
g.players.find((p) => p.id === id)!.hand.push(card);
|
||
return card.id;
|
||
}
|
||
function declare(g: Game, id = 'a') {
|
||
return applyAction(g, id, {
|
||
type: 'card',
|
||
card: g.players
|
||
.find((p) => p.id === id)!
|
||
.hand.find((c) => c.effect === 'truthtrance')!.id,
|
||
});
|
||
}
|
||
function priority(state: Game) {
|
||
let g = state;
|
||
while (g.truthtrance?.stage === 'priority')
|
||
g = applyAction(
|
||
g,
|
||
g.players.find((p) => !g.truthtrance!.passed.includes(p.id))!.id,
|
||
{ type: 'truthPass' },
|
||
);
|
||
return g;
|
||
}
|
||
const fact: TruthQuestion = {
|
||
kind: 'fact',
|
||
target: 'e',
|
||
fact: { kind: 'hand', name: 'Shield' },
|
||
};
|
||
const ask = (g: Game, question: TruthQuestion = fact, id = 'a') =>
|
||
applyAction(g, id, { type: 'truthAsk', question });
|
||
const answer = (g: Game, value = 'yes', id = 'e') =>
|
||
applyAction(g, id, { type: 'truthAnswer', answer: value });
|
||
const cards = (g: Game) =>
|
||
[...g.deck, ...g.discard, ...g.players.flatMap((p) => p.hand)]
|
||
.map((c) => c.id)
|
||
.sort();
|
||
|
||
void test('simultaneous declarations resolve by storm order, independent of network arrival', () => {
|
||
const initial = fixture();
|
||
let g = declare(initial);
|
||
assert.equal(g.truthtrance!.stage, 'priority');
|
||
g = priority(declare(g, 'h'));
|
||
assert.deepEqual(
|
||
g.truthtrance!.queue.map((q) => q.player),
|
||
['h', 'a'],
|
||
);
|
||
assert.equal(g.discard.length, 0);
|
||
assert.throws(() => ask(g), /holder to ask/);
|
||
g = answer(ask(g, fact, 'h'));
|
||
assert.equal(g.truthtrance!.queue[0].player, 'a');
|
||
assert.equal(g.truthtrance!.stage, 'ask');
|
||
assert.equal(g.discard.length, 1);
|
||
g = answer(ask(g));
|
||
assert.equal(g.truthtrance, null);
|
||
assert.equal(g.discard.length, 2);
|
||
assert.deepEqual(cards(g), cards(initial));
|
||
assert.equal(initial.discard.length, 0);
|
||
assert.equal(initial.truthtrance, undefined);
|
||
});
|
||
void test('private fact answer is visible only to its target until publicly answered', () => {
|
||
const g = ask(priority(declare(fixture())));
|
||
for (const id of ['a', 'h']) {
|
||
const v = viewGame(g, id);
|
||
assert.equal(v.truthAnswer, null);
|
||
assert.equal(v.players.find((p) => p.id === 'e')!.hand, undefined);
|
||
assert.deepEqual(v.truthHistory, []);
|
||
assert.equal(v.truthtrance!.question!.kind, 'fact');
|
||
}
|
||
assert.equal(viewGame(g, 'e').truthAnswer, 'yes');
|
||
assert.throws(() => answer(g, 'no'), /truthfully/);
|
||
assert.throws(() => answer(g, 'unknown'), /truthfully/);
|
||
assert.throws(() => answer(g, 'yes', 'a'), /questioned player/);
|
||
const done = answer(JSON.parse(JSON.stringify(g)));
|
||
for (const p of done.players)
|
||
assert.equal(viewGame(done, p.id).truthHistory[0].answer, 'yes');
|
||
assert.equal(viewGame(done, 'a').players[1].hand, undefined);
|
||
});
|
||
void test('AND/OR answers reveal the combined fact rather than the matching private identity', () => {
|
||
const g = fixture();
|
||
g.players[1].traitors.push(CHEAP_HERO_TRAITOR);
|
||
const yes: TruthFact = { kind: 'traitor', leader: CHEAP_HERO_TRAITOR };
|
||
const no: TruthFact = { kind: 'hand', name: 'Lasgun' };
|
||
assert.equal(
|
||
truthFactAnswer(g.players[1], { kind: 'and', terms: [yes, no] }),
|
||
'no',
|
||
);
|
||
assert.equal(
|
||
truthFactAnswer(g.players[1], { kind: 'or', terms: [yes, no] }),
|
||
'yes',
|
||
);
|
||
const asked = ask(priority(declare(g)), {
|
||
kind: 'fact',
|
||
target: 'e',
|
||
fact: { kind: 'or', terms: [yes, no] },
|
||
});
|
||
const done = answer(asked);
|
||
assert.equal(done.truthHistory![0].answer, 'yes');
|
||
assert.deepEqual(Object.keys(done.truthHistory![0]).sort(), [
|
||
'answer',
|
||
'asker',
|
||
'phase',
|
||
'question',
|
||
'turn',
|
||
]);
|
||
assert.equal(viewGame(done, 'a').players[1].traitors, undefined);
|
||
});
|
||
void test('any-time question overlays and restores pending windows without reapplying effects', () => {
|
||
for (const mode of [
|
||
'opening',
|
||
'response',
|
||
'decision',
|
||
'battle',
|
||
'spice',
|
||
] as const) {
|
||
const initial = fixture();
|
||
if (mode === 'opening')
|
||
initial.phaseOpening = { passed: ['e'], initialize: true };
|
||
if (mode === 'response') {
|
||
hold(initial, 'a', 'Karama');
|
||
initial.response = { kind: 'emperorIncome', owner: 'e', passed: ['h'] };
|
||
initial.auction = {
|
||
cards: initial.deck.splice(0, 2),
|
||
index: 0,
|
||
bid: 3,
|
||
bidder: 'a',
|
||
active: 'h',
|
||
passed: [],
|
||
opener: 0,
|
||
};
|
||
}
|
||
if (mode === 'decision') {
|
||
initial.advanced = true;
|
||
initial.phase = 3;
|
||
initial.players.find(p => p.id === 'h')!.specialKaramaUsed = true;
|
||
hold(initial, 'h', 'Shield'); // Preserve a real return choice during the overlay.
|
||
initial.decision = {
|
||
kind: 'handExchange',
|
||
player: 'h',
|
||
target: 'a',
|
||
count: 1,
|
||
};
|
||
initial.pendingExchange = {
|
||
response: { kind: 'harkonnenBonus', owner: 'h', passed: [] },
|
||
decision: null,
|
||
};
|
||
}
|
||
if (mode === 'battle') {
|
||
initial.phase = 6;
|
||
initial.battle = {
|
||
territory: 'arrakeen',
|
||
attacker: 'a',
|
||
defender: 'e',
|
||
prepared: true,
|
||
plans: {
|
||
e: {
|
||
dial: 1,
|
||
leader: initial.players[1].leaders[0].id,
|
||
weapon: null,
|
||
defense: initial.players[1].hand[0].id,
|
||
support: 0,
|
||
},
|
||
},
|
||
revealed: false,
|
||
traitorCalls: {},
|
||
preparation: { kind: 'prescience', owner: 'a', beneficiary: 'a' },
|
||
voice: { target: 'e', kind: 'poison', must: false },
|
||
};
|
||
}
|
||
if (mode === 'spice') {
|
||
initial.phase = 1;
|
||
initial.spiceWindow = {
|
||
territory: 'red_chasm',
|
||
sector: 7,
|
||
amount: 8,
|
||
harvested: false,
|
||
};
|
||
initial.ready = ['e'];
|
||
}
|
||
const before = structuredClone(initial);
|
||
let g = ask(priority(declare(initial, 'a')));
|
||
for (const action of [
|
||
{ type: 'ready' },
|
||
{ type: 'passResponse' },
|
||
{ type: 'decision' },
|
||
{ type: 'battlePlan', dial: 1 },
|
||
{ type: 'card', card: initial.players[2].hand[0].id },
|
||
{ type: 'card', mode: 'special', card: initial.players[2].hand[0].id },
|
||
])
|
||
assert.throws(() => applyAction(g, 'h', action), RuleError);
|
||
g = answer(JSON.parse(JSON.stringify(g)));
|
||
for (const key of [
|
||
'phaseOpening',
|
||
'response',
|
||
'decision',
|
||
'pendingExchange',
|
||
'auction',
|
||
'battle',
|
||
'spiceWindow',
|
||
'ready',
|
||
'phase',
|
||
'turn',
|
||
'active',
|
||
'spice',
|
||
] as const)
|
||
assert.deepEqual(g[key], before[key], `${mode}: ${key}`);
|
||
assert.equal(g.players[1].spice, before.players[1].spice);
|
||
assert.deepEqual(initial, before);
|
||
}
|
||
});
|
||
void test('unknown answers permit a different question or save, without discarding the card', () => {
|
||
const q: TruthQuestion = {
|
||
kind: 'freeform',
|
||
target: 'e',
|
||
text: 'Will you win two battles this turn?',
|
||
scope: 'fact',
|
||
};
|
||
let g = ask(priority(declare(fixture())), q);
|
||
g = answer(g, 'unknown');
|
||
assert.equal(g.truthtrance!.stage, 'unknown');
|
||
assert.equal(g.discard.length, 0);
|
||
assert.throws(
|
||
() => applyAction(g, 'e', { type: 'truthSave' }),
|
||
/can be saved/,
|
||
);
|
||
const saved = applyAction(JSON.parse(JSON.stringify(g)), 'a', {
|
||
type: 'truthSave',
|
||
});
|
||
assert.equal(saved.truthtrance, null);
|
||
assert.ok(saved.players[0].hand.some((c) => c.effect === 'truthtrance'));
|
||
const retried = answer(ask(g));
|
||
assert.equal(retried.truthHistory!.length, 2);
|
||
assert.equal(retried.discard.length, 1);
|
||
assert.throws(
|
||
() =>
|
||
applyAction(ask(priority(declare(fixture()))), 'a', {
|
||
type: 'truthSave',
|
||
}),
|
||
/can be saved/,
|
||
);
|
||
});
|
||
void test('freeform current-turn promises are public records with explicit turn scope', () => {
|
||
const question: TruthQuestion = {
|
||
kind: 'freeform',
|
||
scope: 'currentTurn',
|
||
target: 'e',
|
||
text: 'Will you ship six or more forces to Carthag this turn?',
|
||
};
|
||
const g = answer(ask(priority(declare(fixture())), question), 'no');
|
||
assert.equal(g.truthHistory![0].turn, 2);
|
||
assert.deepEqual(g.truthHistory![0].question, question);
|
||
for (const p of g.players)
|
||
assert.deepEqual(viewGame(g, p.id).truthHistory, g.truthHistory);
|
||
});
|
||
void test('malformed questions, targets and forged answers cannot mutate authoritative state', () => {
|
||
const g = priority(declare(fixture()));
|
||
const before = JSON.stringify(g);
|
||
const invalid: unknown[] = [
|
||
null,
|
||
{},
|
||
{ ...fact, target: 'a' },
|
||
{ ...fact, target: 'intruder' },
|
||
{ ...fact, fact: { kind: 'hand', name: '__proto__' } },
|
||
{ ...fact, fact: { kind: 'traitor', leader: 'missing' } },
|
||
{ ...fact, fact: { kind: 'and', terms: [] } },
|
||
{ ...fact, fact: { kind: 'or', terms: Array(9).fill(fact.fact) } },
|
||
{ kind: 'freeform', target: 'e', text: ' ', scope: 'fact' },
|
||
{ kind: 'freeform', target: 'e', text: 'x'.repeat(501), scope: 'fact' },
|
||
{ kind: 'freeform', target: 'e', text: 'Future?', scope: 'nextTurn' },
|
||
];
|
||
let nested = fact.fact;
|
||
for (let i = 0; i < 6; i++)
|
||
nested = { kind: 'and', terms: [nested, fact.fact] };
|
||
invalid.push({ ...fact, fact: nested });
|
||
for (const question of invalid)
|
||
assert.throws(
|
||
() => applyAction(g, 'a', { type: 'truthAsk', question }),
|
||
RuleError,
|
||
);
|
||
assert.equal(JSON.stringify(g), before);
|
||
assert.throws(
|
||
() => applyAction(ask(g), 'e', { type: 'truthAnswer', answer: true }),
|
||
/Answer Yes/,
|
||
);
|
||
assert.throws(
|
||
() => applyAction(fixture(), 'a', { type: 'truthAnswer', answer: 'yes' }),
|
||
/no pending/,
|
||
);
|
||
});
|
||
void test('unselected setup traitors are unknown and a Truthtrance does not finish setup prematurely', () => {
|
||
const g = fixture();
|
||
g.status = 'setup';
|
||
g.players[1].traitors = [];
|
||
g.players[1].traitorChoices = [g.players[1].leaders[1].id];
|
||
const q: TruthQuestion = {
|
||
kind: 'fact',
|
||
target: 'e',
|
||
fact: { kind: 'traitor', leader: g.players[1].leaders[0].id },
|
||
};
|
||
const pending = ask(priority(declare(g)), q);
|
||
assert.equal(pending.status, 'setup');
|
||
assert.equal(viewGame(pending, 'e').truthAnswer, 'unknown');
|
||
const unknown = answer(pending, 'unknown');
|
||
assert.equal(unknown.status, 'setup');
|
||
const saved = applyAction(unknown, 'a', { type: 'truthSave' });
|
||
assert.equal(saved.status, 'setup');
|
||
assert.deepEqual(
|
||
saved.players[1].traitorChoices,
|
||
g.players[1].traitorChoices,
|
||
);
|
||
});
|
||
void test('all AI levels pass priority and publish verified answers from their own private view', () => {
|
||
for (const level of DIFFICULTIES) {
|
||
const initial = fixture();
|
||
initial.players[1].bot = level;
|
||
initial.players[2].bot = level;
|
||
let g = runBots(declare(initial));
|
||
assert.equal(g.truthtrance!.stage, 'ask');
|
||
g = ask(g);
|
||
assert.deepEqual(botActions(viewGame(g, 'h')), []);
|
||
assert.deepEqual(botActions(viewGame(g, 'e')), [
|
||
{ type: 'truthAnswer', answer: 'yes' },
|
||
]);
|
||
const done = runBots(g, 1);
|
||
assert.equal(done.truthtrance, null);
|
||
assert.equal(done.truthHistory![0].answer, 'yes');
|
||
}
|
||
});
|
||
void test('AI handles unparseable freeform questions honestly and can complete a declared question', () => {
|
||
for (const level of DIFFICULTIES) {
|
||
const initial = fixture();
|
||
initial.players[1].bot = level;
|
||
const q: TruthQuestion = {
|
||
kind: 'freeform',
|
||
target: 'e',
|
||
scope: 'fact',
|
||
text: 'Will you win two battles?',
|
||
};
|
||
const pending = ask(priority(declare(initial)), q);
|
||
assert.throws(() => answer(pending, 'yes'), /cannot yet interpret/);
|
||
const unknown = runBots(pending);
|
||
assert.equal(unknown.truthtrance!.stage, 'unknown');
|
||
assert.equal(unknown.discard.length, 0);
|
||
const bot = fixture();
|
||
bot.players[0].bot = level;
|
||
let g = priority(declare(bot));
|
||
const actions: Action[] = botActions(viewGame(g, 'a'));
|
||
assert.equal(actions.length, 1);
|
||
assert.equal(actions[0].type, 'truthAsk');
|
||
g = applyAction(g, 'a', actions[0]);
|
||
const target = g.truthtrance!.question!.target;
|
||
const actual = viewGame(g, target).truthAnswer!;
|
||
g = answer(g, actual, target);
|
||
assert.equal(g.truthtrance, null);
|
||
}
|
||
});
|
||
void test('truth windows do not bypass lobby or finished-game boundaries and cannot be redeclared after passing', () => {
|
||
for (const status of ['lobby', 'finished'] as const) {
|
||
const g = fixture();
|
||
g.status = status;
|
||
assert.throws(() => declare(g), RuleError);
|
||
}
|
||
let g = declare(fixture());
|
||
assert.throws(() => declare(g), /already declared/);
|
||
g = applyAction(g, 'h', { type: 'truthPass' });
|
||
assert.throws(() => declare(g, 'h'), /already declared/);
|
||
assert.throws(
|
||
() => applyAction(g, 'h', { type: 'truthPass' }),
|
||
/priority window/,
|
||
);
|
||
});
|
||
void test('a holder can declare both physical Truthtrances with separate answers and disposal', () => {
|
||
const initial = fixture();
|
||
initial.players[0].hand.push(initial.players[2].hand.pop()!);
|
||
const ids = initial.players[0].hand.map((c) => c.id);
|
||
for (const extra of [
|
||
[ids[0]],
|
||
[initial.players[1].hand[0].id],
|
||
['forged'],
|
||
'not-an-array',
|
||
])
|
||
assert.throws(
|
||
() =>
|
||
applyAction(initial, 'a', { type: 'card', card: ids[0], cards: extra }),
|
||
RuleError,
|
||
);
|
||
let g = priority(
|
||
applyAction(initial, 'a', { type: 'card', card: ids[0], cards: [ids[1]] }),
|
||
);
|
||
assert.equal(g.truthtrance!.queue.length, 2);
|
||
g = answer(ask(g));
|
||
assert.equal(g.discard.length, 1);
|
||
assert.equal(g.truthtrance!.queue[0].card, ids[1]);
|
||
g = answer(
|
||
ask(g, {
|
||
kind: 'freeform',
|
||
target: 'e',
|
||
text: 'Will you win two battles?',
|
||
scope: 'fact',
|
||
}),
|
||
'unknown',
|
||
);
|
||
g = applyAction(g, 'a', { type: 'truthSave' });
|
||
assert.equal(g.truthtrance, null);
|
||
assert.deepEqual(
|
||
g.players[0].hand.map((c) => c.id),
|
||
[ids[1]],
|
||
);
|
||
assert.deepEqual(cards(g), cards(initial));
|
||
});
|