94 lines
6.0 KiB
TypeScript
94 lines
6.0 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import { viewGame, type Action, type Game } from '../game/engine';
|
|
import type { MixedActionExpression } from '../game/mixed-action-question';
|
|
import type { RevivalExpressionLeaf } from '../game/revival-expression-promises';
|
|
import type { TruthFact } from '../game/truthtrance';
|
|
import {
|
|
actTruthRevivalExpression, advanceTruthRevivalExpression, createTruthRevivalExpressionFixture,
|
|
declareTruthRevivalExpression, finishTruthRevivalExpression, nextTruthRevivalExpression,
|
|
settleTruthRevivalExpression, truthRevivalExpressionClean, truthRevivalExpressionInventory,
|
|
truthRevivalExpressionPlayer, type TruthRevivalExpressionStep,
|
|
} from './fixture-truth-revival-expression';
|
|
|
|
export type TruthMixedRevivalExpression = MixedActionExpression<RevivalExpressionLeaf>;
|
|
export type TruthMixedRevivalStep = TruthRevivalExpressionStep;
|
|
export const actTruthMixedRevival = actTruthRevivalExpression;
|
|
export const advanceTruthMixedRevival = advanceTruthRevivalExpression;
|
|
export const finishTruthMixedRevival = finishTruthRevivalExpression;
|
|
export const nextTruthMixedRevival = nextTruthRevivalExpression;
|
|
export const settleTruthMixedRevival = settleTruthRevivalExpression;
|
|
export const truthMixedRevivalClean = truthRevivalExpressionClean;
|
|
export const truthMixedRevivalInventory = truthRevivalExpressionInventory;
|
|
export const truthMixedRevivalPlayer = truthRevivalExpressionPlayer;
|
|
|
|
export const truthMixedRevivalFact = (fact: TruthFact): TruthMixedRevivalExpression => ({ kind: 'fact', fact });
|
|
export const truthMixedRevivalForce = (minimum = 1, counter: 'total' | 'normal' | 'elite' = 'total'):
|
|
TruthMixedRevivalExpression => ({ kind: 'action', action: { kind: 'forces', counter, minimum } });
|
|
export const truthMixedRevivalLeader = (leader: string): TruthMixedRevivalExpression =>
|
|
({ kind: 'action', action: { kind: 'leader', leader } });
|
|
export const truthMixedRevivalGroup = (kind: 'and' | 'or', ...terms: TruthMixedRevivalExpression[]):
|
|
TruthMixedRevivalExpression => ({ kind, terms });
|
|
|
|
/** Original public H/A/T Ix47: the inherited paid shipment and actual projectile
|
|
* kill reach T4, one tank counter and a cost2 personal early Hidar return. This
|
|
* adapter changes only the raw question. It installs no played state or binding. */
|
|
export function createTruthMixedRevivalFixture(options: {
|
|
advanced?: boolean; window?: 'active' | 'waiting'; ghola?: boolean; bothDead?: boolean;
|
|
mixed?: TruthMixedRevivalExpression;
|
|
} = {}) {
|
|
const { mixed: suppliedMixed, ...sourceOptions } = options;
|
|
const base = createTruthRevivalExpressionFixture(sourceOptions);
|
|
const spiceFact: TruthFact = { kind: 'spice', compare: 'gte', value: 4 };
|
|
const falseSpiceFact: TruthFact = { kind: 'spice', compare: 'gte', value: 5 };
|
|
const forecastFact: TruthFact = { kind: 'stormForecast', compare: 'gte', value: 1 };
|
|
const mixed = structuredClone(suppliedMixed ?? truthMixedRevivalGroup('and', truthMixedRevivalFact(spiceFact),
|
|
truthMixedRevivalForce(), truthMixedRevivalLeader(base.leader)));
|
|
const question = { kind: 'mixedRevival' as const, target: base.target, turn: base.game.turn, mixed };
|
|
return { ...base, revivalSource: base, mixed, question, spiceFact, falseSpiceFact, forecastFact,
|
|
questionAction: { type: 'truthAsk', question } satisfies Action,
|
|
sourceCounts: { inherited: base.sourceActions.length, postStorm: base.postStormSourceActions.length,
|
|
phase3: base.phase3SourceActions.length },
|
|
sourceDisclosure: `${base.sourceDisclosure} This thin mixed adapter changes only the original raw question: current facts and future ordinary typed force/named-leader returns share one AND/OR tree. It inherits every original action and freezes no fact or residual itself.` };
|
|
}
|
|
export type TruthMixedRevivalFixture = ReturnType<typeof createTruthMixedRevivalFixture>;
|
|
|
|
export function declareTruthMixedRevival(f: TruthMixedRevivalFixture, source = f.game,
|
|
options: { copies?: 1 | 2 } = {}) {
|
|
return declareTruthRevivalExpression(f.revivalSource, source, options);
|
|
}
|
|
export function askTruthMixedRevival(game: Game, asker: string, target: string, mixed: TruthMixedRevivalExpression,
|
|
actions: TruthMixedRevivalStep[] = []): Game {
|
|
return actTruthMixedRevival(game, asker, { type: 'truthAsk', question: {
|
|
kind: 'mixedRevival', target, turn: game.turn, mixed: structuredClone(mixed),
|
|
} }, actions);
|
|
}
|
|
export function answerTruthMixedRevival(game: Game, target: string, answer: 'yes' | 'no',
|
|
actions: TruthMixedRevivalStep[] = []): Game {
|
|
return actTruthMixedRevival(game, target, { type: 'truthAnswer', answer }, actions);
|
|
}
|
|
export function bindTruthMixedRevival(f: TruthMixedRevivalFixture, answer: 'yes' | 'no' = 'yes',
|
|
mixed = f.mixed, source = f.game) {
|
|
const declared = declareTruthMixedRevival(f, source), actions = [...declared.actions];
|
|
const asked = askTruthMixedRevival(declared.game, f.asker, f.target, mixed, actions);
|
|
const game = answerTruthMixedRevival(asked, f.target, answer, actions);
|
|
return { game, declared, asked, actions, actionCount: actions.length };
|
|
}
|
|
|
|
/** Own public raw aggregate only; no private frozen clause or residual access. */
|
|
export function truthMixedRevivalPromise(game: Game,
|
|
target = game.truthHistory?.at(-1)?.question.target ?? game.players[0].id) {
|
|
const row = viewGame(game, target).mixedRevivalPromises.find(row => row.player === target);
|
|
assert.ok(row, 'The respondent retains the original mixed question and whole-answer status');
|
|
return row;
|
|
}
|
|
export function completeTruthMixedRevival(game: Game, target: string, actions: TruthMixedRevivalStep[] = []): Game {
|
|
for (let count = 0; count < 4 && !truthMixedRevivalPromise(game, target).fulfilled; count++) {
|
|
const guide = viewGame(game, target).revivalExpressionPromiseGuide;
|
|
assert.ok(guide, 'The owned mixed Yes has an exact native ordinary return guide');
|
|
assert.equal(guide.phase, game.phase);
|
|
game = settleTruthMixedRevival(actTruthMixedRevival(game, target, guide.action, actions), actions);
|
|
}
|
|
assert.equal(truthMixedRevivalPromise(game, target).fulfilled, true);
|
|
return game;
|
|
}
|