rpg-engine 0.0.0-stage → 0.1.0

package/dist/commands/worked-out.d.ts

@@ -0,0 +1,116 @@
+import { type Formula, type FormulaRead } from "../core/formula.ts";
+import type { Problem } from "../core/problem.ts";
+import { type Page, type World } from "../pages/index.ts";
+/** A computed field that has a value, and the values it came from (FOR-8); a field the rows of the classes give may hold text, such as martial-arts 1d6 (PRO-2). */
+export interface WorkedField {
+    field: string;
+    value: number | string;
+    reads: FormulaRead[];
+}
+/**
+ * The computed fields of the game system that have a value with these fields (FOR-4), in the order the system gives them; `explained`, each with only the
+ * values that changed it (FOR-8).
+ */
+export declare function workedFields(world: World, fields: Record<string, unknown>, explained?: boolean): WorkedField[];
+/**
+ * The fields with what the game system works out over them: each computed field that has a value takes it, over what the page writes (FOR-4); a counter
+ * takes the maximum the system works out, and a current above it reads as the maximum (FOR-6). With `sheeted`, the uses it does not write read full (DAT-9).
+ */
+export declare function withWorkedOut(world: World, fields: Record<string, unknown>, sheeted: boolean): Record<string, unknown>;
+/**
+ * Whether a page keeps the sheet of the system (DAT-2, D-225): the player character, and a companion with a level, written or given by its classes, or that
+ * derives from no creature. A fighter who derives from her race does, a wolf with its stat block does not; nor does any other page.
+ */
+export declare function hasSheet(world: World, page: Page): boolean;
+/**
+ * A page's fields with the values its effects give over them (EFF-3): from the newest effect that gives a field, then the page, then its bases; a bonus field
+ * adds up the effects that give it (FOR-5). Before what the system works out, as an item's formulas read it: a weapon under Magic Weapon (PRO-5).
+ */
+export declare function withEffectValues(world: World, page: Page): Record<string, unknown>;
+/** Whether a counter of the system comes back with a rest (DAT-9): who keeps the sheet has it full until it spends it. */
+export declare function isUse(world: World, field: string): boolean;
+/** The uses the system gives a page with these fields that it does not write, each with its maximum (DAT-9): what write puts, full, on who keeps the sheet. */
+export declare function missingUses(world: World, fields: Record<string, unknown>): {
+    field: string;
+    max: number;
+}[];
+/**
+ * How much of a counter comes back with these occasions (DAT-9): the sum of what its refill gives for each, where max is the counter's maximum; undefined when
+ * it names none of them.
+ */
+export declare function refillAmount(world: World, fields: Record<string, unknown>, field: string, occasions: string[], max: number): number | undefined;
+/** A formula of the system worked out on these fields, as a recipe's regain is; undefined when it has no value (FOR-4). */
+export declare function formulaValue(world: World, fields: Record<string, unknown>, formula: Formula): number | undefined;
+/** The list whose items' pages give a field as a formula, as classes for spell-save-dc (PRO-5); undefined when none does. */
+export declare function itemList(world: World, field: string): string | undefined;
+/**
+ * Each item of a list with what the formulas of its page give, field by field, in the order of the list, for a sheet that shows them item by item, as the
+ * attacks of the weapons a character has equipped (PRO-5).
+ */
+export declare function itemLines(world: World, fields: Record<string, unknown>, list: string, names: string[], explained?: boolean): {
+    item: string;
+    values: WorkedField[];
+}[];
+/** The minimum and maximum the game system works out for a counter with these fields, where they have a whole value (FOR-6). */
+export declare function counterLimits(world: World, fields: Record<string, unknown>, field: string): {
+    min?: number;
+    max?: number;
+};
+/**
+ * The name, as the game system declares it, of a counter that starts at 0 where a page does not hold it yet, as temporary hit points or experience points:
+ * declared a counter, with no maximum and not a use that comes back with a rest (CNT-8, D-266). Undefined for any other.
+ */
+export declare function startingAtZero(world: World, field: string): string | undefined;
+/**
+ * The game system's computed field with this name, in any case, and the fields it comes from, when its formula has a value with these fields (FOR-7):
+ * where it has none, as on a creature without a level, the field is written like any other.
+ */
+export declare function computedField(world: World, field: string, fields: Record<string, unknown>): {
+    name: string;
+    value: number | string;
+    from: string[];
+} | undefined;
+/** The written fields the maximum of a counter comes from with these fields, as hp-base, level and con for hp (FOR-6); none when the system works out no maximum. */
+export declare function maximumSources(world: World, field: string, fields: Record<string, unknown>): string[];
+/**
+ * How the maximum the game system works out for a counter is made, "38, from hp-base 28, level 11, con-mod +1", and the written field to raise it with, as at a
+ * new level (FOR-6, D-226); undefined where the system works out none.
+ */
+export declare function maximumHint(world: World, fields: Record<string, unknown>, field: string): {
+    made: string;
+    raise?: string;
+} | undefined;
+/** Why a computed field is not written or changed, and what to change instead: the fields it comes from, or an effect on a bonus among them (FOR-7). */
+export declare function computedMessage(world: World, computed: {
+    name: string;
+    value: number | string;
+    from: string[];
+}, page: string): string;
+/**
+ * The bonus fields among those a computed field comes from, which an effect on the page gives to change it, as bonus-ac for ac (FOR-5); not those the items of a
+ * list give, as a shield's armor-class-bonus, which change on the item (PRO-5).
+ */
+export declare function effectBonuses(world: World, from: string[]): string[];
+/**
+ * The first item of its list whose page gives a field, with the fields of its own that its formula reads, as a shield's bonus (PRO-5): a page of the campaign,
+ * which an effect can change, not one of the system, as the unarmed strike (D-235).
+ */
+export declare function itemSource(world: World, fields: Record<string, unknown>, field: string): {
+    item: string;
+    list: string;
+    own: string[];
+} | undefined;
+/** A value of a field as the outputs show it: with its sign when the system declares the field a modifier or a bonus (FOR-8). */
+export declare function signedText(world: World, field: string, value: number | string): string;
+/** "insight +5: wis-mod +3, proficiency +2, Insight in skill-proficiencies": a computed field and what it came from, leaving out what adds nothing (FOR-8). */
+export declare function workedLine(world: World, worked: WorkedField): string;
+/** "wis-mod +3, proficiency +2, Insight in skill-proficiencies": the values a result came from, leaving out what adds nothing (FOR-8). */
+export declare function workedParts(world: World, reads: FormulaRead[]): string;
+/** The maximum the game system works out for a counter with these fields, with only the values that changed it (FOR-6, FOR-8); undefined where it has none. */
+export declare function workedMaximum(world: World, fields: Record<string, unknown>, field: string): WorkedField | undefined;
+/**
+ * What validate says of the pages of the campaign about what the game system works out (FOR-7): a computed field written on a page, where the system works it
+ * out and the page's value is never read; a written maximum that is not the one the system works out from the page without its effects; what the classes of a
+ * page cannot give (PRO-1, PRO-4). Found once for each world.
+ */
+export declare function workedOutProblems(world: World): Problem[];