rpg-engine 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,52 @@
+import type { Problem } from "../core/problem.ts";
+import { type Grid, type Square } from "../grid/index.ts";
+import { type MovePlan, type Page, type World } from "../pages/index.ts";
+import type { Scene } from "../scene/index.ts";
+/** Someone or something on a place's map (GRD-3): the entry of `at` as written, the page or the copy of the open scene it names, and its square. */
+export interface Standing {
+    entry: string;
+    name: string;
+    page?: Page;
+    copy?: string;
+    square?: Square;
+}
+/** The map of a place (GRD-1): its grid, and what of it cannot be read; none for a page that is no place or has no map block. */
+export declare function placeGrid(page: Page): {
+    grid: Grid;
+    problems: string[];
+} | undefined;
+/**
+ * The grid as the place draws it (D-325): the walls of a cave or a mine as rock, unless the legend says otherwise; and how its ground looks: the legend's own
+ * floor or ground, else a cave's rock, a building's floor where it has walls, a town's paving, the biome the place has or inherits, or plain ground.
+ */
+export declare function placeLook(world: World, place: Page, grid: Grid): {
+    grid: Grid;
+    ground: string;
+};
+/** A word on a map just written (GRD-2): what of it does not read, and the kinds the dashboard does not draw, which it draws neutral. */
+export declare function gridNotes(before: Page | undefined, after: Page): string[];
+/** Who stands where in a place (GRD-3): its `at` entries, each with the page or the copy of the open scene it names, and its square when it gives one. */
+export declare function standing(world: World, place: Page, scene: Scene | undefined): Standing[];
+/** The entry of `at` that puts someone on a square: a page by its link, a copy by its name. */
+export declare function atEntry(who: {
+    page?: Page;
+    copy?: string;
+}, square: Square): string;
+/** The entries of a place's `at`, as written. */
+export declare function atEntries(place: Page): string[];
+/**
+ * The squares a move changes (GRD-3), as edits of the places' `at`: who moves leaves every square they had; who enters a place with a map from a place one of its
+ * squares leads to stands on that square. The edits come first, so that the destination stays the last page written (CON-4).
+ */
+export declare function withSquares(world: World, plan: MovePlan, destination: Page | undefined): MovePlan;
+/** A word to the master when, in a scene at a place with a map, some stand on no square of it (GRD-3): who, and how to put them there. */
+export declare function offMapNote(world: World, place: Page | undefined, scene: Scene, names: string[]): string | undefined;
+/** Takes copies of the open scene off the map of its place (GRD-3), as they leave, or the scene closes or goes elsewhere. */
+export declare function clearCopies(world: World, scene: Scene, names: string[]): void;
+/**
+ * The square a page enters a place's map by (GRD-3): the open one that leads to where it comes from, the nearest of its containers first; none when no such
+ * square leads there, or it comes from inside the place itself, as up from its cellar, or put down by one who is there.
+ */
+export declare function doorFrom(world: World, grid: Grid, page: Page, place: Page): Square | undefined;
+/** What is wrong with the places' maps and with who stands where on them (GRD-2, GRD-3), for validate. */
+export declare function gridProblems(world: World, scene: Scene | undefined): Problem[];

package/dist/commands/game-grids.js

@@ -0,0 +1,162 @@
+// The map of a place in play (GRD-1–GRD-3, D-324): its grid from the page's text, who stands where on it as the place's `at` lists them, what of them is
+// wrong, and the squares a move leaves and takes.
+import { rememberedByText } from "../core/memo.js";
+import { comparableText } from "../core/text.js";
+import { builtIn, closedSquare, firstOpenSquare, mapBlock, readGrid, readSquare, squareName } from "../grid/index.js";
+import { squareKinds } from "../map/index.js";
+import { environmentAt, links, locate, pagesWithName, parsePageReference, writePage } from "../pages/index.js";
+/** The map of a place (GRD-1): its grid, and what of it cannot be read; none for a page that is no place or has no map block. */
+export function placeGrid(page) {
+    return page.type === "place" ? readMap(page.body) : undefined;
+}
+/**
+ * The grid as the place draws it (D-325): the walls of a cave or a mine as rock, unless the legend says otherwise; and how its ground looks: the legend's own
+ * floor or ground, else a cave's rock, a building's floor where it has walls, a town's paving, the biome the place has or inherits, or plain ground.
+ */
+export function placeLook(world, place, grid) {
+    const kindOf = (page) => (typeof page.fields.kind === "string" ? page.fields.kind.trim().toLowerCase() : undefined);
+    const underground = ["cave", "mine"].includes(kindOf(place) ?? "");
+    const named = (symbol) => !builtInLook(grid, symbol);
+    const features = grid.features.map((feature) => (feature.symbol === "#" && underground && !named("#") ? { ...feature, kind: "rock" } : feature));
+    const floor = features.find((feature) => feature.symbol === ".")?.kind ?? "floor";
+    const walled = grid.lines.some((line) => line.includes("#")) && features.find((feature) => feature.symbol === "#")?.kind === "wall";
+    const town = [place, ...locate(world, place).chain].some((page) => ["city", "town", "village"].includes(kindOf(page) ?? ""));
+    const biome = environmentAt(world, place).find(({ entry }) => comparableText(entry.name) === "biome")?.entry.value;
+    const ground = named(".") && floor === "floor" ? "floor" : underground ? "cave" : !named(".") && walled ? "floor" : town ? "paving" : (biome ?? "plain");
+    return { grid: { ...grid, features }, ground };
+}
+/** A word on a map just written (GRD-2): what of it does not read, and the kinds the dashboard does not draw, which it draws neutral. */
+export function gridNotes(before, after) {
+    const map = placeGrid(after);
+    if (map === undefined || (before !== undefined && mapBlock(before.body) === mapBlock(after.body))) {
+        return [];
+    }
+    const known = new Set(squareKinds);
+    const unknown = map.grid.features.filter((feature) => feature.kind !== "" && !known.has(feature.kind)).map((feature) => `${feature.symbol} ${feature.kind}`);
+    const drawn = unknown.length === 0 ? [] : [`The map draws ${unknown.join(", ")} neutral: its kinds are ${squareKinds.join(", ")}.`];
+    return [...map.problems.map((problem) => `${after.name}'s map: ${problem}`), ...drawn];
+}
+/** Who stands where in a place (GRD-3): its `at` entries, each with the page or the copy of the open scene it names, and its square when it gives one. */
+export function standing(world, place, scene) {
+    return atEntries(place).map((entry) => {
+        const match = /^(.*\S)\s+([A-Za-z]+\d+)$/.exec(entry.trim());
+        const who = (match?.[1] ?? entry).trim();
+        const square = match === null ? undefined : readSquare(match[2]);
+        const linked = links(who)[0]?.page;
+        const copy = linked === undefined ? Object.keys(scene?.copies ?? {}).find((name) => comparableText(name) === comparableText(who)) : undefined;
+        const page = copy === undefined ? pagesWithName(world, parsePageReference(linked ?? who).name)[0] : undefined;
+        return { entry, name: copy ?? page?.name ?? linked ?? who, ...(page === undefined ? {} : { page }), ...(copy === undefined ? {} : { copy }), ...(square === undefined ? {} : { square }) };
+    });
+}
+/** The entry of `at` that puts someone on a square: a page by its link, a copy by its name. */
+export function atEntry(who, square) {
+    return `${who.copy ?? `[[${who.page?.name ?? ""}]]`} ${squareName(square)}`;
+}
+/** The entries of a place's `at`, as written. */
+export function atEntries(place) {
+    const value = place.fields.at;
+    return (Array.isArray(value) ? value : value === undefined || value === null ? [] : [value]).filter((entry) => typeof entry === "string");
+}
+/**
+ * The squares a move changes (GRD-3), as edits of the places' `at`: who moves leaves every square they had; who enters a place with a map from a place one of its
+ * squares leads to stands on that square. The edits come first, so that the destination stays the last page written (CON-4).
+ */
+export function withSquares(world, plan, destination) {
+    const leaving = world.pages.filter((place) => place.type === "place").flatMap((place) => {
+        const remove = standing(world, place, undefined).filter((one) => one.page !== undefined && plan.moving.includes(one.page)).map((one) => one.entry);
+        return remove.length === 0 ? [] : [{ holder: place, field: "at", remove, add: [] }];
+    });
+    const map = destination === undefined ? undefined : placeGrid(destination);
+    const entering = map === undefined || destination === undefined ? [] : plan.moving.flatMap((page) => {
+        const door = doorFrom(world, map.grid, page, destination);
+        return door === undefined ? [] : [atEntry({ page }, door)];
+    });
+    const intoDestination = entering.length === 0 || destination === undefined ? [] : [{ holder: destination, field: "at", remove: [], add: entering }];
+    return { ...plan, edits: [...leaving, ...plan.edits, ...intoDestination] };
+}
+/** A word to the master when, in a scene at a place with a map, some stand on no square of it (GRD-3): who, and how to put them there. */
+export function offMapNote(world, place, scene, names) {
+    const map = place === undefined ? undefined : placeGrid(place);
+    if (place === undefined || map === undefined) {
+        return undefined;
+    }
+    const placed = new Set(standing(world, place, scene).filter((one) => one.square !== undefined).map((one) => comparableText(one.name)));
+    const off = names.filter((name) => !placed.has(comparableText(name)));
+    return off.length === 0 ? undefined : `${place.name} has a map: put ${off.join(", ")} on it, one at a time, such as page ${off[0]}, at ${squareName(firstOpenSquare(map.grid))}.`;
+}
+/** Takes copies of the open scene off the map of its place (GRD-3), as they leave, or the scene closes or goes elsewhere. */
+export function clearCopies(world, scene, names) {
+    const place = scene.place === undefined ? undefined : pagesWithName(world, parsePageReference(scene.place).name)[0];
+    const gone = new Set(names.map(comparableText));
+    const leaving = place === undefined ? [] : standing(world, place, scene).filter((one) => one.copy !== undefined && gone.has(comparableText(one.copy))).map((one) => one.entry);
+    if (place !== undefined && leaving.length > 0) {
+        const kept = atEntries(place).filter((entry) => !leaving.includes(entry));
+        writePage(world, place.name, undefined, kept.length === 0 ? { unset: ["at"] } : { set: { at: kept } });
+    }
+}
+/**
+ * The square a page enters a place's map by (GRD-3): the open one that leads to where it comes from, the nearest of its containers first; none when no such
+ * square leads there, or it comes from inside the place itself, as up from its cellar, or put down by one who is there.
+ */
+export function doorFrom(world, grid, page, place) {
+    const holders = locate(world, page).chain;
+    const inside = holders.findIndex((holder) => holder.path === place.path);
+    const chain = (inside === -1 ? holders : holders.slice(0, inside)).map((holder) => comparableText(holder.name));
+    const exits = grid.exits.filter((exit) => chain.includes(comparableText(exit.to)) && closedSquare(grid, exit.square) === undefined);
+    return exits.sort((first, second) => chain.indexOf(comparableText(first.to)) - chain.indexOf(comparableText(second.to)))[0]?.square;
+}
+/** What is wrong with the places' maps and with who stands where on them (GRD-2, GRD-3), for validate. */
+export function gridProblems(world, scene) {
+    const scenePlace = scene?.place === undefined ? undefined : pagesWithName(world, parsePageReference(scene.place).name)[0];
+    return world.pages.filter((page) => page.type === "place" && page.system === undefined).flatMap((place) => {
+        const map = placeGrid(place);
+        const placed = standing(world, place, scenePlace === place ? scene : undefined);
+        if (map === undefined) {
+            return placed.length === 0 ? [] : [{ path: place.path, message: `${place.name} says who stands where, at, but has no map.`, fix: `write its map in a map block (GRD-1), or unset at` }];
+        }
+        const exits = map.grid.exits.filter((exit) => pagesWithName(world, exit.to)[0] === undefined).map((exit) => ({
+            path: place.path,
+            message: `${place.name}'s map leads from ${squareName(exit.square)} to ${exit.to}, which is no page.`,
+            fix: `write ${exit.to}, or the exit with the name of a place`,
+        }));
+        return [
+            ...map.problems.map((message) => ({ path: place.path, message: `${place.name}'s map: ${message}` })),
+            ...exits,
+            ...placed.flatMap((one) => standingProblem(world, place, map.grid, one)),
+            ...twiceOn(place, placed),
+        ];
+    });
+}
+/** Whether a symbol every map has keeps its own name and drawing, the legend saying nothing of it. */
+function builtInLook(grid, symbol) {
+    const feature = grid.features.find((one) => one.symbol === symbol);
+    const own = builtIn.find((one) => one.symbol === symbol);
+    return feature !== undefined && own !== undefined && feature.name === own.name && feature.kind === own.kind;
+}
+const readMap = rememberedByText((text) => {
+    const block = mapBlock(text);
+    return block === undefined ? undefined : readGrid(block);
+});
+/** What is wrong with one entry of a place's `at` (GRD-3): no square, no one by that name, someone the place does not hold, a closed square. */
+function standingProblem(world, place, grid, one) {
+    const fix = `move them there with move, at a square, or remove "${one.entry}" from ${place.name}'s at`;
+    if (one.square === undefined) {
+        return [{ path: place.path, message: `"${one.entry}", in ${place.name}'s at, gives no square.`, fix: `write it as [[Name]] C4` }];
+    }
+    if (one.page === undefined && one.copy === undefined) {
+        return [{ path: place.path, message: `${one.name} stands on ${squareName(one.square)} in ${place.name}, but there is no page or copy of the open scene there by that name.`, fix }];
+    }
+    if (one.page !== undefined && locate(world, one.page).chain[0] !== place) {
+        return [{ path: place.path, message: `${one.name} stands on ${squareName(one.square)} in ${place.name}, but is not in it.`, fix }];
+    }
+    const closed = closedSquare(grid, one.square);
+    return closed === undefined ? [] : [{ path: place.path, message: `${one.name} stands on ${squareName(one.square)} in ${place.name}, but ${closed}.`, fix }];
+}
+/** Those who stand on more than one square of a place (GRD-3): each once, with their squares. */
+function twiceOn(place, placed) {
+    const same = (one, other) => (one.page !== undefined && one.page === other.page) || (one.copy !== undefined && one.copy === other.copy);
+    return placed.filter((one, index) => placed.findIndex((other) => same(other, one)) === index).flatMap((one) => {
+        const squares = placed.flatMap((other) => (same(other, one) && other.square !== undefined ? [squareName(other.square)] : []));
+        return squares.length < 2 ? [] : [{ path: place.path, message: `${one.name} stands on more than one square in ${place.name}: ${squares.join(", ")}.`, fix: "move them with move, at the one square they are on" }];
+    });
+}

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

@@ -0,0 +1,40 @@
+import type { Context } from "../core/context.ts";
+import { type FieldChange, type Page, type Position, type World } from "../pages/index.ts";
+import { type Journey, type OnRoad } from "./game-journey.ts";
+/** Where a place written `here` goes (TRV-14): on a road at the point its journey stopped, or at a point in the open; with the journey and who travels. */
+export interface Here {
+    journey: Journey;
+    movers: Page[];
+    on?: OnRoad;
+    at?: Position;
+}
+/** What a position written for a place does besides (POS-2): the place that becomes the map's centre, and what write says. */
+export interface Placed {
+    origin?: Page;
+    notes: string[];
+}
+/**
+ * Where the journey stopped, for a place written `here` (TRV-14): refused for a page that exists or is not a place, with a position given too, or without a
+ * journey stopped between two places, with how to write a place inside another.
+ */
+export declare function hereOf(root: string, world: World, name: string, existing: Page | undefined, type: string | undefined, change: FieldChange): Here;
+/** The fields a place written `here` in the open takes: the point's position (TRV-14). */
+export declare function hereFields(here: Here, change: FieldChange): FieldChange;
+/**
+ * After the place is written `here` (TRV-14): on a road, it becomes a stop that splits the stretch at the point, and the road holds it; in the open, the region
+ * that covers the point holds it. Those who travel go into it, and the journey goes on from it. Returns the world after it and what write says.
+ */
+export declare function placeHere(root: string, context: Context, world: World, page: Page, here: Here): {
+    world: World;
+    notes: string[];
+};
+/**
+ * A position given to a place (POS-2): the coordinates to write in place of relations, the place that becomes the map's centre when none had a position, and
+ * what write says: how far apart the relations were, and the centre.
+ */
+export declare function positionToWrite(world: World, name: string, change: FieldChange): {
+    change: FieldChange;
+    placed: Placed;
+};
+/** Writes the map's centre on the place a first relation started from (POS-2). */
+export declare function writeOrigin(root: string, context: Context, world: World, origin: Page): World;

package/dist/commands/game-here.js

@@ -0,0 +1,100 @@
+import { appendLogEntry } from "../core/log.js";
+import { comparableText } from "../core/text.js";
+import { formatPosition, pagesWithName, readStops, withPage, writePage } from "../pages/index.js";
+import { journeyPoint, journeyStart, moversMap, moversNamed, readJourney, saveJourney } from "./game-journey.js";
+import { movePages } from "./game-moves.js";
+import { positionFromWrite, regionAt } from "./game-positions.js";
+import { lengthText, roadsOf } from "./game-roads.js";
+import { newDatedLogEntry } from "./game-time.js";
+/**
+ * Where the journey stopped, for a place written `here` (TRV-14): refused for a page that exists or is not a place, with a position given too, or without a
+ * journey stopped between two places, with how to write a place inside another.
+ */
+export function hereOf(root, world, name, existing, type, change) {
+    if (existing !== undefined || type !== "place") {
+        throw new Error(`here makes a new place where the party stopped: give a new name and type place, such as write Accampamento, type place, here. Nothing changed.`);
+    }
+    if (change.set?.position !== undefined) {
+        throw new Error("here gives the place its position, where the party stopped: leave position out. Nothing changed.");
+    }
+    const journey = readJourney(root);
+    const movers = journey === undefined ? [] : moversNamed(world, journey);
+    const on = journey === undefined || journeyStart(world, roadsOf(world), journey, movers) === undefined ? undefined : journey.on;
+    const at = journey === undefined ? undefined : journeyPoint(world, journey, movers);
+    if (journey === undefined || (on === undefined && at === undefined)) {
+        throw new Error(`here is where a journey stopped, on a road or in the open, and none did: to write ${name} inside a place, write ${name}, type place, then add contains=[[${name}]] to that place. Nothing changed.`);
+    }
+    return { journey, movers, on, at };
+}
+/** The fields a place written `here` in the open takes: the point's position (TRV-14). */
+export function hereFields(here, change) {
+    return here.at === undefined ? change : { ...change, set: { ...change.set, position: formatPosition(here.at) } };
+}
+/**
+ * After the place is written `here` (TRV-14): on a road, it becomes a stop that splits the stretch at the point, and the road holds it; in the open, the region
+ * that covers the point holds it. Those who travel go into it, and the journey goes on from it. Returns the world after it and what write says.
+ */
+export function placeHere(root, context, world, page, here) {
+    let now = world;
+    const holder = here.on === undefined ? (here.at === undefined ? undefined : regionAt(now, here.at, moversMap(now, here.journey, here.movers)?.path)?.page) : pagesWithName(now, here.on.road)[0];
+    const notes = [];
+    if (here.on !== undefined) {
+        const road = pagesWithName(now, here.on.road)[0];
+        const stops = splitStops(road, here.on, page.name);
+        now = withPage(now, road, writePage(now, road.name, undefined, { set: { stops } }).page);
+        appendLogEntry(root, newDatedLogEntry(root, context, "page-updated", "hidden", { page: road.name, set: { stops }, why: `${page.name} written where the journey stopped` }));
+        notes.push(`${page.name} is now a stop of ${road.name}: ${stops.join(", ")}.`);
+    }
+    if (holder !== undefined) {
+        now = withPage(now, pagesWithName(now, holder.name)[0], writePage(now, holder.name, undefined, { add: { contains: [`[[${page.name}]]`] } }).page);
+        appendLogEntry(root, newDatedLogEntry(root, context, "page-updated", "hidden", { page: holder.name, add: { contains: [`[[${page.name}]]`] }, why: `${page.name} written where the journey stopped` }));
+    }
+    const placeNow = pagesWithName(now, page.name)[0];
+    const moved = movePages(root, context, now, here.movers.map((mover) => pagesWithName(now, mover.name)[0]), placeNow);
+    saveJourney(root, { ...here.journey, on: undefined, at: undefined });
+    const where = holder === undefined ? "in the open" : `in ${holder.name}`;
+    return { world: moved.world, notes: [...notes, `${here.movers.map((mover) => mover.name).join(", ")} ${here.movers.length === 1 ? "is" : "are"} now in ${page.name}, ${where}; the journey goes on from there.`, ...moved.notes] };
+}
+/**
+ * A position given to a place (POS-2): the coordinates to write in place of relations, the place that becomes the map's centre when none had a position, and
+ * what write says: how far apart the relations were, and the centre.
+ */
+export function positionToWrite(world, name, change) {
+    const value = change.set?.position;
+    if (value === undefined) {
+        return { change, placed: { notes: [] } };
+    }
+    const { position, spread, origin, map } = positionFromWrite(world, value, name);
+    const notes = [
+        spread >= 100 ? `The relations given are up to ${Math.round(spread / 100) / 10} km apart: ${name} is at their middle. If one is wrong, write the position again.` : "",
+        origin === undefined ? "" : `${origin.name} is now the centre of the map, at 0 km E, 0 km N: every other position is given from a place that has one.`,
+        // A place given its position from another map is on that map only once that map's place holds it (POS-8).
+        map === undefined ? "" : `${name} has its position on the map of ${map.name}, but nothing holds it there yet: put it in, such as write ${map.name}, add contains=[[${name}]].`,
+    ].filter((note) => note !== "");
+    return { change: { ...change, set: { ...change.set, position: formatPosition(position) } }, placed: { origin, notes } };
+}
+/** Writes the map's centre on the place a first relation started from (POS-2). */
+export function writeOrigin(root, context, world, origin) {
+    const written = writePage(world, origin.name, undefined, { set: { position: "0 km E, 0 km N" } }).page;
+    appendLogEntry(root, newDatedLogEntry(root, context, "page-updated", "hidden", { page: origin.name, set: { position: "0 km E, 0 km N" }, why: "the centre of the map" }));
+    return withPage(world, origin, written);
+}
+/** A road's stops with a new one splitting the stretch where a journey stopped, the rest as written: the two lengths make the one before, to the metre. */
+function splitStops(road, on, name) {
+    const read = readStops(road.fields.stops);
+    if ("problem" in read || !Array.isArray(road.fields.stops)) {
+        throw new Error(`${road.name}'s stops do not read: fix them first. Nothing changed.`);
+    }
+    const same = (first, second) => comparableText(first) === comparableText(second);
+    const joins = (at) => at >= 0 && at < read.stops.length - 1 && ((same(read.stops[at], on.from) && same(read.stops[at + 1], on.toward)) || (same(read.stops[at], on.toward) && same(read.stops[at + 1], on.from)));
+    // The stretch by its place in the road, so that a road through the same two stops twice splits the right one.
+    const index = joins(on.index) ? on.index : read.stops.findIndex((_, at) => joins(at));
+    const length = read.lengths[index];
+    const along = same(read.stops[index], on.from) ? on.done : length - on.done;
+    const first = Math.min(Math.max(Math.round(along / 100) * 100, 100), length - 100);
+    const metres = (value) => (value % 100 === 0 ? lengthText(value, { units: "metric", imperial: { mile: 0, foot: 0 } }) : `${Math.round(value)} m`);
+    const written = road.fields.stops.map(String);
+    // The stop at `index` is item 2 * index of the list; the length after it, 2 * index + 1.
+    written.splice(2 * index + 1, 1, metres(first), `[[${name}]]`, metres(length - first));
+    return written;
+}

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

@@ -0,0 +1,31 @@
+import type { Context } from "../core/context.ts";
+import type { Problem } from "../core/problem.ts";
+import { type Page, type World } from "../pages/index.ts";
+/**
+ * What the master hears of the places' pictures (D-308, PIC-4): where pictures can be made and the player has not chosen, to ask them once; with new elements, that
+ * the place the party is in, still without a picture, should get one. Nothing otherwise.
+ */
+export declare function picturesNote(root: string, context: Context, world: World, place: Page | undefined): string | undefined;
+/** What the master hears as a quest opens without a picture, where the campaign wants one for each new quest (D-388); undefined otherwise. */
+export declare function questPictureNote(root: string, context: Context, world: World, quest: Page): string | undefined;
+/**
+ * What the master hears as characters and creatures enter a scene without a picture of their own, where the campaign wants one for each one met (D-420, PIC-4):
+ * one line, with the advice to write a creature of the campaign for one of the game system, which is read-only; undefined when all have one, or otherwise.
+ */
+export declare function metPictureNote(root: string, context: Context, entering: Page[]): string | undefined;
+/** The folders whose images folder holds the pictures pages link: the campaign's first, then its game system's (D-267). */
+export declare function imageFolders(root: string, context: Context): string[];
+/** The picture an image field links, as a file; undefined when the field is not a link or no images folder has the file. */
+export declare function imageFile(root: string, context: Context, value: unknown): string | undefined;
+/**
+ * The picture a page shows, as the name of its file and when it last changed: its own, or that of the first page it derives from that has one (D-267), among
+ * the bases `known` takes (D-277); undefined when no images folder has it.
+ */
+export declare function shownImage(root: string, context: Context, world: World, page: Page, known?: (base: Page) => boolean): {
+    file: string;
+    version: number;
+} | undefined;
+/** The page's own image field, as written; undefined when it has none. */
+export declare function ownImage(page: Page): unknown;
+/** The pages of the campaign whose own image field links a file that no images folder has. */
+export declare function imageProblems(root: string, context: Context, world: World): Problem[];

package/dist/commands/game-images.js

@@ -0,0 +1,87 @@
+import { basename } from "node:path";
+import { readSettings } from "../campaign/index.js";
+import { files } from "../core/store.js";
+import { findImage, imageFileName } from "../images/index.js";
+import { baseChain, isPartyMember, ownField } from "../pages/index.js";
+import { campaignSystem } from "./game-world.js";
+/**
+ * What the master hears of the places' pictures (D-308, PIC-4): where pictures can be made and the player has not chosen, to ask them once; with new elements, that
+ * the place the party is in, still without a picture, should get one. Nothing otherwise.
+ */
+export function picturesNote(root, context, world, place) {
+    const setting = readSettings(root).pictures;
+    if (setting === undefined) {
+        const ready = context.pictures?.ready();
+        return ready?.ready === true
+            ? `Pictures: this computer can make the pictures of places, quests and those met with the player's ${ready.maker === "Claude" ? "Claude Code" : "Codex"}, which spends their plan: ask them once whether they want one for each new place, quest and one met, only those they ask for, or none; then config pictures (new elements, on request or none).`
+            : undefined;
+    }
+    if (setting !== "new elements" || place === undefined || place.type !== "place" || shownImage(root, context, world, place) !== undefined) {
+        return undefined;
+    }
+    return `${place.name} has no picture: once you have told it, have one made with image, page ${place.name}, describe what the party sees arriving, never what they cannot see.`;
+}
+/** What the master hears as a quest opens without a picture, where the campaign wants one for each new quest (D-388); undefined otherwise. */
+export function questPictureNote(root, context, world, quest) {
+    return readSettings(root).pictures === "new elements" && shownImage(root, context, world, quest) === undefined
+        ? `${quest.name} has no picture: have one made with image, page ${quest.name}, describe the quest as the character knows it, never what they do not know.`
+        : undefined;
+}
+/**
+ * What the master hears as characters and creatures enter a scene without a picture of their own, where the campaign wants one for each one met (D-420, PIC-4):
+ * one line, with the advice to write a creature of the campaign for one of the game system, which is read-only; undefined when all have one, or otherwise.
+ */
+export function metPictureNote(root, context, entering) {
+    if (readSettings(root).pictures !== "new elements") {
+        return undefined;
+    }
+    const met = entering.filter((page) => !isPartyMember(page));
+    const own = met.filter((page) => page.system === undefined && imageFile(root, context, ownImage(page)) === undefined).map((page) => page.name);
+    // A creature of the game system has at most its system's icon: the campaign's own creature takes the picture.
+    const system = met.filter((page) => page.system !== undefined).map((page) => page.name);
+    const make = own.length === 0 ? [] : [`No picture yet of ${own.join(", ")}: have each made with image, page and describe, what the character sees, never what it does not know.`];
+    const write = system.length === 0
+        ? []
+        : [`${system.join(", ")} ${system.length === 1 ? "is" : "are"} of the game system: for a picture, write a creature of the campaign from it, as write "<name>", type creature, set creature=[[${system[0]}]], and bring that in.`];
+    return make.length + write.length === 0 ? undefined : [...make, ...write].join(" ");
+}
+/** The folders whose images folder holds the pictures pages link: the campaign's first, then its game system's (D-267). */
+export function imageFolders(root, context) {
+    const system = campaignSystem(root, context);
+    return system === undefined ? [root] : [root, system.folder];
+}
+/** The picture an image field links, as a file; undefined when the field is not a link or no images folder has the file. */
+export function imageFile(root, context, value) {
+    const name = imageFileName(value);
+    return name === undefined ? undefined : findImage(imageFolders(root, context), name);
+}
+/**
+ * The picture a page shows, as the name of its file and when it last changed: its own, or that of the first page it derives from that has one (D-267), among
+ * the bases `known` takes (D-277); undefined when no images folder has it.
+ */
+export function shownImage(root, context, world, page, known = () => true) {
+    const holder = [page, ...baseChain(world, page).filter(known)].find((source) => imageFileName(ownImage(source)) !== undefined);
+    const file = holder === undefined ? undefined : imageFile(root, context, ownImage(holder));
+    return file === undefined ? undefined : { file: basename(file), version: Math.trunc(files().modified(file) ?? 0) };
+}
+/** The page's own image field, as written; undefined when it has none. */
+export function ownImage(page) {
+    const field = ownField(page, "image");
+    return field === undefined ? undefined : page.fields[field];
+}
+/** The pages of the campaign whose own image field links a file that no images folder has. */
+export function imageProblems(root, context, world) {
+    const folders = imageFolders(root, context);
+    return world.pages.filter((page) => page.system === undefined).flatMap((page) => {
+        const field = ownField(page, "image");
+        const name = field === undefined ? undefined : imageFileName(page.fields[field]);
+        if (name === undefined || findImage(folders, name) !== undefined) {
+            return [];
+        }
+        return [{
+                path: page.path,
+                message: `image links ${name}, which is in no images folder, of the campaign or of its game system.`,
+                fix: `give ${page.name} its picture again with image, or write the name of a file in images/`,
+            }];
+    });
+}

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

@@ -0,0 +1,62 @@
+import { type Start } from "../map/index.ts";
+import { type Page, type Position, type World } from "../pages/index.ts";
+import { type GameDate } from "../time/index.ts";
+import { type Measures, type Roads } from "./game-roads.ts";
+/** Where on a road a journey stopped (TRV-7): the road, its stretch by its place in the road, the ends of the stretch in the way it went, the metres done after `from`. */
+export interface OnRoad {
+    road: string;
+    index: number;
+    from: string;
+    toward: string;
+    done: number;
+}
+/** How long a stop must last for the hours of travel to start again (TRV-8): a night's rest. */
+export declare const restMinutes: number;
+/** A journey as state.yaml keeps it. */
+export interface Journey {
+    /** What travels: the travellers, or the vehicle that carries them (TRV-6). */
+    movers: string[];
+    /** Where it goes; none once it arrived, while the day's hours still count. */
+    to?: string;
+    /** Off the roads, the way it goes instead of a place, and the metres left, when a distance was given (TRV-12). */
+    heading?: string;
+    left?: number;
+    on?: OnRoad;
+    /** Where in the open it stopped (TRV-12), and on which map, by the place that holds it; none for the main map (POS-8). */
+    at?: Position;
+    map?: string;
+    pace?: string;
+    /** When its last travel ended, the minutes travelled since the last rest, and the hours of travel given for them (TRV-8). */
+    last: GameDate;
+    travelled: number;
+    hours?: number;
+}
+/** The journey in state.yaml; none when there is none, or it does not read: then the next travel starts afresh. */
+export declare function readJourney(root: string): Journey | undefined;
+/** Writes the journey in state.yaml, or removes it. */
+export declare function saveJourney(root: string, journey: Journey | undefined): void;
+/** 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 declare function travelledSinceRest(journey: Journey | undefined, now: GameDate): number;
+/** Whether a journey is made by these movers, the same ones. */
+export declare function sameMovers(journey: Journey, movers: Page[]): boolean;
+/** The movers of a journey as pages, those that still exist. */
+export declare function moversNamed(world: World, journey: Journey): Page[];
+/** 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 declare function journeyStart(world: World, roads: Roads, journey: Journey, movers: Page[]): Start | undefined;
+/** 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 declare function moversMap(world: World, journey: Journey | undefined, movers: Page[]): Page | undefined;
+/**
+ * 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 declare function journeyPoint(world: World, journey: Journey, movers: Page[]): Position | 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 declare function moversPosition(world: World, roads: Roads, journey: Journey | undefined, movers: Page[]): Position | undefined;
+/**
+ * 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 declare function journeyText(world: World, roads: Roads, journey: Journey | undefined, measures: Measures): string | undefined;