rpg-engine 0.0.0-stage → 0.1.0

package/dist/commands/game-thresholds.js

@@ -0,0 +1,41 @@
+// The thresholds of a game system (D-184, DAT-3): the rule that a counter of the player character or of a companion touches when it changes.
+import { comparableText } from "../core/text.js";
+import { readCounterText } from "../counters/index.js";
+import { houseRules, ruleBlock, ruleTitled } from "./game-rules.js";
+/**
+ * The notes of the thresholds that a change of a field touches: it reaches the value, even going beyond it, takes more while at it, leaves it, or goes past it,
+ * as in "hp is at 0, 7 beyond: read rules "Dropping to 0 Hit Points"."; a value an effect gives says so. A threshold without a value gives its rule's text at
+ * every change, a house rule first (DAT-6).
+ */
+export function thresholdNotes(root, system, field, change, effect) {
+    if (system === undefined) {
+        return [];
+    }
+    const before = readCounterText(String(change.before))?.value;
+    const after = readCounterText(String(change.after))?.value;
+    const beyond = Math.abs(change.amount.beyond ?? 0);
+    const where = effect === undefined ? "" : ` in ${effect}`;
+    return system.thresholds.filter((threshold) => comparableText(threshold.field) === comparableText(field)).flatMap((threshold) => {
+        const read = `read rules "${threshold.rule}"`;
+        if (threshold.value === undefined) {
+            const rule = ruleTitled(root, system, threshold.rule);
+            const source = rule?.source === houseRules ? "the house rules" : `the rules of ${system.name}`;
+            return [rule === undefined ? `${field} changed: ${read}.` : `${field} changed: ${threshold.rule}, from ${source}:\n${ruleBlock(rule)}`];
+        }
+        if (before === undefined || after === undefined) {
+            return [];
+        }
+        // Which side of the value a number is on: below, at it, or above.
+        const side = (value) => Math.sign(value - (threshold.value ?? 0));
+        if (side(after) === 0 && side(before) !== 0) {
+            return [`${field} is at ${threshold.value}${where}${beyond > 0 ? `, ${beyond} beyond` : ""}: ${read}.`];
+        }
+        if (side(after) === 0) {
+            return beyond > 0 ? [`${field} is at ${threshold.value}${where} and took ${beyond} more: ${read}.`] : [];
+        }
+        if (side(before) === 0) {
+            return [`${field} is no longer at ${threshold.value}${where}: ${read}.`];
+        }
+        return side(before) === side(after) ? [] : [`${field} went past ${threshold.value}${where}, from ${before} to ${after}: ${read}.`];
+    });
+}

package/dist/commands/game-time.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from "../core/context.ts";
+import { type LogEntry } from "../core/log.ts";
+import type { Problem } from "../core/problem.ts";
+import { type GameDate } from "../time/index.ts";
+/** The present of the game: its date, or the problem that keeps state.yaml from giving one; neither before the game has a date. */
+export declare function readPresent(root: string): {
+    date?: GameDate;
+    problem?: Problem;
+};
+/** The game date now, undefined before the game has one. A state.yaml that cannot give it stops the command, with how to fix it. */
+export declare function presentDate(root: string): GameDate | undefined;
+/** A problem of the present as one sentence, with how to fix it. */
+export declare function problemText(problem: Problem): string;
+/** A new line for the log, stamped with the game date when the game has one that can be read (D-66). It never fails: validate reports a state.yaml it cannot read. */
+export declare function newDatedLogEntry(root: string, context: Context, type: string, visibility: LogEntry["visibility"], data: Record<string, unknown>): LogEntry;
+/** The problems of the game time: a state.yaml that cannot give the game date. The planned events have their own (eventProblems). */
+export declare function timeProblems(root: string): Problem[];

package/dist/commands/game-time.js

@@ -0,0 +1,42 @@
+// The game time as several commands use it: the present date from state.yaml, and the log lines stamped with it.
+import { readState } from "../campaign/index.js";
+import { newLogEntry } from "../core/log.js";
+import { isEmptyField } from "../pages/index.js";
+import { formatGameDate, readGameDate } from "../time/index.js";
+/** The present of the game: its date, or the problem that keeps state.yaml from giving one; neither before the game has a date. */
+export function readPresent(root) {
+    let text;
+    try {
+        text = readState(root).date;
+    }
+    catch (error) {
+        return { problem: { message: error instanceof Error ? error.message : String(error) } };
+    }
+    const date = readGameDate(text);
+    if (isEmptyField(text) || date !== undefined) {
+        return { date };
+    }
+    return { problem: { message: `The game date in state.yaml, "${text}", is not a game date.`, fix: "write it by hand as day 3, 06:00" } };
+}
+/** The game date now, undefined before the game has one. A state.yaml that cannot give it stops the command, with how to fix it. */
+export function presentDate(root) {
+    const { date, problem } = readPresent(root);
+    if (problem !== undefined) {
+        throw new Error(problemText(problem));
+    }
+    return date;
+}
+/** A problem of the present as one sentence, with how to fix it. */
+export function problemText(problem) {
+    return problem.fix === undefined ? problem.message : `${problem.message.replace(/\.$/, "")}: ${problem.fix}.`;
+}
+/** A new line for the log, stamped with the game date when the game has one that can be read (D-66). It never fails: validate reports a state.yaml it cannot read. */
+export function newDatedLogEntry(root, context, type, visibility, data) {
+    const { date } = readPresent(root);
+    return newLogEntry(context, type, visibility, data, date === undefined ? undefined : formatGameDate(date));
+}
+/** The problems of the game time: a state.yaml that cannot give the game date. The planned events have their own (eventProblems). */
+export function timeProblems(root) {
+    const { problem } = readPresent(root);
+    return problem === undefined ? [] : [problem];
+}

package/dist/commands/game-view-journal.d.ts

@@ -0,0 +1,145 @@
+import { type LogEntry } from "../core/log.ts";
+import { type World } from "../pages/index.ts";
+import type { GameDate } from "../time/index.ts";
+import type { SeenEffect } from "./game-effects.ts";
+import { type Knowledge } from "./game-knowledge.ts";
+/** A quest as the journal shows it (VIEW-8). */
+export interface ShownQuest {
+    name: string;
+    status: "open" | "done" | "failed";
+    main: boolean;
+    giver?: string;
+    place?: string;
+    /** Its text as the character knows it, without the goals. */
+    text: string;
+    goals: {
+        text: string;
+        done: boolean;
+    }[];
+    /** Its fields that are counters with a maximum, as clues: 3/5. */
+    counters: {
+        field: string;
+        value: number;
+        max: number;
+    }[];
+    /** Its clock, with what happens when it fills when the master named it (clock-name, D-369). */
+    clock?: {
+        value: number;
+        max: number;
+        name?: string;
+    };
+    /** Its deadline, a game date, with the minutes still to come, below zero once passed; none before the game has a date. */
+    deadline?: {
+        date: string;
+        minutes?: number;
+    };
+    /** Its picture, as the character knows the quest (D-388). */
+    picture?: {
+        file: string;
+        version: number;
+    };
+    /** Its place's picture and kind, as the character knows the place, which its card shows when the quest has no picture (D-389). */
+    placePicture?: {
+        file: string;
+        version: number;
+    };
+    placeKind?: string;
+}
+/** A scene as a chapter of the story (VIEW-9); without a title, what happened between scenes. */
+export interface ShownChapter {
+    title?: string;
+    /** Its number among the scenes, from the first (D-384). */
+    number?: number;
+    type?: string;
+    place?: string;
+    /** The place's kind and picture, as the player character knows the place, else that of the nearest place that holds it (D-384). */
+    kind?: string;
+    picture?: {
+        file: string;
+        version: number;
+    };
+    date?: string;
+    summary?: string;
+    open: boolean;
+    facts: JournalFact[];
+}
+/**
+ * A fact of the story as the journal tells it (VIEW-9), as data the dashboard writes in its language, with its game date: who and where as the character knows
+ * them, someone, creature and somewhere for those it does not (D-254); an effect with its end, and the line status gives it.
+ */
+export type StoryFact = {
+    date?: string;
+} & ({
+    kind: "scene-opened";
+    title: string;
+    type: string;
+} | {
+    kind: "scene-closed";
+    title: string;
+    type: string;
+    summary: string;
+} | {
+    kind: "roll";
+    who?: string;
+    result: string;
+} | {
+    kind: "roll-revealed";
+} | {
+    kind: "counter";
+    who: string;
+    field: string;
+    before: string;
+    after: string;
+} | {
+    kind: "time";
+    from?: string;
+    to: string;
+} | {
+    kind: "moved";
+    who: string[];
+    to?: string;
+} | {
+    kind: "learned";
+    who: string;
+    what: string[];
+} | ({
+    kind: "effect";
+    who: string;
+} & SeenEffect) | {
+    kind: "effect-ended";
+    who: string;
+    effect: string;
+} | {
+    kind: "saved";
+    save: string;
+    label?: string;
+} | {
+    kind: "back";
+    save: string;
+} | {
+    kind: "mode";
+    to: string;
+} | {
+    kind: "quest";
+    status: "open" | "done" | "failed";
+    quest: string;
+});
+/** A fact the journal tells: of the story, never of the game (D-369); the saves made have their own section, the mode is the setup's, the rolls have their column. */
+export type JournalFact = Extract<StoryFact, {
+    kind: (typeof storyKinds)[number];
+}>;
+declare const storyKinds: readonly ["counter", "time", "moved", "learned", "effect", "effect-ended", "back", "quest"];
+/** A page as the journal shows it: its kind and picture, as the player character knows it; a place's, else that of the nearest place that holds it. */
+export type PlaceLook = (name: unknown) => Pick<ShownChapter, "kind" | "picture">;
+/**
+ * The journal (VIEW-8, VIEW-9): the quests the character knows, open ones first, the main ones first among them, then those changed last; and the chapters, the
+ * last first, numbered from the first. `fact` tells a public line of the log as the diary does; `named` names a page as the character knows it; `look` gives a
+ * place's kind and picture.
+ */
+export declare function shownJournal(root: string, world: World, knowledge: Knowledge, now: GameDate | undefined, fact: (entry: LogEntry) => StoryFact | undefined, named: (name: unknown) => string | undefined, look: PlaceLook): {
+    quests: ShownQuest[];
+    chapters: ShownChapter[];
+};
+/** "Ritrovare gli scomparsi: open, main, 1/2 goals, clues 3/5, I rapitori 2/6, deadline day 5, 18:00 (in 2d 4h)": a quest in the chat's words. */
+export declare function questText(quest: ShownQuest): string;
+export {};

package/dist/commands/game-view-journal.js

@@ -0,0 +1,129 @@
+// The player's journal (D-367, VIEW-8, VIEW-9): the quests the player character knows, as a video game's quest log, with their goals, counters, clock and
+// deadline; and the story by its scenes, as chapters, each with what the diary tells of it.
+import { readLog } from "../core/log.js";
+import { comparableText } from "../core/text.js";
+import { goalsIn, links, textsIn } from "../pages/index.js";
+import { knownText } from "./game-knowledge.js";
+import { measuresText, questMeasures } from "./game-quests.js";
+const storyKinds = ["counter", "time", "moved", "learned", "effect", "effect-ended", "back", "quest"];
+const statuses = ["open", "done", "failed"];
+/**
+ * The journal (VIEW-8, VIEW-9): the quests the character knows, open ones first, the main ones first among them, then those changed last; and the chapters, the
+ * last first, numbered from the first. `fact` tells a public line of the log as the diary does; `named` names a page as the character knows it; `look` gives a
+ * place's kind and picture.
+ */
+export function shownJournal(root, world, knowledge, now, fact, named, look) {
+    // Changed last, as the player saw it: by the public lines alone, never by what the master wrote unseen.
+    const log = readLog(root).filter((entry) => entry.visibility === "public");
+    const changed = new Map();
+    log.forEach((entry, index) => typeof entry.data.quest === "string" && changed.set(comparableText(entry.data.quest), index));
+    const order = (quest) => [statuses.indexOf(quest.status), quest.status === "open" && quest.main ? 0 : 1, -(changed.get(comparableText(quest.name)) ?? -1)];
+    const quests = [...knowledge.pages]
+        .filter((page) => page.type === "quest" && statuses.includes(String(page.fields.status)))
+        .map((page) => shownQuest(world, knowledge, page, now, named, look))
+        .sort((one, other) => compareOrders(order(one), order(other)) || one.name.localeCompare(other.name));
+    return { quests, chapters: chaptersOf(log, fact, named, look) };
+}
+/** "Ritrovare gli scomparsi: open, main, 1/2 goals, clues 3/5, I rapitori 2/6, deadline day 5, 18:00 (in 2d 4h)": a quest in the chat's words. */
+export function questText(quest) {
+    const done = quest.goals.filter((goal) => goal.done).length;
+    const measures = measuresText(quest);
+    return [
+        `${quest.name}: ${quest.status}`,
+        ...(quest.main ? ["main"] : []),
+        ...(quest.goals.length === 0 ? [] : [`${done}/${quest.goals.length} goals`]),
+        ...(measures === "" ? [] : [measures]),
+    ].join(", ");
+}
+function shownQuest(world, knowledge, page, now, named, look) {
+    const { goals, rest } = goalsIn(knownText(world, knowledge, page));
+    const giver = shownLink(page.fields.giver, named);
+    const place = shownLink(page.fields.place, named);
+    const picture = look(page.name).picture;
+    const where = page.fields.place === undefined ? {} : look(textsIn(page.fields.place)[0]);
+    return {
+        name: page.name,
+        status: page.fields.status,
+        ...questMeasures(page, now),
+        ...(giver === undefined ? {} : { giver }),
+        ...(place === undefined ? {} : { place }),
+        ...(picture === undefined ? {} : { picture }),
+        ...(where.picture === undefined ? {} : { placePicture: where.picture }),
+        ...(where.kind === undefined ? {} : { placeKind: where.kind }),
+        text: rest,
+        goals,
+    };
+}
+/**
+ * Who gave a quest, where it is, as the character knows them (VIEW-4): a page it knows by its name, one it does not by the words the link shows instead, if
+ * any; a field without a link as it is written.
+ */
+function shownLink(value, named) {
+    const text = textsIn(value)[0]?.trim();
+    if (text === undefined || text === "") {
+        return undefined;
+    }
+    const link = links(text)[0];
+    if (link === undefined) {
+        return text;
+    }
+    const alias = /\|([^\]]+)\]\]/.exec(text)?.[1]?.trim();
+    return named(link.page) === undefined ? alias : (alias ?? named(link.page));
+}
+/**
+ * The story as chapters (VIEW-9): each scene, from its opening to its close, with its summary and the facts the diary tells of it; the facts between scenes in
+ * chapters of their own, the saves and the modes left out. The last first.
+ */
+function chaptersOf(entries, fact, named, look) {
+    const chapters = [];
+    let scene;
+    let scenes = 0;
+    for (const entry of entries) {
+        const data = entry.data;
+        if (entry.type === "scene-opened") {
+            scene = chapter(String(data.title ?? ""), ++scenes, data, entry, named, look);
+            chapters.push(scene);
+            continue;
+        }
+        if (entry.type === "scene-closed") {
+            const closed = scene ?? chapter(String(data.title ?? ""), ++scenes, data, entry, named, look);
+            if (scene === undefined) {
+                chapters.push(closed);
+            }
+            closed.summary = typeof data.summary === "string" && data.summary !== "" ? data.summary : undefined;
+            closed.open = false;
+            scene = undefined;
+            continue;
+        }
+        const told = fact(entry);
+        if (told === undefined || !isJournalFact(told)) {
+            continue;
+        }
+        const between = chapters.at(-1)?.title === undefined ? chapters.at(-1) : undefined;
+        const holder = scene ?? between ?? { open: false, facts: [], ...(entry.date === undefined ? {} : { date: entry.date }) };
+        if (holder !== scene && holder !== between) {
+            chapters.push(holder);
+        }
+        holder.facts.push(told);
+    }
+    return chapters.toReversed();
+}
+function chapter(title, number, data, entry, named, look) {
+    const place = named(data.place);
+    return {
+        title,
+        number,
+        ...(typeof data.type === "string" ? { type: data.type } : {}),
+        ...(place === undefined ? {} : { place, ...look(data.place) }),
+        ...(entry.date === undefined ? {} : { date: entry.date }),
+        open: true,
+        facts: [],
+    };
+}
+function isJournalFact(fact) {
+    return storyKinds.includes(fact.kind);
+}
+function compareOrders(one, other) {
+    const at = one.findIndex((value, index) => value !== other[index]);
+    return at < 0 ? 0 : one[at] - other[at];
+}

package/dist/commands/game-view-map.d.ts

@@ -0,0 +1,78 @@
+import { type Measures } from "./game-roads.ts";
+import type { PlaceSight } from "./game-view-place.ts";
+/** A point of a map, in km east and north of its centre; with the map it is on, by the place that holds it, none for the main map (POS-8). */
+export interface MapPoint {
+    x: number;
+    y: number;
+    map?: string;
+}
+/**
+ * A place the character knows: its kind, its point when it is drawn on its map (a position of its own or from its road), the places it knows that hold it,
+ * the nearest first; for a region its radius in km, biome and terrain; where it is from the party, on the party's map: the km and the point of the compass, none
+ * closer than 50 m, which the dashboard writes in its language.
+ */
+export interface MapPlace {
+    name: string;
+    kind?: string;
+    x?: number;
+    y?: number;
+    map?: string;
+    within: string[];
+    radius?: number;
+    biome?: string;
+    terrain?: string;
+    from?: {
+        km: number;
+        direction?: string;
+    };
+    image?: {
+        file: string;
+        version: number;
+    };
+}
+/**
+ * A road the character knows, from its first known stop to its last: each point with its name when the character knows the stop, its map, and the km from the
+ * point before; beyond, toward a stop it does not know, a short stretch in its direction. A passage's points are on two maps (ROA-8).
+ */
+export interface MapRoad {
+    name: string;
+    kind: string;
+    points: (MapPoint & {
+        name?: string;
+        km: number;
+    })[];
+    before?: MapPoint;
+    after?: MapPoint;
+}
+/** A map the character knows (POS-8): its name, the main map's being the campaign's; and the map it lies under or mirrors, sharing its coordinates. */
+export interface KnownMap {
+    name: string;
+    main?: true;
+    under?: string;
+    mirror?: string;
+}
+/**
+ * The world map as the player character knows it (VIEW-7): the unit of the player and its km, the maps it knows, the places nearest the party first, the roads,
+ * the party and its trail.
+ */
+export interface ShownMap {
+    /** The player's unit and its km; in imperial the game's foot too, in metres, for what is shorter than a mile. */
+    unit: {
+        name: "km" | "mi";
+        km: number;
+        foot?: number;
+    };
+    maps: KnownMap[];
+    places: MapPlace[];
+    roads: MapRoad[];
+    party?: MapPoint & {
+        place?: string;
+    };
+    trail: MapPoint[];
+}
+export declare function shownMap(sight: PlaceSight, measures: Measures, campaign: string): ShownMap;
+/**
+ * The map in the chat (VIEW-7): the places drawn on the party's map, nearest it first, with their kind and where they are; the regions with their biome; then
+ * the places of the other maps the character knows, by map.
+ */
+export declare function mapText(map: ShownMap): string;