rpg-engine 0.0.0-stage → 0.1.1

package/dist/commands/game-journey.js

@@ -0,0 +1,163 @@
+// A journey under way (D-258, TRV-8, TRV-9, TRV-12), kept in state.yaml under journey: what travels, where to or which way, where it stopped (on a road, or at
+// a point in the open), the pace, the hours travelled since the last rest.
+import { changeStateAt, readStateValues } from "../campaign/index.js";
+import { readLength } from "../core/length.js";
+import { comparableText } from "../core/text.js";
+import { pointAlong } from "../map/index.js";
+import { formatPosition, isEmptyField, locate, pagesWithName, parsePageReference, readPosition } from "../pages/index.js";
+import { formatDuration, formatGameDate, minutesBetween, readDuration, readGameDate } from "../time/index.js";
+import { mapOf } from "./game-maps.js";
+import { pointText, positionOf, regionAt } from "./game-positions.js";
+import { hoursText, lengthText } from "./game-roads.js";
+/** How long a stop must last for the hours of travel to start again (TRV-8): a night's rest. */
+export const restMinutes = 8 * 60;
+/** The journey in state.yaml; none when there is none, or it does not read: then the next travel starts afresh. */
+export function readJourney(root) {
+    let value;
+    try {
+        value = readStateValues(root).journey;
+    }
+    catch {
+        // A state.yaml that does not read is reported by validate (TIM-1); without a journey, travel starts afresh.
+        return undefined;
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const fields = value;
+    const name = (field) => (typeof field === "string" && !isEmptyField(field) ? parsePageReference(field).name : undefined);
+    const text = (field) => (typeof field === "string" && !isEmptyField(field) ? field.trim() : undefined);
+    const movers = (Array.isArray(fields.who) ? fields.who : []).map(name).filter((mover) => mover !== undefined);
+    const last = readGameDate(fields.last);
+    const travelled = typeof fields.travelled === "string" ? readDuration(fields.travelled) : undefined;
+    const hours = typeof fields.hours === "number" && fields.hours > 0 ? fields.hours : undefined;
+    if (movers.length === 0 || last === undefined || travelled === undefined) {
+        return undefined;
+    }
+    const [road, from, toward, index] = [name(fields.road), name(fields.from), name(fields.toward), Number(fields.stretch) - 1];
+    const on = road === undefined || from === undefined || toward === undefined ? undefined : { road, index: Number.isInteger(index) ? index : -1, from, toward, done: readLength(fields.done) ?? 0 };
+    const at = readPosition(fields.at);
+    return { movers, to: name(fields.to), heading: text(fields.heading), left: readLength(fields.left), on, at, map: name(fields.map), pace: text(fields.pace), last, travelled, hours };
+}
+/** Writes the journey in state.yaml, or removes it. */
+export function saveJourney(root, journey) {
+    const link = (name) => `[[${name}]]`;
+    const value = journey === undefined ? undefined : {
+        who: journey.movers.map(link),
+        ...(journey.to === undefined ? {} : { to: link(journey.to) }),
+        ...(journey.heading === undefined ? {} : { heading: journey.heading }),
+        ...(journey.left === undefined ? {} : { left: `${Math.round(journey.left)} m` }),
+        ...(journey.on === undefined ? {} : {
+            road: link(journey.on.road),
+            stretch: journey.on.index + 1,
+            from: link(journey.on.from),
+            toward: link(journey.on.toward),
+            done: `${Math.round(journey.on.done)} m`,
+        }),
+        ...(journey.at === undefined ? {} : { at: formatPosition(journey.at) }),
+        ...(journey.map === undefined ? {} : { map: link(journey.map) }),
+        ...(journey.pace === undefined ? {} : { pace: journey.pace }),
+        last: formatGameDate(journey.last),
+        travelled: formatDuration(journey.travelled) || "0m",
+        ...(journey.hours === undefined ? {} : { hours: journey.hours }),
+    };
+    changeStateAt(root, [[["journey"], value]]);
+}
+/** The minutes travelled since the last rest (TRV-8): none once the movers have stopped for a night's rest since the last travel. */
+export function travelledSinceRest(journey, now) {
+    return journey === undefined || minutesBetween(journey.last, now) >= restMinutes ? 0 : journey.travelled;
+}
+/** Whether a journey is made by these movers, the same ones. */
+export function sameMovers(journey, movers) {
+    const names = new Set(movers.map((page) => comparableText(page.name)));
+    return journey.movers.length === names.size && journey.movers.every((name) => names.has(comparableText(name)));
+}
+/** The movers of a journey as pages, those that still exist. */
+export function moversNamed(world, journey) {
+    return journey.movers.map((name) => pagesWithName(world, name)[0]).filter((page) => page !== undefined);
+}
+/** Where on its road a journey stopped (TRV-9), as a start: when its movers are all still right in the road; undefined otherwise. */
+export function journeyStart(world, roads, journey, movers) {
+    const on = journey.on;
+    const road = on === undefined ? undefined : pagesWithName(world, on.road)[0];
+    if (on === undefined || road === undefined || !sameMovers(journey, movers) || !movers.every((page) => locate(world, page).chain[0] === road)) {
+        return undefined;
+    }
+    const same = (first, second) => comparableText(first) === comparableText(second);
+    const joins = (candidate) => (same(candidate.from, on.from) && same(candidate.to, on.toward)) || (same(candidate.from, on.toward) && same(candidate.to, on.from));
+    // The stretch by its place in the road, so that a road through the same two stops twice finds the right one; by its ends when written by hand.
+    const stretch = roads.stretches.find((candidate) => candidate.road === road.name && candidate.index === on.index && joins(candidate))
+        ?? roads.stretches.find((candidate) => candidate.road === road.name && joins(candidate));
+    if (stretch === undefined) {
+        return undefined;
+    }
+    const done = Math.min(Math.max(on.done, 0), stretch.length);
+    return { stretch, done: same(stretch.from, on.from) ? done : stretch.length - done };
+}
+/** The map the movers are on (POS-8): that of the place they are in; in the open, the one their journey stopped on. Undefined for the main map. */
+export function moversMap(world, journey, movers) {
+    const mover = movers[0];
+    if (mover !== undefined && locate(world, mover).chain.length > 0) {
+        return mapOf(world, mover).root;
+    }
+    return journey?.map === undefined ? undefined : pagesWithName(world, journey.map)[0];
+}
+/**
+ * Where in the open a journey stopped (TRV-12), when its movers are still there: in the smallest region that covers the point, or in no place when none does;
+ * undefined otherwise.
+ */
+export function journeyPoint(world, journey, movers) {
+    const holder = movers[0] === undefined ? undefined : locate(world, movers[0]).chain[0];
+    if (journey.at === undefined || !sameMovers(journey, movers) || !movers.every((page) => locate(world, page).chain[0] === holder)) {
+        return undefined;
+    }
+    return regionAt(world, journey.at, moversMap(world, journey, movers)?.path)?.page === holder ? journey.at : undefined;
+}
+/**
+ * Where the movers are on the map (TRV-12): the point in the open their journey stopped at; on its road, the point between the stretch's stops when both have
+ * a position; else the position of the place they are in. Undefined when none gives one.
+ */
+export function moversPosition(world, roads, journey, movers) {
+    const open = journey === undefined ? undefined : journeyPoint(world, journey, movers);
+    const start = journey === undefined ? undefined : journeyStart(world, roads, journey, movers);
+    if (open !== undefined) {
+        return open;
+    }
+    if (start !== undefined && "stretch" in start) {
+        const [from, to] = [pagesWithName(world, start.stretch.from)[0], pagesWithName(world, start.stretch.to)[0]];
+        const [fromAt, toAt] = [from === undefined ? undefined : positionOf(world, from), to === undefined ? undefined : positionOf(world, to)];
+        return fromAt === undefined || toAt === undefined ? undefined : pointAlong(fromAt, toAt, start.done / start.stretch.length);
+    }
+    return movers[0] === undefined ? undefined : positionOf(world, movers[0]);
+}
+/**
+ * The journey under way as status says it (TRV-10): "to Capitale, on Via del Re, 36 km past Rocca, toward Capitale; 8h of travel on day 4. To go on: travel to
+ * Capitale". Undefined when there is none, it arrived, or its movers left where it stopped.
+ */
+export function journeyText(world, roads, journey, measures) {
+    if (journey === undefined) {
+        return undefined;
+    }
+    const movers = moversNamed(world, journey);
+    const stopped = journey.at === undefined ? undefined : journeyPoint(world, journey, movers);
+    const map = moversMap(world, journey, movers)?.path;
+    // Arrived at a point in the open, with nowhere more to go: where they are (TRV-13).
+    if (journey.to === undefined && journey.heading === undefined) {
+        const region = stopped === undefined ? undefined : regionAt(world, stopped, map)?.page.name;
+        return stopped === undefined ? undefined : `stopped ${region === undefined ? "in the open" : `in ${region}`}, ${pointText(world, stopped, measures, map)}.`;
+    }
+    const onRoad = journey.on === undefined ? undefined : journeyStart(world, roads, journey, movers);
+    const open = journey.at === undefined ? undefined : journeyPoint(world, journey, movers);
+    if ((journey.on !== undefined && onRoad === undefined) || (journey.at !== undefined && open === undefined)) {
+        return undefined;
+    }
+    const goal = journey.to === undefined ? `${journey.heading}${journey.left === undefined ? "" : ` for ${lengthText(journey.left, measures)} more`}` : `to ${journey.to}`;
+    const region = open === undefined ? undefined : regionAt(world, open, map)?.page.name;
+    const where = journey.on !== undefined
+        ? `, on ${journey.on.road}, ${lengthText(journey.on.done, measures)} past ${journey.on.from}, toward ${journey.on.toward}`
+        : open !== undefined
+            ? `, ${region === undefined ? "in the open" : `in ${region}`}, ${pointText(world, open, measures, map)}`
+            : "";
+    const call = journey.to === undefined ? `travel toward ${journey.heading}` : `travel to ${journey.to}${journey.at === undefined ? "" : ", across"}`;
+    return `${goal}${where}; ${hoursText(journey.travelled)} of travel since the last rest. To go on: ${call}.`;
+}

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

@@ -0,0 +1,32 @@
+import { type Page, type World } from "../pages/index.ts";
+/** What the player character knows: the pages, and the secrets by the page that writes them. */
+export interface Knowledge {
+    pc: Page;
+    pages: Set<Page>;
+    /** "coppa#veleno": the secrets it discovered, by the page that writes them and their name, as comparable text. */
+    secrets: Set<string>;
+}
+/** The player character: the first living character with role pc, else the first dead one; undefined before there is one. */
+export declare function playerCharacter(world: World): Page | undefined;
+/**
+ * What the player character knows (D-250): what its knows lists, pages and the pages of its secrets; itself, the companions, and the creatures both derive
+ * from (D-275, D-277), what it carries, the places around
+ * it, the characters and places of the scenes it was in, and the places it was moved from and to, with those that hold them (D-316); the pages of the game system but its creatures, which anyone may read (SYS-2). Never a creature
+ * of the campaign it was not told of.
+ */
+export declare function knowledgeOf(root: string, world: World, pc: Page): Knowledge;
+/** Whether the player character knows a page: one of the campaign it knows, or one of the game system but a creature (D-250). */
+export declare function knowsPage(knowledge: Knowledge, page: Page): boolean;
+/**
+ * A page's text as the player character knows it (VIEW-3): its introduction, or that of its nearest base it knows; its sections and those it shows from the bases
+ * it knows (INH-13), never a creature's (D-254); of the secrets, only those discovered, recorded by the page that writes them (REV-2), from any base. A secret
+ * without a name is never known; comments are left out (LNK-2).
+ */
+export declare function knownText(world: World, knowledge: Knowledge, page: Page): string;
+/** The player character's story as the player sees it on the dashboard (D-373): the opening text of its page, without its secrets and comments, the master's. */
+export declare function playerStory(page: Page): string;
+/**
+ * The section or secret of a page the player character knows by this name (VIEW-3): a section whole, with its subsections and the secrets in it it discovered;
+ * from a base, only one it knows, or a secret it discovered. Undefined when it knows none.
+ */
+export declare function knownPart(world: World, knowledge: Knowledge, page: Page, name: string): string | undefined;

package/dist/commands/game-knowledge.js

@@ -0,0 +1,120 @@
+// What the player character knows, as the player's view reads it (D-250, VIEW-2, VIEW-3): the pages it knows and the text of each as it knows it.
+import { readLog } from "../core/log.js";
+import { comparableText } from "../core/text.js";
+import { baseChain, inheritedByBase, introductionText, links, locate, pagesWithNameOrAlias, parsePageReference, readSection, textParts, textsIn, withoutComments } from "../pages/index.js";
+import { readOpenScene } from "./game-scene.js";
+/** The player character: the first living character with role pc, else the first dead one; undefined before there is one. */
+export function playerCharacter(world) {
+    const players = world.pages.filter((page) => page.type === "character" && page.fields.role === "pc");
+    return players.find((page) => page.fields.status !== "dead") ?? players[0];
+}
+/**
+ * What the player character knows (D-250): what its knows lists, pages and the pages of its secrets; itself, the companions, and the creatures both derive
+ * from (D-275, D-277), what it carries, the places around
+ * it, the characters and places of the scenes it was in, and the places it was moved from and to, with those that hold them (D-316); the pages of the game system but its creatures, which anyone may read (SYS-2). Never a creature
+ * of the campaign it was not told of.
+ */
+export function knowledgeOf(root, world, pc) {
+    // A name the log or knows keeps finds a renamed page by its old name, among its aliases (D-417).
+    const named = (name) => pagesWithNameOrAlias(world, parsePageReference(name).name).slice(0, 1);
+    // A link in knows, to a page or to one of its secrets, read with its secret (REV-1).
+    const known = textsIn(pc.fields.knows).flatMap(links);
+    const secrets = new Set(known.filter((link) => link.section !== undefined).map((link) => secretKey(link.page, link.section ?? "")));
+    const pages = new Set([
+        pc,
+        // A secret discovered makes its page known, but a creature's: the secret is known, the creature's numbers stay the master's (D-254).
+        ...known.flatMap((link) => named(link.page).filter((page) => link.section === undefined || page.type !== "creature")),
+        // The party, and the creatures its members derive from: the player knows a companion's stat block and the race of the character (D-275, D-277).
+        ...[pc, ...world.pages.filter((page) => page.type === "character" && page.fields.role === "companion")].flatMap((page) => [
+            page,
+            ...baseChain(world, page).filter((base) => base.type === "creature"),
+        ]),
+        // The quests the player took (D-250).
+        ...world.pages.filter((page) => page.type === "quest" && ["open", "done", "failed"].includes(String(page.fields.status))),
+        ...world.pages.filter((page) => page !== pc && locate(world, page).chain.includes(pc)),
+        ...locate(world, pc).chain,
+        // The places it was in, and those that hold them, as the regions it crossed (D-316).
+        ...livedOf(root, world, pc).flatMap((page) => (page.type === "place" ? [page, ...locate(world, page).chain] : page.type === "character" ? [page] : [])),
+    ]);
+    return { pc, pages, secrets };
+}
+/** Whether the player character knows a page: one of the campaign it knows, or one of the game system but a creature (D-250). */
+export function knowsPage(knowledge, page) {
+    return knowledge.pages.has(page) || (page.system !== undefined && page.type !== "creature");
+}
+/**
+ * A page's text as the player character knows it (VIEW-3): its introduction, or that of its nearest base it knows; its sections and those it shows from the bases
+ * it knows (INH-13), never a creature's (D-254); of the secrets, only those discovered, recorded by the page that writes them (REV-2), from any base. A secret
+ * without a name is never known; comments are left out (LNK-2).
+ */
+export function knownText(world, knowledge, page) {
+    const parts = [
+        ...partsOf(page),
+        ...inheritedByBase(world, page).flatMap((group) => group.parts.map((part) => ({ ...part, holder: group.base }))),
+    ].filter((part) => isShown(knowledge, page, part));
+    const introduction = introductionText(page.body) || (baseChain(world, page).filter((base) => knowsPage(knowledge, base)).map((base) => introductionText(base.body)).find((text) => text !== "") ?? "");
+    return withoutComments([introduction, ...parts.map((part) => part.text)].filter((text) => text !== "").join("\n\n"));
+}
+/** The player character's story as the player sees it on the dashboard (D-373): the opening text of its page, without its secrets and comments, the master's. */
+export function playerStory(page) {
+    return withoutComments(introductionText(page.body));
+}
+/**
+ * The section or secret of a page the player character knows by this name (VIEW-3): a section whole, with its subsections and the secrets in it it discovered;
+ * from a base, only one it knows, or a secret it discovered. Undefined when it knows none.
+ */
+export function knownPart(world, knowledge, page, name) {
+    const wanted = comparableText(name.trim());
+    for (const holder of [page, ...baseChain(world, page)]) {
+        const part = partsOf(holder).find((candidate) => comparableText(candidate.name) === wanted);
+        if (part === undefined) {
+            continue;
+        }
+        if (!isShown(knowledge, page, part)) {
+            return undefined;
+        }
+        const whole = isSecretText(part.text) ? part.text : (readSection(holder.body, part.name) ?? part.text);
+        const kept = isSecretText(part.text) ? [part] : partsOf({ ...holder, body: whole }).map((inner) => ({ ...inner, holder })).filter((inner) => isShown(knowledge, page, inner));
+        return withoutComments(kept.map((inner) => inner.text).join("\n\n"));
+    }
+    return undefined;
+}
+/** Whether a part shows to the player character: a secret it discovered, or a section of the page or of a base it knows (D-254). */
+function isShown(knowledge, page, part) {
+    return isSecretText(part.text) ? knowledge.secrets.has(secretKey(part.holder.name, part.name)) : part.holder === page || knowsPage(knowledge, part.holder);
+}
+/** The sections and secrets of a page's own text, each with the page. */
+function partsOf(page) {
+    return textParts(page.body).map((part) => ({ ...part, holder: page }));
+}
+function isSecretText(text) {
+    return /^[ \t]{0,3}>[ \t]*\[!secret\]/i.test(text);
+}
+function secretKey(page, secret) {
+    return `${comparableText(page)}#${comparableText(secret)}`;
+}
+/**
+ * The pages of what the player character lived, as the log keeps it: the characters and places of the scenes it was in, those closed and the open one, and where
+ * it was moved from and to; never one the master gave only by what the character sees of them, in any scene (D-416, VIEW-2).
+ */
+function livedOf(root, world, pc) {
+    const pageOf = (name) => pagesWithNameOrAlias(world, parsePageReference(name).name)[0];
+    const isPc = (name) => pageOf(name) === pc;
+    const log = readLog(root);
+    const closed = log.filter((entry) => entry.type === "scene-closed").map((entry) => entry.data);
+    const { scene } = readOpenScene(root);
+    const scenes = [...closed, ...(scene === undefined ? [] : [{ place: scene.place, with: scene.with, left: scene.left, unnamed: Object.keys(scene.seen ?? {}) }])];
+    const unnamed = new Set(scenes.flatMap((one) => textList(one.unnamed).flatMap((name) => pageOf(name) ?? [])));
+    const met = scenes.flatMap((one) => {
+        const people = [...textList(one.with), ...textList(one.left)];
+        return people.some(isPc) ? [...people, ...textList(one.place)] : [];
+    });
+    const moved = log.filter((entry) => entry.type === "moved" && textList(entry.data.pages).some(isPc)).flatMap((entry) => {
+        const from = entry.data.from !== null && typeof entry.data.from === "object" ? Object.entries(entry.data.from).filter(([name]) => isPc(name)).map(([, holder]) => holder) : [];
+        return [...textList(from), ...textList(entry.data.to)];
+    });
+    return [...met, ...moved].flatMap((name) => pageOf(name) ?? []).filter((page) => !unnamed.has(page));
+}
+function textList(value) {
+    return (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string");
+}

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

@@ -0,0 +1,20 @@
+import type { Problem } from "../core/problem.ts";
+import { type Page, type World } from "../pages/index.ts";
+/** A map: the place that holds it, none for the main map; the key of its coordinates; and, when it shares another map's, how and with which place's map. */
+export interface PlaceMap {
+    root?: Page;
+    /** The root whose coordinates the map uses, by its file; "" for the main map's. */
+    frame: string;
+    aligned?: {
+        how: "under" | "mirror";
+        of: Page;
+    };
+}
+/** The map a page is on (POS-8): that of the nearest place of its chain, itself first, that holds one; else the main map. */
+export declare function mapOf(world: World, page: Page): PlaceMap;
+/** Which map a page is on, as a key: the file of the place that holds it, "" for the main map. Regions, terrain and the places near hold on one map (POS-6). */
+export declare function mapKey(world: World, page: Page): string;
+/** Whether two pages share their coordinates (POS-2, POS-4): positions are given and stops placed between them. */
+export declare function sameFrame(world: World, first: Page, second: Page): boolean;
+/** The places whose map field does not read, or names a place that is not there (POS-8). */
+export declare function mapProblems(world: World): Problem[];

package/dist/commands/game-maps.js

@@ -0,0 +1,51 @@
+import { locate, pagesWithName, readMapField } from "../pages/index.js";
+/** The map a page is on (POS-8): that of the nearest place of its chain, itself first, that holds one; else the main map. */
+export function mapOf(world, page) {
+    let byPage = known.get(world);
+    if (byPage === undefined) {
+        byPage = new Map();
+        known.set(world, byPage);
+    }
+    let map = byPage.get(page.path);
+    if (map === undefined) {
+        const root = rootOf(world, page);
+        map = root === undefined ? { frame: "" } : rootMap(world, root, new Set());
+        byPage.set(page.path, map);
+    }
+    return map;
+}
+/** Which map a page is on, as a key: the file of the place that holds it, "" for the main map. Regions, terrain and the places near hold on one map (POS-6). */
+export function mapKey(world, page) {
+    return mapOf(world, page).root?.path ?? "";
+}
+/** Whether two pages share their coordinates (POS-2, POS-4): positions are given and stops placed between them. */
+export function sameFrame(world, first, second) {
+    return mapOf(world, first).frame === mapOf(world, second).frame;
+}
+/** The places whose map field does not read, or names a place that is not there (POS-8). */
+export function mapProblems(world) {
+    return world.pages.filter((page) => page.type === "place" && page.system === undefined && page.fields.map !== undefined).flatMap((page) => {
+        const field = readMapField(page.fields.map);
+        if (field === undefined || field.how === "own" || pagesWithName(world, field.of)[0]?.type === "place") {
+            return [];
+        }
+        return [{ path: page.path, message: `${page.name}'s map is ${field.how === "under" ? "under" : "the mirror of"} ${field.of}, which is no place.`, fix: `write ${page.name}, set map to own, or name a place of the map it shares` }];
+    });
+}
+const known = new WeakMap();
+/** The nearest place of a page's chain, itself first, that holds a map. */
+function rootOf(world, page) {
+    return [page, ...locate(world, page).chain].find((holder) => holder.type === "place" && holder.system === undefined && readMapField(holder.fields.map) !== undefined);
+}
+/** The map a place holds: its own coordinates, or those of the map of the place it is under or mirrors; a broken or circular alignment keeps its own. */
+function rootMap(world, root, seen) {
+    const field = readMapField(root.fields.map);
+    const of = field === undefined || field.how === "own" ? undefined : pagesWithName(world, field.of)[0];
+    if (field === undefined || field.how === "own" || of === undefined || seen.has(root.path)) {
+        return { root, frame: root.path };
+    }
+    seen.add(root.path);
+    const target = rootOf(world, of);
+    const frame = target === undefined ? "" : target === root ? root.path : rootMap(world, target, seen).frame;
+    return { root, frame, aligned: { how: field.how, of } };
+}

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

@@ -0,0 +1,31 @@
+import type { Context } from "../core/context.ts";
+import type { Problem } from "../core/problem.ts";
+import { type World } from "../pages/index.ts";
+import type { GameSystem } from "../systems/index.ts";
+/** The modes, in their order (D-75, D-77). */
+export declare const modes: readonly ["setup", "session zero", "play"];
+export type Mode = (typeof modes)[number];
+/** What a mode lacks before the campaign may leave it: the mode whose checklist is not complete, and its items. */
+export interface Blocked {
+    mode: Mode;
+    missing: string[];
+}
+/**
+ * The mode the campaign is in: the one state.yaml keeps; for a campaign made before modes, or one whose mode is written wrongly, play once it has had a scene,
+ * session zero once it has a player character, setup before (MOD-1).
+ */
+export declare function campaignMode(root: string, world: World): Mode;
+/** A mode written by hand in state.yaml that is no mode: it counts as none (MOD-1), and validate says how to fix it. */
+export declare function modeProblems(root: string): Problem[];
+/** The first checklist the campaign must complete before entering `mode`: the setup's, then session zero's; undefined when nothing stops it (MOD-2). */
+export declare function blockingMode(mode: Mode, root: string, context: Context, world: World): Blocked | undefined;
+/** "still to agree with the player: lethality (…); set each with config", or what session zero still has to make: what a checklist lacks, as outputs say it. */
+export declare function missingText(blocked: Blocked): string;
+/** What the campaign still needs, as init, config and status say it: before play, the checklist and the call that moves on; in play, the settings still missing (MOD-7). */
+export declare function campaignNote(root: string, context: Context): string;
+/** Before play, what the next mode still needs and the call that enters it once the player confirms (MOD-7); undefined in play. */
+export declare function checklistLine(mode: Mode, root: string, context: Context, world: World): string | undefined;
+/** The call that enters a mode, as outputs give it: mode, to "session zero". */
+export declare function modeCall(mode: Mode): string;
+/** The part of the instructions of a mode, the core's with the system's (MOD-5): the file setup, session-zero or play. */
+export declare function modePart(mode: Mode, system: GameSystem | undefined): string | undefined;

package/dist/commands/game-mode.js

@@ -0,0 +1,128 @@
+// The mode of the campaign, the main state of the game (D-77): setup, session zero or play, each opened by the checklist of the one before (D-221, D-241; MOD-1–MOD-7).
+import { basename } from "node:path";
+import { companionWays, diceWays, difficulties, lethalities, missingSettings, preparations, readSettings, readStateValues, rigors, saveModes, unansweredSettings, unitSystems } from "../campaign/index.js";
+import { readLog } from "../core/log.js";
+import { comparableText } from "../core/text.js";
+import { isInParty } from "../pages/index.js";
+import { campaignSystem, campaignWorld, missingWithSystems } from "./game-world.js";
+import { missingSettingsNote } from "./notes.js";
+import { partText } from "./parts.js";
+import { missingSheetFields } from "./sheet.js";
+/** The modes, in their order (D-75, D-77). */
+export const modes = ["setup", "session zero", "play"];
+// The settings the setup asks, with the values they take, so that the master offers them as they are (MOD-3).
+const settingLabels = {
+    language: "language (a code, such as it)",
+    mentor: "mentor (ask how well the player knows the game: never played, tutorial; a little, hints; well, off)",
+    premise: "premise (the genre, the tone and a few elements of the world, in the player's words)",
+    preparation: `preparation (${preparations.join(", ")})`,
+    difficulty: `difficulty (${difficulties.join(", ")})`,
+    lethality: `lethality (${lethalities.join(", ")})`,
+    saves: `saves (${saveModes.join(", ")})`,
+    rigor: `rigor (${rigors.join(", ")})`,
+    dice: `dice (${diceWays.join(", ")})`,
+    units: `units (${unitSystems.join(", ")})`,
+    companions: `companions (${companionWays.join(", ")})`,
+    lines: 'lines ("none" is an answer)',
+    veils: 'veils ("none" is an answer)',
+};
+/**
+ * The mode the campaign is in: the one state.yaml keeps; for a campaign made before modes, or one whose mode is written wrongly, play once it has had a scene,
+ * session zero once it has a player character, setup before (MOD-1).
+ */
+export function campaignMode(root, world) {
+    const written = writtenMode(root);
+    const known = modes.find((mode) => typeof written === "string" && comparableText(mode) === comparableText(written));
+    if (known !== undefined) {
+        return known;
+    }
+    if (readLog(root).some((entry) => entry.type === "scene-opened")) {
+        return "play";
+    }
+    return world.pages.some((page) => page.type === "character" && page.fields.role === "pc") ? "session zero" : "setup";
+}
+/** A mode written by hand in state.yaml that is no mode: it counts as none (MOD-1), and validate says how to fix it. */
+export function modeProblems(root) {
+    const written = writtenMode(root);
+    const known = typeof written === "string" && modes.some((mode) => comparableText(mode) === comparableText(written));
+    if (written === undefined || written === null || known) {
+        return [];
+    }
+    return [{ path: "state.yaml", message: `The mode in state.yaml, "${String(written)}", is not a mode: ${modes.join(", ")}.`, fix: "call mode with the one the campaign is in" }];
+}
+/** The first checklist the campaign must complete before entering `mode`: the setup's, then session zero's; undefined when nothing stops it (MOD-2). */
+export function blockingMode(mode, root, context, world) {
+    if (mode === "setup") {
+        return undefined;
+    }
+    const setup = setupMissing(root, context, world);
+    if (setup.length > 0) {
+        return { mode: "setup", missing: setup };
+    }
+    const zero = mode === "play" ? sessionZeroMissing(root, context, world) : [];
+    return zero.length > 0 ? { mode: "session zero", missing: zero } : undefined;
+}
+/** "still to agree with the player: lethality (…); set each with config", or what session zero still has to make: what a checklist lacks, as outputs say it. */
+export function missingText(blocked) {
+    return blocked.mode === "setup"
+        ? `still to agree with the player: ${blocked.missing.join(", ")}; set each with config`
+        : `still to make with the player: ${blocked.missing.join("; ")}`;
+}
+/** What the campaign still needs, as init, config and status say it: before play, the checklist and the call that moves on; in play, the settings still missing (MOD-7). */
+export function campaignNote(root, context) {
+    const world = campaignWorld(root, context);
+    return checklistLine(campaignMode(root, world), root, context, world) ?? missingSettingsNote(missingWithSystems(root, missingSettings(readSettings(root)), context));
+}
+/** Before play, what the next mode still needs and the call that enters it once the player confirms (MOD-7); undefined in play. */
+export function checklistLine(mode, root, context, world) {
+    if (mode === "play") {
+        return undefined;
+    }
+    const next = mode === "setup" ? "session zero" : "play";
+    const blocked = blockingMode(next, root, context, world);
+    const missing = blocked === undefined ? "nothing is missing" : missingText(blocked);
+    const settings = readSettings(root);
+    const unnamed = mode === "setup" && settings.premise !== undefined && comparableText(settings.name) === comparableText(basename(root));
+    const name = unnamed ? ` The campaign is still named after its folder, ${settings.name}: propose a name that fits the premise, and set it with config name once the player likes it.` : "";
+    // With the dashboard open, the setup's closed choices are made there, one at a time (D-370).
+    const page = mode === "setup" && context.dashboard !== undefined
+        ? " The player can make the setup's choices on the dashboard, one at a time: offer it, and meanwhile ask in the chat only the premise and the language. "
+            + "Ask the rest only when they leave it to you, or once they say they are ready."
+        : "";
+    return `${missing.charAt(0).toUpperCase()}${missing.slice(1)}. When ${blocked === undefined ? "" : "none is left and "}the player confirms: ${modeCall(next)}.${name}${page}`;
+}
+/** The call that enters a mode, as outputs give it: mode, to "session zero". */
+export function modeCall(mode) {
+    return `mode, to ${mode.includes(" ") ? `"${mode}"` : mode}`;
+}
+/** The part of the instructions of a mode, the core's with the system's (MOD-5): the file setup, session-zero or play. */
+export function modePart(mode, system) {
+    return partText(mode.replace(" ", "-"), system);
+}
+/** The mode state.yaml writes; undefined when it writes none, or cannot be read, which status and validate say elsewhere: the other commands go on. */
+function writtenMode(root) {
+    try {
+        return readStateValues(root).mode;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** What the setup still has to agree with the player, each setting with the values it takes, the system's own too (MOD-3). */
+function setupMissing(root, context, world) {
+    const unanswered = unansweredSettings(readSettings(root), world.pages.length > 0);
+    return missingWithSystems(root, unanswered, context).map((name) => settingLabels[name] ?? name);
+}
+/** What session zero still has to make (MOD-4): a living player character, the companions the setup said are made in it, and the sheets they keep, whole. */
+function sessionZeroMissing(root, context, world) {
+    const system = campaignSystem(root, context);
+    const players = world.pages.filter((page) => isInParty(page) && page.fields.role === "pc");
+    const companions = world.pages.filter((page) => isInParty(page) && page.fields.role === "companion");
+    const way = readSettings(root).companions;
+    const made = (way === "made with the player" || way === "made by the master") && companions.length === 0;
+    const sheets = [...players, ...companions].flatMap((page) => {
+        const missing = missingSheetFields(system, world, page);
+        return missing.length === 0 ? [] : [`${page.name}'s sheet, which lacks ${missing.join(", ")}`];
+    });
+    return [...(players.length === 0 ? ["a player character"] : []), ...(made ? [`a companion, ${way}`] : []), ...sheets];
+}

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

@@ -0,0 +1,17 @@
+import type { Context } from "../core/context.ts";
+import type { Problem } from "../core/problem.ts";
+import { type Coin } from "../money/index.ts";
+/**
+ * The coins of the campaign, or the problem that keeps campaign.yaml from giving them; neither when the game has no money (MON-1).
+ * They are read on their own, so that a mistake in another setting does not turn every purse into text. A campaign without coins of its own
+ * has those of its game system, if it gives them (DAT-1); `from` names that system.
+ */
+export declare function campaignCoins(root: string, context: Context): {
+    coins?: Coin[];
+    problem?: Problem;
+    from?: string;
+};
+/** The coins as config shows them: "gp/mo 100, pp 1000 rare, sp 10, cp 1", with where they come from when it is the game system, or what is wrong with them. */
+export declare function coinsShown(root: string, context: Context): string;
+/** The problem of the list of coins, for validate (MON-8); a campaign.yaml that cannot be read is reported with the settings. */
+export declare function moneyProblems(root: string, context: Context): Problem[];

package/dist/commands/game-money.js

@@ -0,0 +1,55 @@
+// The coins of a campaign as several commands use them: from campaign.yaml, read on their own, or else from its game system (DAT-1); checked, and shown (D-126–D-129, D-182).
+import { readCoinsSetting } from "../campaign/index.js";
+import { coinList, coinsProblem, coinsText, readCoins } from "../money/index.js";
+import { campaignSystem } from "./game-world.js";
+/**
+ * The coins of the campaign, or the problem that keeps campaign.yaml from giving them; neither when the game has no money (MON-1).
+ * They are read on their own, so that a mistake in another setting does not turn every purse into text. A campaign without coins of its own
+ * has those of its game system, if it gives them (DAT-1); `from` names that system.
+ */
+export function campaignCoins(root, context) {
+    let value;
+    try {
+        value = readCoinsSetting(root);
+    }
+    catch (error) {
+        return { problem: { path: "campaign.yaml", message: error instanceof Error ? error.message : String(error), fix: "fix campaign.yaml by hand" } };
+    }
+    if (value === undefined || value === null) {
+        return systemCoins(root, context);
+    }
+    const problem = coinsProblem(value);
+    // Without coins of its own, the campaign has those of its game system: removing the line is a fix too.
+    const fallback = systemCoins(root, context).from;
+    const remove = fallback === undefined ? "" : `, or remove them from campaign.yaml to have those of the system ${fallback}`;
+    return problem === undefined
+        ? { coins: coinList(value) }
+        : { problem: { path: "campaign.yaml", message: `coins: ${problem}`, fix: `fix the coins in campaign.yaml by hand, or set them again with config, each with its value in the smallest coin${remove}` } };
+}
+/** The coins as config shows them: "gp/mo 100, pp 1000 rare, sp 10, cp 1", with where they come from when it is the game system, or what is wrong with them. */
+export function coinsShown(root, context) {
+    const { coins, problem, from } = campaignCoins(root, context);
+    if (problem !== undefined) {
+        return `cannot be read: ${problem.message}`;
+    }
+    return coins === undefined ? "(none: neither the campaign nor its game system gives coins)" : `${coinsText(coins)}${from === undefined ? "" : ` (from the system ${from})`}`;
+}
+/** The problem of the list of coins, for validate (MON-8); a campaign.yaml that cannot be read is reported with the settings. */
+export function moneyProblems(root, context) {
+    const { problem } = campaignCoins(root, context);
+    return problem === undefined || !problem.message.startsWith("coins:") ? [] : [problem];
+}
+/** The coins of the campaign's game system; none when it gives none, or its list cannot be read (the checks every system passes look after that). */
+function systemCoins(root, context) {
+    const system = campaignSystem(root, context);
+    if (system?.coins === undefined) {
+        return {};
+    }
+    try {
+        const value = typeof system.coins === "string" ? readCoins(system.coins) : system.coins;
+        return coinsProblem(value) === undefined ? { coins: coinList(value), from: system.name } : {};
+    }
+    catch {
+        return {};
+    }
+}