376 lines
12 KiB
TypeScript
376 lines
12 KiB
TypeScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { baseDeck } from '../game/cards';
|
|
import {
|
|
applyAction,
|
|
createGame,
|
|
newPlayer,
|
|
viewGame,
|
|
type Game,
|
|
} from '../game/engine';
|
|
import { botActions } from '../game/bots';
|
|
import { DIFFICULTIES } from '../game/bot-profiles';
|
|
import { type TruthFact } from '../game/truthtrance';
|
|
import {
|
|
parseCardCountFact,
|
|
cardCountFactMatches,
|
|
cardCountFactText,
|
|
type CardCountFact,
|
|
} from '../game/truthtrance-card-count';
|
|
|
|
const names = [...new Set(baseDeck().map((card) => card.name))];
|
|
|
|
void test('named-card counts distinguish multiple physical copies and compare zero through large thresholds', () => {
|
|
const shields = baseDeck().filter((card) => card.name === 'Shield');
|
|
assert.equal(shields.length, 4);
|
|
assert.equal(new Set(shields.map((card) => card.id)).size, 4);
|
|
for (let held = 0; held <= shields.length; held++) {
|
|
const hand = shields.slice(0, held);
|
|
for (const value of [0, 1, 2, 3, 4, 5, 41, Number.MAX_SAFE_INTEGER])
|
|
for (const compare of ['eq', 'gte', 'lte'] as const) {
|
|
const fact = parseCardCountFact(
|
|
{ kind: 'handCount', name: 'Shield', compare, value },
|
|
names,
|
|
);
|
|
assert.equal(
|
|
cardCountFactMatches(hand, fact),
|
|
compare === 'eq'
|
|
? held === value
|
|
: compare === 'gte'
|
|
? held >= value
|
|
: held <= value,
|
|
);
|
|
}
|
|
}
|
|
});
|
|
|
|
void test('exact named custody excludes similarly named defenses and remains a current fact after a legal custody change', () => {
|
|
const hand = [
|
|
{ id: 's1', name: 'Shield' },
|
|
{ id: 's2', name: 'Shield' },
|
|
{ id: 'ss', name: 'Shield Snooper' },
|
|
{ id: 'p', name: 'Portable Snooper' },
|
|
];
|
|
const before = structuredClone(hand);
|
|
const fact = parseCardCountFact(
|
|
{ kind: 'handCount', name: 'Shield', compare: 'gte', value: 2 },
|
|
names,
|
|
);
|
|
assert.equal(cardCountFactMatches(hand, fact), true);
|
|
assert.deepEqual(hand, before);
|
|
assert.equal(cardCountFactMatches(hand.slice(1), fact), false);
|
|
assert.equal(
|
|
cardCountFactMatches([...hand, { id: 'unknown', name: 'shield' }], {
|
|
...fact,
|
|
compare: 'eq',
|
|
}),
|
|
true,
|
|
);
|
|
assert.deepEqual(fact, {
|
|
kind: 'handCount',
|
|
name: 'Shield',
|
|
compare: 'gte',
|
|
value: 2,
|
|
});
|
|
});
|
|
|
|
void test('parser normalizes facts and rejects malformed names, comparisons and nonintegral counts without mutation', () => {
|
|
const valid = {
|
|
kind: 'handCount',
|
|
name: 'Shield',
|
|
compare: 'eq',
|
|
value: 2,
|
|
secret: 'ignored',
|
|
};
|
|
const before = structuredClone(valid);
|
|
assert.deepEqual(parseCardCountFact(valid, names), {
|
|
kind: 'handCount',
|
|
name: 'Shield',
|
|
compare: 'eq',
|
|
value: 2,
|
|
});
|
|
assert.deepEqual(valid, before);
|
|
for (const value of [
|
|
-1,
|
|
0.5,
|
|
NaN,
|
|
Infinity,
|
|
Number.MAX_SAFE_INTEGER + 1,
|
|
'2',
|
|
null,
|
|
undefined,
|
|
])
|
|
assert.throws(
|
|
() => parseCardCountFact({ ...valid, value }, names),
|
|
/whole card count/,
|
|
);
|
|
for (const compare of ['gt', 'lt', '=', 1, null, undefined])
|
|
assert.throws(
|
|
() => parseCardCountFact({ ...valid, compare }, names),
|
|
/Compare held cards/,
|
|
);
|
|
for (const name of ['shield', 'Not a card', '', 1, null, undefined])
|
|
assert.throws(
|
|
() => parseCardCountFact({ ...valid, name }, names),
|
|
/known treachery/,
|
|
);
|
|
assert.throws(
|
|
() => parseCardCountFact({ ...valid, kind: 'hand' }, names),
|
|
/known treachery/,
|
|
);
|
|
});
|
|
|
|
void test('question text states the selected current comparison and never adds hidden inventory', () => {
|
|
assert.equal(
|
|
cardCountFactText({
|
|
kind: 'handCount',
|
|
name: 'Shield',
|
|
compare: 'gte',
|
|
value: 2,
|
|
}),
|
|
'you currently hold at least 2 cards named Shield',
|
|
);
|
|
assert.equal(
|
|
cardCountFactText({
|
|
kind: 'handCount',
|
|
name: 'Shield',
|
|
compare: 'eq',
|
|
value: 1,
|
|
}),
|
|
'you currently hold exactly 1 card named Shield',
|
|
);
|
|
assert.equal(
|
|
cardCountFactText({
|
|
kind: 'handCount',
|
|
name: 'Shield',
|
|
compare: 'lte',
|
|
value: 0,
|
|
}),
|
|
'you currently hold at most 0 cards named Shield',
|
|
);
|
|
});
|
|
|
|
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 fixture(shields = 2) {
|
|
const g = createGame('COUNTTRUTH', newPlayer('a', 'Asker', 'atreides'));
|
|
g.players.push(
|
|
newPlayer('e', 'Target', 'emperor'),
|
|
newPlayer('h', 'Observer', 'harkonnen'),
|
|
);
|
|
Object.assign(g, {
|
|
status: 'playing',
|
|
turn: 2,
|
|
phase: 4,
|
|
order: ['h', 'e', 'a'],
|
|
deck: baseDeck(),
|
|
});
|
|
for (const p of g.players) {
|
|
p.spice = 20;
|
|
p.traitors = [p.leaders[0].id];
|
|
}
|
|
const selected = new Set(g.players.flatMap((p) => p.traitors));
|
|
g.traitorReserve = g.players
|
|
.flatMap((p) => p.leaders.map((l) => l.id))
|
|
.filter((id) => !selected.has(id));
|
|
hold(g, 'a', 'Truthtrance');
|
|
hold(g, 'h', 'Truthtrance');
|
|
hold(g, 'h', 'Snooper');
|
|
for (let i = 0; i < shields; i++) hold(g, 'e', 'Shield');
|
|
return g;
|
|
}
|
|
function priority(g: Game) {
|
|
g = applyAction(g, 'a', { type: 'card', card: g.players[0].hand[0].id });
|
|
for (let n = 0; n < 10 && g.truthtrance?.stage === 'priority'; n++)
|
|
g = applyAction(
|
|
g,
|
|
g.players.find((p) => !g.truthtrance!.passed.includes(p.id))!.id,
|
|
{ type: 'truthPass' },
|
|
);
|
|
assert.equal(g.truthtrance?.stage, 'ask');
|
|
return g;
|
|
}
|
|
function ask(g: Game, fact: TruthFact) {
|
|
return applyAction(g, 'a', {
|
|
type: 'truthAsk',
|
|
question: { kind: 'fact', target: 'e', fact },
|
|
});
|
|
}
|
|
const countFact = (
|
|
compare: CardCountFact['compare'],
|
|
value: number,
|
|
): CardCountFact => ({ kind: 'handCount', name: 'Shield', compare, value });
|
|
const cardIds = (g: Game) =>
|
|
[...g.deck, ...g.discard, ...g.players.flatMap((p) => p.hand)]
|
|
.map((c) => c.id)
|
|
.sort();
|
|
|
|
void test('real Truthtrance count questions enforce truthful answers and discard exactly once across comparator boundaries', () => {
|
|
for (let held = 0; held <= 4; held++)
|
|
for (const value of [0, 1, 2, 4, 41])
|
|
for (const compare of ['eq', 'gte', 'lte'] as const) {
|
|
const initial = fixture(held);
|
|
const originalCards = cardIds(initial);
|
|
const fact = countFact(compare, value);
|
|
const expected = cardCountFactMatches(initial.players[1].hand, fact)
|
|
? 'yes'
|
|
: 'no';
|
|
const g = ask(priority(initial), fact);
|
|
assert.equal(viewGame(g, 'e').truthAnswer, expected);
|
|
assert.equal(viewGame(g, 'a').truthAnswer, null);
|
|
assert.equal(viewGame(g, 'h').truthAnswer, null);
|
|
const before = structuredClone(g);
|
|
for (const answer of [expected === 'yes' ? 'no' : 'yes', 'unknown'])
|
|
assert.throws(() =>
|
|
applyAction(g, 'e', { type: 'truthAnswer', answer }),
|
|
);
|
|
assert.throws(() =>
|
|
applyAction(g, 'h', { type: 'truthAnswer', answer: expected }),
|
|
);
|
|
assert.deepEqual(g, before);
|
|
const done = applyAction(JSON.parse(JSON.stringify(g)), 'e', {
|
|
type: 'truthAnswer',
|
|
answer: expected,
|
|
});
|
|
assert.equal(done.truthtrance, null);
|
|
assert.equal(done.truthHistory!.at(-1)!.answer, expected);
|
|
assert.deepEqual(done.truthHistory!.at(-1)!.question, {
|
|
kind: 'fact',
|
|
target: 'e',
|
|
fact,
|
|
});
|
|
assert.deepEqual(cardIds(done), originalCards);
|
|
assert.deepEqual(done.players[1].hand, initial.players[1].hand);
|
|
assert.equal(
|
|
done.discard.filter((c) => c.id === initial.players[0].hand[0].id)
|
|
.length,
|
|
1,
|
|
);
|
|
assert.throws(() =>
|
|
applyAction(done, 'e', { type: 'truthAnswer', answer: expected }),
|
|
);
|
|
}
|
|
});
|
|
|
|
void test('engine rejects malformed count clauses atomically even when another OR clause already determines the answer', () => {
|
|
const g = priority(fixture());
|
|
const invalid = [
|
|
{ ...countFact('gte', 2), value: -1 },
|
|
{ ...countFact('gte', 2), value: 1.5 },
|
|
{ ...countFact('gte', 2), value: '2' },
|
|
{ ...countFact('gte', 2), compare: 'gt' },
|
|
{ ...countFact('gte', 2), name: 'not a card' },
|
|
];
|
|
for (const leaf of invalid) {
|
|
const before = structuredClone(g);
|
|
assert.throws(() =>
|
|
applyAction(g, 'a', {
|
|
type: 'truthAsk',
|
|
question: {
|
|
kind: 'fact',
|
|
target: 'e',
|
|
fact: { kind: 'or', terms: [{ kind: 'hand', name: 'Shield' }, leaf] },
|
|
},
|
|
}),
|
|
);
|
|
assert.deepEqual(g, before);
|
|
}
|
|
});
|
|
|
|
void test('composed current counts disclose only the aggregate answer and preserve unknown traitor semantics', () => {
|
|
const initial = fixture();
|
|
initial.players[1].traitorChoices = ['atreides-1'];
|
|
initial.traitorReserve = initial.traitorReserve!.filter(
|
|
(id) => id !== 'atreides-1',
|
|
);
|
|
const scenarios: [TruthFact, 'yes' | 'no' | 'unknown'][] = [
|
|
[
|
|
{
|
|
kind: 'and',
|
|
terms: [
|
|
countFact('gte', 2),
|
|
{ kind: 'spice', compare: 'eq', value: 20 },
|
|
],
|
|
},
|
|
'yes',
|
|
],
|
|
[
|
|
{
|
|
kind: 'and',
|
|
terms: [countFact('gte', 3), { kind: 'traitor', leader: 'atreides-1' }],
|
|
},
|
|
'no',
|
|
],
|
|
[
|
|
{
|
|
kind: 'and',
|
|
terms: [countFact('eq', 2), { kind: 'traitor', leader: 'atreides-1' }],
|
|
},
|
|
'unknown',
|
|
],
|
|
[
|
|
{
|
|
kind: 'or',
|
|
terms: [countFact('eq', 2), { kind: 'traitor', leader: 'atreides-1' }],
|
|
},
|
|
'yes',
|
|
],
|
|
];
|
|
for (const [fact, expected] of scenarios) {
|
|
const g = ask(priority(initial), fact);
|
|
assert.equal(viewGame(g, 'e').truthAnswer, expected);
|
|
for (const id of ['a', 'h']) {
|
|
const view = viewGame(g, id);
|
|
assert.equal(view.truthAnswer, null);
|
|
assert.equal(view.players.find((p) => p.id === 'e')!.hand, undefined);
|
|
assert.equal(
|
|
view.players.find((p) => p.id === 'e')!.traitorChoices,
|
|
undefined,
|
|
);
|
|
}
|
|
const done = applyAction(g, 'e', { type: 'truthAnswer', answer: expected });
|
|
assert.equal(done.truthHistory!.at(-1)!.answer, expected);
|
|
}
|
|
});
|
|
|
|
void test('all four AI profiles answer current card counts from target-only projections with foreign-hand noninterference', () => {
|
|
for (const difficulty of DIFFICULTIES)
|
|
for (const fact of [
|
|
countFact('eq', 2),
|
|
countFact('gte', 3),
|
|
countFact('lte', 0),
|
|
countFact('gte', 0),
|
|
]) {
|
|
const initial = fixture();
|
|
initial.players[1].bot = difficulty;
|
|
const g = ask(priority(initial), fact);
|
|
const view = viewGame(g, 'e');
|
|
const snapshot = structuredClone(view);
|
|
const expected = cardCountFactMatches(g.players[1].hand, fact)
|
|
? 'yes'
|
|
: 'no';
|
|
const actions = botActions(view);
|
|
assert.deepEqual(view, snapshot);
|
|
assert.deepEqual(actions, [{ type: 'truthAnswer', answer: expected }]);
|
|
assert.deepEqual(botActions(viewGame(g, 'h')), []);
|
|
const altered = structuredClone(g);
|
|
const observer = altered.players[2];
|
|
const snooperIndex = observer.hand.findIndex((c) => c.name === 'Snooper');
|
|
altered.deck.push(observer.hand.splice(snooperIndex, 1)[0]);
|
|
hold(altered, 'h', 'Gom Jabbar');
|
|
altered.players[0].spice = 999;
|
|
assert.deepEqual(viewGame(altered, 'e'), view);
|
|
assert.deepEqual(botActions(viewGame(altered, 'e')), actions);
|
|
for (const input of [g, altered]) {
|
|
const done = applyAction(input, 'e', actions[0]);
|
|
assert.equal(done.truthHistory!.at(-1)!.answer, expected);
|
|
assert.equal(done.truthtrance, null);
|
|
}
|
|
}
|
|
});
|