Add current concealed No-Field Truthtrance facts
This commit is contained in:
1 parent
24c38ebccd
commit
5509abf1e5
13 files changed
+797
-12
No files matched your search
@@ -0,0 +1,175 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import { applyAction, viewGame, type Action, type Game } from '../game/engine';
|
||||
import type { Card } from '../game/cards';
|
||||
import type { NoFieldValue } from '../game/richese-no-field';
|
||||
import type { TruthFact } from '../game/truthtrance';
|
||||
import {
|
||||
createHarassNoFieldFixture, type HarassNoFieldFixture,
|
||||
} from './fixture-harass-no-field';
|
||||
import {
|
||||
createNoFieldFullPlanFixture, type NoFieldFullPlanFixture,
|
||||
} from './fixture-no-field-full-plan';
|
||||
|
||||
export type TruthtranceNoFieldOptions = {
|
||||
advanced?: boolean;
|
||||
marker?: NoFieldValue;
|
||||
reserves?: number;
|
||||
boundary?: 'beforeShipment' | 'afterShipment' | 'battle' | 'fullPlanOffer';
|
||||
};
|
||||
export type TruthtranceNoFieldFixture = {
|
||||
game: Game;
|
||||
owner: string;
|
||||
asker: string;
|
||||
opponent: string;
|
||||
observer: string;
|
||||
token: { id: string; value: NoFieldValue };
|
||||
truthCard: Card;
|
||||
staging: string[];
|
||||
harass: HarassNoFieldFixture | null;
|
||||
fullPlan: NoFieldFullPlanFixture | null;
|
||||
};
|
||||
export function truthtranceNoFieldPlayer(game: Game, actor: string) {
|
||||
const player = game.players.find(candidate => candidate.id === actor);
|
||||
assert.ok(player, `Missing original No-Field seat ${actor}`);
|
||||
return player;
|
||||
}
|
||||
|
||||
/** Physical inventory at these settled native boundaries; no catalog is redealt. */
|
||||
export function truthtranceNoFieldCards(game: Game) {
|
||||
return [
|
||||
...game.deck, ...game.discard, ...(game.richeseCache ?? []), ...(game.richeseRemoved ?? []),
|
||||
...game.players.flatMap(player => player.hand),
|
||||
].map(card => card.id).sort();
|
||||
}
|
||||
|
||||
/** Conserved hand staging after genuine setup, never a replacement or invented card. */
|
||||
export function stageNoFieldTruthtrance(game: Game, actor: string, staging: string[]): Card {
|
||||
const inventory = truthtranceNoFieldCards(game);
|
||||
const player = truthtranceNoFieldPlayer(game, actor);
|
||||
const held = player.hand.find(card => card.effect === 'truthtrance');
|
||||
if (held) return structuredClone(held);
|
||||
const source = [game.deck, ...game.players.filter(candidate => candidate.id !== actor).map(candidate => candidate.hand)]
|
||||
.find(cards => cards.some(card => card.effect === 'truthtrance'));
|
||||
assert.ok(source, 'Relocate an originally selected, unused physical Truthtrance');
|
||||
if (player.hand.length === 4) {
|
||||
const returned = player.hand.pop()!;
|
||||
game.deck.push(returned);
|
||||
staging.push(`After genuine setup: conserve ${returned.id} by returning it from ${actor}'s full hand to the original deck.`);
|
||||
}
|
||||
assert.ok(player.hand.length < 4);
|
||||
const card = source.splice(source.findIndex(candidate => candidate.effect === 'truthtrance'), 1)[0];
|
||||
player.hand.push(card);
|
||||
staging.push(`After genuine setup: conserve original physical Truthtrance ${card.id} by relocating it into ${actor}'s hand; no hand exceeds four.`);
|
||||
assert.deepEqual(truthtranceNoFieldCards(game), inventory);
|
||||
return structuredClone(card);
|
||||
}
|
||||
|
||||
/** All windows and marker custody come from the original setup/shipment/battle actions. */
|
||||
export function createTruthtranceNoFieldFixture(options: TruthtranceNoFieldOptions = {}): TruthtranceNoFieldFixture {
|
||||
const boundary = options.boundary ?? 'afterShipment';
|
||||
const harass = boundary === 'fullPlanOffer' ? null : createHarassNoFieldFixture({
|
||||
advanced: options.advanced ?? false, marker: options.marker, reserves: options.reserves,
|
||||
});
|
||||
if (boundary === 'fullPlanOffer') assert.notEqual(options.advanced, false, 'The native full-plan offer is Advanced');
|
||||
const fullPlan = boundary === 'fullPlanOffer' ? createNoFieldFullPlanFixture({
|
||||
marker: options.marker, reserves: options.reserves,
|
||||
}) : null;
|
||||
const native = harass ?? fullPlan!;
|
||||
const source = boundary === 'beforeShipment' ? native.beforeShipment
|
||||
: boundary === 'afterShipment' ? native.afterShipment : native.game;
|
||||
const game = structuredClone(source);
|
||||
const asker = fullPlan ? fullPlan.atreides : harass!.observer;
|
||||
const staging = [...native.staging];
|
||||
const truthCard = stageNoFieldTruthtrance(game, asker, staging);
|
||||
const inventory = truthtranceNoFieldCards(game);
|
||||
assert.equal(new Set(inventory).size, inventory.length);
|
||||
assert.deepEqual(inventory, truthtranceNoFieldCards(native.afterSetup));
|
||||
for (const player of game.players) {
|
||||
assert.ok(player.hand.length <= 4);
|
||||
assert.equal(player.reserves + player.tanks + Object.values(player.forces).reduce((sum, count) => sum + count, 0), 20);
|
||||
}
|
||||
return {
|
||||
game, owner: native.owner, asker, opponent: native.opponent, observer: native.observer,
|
||||
token: structuredClone(native.token), truthCard, staging, harass, fullPlan,
|
||||
};
|
||||
}
|
||||
|
||||
export function noFieldTruthFact(value: NoFieldValue): TruthFact {
|
||||
return { kind: 'noFieldValue', value };
|
||||
}
|
||||
export function declareNoFieldTruthtrance(game: Game, asker: string): Game {
|
||||
const card = truthtranceNoFieldPlayer(game, asker).hand.find(candidate => candidate.effect === 'truthtrance');
|
||||
assert.ok(card);
|
||||
return applyAction(game, asker, { type: 'card', card: card.id });
|
||||
}
|
||||
export function passNoFieldTruthPriority(game: Game): Game {
|
||||
for (let count = 0; game.truthtrance?.stage === 'priority' && count < game.players.length; count++) {
|
||||
const actor = game.players.find(player => !game.truthtrance!.passed.includes(player.id));
|
||||
assert.ok(actor);
|
||||
game = applyAction(game, actor.id, { type: 'truthPass' });
|
||||
}
|
||||
assert.equal(game.truthtrance?.stage, 'ask');
|
||||
return game;
|
||||
}
|
||||
export function askNoFieldTruth(game: Game, asker: string, target: string, fact: TruthFact): Game {
|
||||
if (!game.truthtrance) game = passNoFieldTruthPriority(declareNoFieldTruthtrance(game, asker));
|
||||
assert.equal(game.truthtrance?.stage, 'ask');
|
||||
return applyAction(game, asker, { type: 'truthAsk', question: { kind: 'fact', target, fact } });
|
||||
}
|
||||
export function answerNoFieldTruth(game: Game, expected: 'yes' | 'no'): Game {
|
||||
const question = game.truthtrance?.question;
|
||||
assert.equal(game.truthtrance?.stage, 'answer');
|
||||
assert.ok(question?.kind === 'fact');
|
||||
assert.equal(viewGame(game, question.target).truthAnswer, expected);
|
||||
return applyAction(game, question.target, { type: 'truthAnswer', answer: expected });
|
||||
}
|
||||
export function rejectNoFieldTruthAction(game: Game, actor: string, action: Action): void {
|
||||
const before = structuredClone(game);
|
||||
assert.throws(() => applyAction(game, actor, action));
|
||||
assert.deepEqual(game, before);
|
||||
}
|
||||
|
||||
/** Everything observed must stay put, including live opportunities and prior shipment history. */
|
||||
export function noFieldTruthObservation(game: Game) {
|
||||
return structuredClone({
|
||||
turn: game.turn, phase: game.phase, active: game.active, ready: game.ready,
|
||||
movementRemaining: game.movementRemaining, response: game.response, decision: game.decision,
|
||||
phaseOpening: game.phaseOpening, pendingShipment: game.pendingShipment, battle: game.battle,
|
||||
shipmentPromises: game.shipmentPromises, richeseAllyOpportunity: game.richeseAllyOpportunity,
|
||||
richeseAllyOffer: game.richeseAllyOffer,
|
||||
players: game.players.map(player => ({
|
||||
id: player.id, noField: player.noField, noFieldEvent: player.noFieldEvent,
|
||||
reserves: player.reserves, tanks: player.tanks, forces: player.forces, elites: player.elites,
|
||||
spice: player.spice, shipped: player.shipped, moved: player.moved, revived: player.revived,
|
||||
})),
|
||||
});
|
||||
}
|
||||
|
||||
/** Finish the real public answer and its original physical discard, without driving the parent. */
|
||||
export function finishNoFieldTruth(game: Game, expected: 'yes' | 'no'): Game {
|
||||
const before = structuredClone(game);
|
||||
const window = before.truthtrance!;
|
||||
assert.equal(window.queue.length, 1);
|
||||
assert.ok(window.question?.kind === 'fact');
|
||||
const consumed = window.queue[0];
|
||||
const card = truthtranceNoFieldPlayer(before, consumed.player).hand.find(candidate => candidate.id === consumed.card);
|
||||
assert.ok(card?.effect === 'truthtrance');
|
||||
const done = answerNoFieldTruth(game, expected);
|
||||
assert.equal(done.truthtrance, null);
|
||||
assert.ok(!done.pendingTreacheryDiscard);
|
||||
assert.deepEqual(noFieldTruthObservation(done), noFieldTruthObservation(before));
|
||||
assert.deepEqual(done.truthHistory, [...(before.truthHistory ?? []), {
|
||||
turn: before.turn, phase: before.phase, asker: consumed.player,
|
||||
question: window.question, answer: expected,
|
||||
}]);
|
||||
assert.deepEqual(done.deck, before.deck);
|
||||
assert.deepEqual(done.richeseCache, before.richeseCache);
|
||||
assert.deepEqual(done.richeseRemoved, before.richeseRemoved);
|
||||
assert.deepEqual(done.discard, [...before.discard, card]);
|
||||
for (const player of done.players) {
|
||||
const original = truthtranceNoFieldPlayer(before, player.id);
|
||||
assert.deepEqual(player.hand, original.hand.filter(candidate => candidate.id !== consumed.card));
|
||||
}
|
||||
assert.deepEqual(truthtranceNoFieldCards(done), truthtranceNoFieldCards(before));
|
||||
return done;
|
||||
}
|
||||
Reference in new issue
Block a user