rpg-engine 0.0.0-stage → 0.1.0

package/dist/commands/move.js

@@ -0,0 +1,274 @@
+import { z } from "zod";
+import { requireCampaign } from "../campaign/index.js";
+import { appendLogEntry } from "../core/log.js";
+import { defineCommand } from "../core/registry.js";
+import { closedSquare, featureAt, firstOpenSquare, readSquare, squareName } from "../grid/index.js";
+import { isInParty, locate, pageNamed, pagesWithName, pageTypeNames, parsePageReference, writePage } from "../pages/index.js";
+import { surroundings, surroundingsChange } from "./game-environment.js";
+import { moveFacts } from "./game-grid-moves.js";
+import { atEntries, atEntry, clearCopies, offMapNote, placeGrid, standing } from "./game-grids.js";
+import { picturesNote } from "./game-images.js";
+import { movePages } from "./game-moves.js";
+import { measuresOf, roadsOf, sameSpot, stopOf } from "./game-roads.js";
+import { copyName, readOpenScene, updateScene } from "./game-scene.js";
+import { newDatedLogEntry } from "./game-time.js";
+import { campaignSystem, campaignWorld, missingSystemHint } from "./game-world.js";
+import { shortList, skippedPagesNote } from "./notes.js";
+// A list, or one text, as an MCP client may send it.
+const textList = z.union([z.string(), z.array(z.string())]);
+export const move = defineCommand({
+    name: "move",
+    description: "Move characters, items or places into a place, a character's inventory or an item: whenever someone or something goes somewhere, before you narrate it. "
+        + "Each ends up only there, wherever it was before, and conditions such as party in [[Ossario]] fire. Time does not pass: advance does that. "
+        + "Example: page [Ettore, Lena], to Ossario.",
+    group: "game",
+    positionals: ["page"],
+    input: z.object({
+        page: textList.describe("what moves: one or more characters, items or places, such as [Ettore, Lena]"),
+        to: z.string().optional().describe("where: a place; for characters and items also an item, such as a cart; for items also a character who carries them"),
+        at: z.string().optional().describe("the square one stands on, such as E6: on the map of the place they are in, or with to of the place they go into; for one page or one copy of the open scene"),
+    }),
+    run(input, context) {
+        const root = requireCampaign(context.folder);
+        const world = campaignWorld(root, context);
+        const { scene } = readOpenScene(root);
+        const names = (typeof input.page === "string" ? [input.page] : input.page).filter((name) => name.trim() !== "");
+        if (names.length === 0) {
+            throw new Error("Give what moves, such as page Ettore.");
+        }
+        if (input.at !== undefined) {
+            return moveOnMap(root, context, world, scene, names, input.at, input.to);
+        }
+        if (input.to === undefined) {
+            throw new Error("Give where they go, to, such as to Ossario; or the square of the map they stand on, at, such as E6. Nothing moved.");
+        }
+        return moveInto(root, context, world, scene, names, input.to);
+    },
+    format(result) {
+        const way = result.placed?.distance === undefined ? "" : `, ${result.placed.distance} from ${result.placed.from ?? "where they stood"}`;
+        const placed = result.placed === undefined ? "" : `${result.placed.who}: now on ${result.placed.square} in ${result.placed.place}${way}.`;
+        if (result.moved.length === 0 && result.placed !== undefined) {
+            return [[placed, ...result.notes].filter((line) => line !== "").join("\n"), skippedPagesNote(result.problems)].filter((block) => block !== "").join("\n\n");
+        }
+        if (result.moved.length === 0) {
+            return [`Nothing changed: ${result.already.join(", ")} ${result.already.length === 1 ? "is" : "are"} already in ${result.to}.`, skippedPagesNote(result.problems)].filter((block) => block !== "").join("\n\n");
+        }
+        const already = result.already.length === 0 ? "" : ` Already there: ${result.already.join(", ")}.`;
+        const there = result.there.length === 0 ? "" : ` There: ${shortList(result.there, ", ")}.`;
+        const around = [result.here.length === 0 ? "" : `Here: ${result.here.join(" · ")}.`, result.noLonger.length === 0 ? "" : `No longer: ${result.noLonger.join(" · ")}.`].filter((part) => part !== "").join(" ");
+        const lines = [`Moved ${result.moved.join(", ")}: now in ${result.chain.join(" › ")}.${already}${there}`, placed, around, ...result.notes];
+        return [lines.filter((line) => line !== "").join("\n"), skippedPagesNote(result.problems)].filter((block) => block !== "").join("\n\n");
+    },
+});
+/** Puts one on a square of the map of the place it is right in, as move with at, and what move says of it (ASK-11). */
+export function placeOnMap(root, context, name, square) {
+    const { scene } = readOpenScene(root);
+    return move.format(moveOnMap(root, context, campaignWorld(root, context), scene, [name], square, undefined));
+}
+/** Moves pages into a place, an item or a character (CON-4), and says what changed around them (CON-8, ENV-5). */
+function moveInto(root, context, world, scene, names, to, placing = false) {
+    const pages = names.map((name) => pageOf(world, scene, name, "what")).filter((page, index, all) => all.indexOf(page) === index);
+    const destination = pageOf(world, scene, to, "where");
+    // The characters who go, by themselves or inside a place that goes, such as a cart or a ship (CON-8, ENV-5).
+    const riders = world.pages.filter((page) => page.type === "character" && (pages.includes(page) || locate(world, page).chain.some((holder) => pages.includes(holder))));
+    const before = new Map(riders.map((page) => [page.path, surroundings(world, page)]));
+    const journey = journeyNote(world, riders, destination);
+    const done = movePages(root, context, world, pages, destination);
+    const after = done.world;
+    const now = (page) => after.pages.find((other) => other.path === page.path) ?? page;
+    const target = now(destination);
+    const moved = new Set(done.moved.map((page) => page.path));
+    const changes = riders.map((page) => surroundingsChange(before.get(page.path) ?? [], surroundings(after, now(page))));
+    const went = riders.filter((page) => moved.has(page.path) || locate(world, page).chain.some((holder) => moved.has(holder.path)));
+    const sceneNote = scene === undefined ? undefined : followParty(root, context, after, scene, went, target);
+    // Who else is there matters to characters who arrive (CON-8), not to things.
+    // The party's player character arrives where the campaign wants pictures: the place gets one (D-308).
+    const arrived = went.some((page) => page.fields.role === "pc") ? picturesNote(root, context, after, target) : undefined;
+    const there = riders.length === 0 ? [] : after.pages.filter((page) => page.type === "character" && !pages.some((other) => other.path === page.path) && locate(after, page).chain[0] === target);
+    // Who is put on a square at once needs no word on where they came in.
+    const squares = placing ? undefined : squaresNote(after, target, done.moved);
+    return {
+        moved: done.moved.map((page) => page.name),
+        already: pages.filter((page) => !moved.has(page.path)).map((page) => page.name),
+        to: target.name,
+        chain: [target, ...locate(after, target).chain].map((page) => page.name),
+        there: there.map((page) => (page.fields.status === "dead" ? `${page.name} (dead)` : page.name)),
+        here: distinctTexts(changes.flatMap((change) => change.here)),
+        noLonger: distinctTexts(changes.flatMap((change) => change.noLonger)),
+        notes: [
+            ...done.notes,
+            ...(sceneNote === undefined ? [] : [sceneNote]),
+            ...(done.moved.length === 0 || journey === undefined ? [] : [journey]),
+            ...(arrived === undefined ? [] : [arrived]),
+            ...(squares === undefined ? [] : [squares]),
+        ],
+        problems: world.problems,
+    };
+}
+/**
+ * Puts one page or copy of the open scene on a square of a place's map (GRD-3): of the place it goes to with `to`, or of the one it is right in; the place's
+ * `at` changes, and a line goes in the log, kept out of the diary. Refused before anything moves: outside the map, on a wall or on what blocks, or for a place
+ * without a map.
+ */
+function moveOnMap(root, context, world, scene, names, at, to) {
+    const square = readSquare(at);
+    if (square === undefined) {
+        throw new Error(`Give the square as the map names it, a letter and a number, such as E6. Nothing moved.`);
+    }
+    if (names.length > 1) {
+        throw new Error(`Put one at a time on the map: each stands on its own square, such as page ${names[0]}, at ${squareName(square)}. Nothing moved.`);
+    }
+    const copy = copyName(world, scene, parsePageReference(names[0]).name);
+    if (copy !== undefined && to !== undefined) {
+        throw new Error(`${copy} is a copy in the open scene: it stands where the scene is, so give it only at, such as page ${copy}, at ${squareName(square)}. Nothing moved.`);
+    }
+    const page = copy === undefined ? pageOf(world, scene, names[0], "what") : undefined;
+    const who = copy ?? page?.name ?? names[0];
+    // The place whose map they stand on: the scene's for a copy, the one they go into with to, else the one they are right in.
+    const place = copy !== undefined ? scenePlace(world, scene) : to !== undefined ? pageOf(world, scene, to, "where") : page === undefined ? undefined : locate(world, page).chain[0];
+    if (place === undefined || place.type !== "place") {
+        throw new Error(to === undefined
+            ? `${who} is not right in a place${place === undefined ? "" : `: it is in ${place.name}`}, so it has no square to stand on. Move it into a place first, with to. Nothing moved.`
+            : `${place?.name ?? to} is not a place, so ${who} would stand on no square of it: give at only with a place, or move without at. Nothing moved.`);
+    }
+    const map = placeGrid(place);
+    if (map === undefined) {
+        throw new Error(`${place.name} has no map, so ${who} has no square to stand on: write one in a map block of its page (GRD-1). Nothing moved.`);
+    }
+    const closed = closedSquare(map.grid, square);
+    if (closed !== undefined) {
+        throw new Error(`${closed}: ${who} cannot stand there. Give a square of the floor. Nothing moved.`);
+    }
+    const moved = to === undefined ? undefined : moveInto(root, context, world, scene, names, to, true);
+    const now = moved === undefined ? world : campaignWorld(root, context);
+    const fresh = page === undefined ? undefined : now.pages.find((other) => other.path === page.path);
+    const here = now.pages.find((other) => other.path === place.path) ?? place;
+    // Where everyone stood before: the mover's square, from which the way is counted, the one it came in by when it just came in (GRD-5).
+    const before = standing(now, here, scene);
+    const isMover = (one) => (copy === undefined ? one.page === fresh : one.copy === copy);
+    const from = before.find((one) => isMover(one) && one.square !== undefined)?.square;
+    const entry = atEntry({ ...(fresh === undefined ? {} : { page: fresh }), ...(copy === undefined ? {} : { copy }) }, square);
+    const kept = atEntries(here).filter((other) => !before.some((one) => one.entry === other && isMover(one)));
+    writePage(now, here.name, undefined, { set: { at: [...kept, entry] } });
+    const party = fresh !== undefined && (isInParty(fresh) || locate(now, fresh).chain.some(isInParty));
+    appendLogEntry(root, newDatedLogEntry(root, context, "placed", party ? "public" : "hidden", { page: who, place: here.name, square: squareName(square) }));
+    const system = campaignSystem(root, context);
+    const mover = { entry, name: who, ...(fresh === undefined ? {} : { page: fresh }), ...(copy === undefined ? {} : { copy }), square };
+    const others = before.filter((one) => !isMover(one));
+    const facts = from === undefined ? undefined : moveFacts(now, system, measuresOf(root, system), scene, { grid: map.grid, who: mover, from, to: square, others });
+    if (facts?.moved !== undefined) {
+        updateScene(root, [[["moved"], facts.moved]]);
+    }
+    const cameIn = moved !== undefined && moved.moved.length > 0;
+    const ground = groundNote(map.grid, square);
+    return {
+        ...(moved ?? { moved: [], already: [], to: here.name, chain: [here.name], there: [], here: [], noLonger: [], notes: [], problems: world.problems }),
+        notes: [...(moved?.notes ?? []), ...(ground === undefined ? [] : [ground]), ...(facts?.notes ?? [])],
+        placed: {
+            who,
+            square: squareName(square),
+            place: here.name,
+            ...(facts?.distance === undefined || from === undefined ? {} : { distance: facts.distance, from: cameIn ? `${squareName(from)}, where ${who} came in` : squareName(from) }),
+        },
+    };
+}
+/** A word to the master on the square one now stands on (GRD-5): what it is, when it is difficult or hidden from the player. */
+function groundNote(grid, square) {
+    const feature = featureAt(grid, square);
+    const marks = [feature?.difficult ? "difficult ground" : "", feature?.hidden ? "hidden: the player does not know it is there" : ""].filter((mark) => mark !== "");
+    return feature === undefined || marks.length === 0 ? undefined : `${squareName(square)} is ${feature.name}, ${marks.join(", ")}.`;
+}
+/** The place where the open scene is; none when there is no scene, or it is in no place. */
+function scenePlace(world, scene) {
+    return scene?.place === undefined ? undefined : pagesWithName(world, parsePageReference(scene.place).name)[0];
+}
+/**
+ * Where those who went into a place with a map stand (GRD-3): on the square they entered by, or, for those whose way in the map does not show, a word that the
+ * map wants them on it.
+ */
+function squaresNote(world, place, moved) {
+    const map = placeGrid(place);
+    const characters = moved.filter((page) => page.type === "character");
+    if (map === undefined || characters.length === 0) {
+        return undefined;
+    }
+    const placed = standing(world, place, undefined);
+    const on = characters.flatMap((page) => placed.flatMap((one) => (one.page?.path === page.path && one.square !== undefined ? [`${page.name} on ${squareName(one.square)}`] : [])));
+    const off = characters.filter((page) => !placed.some((one) => one.page?.path === page.path)).map((page) => page.name);
+    const entered = on.length === 0 ? "" : `They stand where they came in: ${on.join(", ")}.`;
+    const missing = off.length === 0 ? "" : `${place.name} has a map: put ${off.join(", ")} on it, such as page ${off[0]}, at ${squareName(firstOpenSquare(map.grid))}.`;
+    return [entered, missing].filter((part) => part !== "").join(" ");
+}
+/** The page that moves, or where it goes: by name or alias, never a copy in the open scene, which has no place of its own (CON-3). */
+function pageOf(world, scene, name, role) {
+    const reference = parsePageReference(name);
+    if (reference.section !== undefined) {
+        throw new Error(`Give ${reference.name} without #${reference.section}: whole pages move. Nothing moved.`);
+    }
+    const copy = copyName(world, scene, reference.name);
+    if (copy !== undefined) {
+        const why = role === "what" ? "has no place of its own: it is where the scene is, and one that goes leaves with scene leave" : "holds nothing: give a place, a character or an item";
+        throw new Error(`${copy} is a copy in the open scene, which ${why}. Nothing moved.`);
+    }
+    const page = pageNamed(world, reference.name);
+    if (page === undefined) {
+        // A list sent as one text, as some clients do, names no page: creating one by that name would be wrong.
+        const list = reference.name.includes(",")
+            ? ` For more than one, give a list, such as page [${reference.name.split(",").map((part) => part.trim()).join(", ")}].`
+            : ` Look for it with find, or create it with write and its type: ${pageTypeNames.join(", ")}.`;
+        throw new Error(`There is no page named ${reference.name}.${list}${missingSystemHint(world)} Nothing moved.`);
+    }
+    return page;
+}
+/**
+ * The open scene follows the party (CON-6): when all its living members in the scene went, by themselves or aboard a place that moved, into the destination and out
+ * of the scene's place, the scene goes there, copies and all; when only some of them left the scene's place, they may have left the scene.
+ */
+function followParty(root, context, world, scene, went, destination) {
+    // Read without stopping at names two pages share: the move is already done.
+    const pageCalled = (link) => pagesWithName(world, parsePageReference(link).name)[0];
+    const party = scene.with.map(pageCalled).filter((page) => page !== undefined && isInParty(page));
+    const gone = party.filter((page) => went.some((other) => other.path === page.path));
+    const place = scene.place === undefined ? undefined : pageCalled(scene.place);
+    const outside = (page) => place === undefined || !locate(world, page).chain.includes(place);
+    if (gone.length === 0) {
+        return undefined;
+    }
+    // A scene is in a place: into an item, such as a cart, it goes to the place the item is in.
+    const spot = [destination, ...locate(world, destination).chain].find((holder) => holder.type === "place");
+    if (spot !== undefined && party.every((page) => locate(world, page).chain.includes(destination) && outside(page))) {
+        // The copies leave the squares of the place they were in: on the new map the master puts them again (GRD-3).
+        clearCopies(world, scene, Object.keys(scene.copies));
+        updateScene(root, [[["place"], `[[${spot.name}]]`]]);
+        appendLogEntry(root, newDatedLogEntry(root, context, "scene-changed", "hidden", { title: scene.title, place: `[[${spot.name}]]` }));
+        const copies = Object.keys(scene.copies);
+        const copiesToo = copies.length === 0 ? "" : `, with ${copies.join(", ")}`;
+        // The copies stand on no square of the new map until the master puts them there.
+        const onTheMap = offMapNote(world, spot, scene, copies);
+        const ended = `Close it if it ended${place === undefined ? "" : ` in ${place.name}`}; scene leave whoever stays behind.`;
+        return `The open scene, ${scene.title}, goes with them: now at ${spot.name}${copiesToo}. ${ended}${onTheMap === undefined ? "" : ` ${onTheMap}`}`;
+    }
+    if (place === undefined) {
+        return undefined;
+    }
+    const left = gone.filter(outside).map((page) => page.name);
+    const who = left.length === 1 ? left[0] : `[${left.join(", ")}]`;
+    return left.length === 0 ? undefined : `${left.join(", ")} left ${place.name}, where the open scene is: if they left the scene, scene leave, who ${who}.`;
+}
+/**
+ * A journey made with move (TRV-15): the party taken from one stop of the roads to another, which travel would walk stop by stop, letting the time pass; undefined
+ * for any other move.
+ */
+function journeyNote(world, riders, destination) {
+    const roads = roadsOf(world);
+    const member = riders.find(isInParty);
+    const [from, to] = [member === undefined ? undefined : stopOf(world, roads, member), stopOf(world, roads, destination)];
+    if (from === undefined || to === undefined || sameSpot(world, from, to) !== undefined) {
+        return undefined;
+    }
+    return `${from.name} and ${to.name} are joined by roads: a journey goes with travel, which lets the time pass and moves them stop by stop (route to ${destination.name} says how long). If the time has passed already, advance it.`;
+}
+/** The texts of what changed around those who moved, each once. */
+function distinctTexts(items) {
+    return [...new Set(items.map((item) => item.text))];
+}

package/dist/commands/notes.d.ts

@@ -0,0 +1,10 @@
+/** Says which settings are missing and how to set them; empty when none is. */
+export declare function missingSettingsNote(missing: string[]): string;
+/** The first names of a long list, joined, and how many more there are: "A · B, and 3 more". */
+export declare function shortList(names: string[], separator: string): string;
+/** "Changed with it, since they read hp from Lupo: Zanna (hp 13/13)…", or nothing when no page changed with it; `command` is the one that changes a single page. */
+export declare function followersNote(followers: string[], why: string, command: "change" | "write", value?: string): string;
+/** "Not changed, since they hold their own hp: Grigio (hp 5/11)", ten at most, or nothing when no page keeps its own. */
+export declare function keepersNote(keepers: string[], field: string): string;
+/** Lists the files of the world that could not be read as pages; empty when there are none. */
+export declare function skippedPagesNote(problems: string[]): string;

package/dist/commands/notes.js

@@ -0,0 +1,37 @@
+// Lines that several commands add to their plain-text output.
+/** Says which settings are missing and how to set them; empty when none is. */
+export function missingSettingsNote(missing) {
+    if (missing.length === 0) {
+        return "";
+    }
+    return `Still missing: ${missing.join(", ")}. Ask the player, then set ${missing.length === 1 ? "it" : "each one"} with the config command (setting and value).`;
+}
+// Long lists in outputs show this many names; the rest are counted.
+const listedNames = 10;
+/** The first names of a long list, joined, and how many more there are: "A · B, and 3 more". */
+export function shortList(names, separator) {
+    const more = names.length > listedNames ? `, and ${names.length - listedNames} more` : "";
+    return `${names.slice(0, listedNames).join(separator)}${more}`;
+}
+/** "Changed with it, since they read hp from Lupo: Zanna (hp 13/13)…", or nothing when no page changed with it; `command` is the one that changes a single page. */
+export function followersNote(followers, why, command, value) {
+    if (followers.length === 0) {
+        return "";
+    }
+    const listed = followers.map((name) => (value === undefined ? name : `${name} (${value})`));
+    return `Changed with it, ${why}: ${shortList(listed, ", ")}. To change only one of them, ${command} that page instead.`;
+}
+/** "Not changed, since they hold their own hp: Grigio (hp 5/11)", ten at most, or nothing when no page keeps its own. */
+export function keepersNote(keepers, field) {
+    if (keepers.length === 0) {
+        return "";
+    }
+    return `Not changed, since they hold their own ${field}: ${shortList(keepers, ", ")}.`;
+}
+/** Lists the files of the world that could not be read as pages; empty when there are none. */
+export function skippedPagesNote(problems) {
+    if (problems.length === 0) {
+        return "";
+    }
+    return `These files could not be read as pages and were left out:\n${problems.map((problem) => `- ${problem}`).join("\n")}`;
+}

package/dist/commands/page-counters.d.ts

@@ -0,0 +1,24 @@
+import { type Coin } from "../money/index.ts";
+import { type Page, type World } from "../pages/index.ts";
+import type { GameSystem } from "../systems/index.ts";
+/**
+ * The counters of a page as the outputs show them, such as hp 5/12: all those it holds, and those it inherits written as current/max (D-116, as for copies in D-110).
+ * A statistic it inherits, such as ac 13, is read from its base. With the campaign's coins, its money too, held or inherited (MON-7).
+ */
+export declare function pageCounters(world: World, page: Page, coins?: Coin[]): Record<string, unknown>;
+/**
+ * The counters of the player character or a companion as their line shows them (DAT-2): first the fields of the system's status line, in its order, numbers it
+ * declares too, one marked so only when it is not at zero; then the other counters, but one the system declares without a maximum, such as xp, at zero.
+ */
+export declare function partyCounters(world: World, page: Page, coins: Coin[] | undefined, system: GameSystem | undefined): Record<string, unknown>;
+/** The counters of someone's line as partyCounters gives them, but for the experience's next level, which view gives the dashboard beside its points. */
+export declare function lineCounters(world: World, page: Page, coins: Coin[] | undefined, system: GameSystem | undefined): Record<string, unknown>;
+/** The experience among someone's counters, with how many points the next level needs or the level they reach (PRO-6); undefined when it says neither. */
+export declare function lineExperience(world: World, page: Page, counters: Record<string, unknown>): {
+    field: string;
+    text: string;
+} | undefined;
+/** The fields of kept rolls a page holds that are not empty, each with its numbers (KEP-1). */
+export declare function keptRolls(world: World, page: Page): [string, number[]][];
+/** "hp 5/12 · arrows 18": counters as the outputs show them. */
+export declare function countersText(counters: Record<string, unknown>): string;

package/dist/commands/page-counters.js

@@ -0,0 +1,84 @@
+import { comparableText, sameName } from "../core/text.js";
+import { readCounter } from "../counters/index.js";
+import { formatAmount, readAmount } from "../money/index.js";
+import { declaredKind, isDeclaredUncounted, isEmptyField, isStandardField } from "../pages/index.js";
+import { effectiveFields, effectsOf } from "./effect-layer.js";
+import { experienceOf, experienceText } from "./game-experience.js";
+import { signedText } from "./worked-out.js";
+/**
+ * The counters of a page as the outputs show them, such as hp 5/12: all those it holds, and those it inherits written as current/max (D-116, as for copies in D-110).
+ * A statistic it inherits, such as ac 13, is read from its base. With the campaign's coins, its money too, held or inherited (MON-7).
+ */
+export function pageCounters(world, page, coins) {
+    const given = effectsOf(page).flatMap((effect) => effect.values.map(([field]) => field));
+    const own = new Set([...Object.entries(page.fields).filter(([, value]) => !isEmptyField(value)).map(([field]) => field), ...given].map(comparableText));
+    // A field the game system declares as a number, text or list is never counted, and no field it declares is money (SYS-8).
+    const counter = (field, value) => !isStandardField(page.type, field) && !isDeclaredUncounted(world, field) && readCounter(value) !== undefined && (own.has(comparableText(field)) || readCounter(value)?.max !== undefined);
+    return Object.fromEntries(Object.entries(effectiveFields(world, page)).flatMap(([field, value]) => {
+        const purse = coins === undefined || isStandardField(page.type, field) || declaredKind(world, field) !== undefined ? undefined : readAmount(value, coins);
+        return purse !== undefined && coins !== undefined ? [[field, formatAmount(purse, coins)]] : counter(field, value) ? [[field, value]] : [];
+    }));
+}
+/**
+ * The counters of the player character or a companion as their line shows them (DAT-2): first the fields of the system's status line, in its order, numbers it
+ * declares too, one marked so only when it is not at zero; then the other counters, but one the system declares without a maximum, such as xp, at zero.
+ */
+export function partyCounters(world, page, coins, system) {
+    const shown = lineCounters(world, page, coins, system);
+    const experience = lineExperience(world, page, shown);
+    if (experience !== undefined) {
+        shown[experience.field] = `${String(shown[experience.field])} (${experience.text})`;
+    }
+    return shown;
+}
+/** The counters of someone's line as partyCounters gives them, but for the experience's next level, which view gives the dashboard beside its points. */
+export function lineCounters(world, page, coins, system) {
+    const counters = pageCounters(world, page, coins);
+    const fields = effectiveFields(world, page);
+    const shown = {};
+    const used = new Set();
+    for (const { field, whenSet } of system?.statusLine ?? []) {
+        const key = sameName(Object.keys(fields), field);
+        // A value written by hand as a map or a list, such as ac: {base: 14, shield: 2}, is not one a line can show.
+        if (key === undefined || isEmptyField(fields[key]) || !["number", "string"].includes(typeof fields[key])) {
+            continue;
+        }
+        used.add(key);
+        const value = counters[key] ?? fields[key];
+        if (!whenSet || readCounter(value)?.value !== 0) {
+            // A modifier shows its sign, as the system declares it (FOR-8).
+            shown[key] = typeof value === "number" ? signedText(world, key, value) : value;
+        }
+    }
+    // A field the campaign's settings leave out, as xp with milestones, is not shown (DAT-10).
+    const leftOut = (field) => (system?.leftOut ?? []).some((name) => comparableText(name) === comparableText(field));
+    for (const [field, value] of Object.entries(counters)) {
+        const counter = readCounter(value);
+        if (!used.has(field) && !leftOut(field) && !(declaredKind(world, field) === "counter" && counter?.max === undefined && counter?.value === 0)) {
+            shown[field] = value;
+        }
+    }
+    // Rolls kept for later, such as a diviner's Portent, when there are any (KEP-1).
+    for (const [field, value] of keptRolls(world, page)) {
+        shown[field] = value.join(", ");
+    }
+    return shown;
+}
+/** The experience among someone's counters, with how many points the next level needs or the level they reach (PRO-6); undefined when it says neither. */
+export function lineExperience(world, page, counters) {
+    const experience = experienceOf(world, effectiveFields(world, page));
+    const text = experience === undefined ? undefined : experienceText(experience);
+    const field = experience === undefined ? undefined : sameName(Object.keys(counters), experience.field);
+    return field === undefined || text === undefined ? undefined : { field, text };
+}
+/** The fields of kept rolls a page holds that are not empty, each with its numbers (KEP-1). */
+export function keptRolls(world, page) {
+    return Object.entries(effectiveFields(world, page)).flatMap(([field, value]) => {
+        const numbers = (Array.isArray(value) ? value : [value]).map(Number).filter((number) => Number.isFinite(number));
+        return declaredKind(world, field) !== "rolls" || isEmptyField(value) || numbers.length === 0 ? [] : [[field, numbers]];
+    });
+}
+/** "hp 5/12 · arrows 18": counters as the outputs show them. */
+export function countersText(counters) {
+    return Object.entries(counters).map(([field, value]) => `${field} ${String(value).trim()}`).join(" · ");
+}

package/dist/commands/parts.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from "../core/context.ts";
+import type { GameSystem } from "../systems/index.ts";
+/** A part of the instructions as the core and the system give it, with no regard to what was told; undefined when neither has it. */
+export declare function partText(name: string, system: GameSystem | undefined): string | undefined;
+/** A part of the instructions for a situation that opens: once in a chat where the MCP server keeps what it told, until instructions; every time elsewhere. Empty when there is none, or it was told. */
+export declare function situationPart(name: string, context: Context, system: GameSystem | undefined): string;
+/**
+ * The mentor's part for the way the player wants the game taught (D-347), once in a chat as a situation's part: none when off; with the tutorial, the
+ * mechanics already explained.
+ */
+export declare function mentorPart(root: string, context: Context, mentor: string | undefined): string;
+/**
+ * How the master writes, as the player chose it (D-395): the author's part in place of the prose's, the story's, and the player's own words, each with what
+ * was written in it; none for the core's own ways. Every time it is asked, as a change of them must reach the chat.
+ */
+export declare function stylePart(root: string, context: Context): string;

package/dist/commands/parts.js

@@ -0,0 +1,49 @@
+// The parts of the master's instructions that the tools give when a situation opens, such as a fight or a new day (D-97, D-121).
+import { readSettings } from "../campaign/index.js";
+import { corePart, layeredPart } from "../instructions/index.js";
+import { campaignSystem } from "./game-world.js";
+/** A part of the instructions as the core and the system give it, with no regard to what was told; undefined when neither has it. */
+export function partText(name, system) {
+    const core = corePart(name);
+    return layeredPart([core === undefined ? undefined : { text: core, replace: false }, system?.parts[name]]);
+}
+/** A part of the instructions for a situation that opens: once in a chat where the MCP server keeps what it told, until instructions; every time elsewhere. Empty when there is none, or it was told. */
+export function situationPart(name, context, system) {
+    const text = partText(name, system);
+    if (text === undefined || context.told?.has(name)) {
+        return "";
+    }
+    context.told?.add(name);
+    return text;
+}
+/**
+ * The mentor's part for the way the player wants the game taught (D-347), once in a chat as a situation's part: none when off; with the tutorial, the
+ * mechanics already explained.
+ */
+export function mentorPart(root, context, mentor) {
+    if (mentor !== "hints" && mentor !== "tutorial") {
+        return "";
+    }
+    const part = situationPart(`mentor-${mentor}`, context, campaignSystem(root, context));
+    const learned = mentor === "tutorial" ? (readSettings(root).learned ?? []) : [];
+    return part === "" || learned.length === 0 ? part : `${part}\n\nAlready explained: ${learned.join(", ")}.`;
+}
+/**
+ * How the master writes, as the player chose it (D-395): the author's part in place of the prose's, the story's, and the player's own words, each with what
+ * was written in it; none for the core's own ways. Every time it is asked, as a change of them must reach the chat.
+ */
+export function stylePart(root, context) {
+    const settings = readSettings(root);
+    const system = campaignSystem(root, context);
+    const part = (name, value, placeholder) => {
+        const text = value === undefined ? undefined : partText(name, system);
+        // The player's words as they are: replaceAll would read a $ in them.
+        return text === undefined ? "" : placeholder === undefined || value === undefined ? text : text.split(placeholder).join(value);
+    };
+    return [
+        part("author", settings.author, "{author}"),
+        settings.author !== undefined || settings.prose === "plain" ? "" : part(`prose-${settings.prose}`, settings.prose),
+        settings.story === "situations" ? "" : part(`story-${settings.story}`, settings.story),
+        part("style", settings.style, "{style}"),
+    ].filter((text) => text !== "").join("\n\n");
+}

package/dist/commands/problems.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from "../core/context.ts";
+import type { Problem } from "../core/problem.ts";
+import { type World } from "../pages/index.ts";
+/** Every problem in a campaign: its settings, its game system and coins, its log, its world, its pictures, its roads, its game time, its planned events, its effects and its open scene. */
+export declare function campaignProblems(root: string, world: World, context: Context): Problem[];

package/dist/commands/problems.js

@@ -0,0 +1,47 @@
+import { checkSettings } from "../campaign/index.js";
+import { checkLog } from "../core/log.js";
+import { checkWorld } from "../pages/index.js";
+import { effectProblems } from "./game-effects.js";
+import { eventProblems } from "./game-events.js";
+import { experienceProblems } from "./game-experience.js";
+import { gridProblems } from "./game-grids.js";
+import { imageProblems } from "./game-images.js";
+import { mapProblems } from "./game-maps.js";
+import { modeProblems } from "./game-mode.js";
+import { moneyProblems } from "./game-money.js";
+import { shortRoadProblems } from "./game-positions.js";
+import { questProblems } from "./game-quests.js";
+import { passageProblems, roadProblems } from "./game-roads.js";
+import { readOpenScene, sceneProblems } from "./game-scene.js";
+import { readPresent, timeProblems } from "./game-time.js";
+import { campaignSystem, systemOccasions, systemProblems, systemSettingProblems } from "./game-world.js";
+import { listValueProblems } from "./sheet.js";
+import { workedOutProblems } from "./worked-out.js";
+/** Every problem in a campaign: its settings, its game system and coins, its log, its world, its pictures, its roads, its game time, its planned events, its effects and its open scene. */
+export function campaignProblems(root, world, context) {
+    const system = systemProblems(root, context);
+    return [
+        ...checkSettings(root),
+        ...system,
+        ...systemSettingProblems(root, context),
+        ...moneyProblems(root, context),
+        ...checkLog(root),
+        ...checkWorld(world),
+        // While what campaign.yaml adds does not read, what the pages hold is not judged by the system alone: that fix comes first (CAM-3).
+        ...(system.length === 0 ? workedOutProblems(world) : []),
+        ...listValueProblems(world, campaignSystem(root, context)),
+        ...experienceProblems(world),
+        ...imageProblems(root, context, world),
+        ...roadProblems(world, campaignSystem(root, context)),
+        ...passageProblems(world, campaignSystem(root, context)),
+        ...mapProblems(world),
+        ...gridProblems(world, readOpenScene(root).scene),
+        ...shortRoadProblems(world),
+        ...timeProblems(root),
+        ...modeProblems(root),
+        ...eventProblems(world),
+        ...questProblems(world),
+        ...effectProblems(world, readOpenScene(root).scene, readPresent(root).date, systemOccasions(root, context)),
+        ...sceneProblems(root, world),
+    ];
+}

package/dist/commands/progression.d.ts

@@ -0,0 +1,68 @@
+import type { Problem } from "../core/problem.ts";
+import { type Page, type World } from "../pages/index.ts";
+/** A field the rows give, with its value and the items it comes from, such as rage-damage +2 from Barbarian 3 (PRO-2). */
+export interface ProgressionValue {
+    field: string;
+    value: number | string;
+    from: {
+        name: string;
+        level: number;
+    }[];
+    /** The value each item's row gives, in the order of `from`. */
+    cells: (number | string)[];
+}
+/**
+ * What the classes of a character give: the fields of their rows, in the order of their columns, and its features, each with the pages that tell it, more than
+ * one when two classes give the same name (PRO-2–PRO-4).
+ */
+export interface Progression {
+    /** The list the items come from, such as classes, and the list of the parts, such as subclasses. */
+    lists: string[];
+    values: ProgressionValue[];
+    /** The name of the field that holds the features, such as features. */
+    featuresField: string;
+    features: {
+        name: string;
+        pages: Page[];
+    }[];
+    /** Each feature as a row or a part gives it, before they are merged, with its level and page: what a new level adds, even a feature gained again. */
+    gains: {
+        name: string;
+        level: number;
+        page: Page;
+    }[];
+    /** What the parts add to the character's lists by their level, each with its list and page: a domain's spells, always prepared (PRO-7). */
+    given: {
+        list: string;
+        name: string;
+        page: Page;
+    }[];
+    /** The items that give them: each class with its level, and each part that adds features. */
+    from: {
+        list: string;
+        name: string;
+        level?: number;
+    }[];
+}
+/** What the classes in these fields give, by the system's progression; undefined when the system has none or the fields name no class (PRO-1). */
+export declare function progressionOf(world: World, fields: Record<string, unknown>): Progression | undefined;
+/** What the parts add to a list of the character, each with the page that adds it, as Bless from Life Domain in prepared (PRO-7). */
+export declare function givenItems(progression: Progression | undefined, list: string): {
+    name: string;
+    page: Page;
+}[];
+/** The value the progression gives a field, or the features for its features field; undefined for any other field (PRO-2, PRO-3). */
+export declare function progressionValue(progression: Progression | undefined, field: string): number | string | string[] | undefined;
+/**
+ * The pages that tell a feature a character has, in the order of the classes, and its section's title, found by the name with or without its value in
+ * parentheses (PRO-4); undefined when the character has no such feature.
+ */
+export declare function featureSource(progression: Progression | undefined, name: string): {
+    pages: Page[];
+    title: string;
+} | undefined;
+/**
+ * What validate says of the progression on a page (PRO-1, PRO-4): an item whose page has no table of levels, or no row at its level; a part whose page names no
+ * item, names one the list lacks, or lists features without a level.
+ */
+export declare function progressionProblems(world: World, page: Page, fields: Record<string, unknown>): Problem[];