rpg-engine 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,22 @@
+import type { LogEntry } from "../core/log.ts";
+import { type Mood } from "../core/mood.ts";
+import { type Page } from "../pages/index.ts";
+/** The key of state.yaml that keeps the master's mood. */
+export declare const masterMoodKey = "master-mood";
+/** The log's types: a mood that stays, and a moment of the master's, which the dashboard shows for a few seconds. */
+export declare const moodChanged = "mood-changed";
+export declare const moodMoment = "mood-moment";
+/** A moment of the master's (MOOD-4): its line of the log, which tells it apart from the one before, the mood, and when, in real time. */
+export interface MoodMoment {
+    id: string;
+    mood: Mood;
+    at: string;
+}
+/** The master's mood; neutral when state.yaml has none, or one that is not a mood, or cannot be read, which status reports as a problem of its own. */
+export declare function masterMood(root: string): Mood;
+/** A character's own mood, never one of a base (INH-8); neutral when it has none. */
+export declare function pageMood(page: Page): Mood;
+/** A character's mood while alive: the dead have none to show. */
+export declare function livingMood(page: Page): Mood;
+/** The master's last moment in the log, if any. */
+export declare function lastMoment(entries: LogEntry[]): MoodMoment | undefined;

package/dist/commands/game-moods.js

@@ -0,0 +1,32 @@
+// Where the moods are kept (MOOD-3, MOOD-4): the master's in state.yaml, a character's on its page, a moment of the master's only in the log.
+import { readStateValues } from "../campaign/index.js";
+import { readMood } from "../core/mood.js";
+import { ownField } from "../pages/index.js";
+/** The key of state.yaml that keeps the master's mood. */
+export const masterMoodKey = "master-mood";
+/** The log's types: a mood that stays, and a moment of the master's, which the dashboard shows for a few seconds. */
+export const moodChanged = "mood-changed";
+export const moodMoment = "mood-moment";
+/** The master's mood; neutral when state.yaml has none, or one that is not a mood, or cannot be read, which status reports as a problem of its own. */
+export function masterMood(root) {
+    try {
+        return readMood(readStateValues(root)[masterMoodKey]);
+    }
+    catch {
+        return "neutral";
+    }
+}
+/** A character's own mood, never one of a base (INH-8); neutral when it has none. */
+export function pageMood(page) {
+    const field = ownField(page, "mood");
+    return field === undefined ? "neutral" : readMood(page.fields[field]);
+}
+/** A character's mood while alive: the dead have none to show. */
+export function livingMood(page) {
+    return page.fields.status === "dead" ? "neutral" : pageMood(page);
+}
+/** The master's last moment in the log, if any. */
+export function lastMoment(entries) {
+    const entry = entries.findLast((line) => line.type === moodMoment);
+    return entry === undefined ? undefined : { id: entry.id, mood: readMood(entry.data.mood), at: entry.at };
+}

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

@@ -0,0 +1,14 @@
+import type { Context } from "../core/context.ts";
+import { type Page, type World } from "../pages/index.ts";
+/** What a move did: the pages that changed place, the world after it and after the events it set off, the events it made due, and what the master should know. */
+export interface MoveDone {
+    moved: Page[];
+    world: World;
+    due: string[];
+    notes: string[];
+}
+/**
+ * Moves pages into a container (CON-4), or out of every one, and does what follows: a line in the log for the pages that concern the player, public, and one for the others, hidden (CON-9);
+ * the events it sets off, judged once on the world before and after it; what links to the pages that moved, but the living members of the party (CON-5).
+ */
+export declare function movePages(root: string, context: Context, world: World, pages: Page[], destination: Page | undefined): MoveDone;

package/dist/commands/game-moves.js

@@ -0,0 +1,43 @@
+import { appendLogEntry } from "../core/log.js";
+import { applyMove, concernsPlayer, isInParty, links, locate, planLeave, planMove } from "../pages/index.js";
+import { fireEvents, heldNote, linkedStoryNotes, nowDueNote } from "./game-events.js";
+import { withSquares } from "./game-grids.js";
+import { newDatedLogEntry, readPresent } from "./game-time.js";
+/**
+ * Moves pages into a container (CON-4), or out of every one, and does what follows: a line in the log for the pages that concern the player, public, and one for the others, hidden (CON-9);
+ * the events it sets off, judged once on the world before and after it; what links to the pages that moved, but the living members of the party (CON-5).
+ */
+export function movePages(root, context, world, pages, destination) {
+    // Without a destination, out of every container: in the open, between the places of the map (TRV-12).
+    const planned = destination === undefined ? planLeave(world, pages) : planMove(world, pages, destination);
+    if (planned.edits.length === 0) {
+        return { moved: [], world, due: [], notes: [] };
+    }
+    // Who moves leaves the squares they had, and enters a map by the square that leads from where they were (GRD-3).
+    const plan = withSquares(world, planned, destination);
+    const after = applyMove(world, plan);
+    logMoves(root, context, world, after, plan.moving, destination);
+    const present = readPresent(root).date;
+    const fired = fireEvents(root, context, world, after, present);
+    const now = (page) => fired.world.pages.find((other) => other.path === page.path) ?? page;
+    const linked = linkedStoryNotes(fired.world, plan.moving.filter((page) => !isInParty(page)).map(now), fired.due.map((event) => event.name), present);
+    return { moved: plan.moving.map(now), world: fired.world, due: fired.due.map((event) => event.name), notes: [...unequippedNotes(plan), nowDueNote(fired.due), heldNote(fired.held), ...linked].filter((note) => note !== "") };
+}
+/** "Gara has Spada equipped no more.": who no longer holds what it had equipped (CON-12). */
+function unequippedNotes(plan) {
+    return plan.edits.filter((edit) => edit.field === "equipped").map((edit) => `${edit.holder.name} has ${edit.remove.map((entry) => links(entry)[0]?.page ?? entry).join(", ")} equipped no more.`);
+}
+/**
+ * One line for the pages the player may see, before the move or after it (D-93), or that carry one of the party, as a ship with the party aboard, public;
+ * one for the others, hidden. Each says where they were and where they went (CON-9).
+ */
+function logMoves(root, context, before, after, moved, destination) {
+    const now = (page) => after.pages.find((other) => other.path === page.path) ?? page;
+    const carriesParty = (page) => before.pages.some((member) => isInParty(member) && locate(before, member).chain.some((holder) => holder.path === page.path));
+    const seen = (page) => concernsPlayer(before, page) || concernsPlayer(after, now(page)) || carriesParty(page);
+    const groups = [["public", moved.filter(seen)], ["hidden", moved.filter((page) => !seen(page))]];
+    for (const [visibility, pages] of groups.filter(([, group]) => group.length > 0)) {
+        const from = Object.fromEntries(pages.map((page) => [page.name, locate(before, page).chain[0]?.name ?? null]));
+        appendLogEntry(root, newDatedLogEntry(root, context, "moved", visibility, { pages: pages.map((page) => page.name), from, to: destination?.name ?? null }));
+    }
+}

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

@@ -0,0 +1,18 @@
+import { type Page, type Position, type World } from "../pages/index.ts";
+import type { GameSystem } from "../systems/index.ts";
+import { type Measures, type Roads } from "./game-roads.ts";
+/** A leg of a straight line across country: the region it runs in, none in the open, its length in metres and the metres a minute at the pace there. */
+export interface OpenLeg {
+    region?: Page;
+    length: number;
+    metresAMinute: number;
+}
+/**
+ * The legs of a straight line from a point to another of a map, by its key (TRV-12, POS-8): where the smallest region that covers it changes, a new leg, at the
+ * pace times its terrain.
+ */
+export declare function openLegs(world: World, system: GameSystem | undefined, from: Position, to: Position, metresAnHour: number, map?: string): OpenLeg[];
+/** " Straight across country it is 9 km north-east: travel to Torre, across.": the way off the roads, when both places have a position on one map (TRV-13, POS-8). */
+export declare function acrossHint(world: World, from: Page, to: Page, measures: Measures): string;
+/** "Strada vecchia, 3 km out": the roads of a map a straight line crosses, between stops with a position, each once, nearest first (TRV-13, POS-8). */
+export declare function crossedRoads(world: World, roads: Roads, from: Position, to: Position, measures: Measures, map?: string): string[];

package/dist/commands/game-open.js

@@ -0,0 +1,47 @@
+// Travel off the roads (D-259, TRV-12, TRV-13): a straight line across the regions of the map, each with its terrain, and the roads it crosses.
+import { crossingAlong, distanceBetween, pointAlong } from "../map/index.js";
+import { pagesWithName } from "../pages/index.js";
+import { mapKey } from "./game-maps.js";
+import { placedPosition, positionOf, regionAt, relationText } from "./game-positions.js";
+import { lengthText, terrainFactor } from "./game-roads.js";
+// The line is judged every this many metres: a region smaller than this may be missed, which the master can always say.
+const sampleMetres = 250;
+/**
+ * The legs of a straight line from a point to another of a map, by its key (TRV-12, POS-8): where the smallest region that covers it changes, a new leg, at the
+ * pace times its terrain.
+ */
+export function openLegs(world, system, from, to, metresAnHour, map = "") {
+    const total = distanceBetween(from, to);
+    const samples = Math.max(1, Math.ceil(total / sampleMetres));
+    const legs = [];
+    for (let index = 0; index < samples; index++) {
+        const region = regionAt(world, pointAlong(from, to, (index + 0.5) / samples), map)?.page;
+        const last = legs.at(-1);
+        if (last !== undefined && last.region === region) {
+            last.length += total / samples;
+        }
+        else {
+            legs.push({ region, length: total / samples, metresAMinute: (metresAnHour * (region === undefined ? 1 : terrainFactor(world, system, region))) / 60 });
+        }
+    }
+    return total === 0 ? [] : legs;
+}
+/** " Straight across country it is 9 km north-east: travel to Torre, across.": the way off the roads, when both places have a position on one map (TRV-13, POS-8). */
+export function acrossHint(world, from, to, measures) {
+    const [start, end] = [positionOf(world, from), positionOf(world, to)];
+    return start === undefined || end === undefined || mapKey(world, from) !== mapKey(world, to) ? "" : ` Straight across country it is ${relationText(start, end, measures)}: travel to ${to.name}, across.`;
+}
+/** "Strada vecchia, 3 km out": the roads of a map a straight line crosses, between stops with a position, each once, nearest first (TRV-13, POS-8). */
+export function crossedRoads(world, roads, from, to, measures, map = "") {
+    const length = distanceBetween(from, to);
+    const crossings = roads.stretches.flatMap((stretch) => {
+        const [start, end] = [stretch.from, stretch.to].map((name) => {
+            const page = pagesWithName(world, name)[0];
+            return page === undefined || mapKey(world, page) !== map ? undefined : placedPosition(world, page);
+        });
+        const along = start === undefined || end === undefined ? undefined : crossingAlong(from, to, start, end);
+        // A road that starts or ends where the line does is not crossed.
+        return along === undefined || along * length < 50 || along * length > length - 50 ? [] : [{ road: stretch.road, metres: along * length }];
+    }).sort((first, second) => first.metres - second.metres);
+    return crossings.filter((crossing, index) => crossings.findIndex((other) => other.road === crossing.road) === index).map((crossing) => `${crossing.road}, ${lengthText(crossing.metres, measures)} out`);
+}

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

@@ -0,0 +1,14 @@
+import type { Context } from "../core/context.ts";
+import type { OutsideChange } from "../core/session-store.ts";
+import { type World } from "../pages/index.ts";
+/**
+ * What changed outside the chat since its last call (OUT-1–OUT-3): each page with its fields before and after and whether its text changed, campaign.yaml and
+ * state.yaml with their keys, the other files named; a hidden line in the log; and the events it set off, fired from the world `before` it, when known.
+ * Nothing for a change that leaves the game as it was, nor for the log, which the commands write.
+ */
+export declare function outsideNews(root: string, context: Context, changes: OutsideChange[], before: World | undefined): string[];
+/**
+ * The files changed while no chat was open (OUT-4): those of world, rules and campaign.yaml written after the log's last line and before the chat `began`, as by
+ * hand in Obsidian. Named only, with a hidden line in the log: no earlier copy of them is kept.
+ */
+export declare function whileClosedNews(root: string, context: Context, began: number): string[];

package/dist/commands/game-outside.js

@@ -0,0 +1,151 @@
+// What changed in a campaign outside the chat's commands (OUT-1–OUT-4, D-364): by hand, as in Obsidian, by another chat or by the command line. The master
+// hears it at the head of the next call, the log keeps it hidden, and the planned events it sets off fire as after a command.
+import { join, relative, sep } from "node:path";
+import { parse } from "yaml";
+import { campaignFileName } from "../campaign/index.js";
+import { filesIn } from "../core/files.js";
+import { appendLogEntry, logFileName, readLog } from "../core/log.js";
+import { files } from "../core/store.js";
+import { readFields, splitPageFile, worldFolderName } from "../pages/index.js";
+import { fireEvents, nowDueNote } from "./game-events.js";
+import { isGameFile } from "./game-saves.js";
+import { newDatedLogEntry, readPresent } from "./game-time.js";
+import { campaignWorld } from "./game-world.js";
+// At most this many changes are named; the rest are counted: a folder rewritten whole would fill the answer.
+const mostNamed = 10;
+// The files a command writes before its line in the log is stamped: a file changed this long after the log's last line was changed outside it.
+const writeSlack = 2000;
+// The files of the game a change can be told of: pages, settings and state, house rules, pictures; never an editor's copy or a system's file (OUT-1).
+const gameKinds = /\.(md|ya?ml|png|jpe?g|webp|gif|svg)$/i;
+/**
+ * What changed outside the chat since its last call (OUT-1–OUT-3): each page with its fields before and after and whether its text changed, campaign.yaml and
+ * state.yaml with their keys, the other files named; a hidden line in the log; and the events it set off, fired from the world `before` it, when known.
+ * Nothing for a change that leaves the game as it was, nor for the log, which the commands write.
+ */
+export function outsideNews(root, context, changes, before) {
+    const counted = changes.filter((change) => isToldFile(root, change.path));
+    const items = counted.flatMap((change) => itemOf(root, change));
+    const outside = { ...context, actor: "outside" };
+    if (items.length === 0) {
+        // A change of form alone, as spaces: nothing to tell, but the log notes it, so that the next chat never takes it for one made while it was closed.
+        if (counted.length > 0) {
+            appendLogEntry(root, newDatedLogEntry(root, outside, "changed-outside", "hidden", { files: counted.map((change) => ({ file: fileOf(root, change.path), form: true })) }));
+        }
+        return [];
+    }
+    appendLogEntry(root, newDatedLogEntry(root, outside, "changed-outside", "hidden", { files: items.map(logged) }));
+    const shown = items.slice(0, mostNamed).map(itemText).join(" · ");
+    const more = items.length > mostNamed ? `, and ${items.length - mostNamed} more` : "";
+    return [
+        `Changed outside this chat since your last call, by hand or elsewhere (the log keeps it, hidden): ${shown}${more}. Take it as the game's truth, and go on from it.`,
+        ...dueAfter(root, outside, before),
+    ];
+}
+/**
+ * The files changed while no chat was open (OUT-4): those of world, rules and campaign.yaml written after the log's last line and before the chat `began`, as by
+ * hand in Obsidian. Named only, with a hidden line in the log: no earlier copy of them is kept.
+ */
+export function whileClosedNews(root, context, began) {
+    const last = readLog(root).at(-1);
+    const since = last === undefined ? Number.NaN : Date.parse(last.at) + writeSlack;
+    if (Number.isNaN(since)) {
+        return [];
+    }
+    const changed = [...filesIn(join(root, worldFolderName), () => true), ...filesIn(join(root, "rules"), () => true), join(root, campaignFileName)]
+        .filter((path) => isToldFile(root, path) && (files().modified(path) ?? 0) > since && (files().modified(path) ?? 0) < began)
+        .map((path) => relative(root, path).split(sep).join("/"));
+    if (changed.length === 0) {
+        return [];
+    }
+    appendLogEntry(root, newDatedLogEntry(root, { ...context, actor: "outside" }, "changed-outside", "hidden", { files: changed.map((file) => ({ file })), whileClosed: true }));
+    const more = changed.length > mostNamed ? `, and ${changed.length - mostNamed} more` : "";
+    return [`Changed outside rpg while no chat was open (the log keeps it, hidden): ${changed.slice(0, mostNamed).join(" · ")}${more}. Read those that matter with show.`];
+}
+/** Whether a changed file is one the master hears of: a game file of its kinds, not the log, nor a name with a dot or a tilde anywhere in its path. */
+function isToldFile(root, path) {
+    const parts = relative(root, path).split(sep);
+    return isGameFile(root, path) && relative(root, path) !== logFileName && gameKinds.test(path) && !parts.some((part) => part.startsWith(".") || part.endsWith("~"));
+}
+function fileOf(root, path) {
+    return relative(root, path).split(sep).join("/");
+}
+/** A change as an item: a page by its name, campaign.yaml and state.yaml by their keys, any other file by its path; none when nothing that counts changed. */
+function itemOf(root, change) {
+    const file = relative(root, change.path).split(sep).join("/");
+    const page = file.startsWith(`${worldFolderName}/`) && file.toLowerCase().endsWith(".md");
+    const name = page ? (file.split("/").at(-1) ?? file).replace(/\.md$/i, "") : file;
+    if (change.before === undefined || change.after === undefined) {
+        return [{ file, name, ...(change.before === undefined ? { added: true } : { gone: true }) }];
+    }
+    try {
+        if (page) {
+            const [then, now] = [splitPageFile(change.before), splitPageFile(change.after)];
+            const fields = fieldChanges(readFields(then.frontmatter, file), readFields(now.frontmatter, file));
+            const text = then.body !== now.body;
+            return fields.length === 0 && !text ? [] : [{ file, name, ...(fields.length === 0 ? {} : { fields }), ...(text ? { text } : {}) }];
+        }
+        if (file === campaignFileName || file === "state.yaml") {
+            const fields = fieldChanges(keysOf(change.before), keysOf(change.after));
+            return fields.length === 0 ? [] : [{ file, name, fields }];
+        }
+    }
+    catch {
+        // A file that no longer reads: named, and validate says how to fix it.
+        return [{ file, name, unread: true }];
+    }
+    return [{ file, name, text: true }];
+}
+function keysOf(text) {
+    const values = parse(text) ?? {};
+    return typeof values === "object" && values !== null && !Array.isArray(values) ? values : {};
+}
+/** The fields whose value differs, in the order the page has them now, then those gone. */
+function fieldChanges(before, after) {
+    const names = [...new Set([...Object.keys(after), ...Object.keys(before)])];
+    return names.filter((name) => JSON.stringify(before[name]) !== JSON.stringify(after[name])).map((name) => [name, before[name], after[name]]);
+}
+/** "Kira: hp 7 → 12, and its text", "new: Cortile", "gone: Bran". */
+function itemText(item) {
+    if (item.added === true || item.gone === true) {
+        return `${item.added === true ? "new" : "gone"}: ${item.name}`;
+    }
+    if (item.unread === true) {
+        return `${item.name}: changed, and it no longer reads (validate says how to fix it)`;
+    }
+    const fields = (item.fields ?? []).map(([name, before, after]) => `${name} ${valueText(before)} → ${valueText(after)}`);
+    return `${item.name}: ${[...fields, ...(item.text === true ? [fields.length === 0 ? "its text" : "and its text"] : [])].join(", ")}`;
+}
+/** A value as the master reads it, short: a list's items, none as a dash. */
+function valueText(value) {
+    const text = value === undefined || value === null
+        ? "—"
+        : Array.isArray(value)
+            ? value.map(String).join(", ")
+            : typeof value === "object"
+                ? JSON.stringify(value)
+                : String(value);
+    return text.length > 40 ? `${text.slice(0, 39)}…` : text;
+}
+function logged(item) {
+    return {
+        file: item.file,
+        ...(item.fields === undefined ? {} : { fields: Object.fromEntries(item.fields.map(([name, before, after]) => [name, [before ?? null, after ?? null]])) }),
+        ...(item.text === true ? { text: true } : {}),
+        ...(item.added === true ? { added: true } : {}),
+        ...(item.gone === true ? { gone: true } : {}),
+        ...(item.unread === true ? { unread: true } : {}),
+    };
+}
+/** The planned events the changes set off, fired as after a command (OUT-3, EVT-4); none without the world before them, or with a world that does not read. */
+function dueAfter(root, context, before) {
+    if (before === undefined) {
+        return [];
+    }
+    try {
+        const note = nowDueNote(fireEvents(root, context, before, campaignWorld(root, context), readPresent(root).date).due);
+        return note === "" ? [] : [note];
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,52 @@
+import type { Problem } from "../core/problem.ts";
+import { type Page, type Position, type World } from "../pages/index.ts";
+import { type Measures } from "./game-roads.ts";
+/** A region (POS-6): a place with a position and a radius, which covers the circle. */
+export interface Region {
+    page: Page;
+    centre: Position;
+    radius: number;
+}
+/** How to write a relation, for messages. */
+export declare const relationHelp = "a distance, a direction and a place with a position, such as 12 km NE of [[Guadoscuro]]";
+/**
+ * Where a page is on the map (POS-4): the first of its chain, itself first, with a position: its own; for a stop, on the line between the nearest stops of its
+ * road that have one, by the lengths; undefined when none has one. A character or an item is where the place that holds it is.
+ */
+export declare function positionOf(world: World, page: Page): Position | undefined;
+/** A place's own position, or the one its roads give it, rather than its container's: the places that show on the map. */
+export declare function placedPosition(world: World, page: Page): Position | undefined;
+/**
+ * The position a write gives a place (POS-2): written as the engine writes it, or as relations, whose points are averaged, with the largest distance between
+ * them. When no place with the same coordinates has a position yet, the one a relation starts from becomes the centre of its map: `origin`, to write too. The
+ * places it is given from share their coordinates, and those of the place written when something already holds it (POS-8); a place nothing holds yet takes
+ * them, and `map` names the map to put it in. Refused with the fix otherwise.
+ */
+export declare function positionFromWrite(world: World, value: unknown, name: string): {
+    position: Position;
+    spread: number;
+    origin?: Page;
+    map?: Page;
+};
+/** The regions of the world (POS-6): places of the campaign with a radius and a position, their own or one their roads give them. */
+export declare function regionsOf(world: World): Region[];
+/** The smallest region of a map, by its key (POS-8), that covers a point (POS-6); undefined when none does. */
+export declare function regionAt(world: World, point: Position, map?: string): Region | undefined;
+/**
+ * The places near a point (TRV-13): those with a position of their own or from their roads within 3 km, nearest first, at most 5, or else the nearest one; each
+ * as "Torre Mozza, 2.1 km north-east". Regions and roads are left out.
+ */
+export declare function nearPlaces(world: World, point: Position, measures: Measures, map?: string, except?: Page[]): string[];
+/** "12 km west of Guadoscuro": a point of a map told from its nearest place with a position, or that place's name at it; its position when there is none. */
+export declare function pointText(world: World, point: Position, measures: Measures, map?: string): string;
+/** "2.1 km north-east", from a point to another; "here" closer than 50 m. */
+export declare function relationText(from: Position, to: Position, measures: Measures): string;
+/**
+ * What write says when a place first comes on the map without a kind, a region apart, or becomes a region without a biome (POS-7): the names the map draws. `before`
+ * is the world before the write, `existing` the page as it was there.
+ */
+export declare function mapLookNotes(before: World, existing: Page | undefined, after: World, page: Page): string[];
+/** The roads shorter than the straight line between two of their stops that have a position of their own (POS-5): a length or a position is wrong. */
+export declare function shortRoadProblems(world: World): Problem[];
+/** What write says of the roads a place's position or a road's stops make shorter than the straight line (POS-5): those of the page, or with it as a stop. */
+export declare function shortRoadNotes(world: World, page: Page): string[];