rpg-engine 0.0.0-stage → 0.1.1

package/dist/commands/game-events.js

@@ -0,0 +1,325 @@
+import { appendLogEntry } from "../core/log.js";
+import { comparableText } from "../core/text.js";
+import { formatCounter, readCounter } from "../counters/index.js";
+import { backlinks, containerFieldOf, isEmptyField, isInParty, linksIn, locate, newPageFields, pagesWithName, pageWithPath, parsePageReference, standardValues, systemLabel, systemPageNamed, withPage, writePage, } from "../pages/index.js";
+import { formatDuration, formatGameDate, minutesBetween, readGameDate } from "../time/index.js";
+import { formatTrigger, readTriggers, triggerHolds } from "../triggers/index.js";
+import { newDatedLogEntry } from "./game-time.js";
+import { shortList } from "./notes.js";
+/** The planned events: those with a game date first, in order of date, then those without one. */
+export function plannedEvents(world) {
+    const events = world.pages.filter((page) => isPlannedEvent(page.type, page.fields)).map(plannedEventOf);
+    const dated = events.filter(isDated).sort((first, second) => minutesBetween(second.date, first.date));
+    return [...dated, ...events.filter((event) => !isDated(event))];
+}
+export function isDated(event) {
+    return event.date !== undefined;
+}
+/** The party and the containers of the world, as conditions read them (EVT-3). */
+export function worldFacts(world) {
+    const byName = new Map();
+    for (const page of world.pages) {
+        byName.set(comparableText(page.name), [...(byName.get(comparableText(page.name)) ?? []), page]);
+    }
+    const single = (name) => {
+        const pages = byName.get(comparableText(name)) ?? [];
+        return pages.length === 1 ? pages[0] : undefined;
+    };
+    return {
+        party: world.pages.filter(isInParty).map((page) => page.name),
+        isPage: (name) => single(name) !== undefined,
+        containersOf: (name) => {
+            const page = single(name);
+            return page === undefined ? [] : locate(world, page).chain.map((holder) => holder.name);
+        },
+        statusOf: (name) => {
+            const page = single(name);
+            return page === undefined ? undefined : statusOf(page);
+        },
+    };
+}
+/**
+ * Whether a planned event is due (EVT-1): its date has come. Without a date it can read, or before the game has a date,
+ * also when its clock is full or one of its conditions holds.
+ */
+export function isDue(event, now, facts) {
+    if (event.date !== undefined && now !== undefined) {
+        return minutesBetween(now, event.date) <= 0;
+    }
+    return triggerOf(event.page, facts) !== undefined;
+}
+/** The planned events due now (EVT-1), in the order of plannedEvents. */
+export function dueEvents(world, now, facts = worldFacts(world)) {
+    return plannedEvents(world).filter((event) => isDue(event, now, facts));
+}
+/** A due event as outputs name it, with where it happens, which tells who sees it: "Sparizione di Rosa (day 1, 23:00, at Guadoscuro)". */
+export function dueText(event) {
+    const place = typeof event.page.fields.place === "string" && !isEmptyField(event.page.fields.place) ? parsePageReference(event.page.fields.place).name : undefined;
+    return withParts(event.page.name, [event.date === undefined ? undefined : formatGameDate(event.date), place === undefined ? undefined : `at ${place}`]);
+}
+/** A planned event still to come, with what brings it (EVT-9): "La marcia della Confraternita (clock 2/4, day 3, 06:00, in 1d)", "I servitori si svegliano (when party in Ossario)". */
+export function plannedText(event, now) {
+    const clock = eventClock(event.page);
+    const until = now === undefined || event.date === undefined ? 0 : minutesBetween(now, event.date);
+    const triggers = eventTriggers(event.page).map((trigger) => formatTrigger(trigger, false));
+    return withParts(event.page.name, [
+        clock === undefined ? undefined : `clock ${formatCounter(clock)}`,
+        event.date === undefined ? undefined : formatGameDate(event.date),
+        until > 0 ? `in ${formatDuration(until)}` : undefined,
+        triggers.length === 0 ? undefined : `when ${triggers.join(" or ")}`,
+    ]);
+}
+/** What to do with due events (D-106): seen or heard, a scene; out of sight, off screen; then their status, or a later date. */
+export function dueAdvice(count) {
+    return count === 1
+        ? "If the characters see or hear it, play it as a scene; if not, it happens off screen, and they will find its traces. Then set its status: happened if it went as written, cancelled if it never will; or give it a later date if it is put off or tried again."
+        : "Play as scenes those the characters see or hear; the others happen off screen, and they will find their traces. Then set each one's status: happened if it went as written, cancelled if it never will; or give it a later date if it is put off or tried again.";
+}
+/**
+ * Fires the planned events that a command set off (EVT-4): each gets the present date, unless it has one that has come, and a hidden line in the log.
+ * `before` and `after` are the world before and after the command. Returns the events the command made due, fired or not (EVT-5).
+ */
+export function fireEvents(root, context, before, after, now) {
+    const { fired, held } = eventsToFire(before, after, now);
+    let world = after;
+    for (const { event, cause, date } of fired) {
+        if (date !== undefined) {
+            world = withPage(world, event.page, writePage(world, event.page.name, undefined, { set: { date } }).page);
+        }
+        const was = date === undefined || isEmptyField(event.page.fields.date) ? undefined : event.page.fields.date;
+        appendLogEntry(root, newDatedLogEntry(root, context, "event-due", "hidden", { event: event.page.name, since: cause, date, was }));
+    }
+    const causes = new Map(fired.map(({ event, cause }) => [event.page.path, cause]));
+    const wasDue = new Set(dueEvents(before, now).map((event) => event.page.path));
+    const due = dueEvents(world, now).filter((event) => !wasDue.has(event.page.path)).map((event) => {
+        const cause = causes.get(event.page.path);
+        return { name: event.page.name, text: cause === undefined ? dueText(event) : `${dueText(event)}, since ${cause}` };
+    });
+    return { due, held: held.map((event) => plannedText(event, now)), world };
+}
+/**
+ * The events that fire between the world before a command and the world after it (EVT-4): planned after it, set off after it and not before, and not due before it.
+ * Each with what set it off and the date to write on it: the present one, when the game has one and the event has none that has come. An event whose name two pages
+ * share never fires, since no write could pick it. An event given a date still to come by this very command waits for it: those are `held`.
+ */
+export function eventsToFire(before, after, now) {
+    const factsBefore = worldFacts(before);
+    const factsAfter = worldFacts(after);
+    const fired = [];
+    const held = [];
+    for (const event of plannedEvents(after)) {
+        const cause = triggerOf(event.page, factsAfter);
+        const old = pageWithPath(before, event.page.path);
+        const wasPlanned = old !== undefined && isPlannedEvent(old.type, old.fields);
+        const dateChanged = JSON.stringify(old?.fields.date) !== JSON.stringify(event.page.fields.date);
+        // Due before, it already came; set off before with the same date, it waits for that date, put off or given by an earlier command.
+        const cameOrWaits = wasPlanned && (isDue(plannedEventOf(old), now, factsBefore) || (triggerOf(old, factsBefore) !== undefined && !dateChanged));
+        if (cause === undefined || cameOrWaits || !factsAfter.isPage(event.page.name)) {
+            continue;
+        }
+        const comesLater = now !== undefined && event.date !== undefined && minutesBetween(now, event.date) > 0;
+        if (comesLater && dateChanged) {
+            held.push(event);
+        }
+        else {
+            fired.push({ event, cause, date: now !== undefined && (event.date === undefined || comesLater) ? formatGameDate(now) : undefined });
+        }
+    }
+    return { fired, held };
+}
+/** "Now due: …", with how to play them; empty when nothing came due. */
+export function nowDueNote(due) {
+    return due.length === 0 ? "" : `Now due: ${due.map((event) => event.text).join(" · ")}. ${dueAdvice(due.length)}`;
+}
+/** The events set off that wait for the date this command gave them (EVT-4); empty when there are none. */
+export function heldNote(held) {
+    return held.length === 0 ? "" : `Set off, but given a date still to come, so waiting for it: ${held.join(" · ")}. To have it come now, unset its date.`;
+}
+/**
+ * What a write changed that matters to the story (D-117, EVT-7): a page's status as the tools read it, or something leaving a container, but a living member of the party
+ * moving, which is the game itself (D-146). The planned events and the planned or open quests that link to the page or to what left, as a note for the master to judge;
+ * `skipped` are the events already said due.
+ */
+export function consequencesNotes(world, before, after, skipped, now) {
+    if (before === undefined) {
+        return [];
+    }
+    const party = new Set(world.pages.filter(isInParty).map((page) => comparableText(page.name)));
+    const field = containerFieldOf(after.type);
+    const kept = new Set(linksIn(field === undefined ? undefined : after.fields[field]).map(comparableText));
+    const left = linksIn(field === undefined ? undefined : before.fields[field]).map(comparableText).filter((name) => !kept.has(name) && !party.has(name));
+    const subjects = new Set([...(statusOf(before) === statusOf(after) ? [] : [comparableText(after.name)]), ...left]);
+    return linkedStoryNotes(world, world.pages.filter((page) => subjects.has(comparableText(page.name))), skipped, now);
+}
+/**
+ * For each page, the planned events and the planned or open quests linked to it, as a note for the master to judge (D-117, EVT-7, CON-5); `skipped` are the events
+ * already said due.
+ */
+export function linkedStoryNotes(world, pages, skipped, now) {
+    const shown = new Set(skipped.map(comparableText));
+    return pages.flatMap((page) => {
+        const linked = backlinks(world, page).map((link) => link.page).filter((other) => isOpenStory(other) && !shown.has(comparableText(other.name)));
+        return linked.length === 0 ? [] : [`Linked to ${page.name}: ${shortList(linked.map((other) => storyText(other, now)), " · ")}. ${storyAdvice(linked)}`];
+    });
+}
+/** What the master may write of the stories linked to a page: an event's status, date or by; a quest's status, when its story has ended. */
+function storyAdvice(linked) {
+    const events = linked.some((page) => page.type !== "quest") ? "If an event no longer goes as planned, write it: its status, date or by." : "";
+    const quests = linked.some((page) => page.type === "quest") ? "If the story of a quest has ended, set its status." : "";
+    return [events, quests].filter((advice) => advice !== "").join(" ");
+}
+/** The clocks of the planned events not due yet, with who carries them (EVT-8, D-135): "La marcia della Confraternita 2/4 (Fratello Odo)". */
+export function clocksToMove(world, now, facts = worldFacts(world)) {
+    return plannedEvents(world).filter((event) => !isDue(event, now, facts)).flatMap((event) => {
+        const clock = eventClock(event.page);
+        const makers = linksIn(event.page.fields.by);
+        return clock === undefined ? [] : [`${event.page.name} ${formatCounter(clock)}${makers.length === 0 ? "" : ` (${makers.join(", ")})`}`];
+    });
+}
+/** Why the date of a planned event cannot be used: a planned event comes due at its date, so the engine must read it (D-100). Undefined for anything else. */
+export function plannedEventDateProblem(type, fields) {
+    if (!isPlannedEvent(type, fields) || isEmptyField(fields.date) || readGameDate(fields.date) !== undefined) {
+        return undefined;
+    }
+    return `The date ${JSON.stringify(fields.date)} is not a game date: a planned event needs one the engine can read, such as day 1, 23:00. Words, such as two winters ago, fit only an event that has happened.`;
+}
+/** What is wrong with an event's clock or conditions, among the fields a write changed (EVT-10); undefined when they read. Statuses are checked on the pages that exist. */
+export function eventFieldsProblem(world, fields, changed) {
+    return (changed.includes("clock") ? clockProblem(fields.clock) : undefined) ?? (changed.includes("when") ? whenProblem(world, fields.when) : undefined);
+}
+/** Conditions on pages that do not exist yet: they cannot hold until a page has that name, which may be an alias of another (EVT-10). */
+export function conditionNotes(world, when) {
+    const read = isEmptyField(when) ? { triggers: [] } : readTriggers(when);
+    const named = "triggers" in read ? read.triggers.flatMap(namedPages) : [];
+    return [...new Set(named)].filter((name) => pagesWithName(world, name).length === 0).map((name) => {
+        const system = systemPageNamed(world, name);
+        if (system !== undefined) {
+            return systemConditionText(system);
+        }
+        const aliased = world.pages.find((page) => textsOf(page.fields.aliases).some((alias) => comparableText(alias) === comparableText(name)));
+        const hint = aliased === undefined ? "" : ` ${aliased.name} has ${name} among its aliases: write [[${aliased.name}]].`;
+        return `[[${name}]] is not a page yet: the condition on it cannot hold until a page has that name.${hint}`;
+    });
+}
+/** The problems of the planned events (D-100, EVT-10, D-117): dates the engine cannot read, clocks and conditions that do not read, events made to happen by the dead. */
+export function eventProblems(world) {
+    return world.pages.filter((page) => page.type === "event").flatMap((page) => {
+        const problem = (message, fix) => (message === undefined ? [] : [{ path: page.path, message, fix }]);
+        const dead = isPlannedEvent(page.type, page.fields) ? deadMakers(world, page) : [];
+        const makers = dead.length === 1 ? `${dead[0]}, who makes it happen, is` : `${dead.join(" and ")}, who make it happen, are`;
+        const date = plannedEventDateProblem(page.type, page.fields) === undefined ? undefined : `${page.name} is planned, but its date ${JSON.stringify(page.fields.date)} is not a game date.`;
+        // A clock or conditions of the wrong kind of value are reported once, with the standard fields.
+        const clock = typeof page.fields.clock === "string" || typeof page.fields.clock === "number" ? clockProblem(page.fields.clock) : undefined;
+        const when = textsOf(page.fields.when).length === (Array.isArray(page.fields.when) ? page.fields.when.length : 1) ? whenProblem(world, page.fields.when) : undefined;
+        return [
+            ...problem(date, `write ${page.name}, set date to a game date such as day 1, 23:00, or status to happened if it already took place`),
+            ...problem(clock === undefined ? undefined : `${page.name}: ${clock}`, `write ${page.name}, set clock to current/max, such as 0/4, or unset it`),
+            ...problem(when === undefined ? undefined : `${page.name}: ${when}`, `write ${page.name}, set when to a condition such as party in [[Place]], or unset it`),
+            ...problem(dead.length === 0 ? undefined : `${page.name} is planned, but ${makers} dead.`, "cancel it, give it to someone else with by, or write what happens instead"),
+        ];
+    });
+}
+/** What sets an event off now: its full clock, or the first of its conditions that holds; undefined when nothing does (EVT-2, EVT-3). */
+function triggerOf(page, facts) {
+    const clock = eventClock(page);
+    if (clock !== undefined && clock.value >= clock.max) {
+        return `clock ${formatCounter(clock)}`;
+    }
+    const holding = eventTriggers(page).find((trigger) => triggerHolds(trigger, facts));
+    return holding === undefined ? undefined : formatTrigger(holding, false);
+}
+/** An event is planned when its status says so, or when it has none (D-107). */
+function isPlannedEvent(type, fields) {
+    return type === "event" && (fields.status === "planned" || isEmptyField(fields.status));
+}
+function plannedEventOf(page) {
+    return { page, date: readGameDate(page.fields.date) };
+}
+/** Why a clock does not read: it is current/max, with a maximum of at least 1 (EVT-2). */
+function clockProblem(value) {
+    return isEmptyField(value) || clockOf(value) !== undefined ? undefined : `The clock ${JSON.stringify(value)} is not a clock: write it as current/max, with a maximum of at least 1, such as 0/4.`;
+}
+/** Why conditions do not read, or ask a page for a status its type does not have. */
+function whenProblem(world, when) {
+    if (isEmptyField(when)) {
+        return undefined;
+    }
+    const read = readTriggers(when);
+    return "problem" in read ? read.problem : read.triggers.map((trigger) => statusProblem(world, trigger) ?? systemConditionProblem(world, trigger)).find((problem) => problem !== undefined);
+}
+/** A condition on a page of the game system, which no page of the campaign hides: it can never hold (SYS-2). */
+function systemConditionProblem(world, trigger) {
+    const system = namedPages(trigger)
+        .filter((name) => pagesWithName(world, name).length === 0)
+        .map((name) => systemPageNamed(world, name))
+        .find((page) => page !== undefined);
+    return system === undefined ? undefined : systemConditionText(system);
+}
+/** "[[Wolf]] is a creature of the system 5e, a kind: never anywhere, never dead, so the condition on it can never hold. …" */
+function systemConditionText(page) {
+    return `[[${page.name}]] is ${systemLabel(page)}, a kind: never anywhere, never dead, so the condition on it can never hold. `
+        + `Name a page of the campaign instead, such as one with ${page.type === "item" ? "item" : "creature"}=[[${page.name}]].`;
+}
+/** The characters an event names in by who are dead (EVT-6). */
+function deadMakers(world, event) {
+    return linksIn(event.fields.by).flatMap((name) => {
+        const pages = pagesWithName(world, name);
+        return pages.length === 1 && pages[0].type === "character" && pages[0].fields.status === "dead" ? [pages[0].name] : [];
+    });
+}
+/** A status condition on a page whose type has no such status, such as [[Ossario]] dead; pages that do not exist are left to the notes and the link check. */
+function statusProblem(world, trigger) {
+    const pages = trigger.kind === "status" ? pagesWithName(world, trigger.page) : [];
+    if (trigger.kind !== "status" || pages.length !== 1) {
+        return undefined;
+    }
+    const page = pages[0];
+    const values = standardValues(page.type, "status");
+    if (values === undefined) {
+        return `[[${page.name}]] ${trigger.status} can never hold: ${page.name} has no status. Conditions on it are "[[${page.name}]] in [[Place]]" or "[[${page.name}]] in party".`;
+    }
+    return values.includes(trigger.status) ? undefined : `[[${page.name}]] ${trigger.status} can never hold: the status of ${page.name} is one of ${values.join(", ")}.`;
+}
+/** A page's status as the tools read it (EVT-3): a character without one is alive, a quest or an event without one is planned; undefined for a type without statuses. */
+function statusOf(page) {
+    if (page.type === undefined || standardValues(page.type, "status") === undefined) {
+        return undefined;
+    }
+    return isEmptyField(page.fields.status) ? String(newPageFields(page.type).status ?? "alive") : String(page.fields.status);
+}
+/** An event's clock: current/max with a maximum of at least 1 (EVT-2); undefined for anything else. */
+function eventClock(page) {
+    return clockOf(page.fields.clock);
+}
+function clockOf(value) {
+    const counter = readCounter(value);
+    return counter?.max !== undefined && counter.max >= 1 ? { value: counter.value, max: counter.max } : undefined;
+}
+/** The conditions an event listens to; none when its when cannot be read, which validate reports (EVT-10). */
+function eventTriggers(page) {
+    if (isEmptyField(page.fields.when)) {
+        return [];
+    }
+    const read = readTriggers(page.fields.when);
+    return "triggers" in read ? read.triggers : [];
+}
+/** The pages a condition names. */
+function namedPages(trigger) {
+    return trigger.kind === "status" ? [trigger.page] : [trigger.what, trigger.where].flatMap((subject) => ("page" in subject ? [subject.page] : []));
+}
+/** A planned event, or a planned or open quest: what a change in the story may change. */
+function isOpenStory(page) {
+    return isPlannedEvent(page.type, page.fields) || (page.type === "quest" && ["planned", "open"].includes(statusOf(page) ?? ""));
+}
+function storyText(page, now) {
+    return page.type === "quest" ? `${page.name} (quest, ${statusOf(page) ?? ""})` : plannedText(plannedEventOf(page), now);
+}
+/** The texts a field holds: itself when it is text, the texts in it when it is a list. */
+function textsOf(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : typeof value === "string" ? [value] : [];
+}
+/** "Name (a, b)", or the name alone when there are no parts. */
+function withParts(name, parts) {
+    const given = parts.filter((part) => part !== undefined);
+    return given.length === 0 ? name : `${name} (${given.join(", ")})`;
+}

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

@@ -0,0 +1,57 @@
+import type { Problem } from "../core/problem.ts";
+import { type World } from "../pages/index.ts";
+/**
+ * A character's points as the system counts them: its level, the least its level needs, the next level and the points it needs, and the highest level the
+ * points reach beyond its own.
+ */
+export interface Experience {
+    field: string;
+    points: number;
+    level: number;
+    least?: number;
+    next?: {
+        level: number;
+        points: number;
+    };
+    due?: number;
+    rules?: string;
+}
+/**
+ * The experience of a character with these fields, when the system counts it (PRO-6): the level is the sum of the numbers of the progression's list. Undefined
+ * without a system that counts it, without points, or without a level.
+ */
+export declare function experienceOf(world: World, fields: Record<string, unknown>): Experience | undefined;
+/** What the points say of the levels (PRO-6): how many the next level needs, the level they reach that is due, or the least the level needs when they are below it. */
+export type LevelNeed = {
+    needs: number;
+    level: number;
+} | {
+    due: number;
+} | {
+    least: number;
+    level: number;
+};
+/** What the points say of the levels, as the dashboard writes it in its language (PRO-6); undefined at the last level of the table. */
+export declare function levelNeed(experience: Experience): LevelNeed | undefined;
+/**
+ * "550 to level 3", "level 3 due", or "at least 6500 at level 5" for points below what the level needs: what the line and the sheet say beside the points
+ * (PRO-6); undefined at the last level of the table.
+ */
+export declare function experienceText(experience: Experience): string | undefined;
+/**
+ * "Ennio has the xp for level 3: level up with the player, …": said while the points reach a level the classes have not (PRO-6); a companion's choices are the
+ * master's (D-205, D-209). Undefined when they reach none.
+ */
+export declare function levelDueNote(name: string, experience: Experience | undefined, companion: boolean): string | undefined;
+/**
+ * The note of a change that brings the points to a new level, with what `levelUp` gives of the part on what a level gives, empty once told (PRO-6, D-97): none when
+ * that level was already due, and then the part is not asked for.
+ */
+export declare function newLevelNotes(name: string, before: Experience | undefined, after: Experience | undefined, companion: boolean, levelUp: () => string): string[];
+/** "Ennio is level 5: a character of that level has at least 6500 xp": said when a write leaves the points below what the level needs (PRO-6). */
+export declare function leastNotes(name: string, before: Experience | undefined, after: Experience | undefined): string[];
+/**
+ * The living player characters and companions whose points are below what their level needs, or are written with a maximum, which points never have (PRO-6), as
+ * validate reports them.
+ */
+export declare function experienceProblems(world: World): Problem[];

package/dist/commands/game-experience.js

@@ -0,0 +1,119 @@
+// The experience points of a character (D-205, D-233, PRO-6): how many it lacks for the next level, the least its level needs, and the level they reach that its
+// classes have not.
+import { listItems, numberOf } from "../core/formula.js";
+import { comparableText, valueNamed } from "../core/text.js";
+import { readCounter } from "../counters/index.js";
+import { isInParty } from "../pages/index.js";
+import { effectiveFields } from "./effect-layer.js";
+/**
+ * The experience of a character with these fields, when the system counts it (PRO-6): the level is the sum of the numbers of the progression's list. Undefined
+ * without a system that counts it, without points, or without a level.
+ */
+export function experienceOf(world, fields) {
+    const progression = world.system?.progression;
+    const rule = progression?.experience;
+    const table = rule === undefined ? undefined : Object.entries(world.system?.formulas?.tables ?? {}).find(([name]) => comparableText(name) === comparableText(rule.table))?.[1];
+    const points = rule === undefined ? undefined : numberOf(fieldOf(fields, rule.field));
+    const level = progression === undefined ? 0 : listItems(fieldOf(fields, progression.list)).reduce((total, item) => total + (item.number ?? 0), 0);
+    if (rule === undefined || table === undefined || points === undefined || level === 0) {
+        return undefined;
+    }
+    const needs = (target) => table.rows.find(([key]) => Number(key) === target)?.[1];
+    const reached = table.rows.filter(([key, value]) => Number(key) > level && value <= points).map(([key]) => Number(key));
+    const least = needs(level);
+    const next = needs(level + 1);
+    return {
+        field: rule.field,
+        points,
+        level,
+        ...(least === undefined ? {} : { least }),
+        ...(next === undefined ? {} : { next: { level: level + 1, points: next } }),
+        ...(reached.length === 0 ? {} : { due: Math.max(...reached) }),
+        ...(rule.rules === undefined ? {} : { rules: rule.rules }),
+    };
+}
+/** What the points say of the levels, as the dashboard writes it in its language (PRO-6); undefined at the last level of the table. */
+export function levelNeed(experience) {
+    if (experience.least !== undefined && experience.points < experience.least) {
+        return { least: experience.least, level: experience.level };
+    }
+    if (experience.due !== undefined) {
+        return { due: experience.due };
+    }
+    return experience.next === undefined ? undefined : { needs: experience.next.points - experience.points, level: experience.next.level };
+}
+/**
+ * "550 to level 3", "level 3 due", or "at least 6500 at level 5" for points below what the level needs: what the line and the sheet say beside the points
+ * (PRO-6); undefined at the last level of the table.
+ */
+export function experienceText(experience) {
+    const need = levelNeed(experience);
+    if (need === undefined) {
+        return undefined;
+    }
+    return "least" in need ? `at least ${need.least} at level ${need.level}` : "due" in need ? `level ${need.due} due` : `${need.needs} to level ${need.level}`;
+}
+/**
+ * "Ennio has the xp for level 3: level up with the player, …": said while the points reach a level the classes have not (PRO-6); a companion's choices are the
+ * master's (D-205, D-209). Undefined when they reach none.
+ */
+export function levelDueNote(name, experience, companion) {
+    if (experience?.due === undefined) {
+        return undefined;
+    }
+    const rules = experience.rules === undefined ? "" : `: read rules "${experience.rules}"`;
+    const how = companion
+        ? "level up the companion: the class and what the new level asks are yours to choose, as the story has shaped the companion, or the player's if they made it"
+        : "level up with the player, out of the story, now or at the next rest as they prefer; they choose the class and what the new level asks";
+    return `${name} has the ${experience.field} for level ${experience.due}: ${how}${rules}.`;
+}
+/**
+ * The note of a change that brings the points to a new level, with what `levelUp` gives of the part on what a level gives, empty once told (PRO-6, D-97): none when
+ * that level was already due, and then the part is not asked for.
+ */
+export function newLevelNotes(name, before, after, companion, levelUp) {
+    const note = levelDueNote(name, after, companion);
+    if (note === undefined || (before?.due !== undefined && before.due >= (after?.due ?? 0))) {
+        return [];
+    }
+    const part = levelUp();
+    return [part === "" ? note : `${note} ${part}`];
+}
+/** "Ennio is level 5: a character of that level has at least 6500 xp": said when a write leaves the points below what the level needs (PRO-6). */
+export function leastNotes(name, before, after) {
+    const low = (experience) => experience?.least !== undefined && experience.points < experience.least;
+    return after === undefined || !low(after) || (low(before) && before?.level === after.level)
+        ? []
+        : [`${name} is level ${after.level}: a character of that level has at least ${after.least ?? 0} ${after.field}: change ${name}, field ${after.field}, to ${after.least ?? 0}.`];
+}
+/**
+ * The living player characters and companions whose points are below what their level needs, or are written with a maximum, which points never have (PRO-6), as
+ * validate reports them.
+ */
+export function experienceProblems(world) {
+    const field = world.system?.progression?.experience?.field;
+    return world.pages.filter(isInParty).flatMap((page) => {
+        const experience = experienceOf(world, effectiveFields(world, page));
+        const written = experience === undefined ? undefined : readCounter(fieldOf(page.fields, experience.field));
+        const raw = field === undefined ? undefined : fieldOf(page.fields, field);
+        // Points written as text, such as 350 XP, count for nothing.
+        if (field !== undefined && raw !== undefined && raw !== null && readCounter(raw) === undefined) {
+            return [{ path: page.path, message: `${page.name} has ${field} "${String(raw)}", which is no number of points.`, fix: `write ${page.name}, set ${field} as a whole number, such as ${field}=0` }];
+        }
+        if (experience !== undefined && written?.max !== undefined) {
+            return [{
+                    path: page.path,
+                    message: `${page.name} has ${experience.field} written with a maximum, ${written.max}: experience points have none, and change stops at it.`,
+                    fix: `write ${page.name}, set ${experience.field}=${written.value}`,
+                }];
+        }
+        return experience?.least === undefined || experience.points >= experience.least ? [] : [{
+                path: page.path,
+                message: `${page.name} has ${experience.points} ${experience.field} at level ${experience.level}, which needs at least ${experience.least}.`,
+                fix: `change ${page.name}, field ${experience.field}, to ${experience.least}`,
+            }];
+    });
+}
+function fieldOf(fields, field) {
+    return valueNamed(fields, field);
+}

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

@@ -0,0 +1,33 @@
+import { type Grid, type Square } from "../grid/index.ts";
+import { type World } from "../pages/index.ts";
+import type { Scene } from "../scene/index.ts";
+import type { GameSystem, GridRules } from "../systems/index.ts";
+import type { Standing } from "./game-grids.ts";
+import type { Measures } from "./game-roads.ts";
+/** A move on a place's map: who moves, as the place's `at` names them, from where to where, and the others on it as they stood before. */
+export interface MapMove {
+    grid: Grid;
+    who: Standing;
+    from: Square;
+    to: Square;
+    others: Standing[];
+}
+/** What a move on a map says (GRD-5): how far it went, the words for the master, and the scene's new count of the turn when it changes. */
+export interface MoveFacts {
+    distance?: string;
+    notes: string[];
+    moved?: Scene["moved"];
+}
+/** The facts of a move on a place's map (GRD-5), as the game's grid counts them; nothing to tell when the game has no grid. */
+export declare function moveFacts(world: World, system: GameSystem | undefined, measures: Measures, scene: Scene | undefined, move: MapMove): MoveFacts;
+/** The side in squares of what one fills on the map (GRD-4): from the size of its page, or of its copy's creature; 1 when the game says nothing of it. */
+export declare function sideOf(world: World, rules: GridRules, scene: Scene | undefined, one: Standing): number;
+/** Whether it is one's turn in the open scene, which has turns (GRD-5). */
+export declare function isTurnOf(scene: Scene | undefined, name: string): boolean;
+/** How many squares the one whose turn it is has moved in it, as the scene keeps it (GRD-5): 0 at the start of a turn. */
+export declare function movedThisTurn(scene: Scene): number;
+/** One's walking speed (GRD-5): the field the system names as written, and its first length in metres, when it gives one. */
+export declare function walkingSpeed(world: World, rules: GridRules, measures: Measures, scene: Scene | undefined, one: Standing): {
+    written: unknown;
+    metres?: number;
+};

package/dist/commands/game-grid-moves.js

@@ -0,0 +1,94 @@
+// What a move on the map of a place tells the master (GRD-4, GRD-5): how far it went by the shortest way, whose side it left on the way and who stands next to
+// it now; in a fight, on its turn, how far it has moved and what is left of its speed, which the open scene keeps for the turn.
+import { formatStep, readFirstLength } from "../core/length.js";
+import { comparableText, valueNamed } from "../core/text.js";
+import { closedSquare, coveredSquares, isNextTo, shortestWay, squareName } from "../grid/index.js";
+import { isEmptyField, isPartyMember } from "../pages/index.js";
+import { effectiveFields } from "./effect-layer.js";
+import { copyPage } from "./game-scene.js";
+/** The facts of a move on a place's map (GRD-5), as the game's grid counts them; nothing to tell when the game has no grid. */
+export function moveFacts(world, system, measures, scene, move) {
+    const rules = system?.grid;
+    if (rules === undefined) {
+        return { notes: [] };
+    }
+    const way = shortestWay(move.grid, move.from, move.to, { diagonal: rules.diagonal, difficult: rules.difficult });
+    const name = move.who.name;
+    if (way === undefined) {
+        return { notes: [`No way on foot leads from ${squareName(move.from)} to ${squareName(move.to)}: ${name} stands there all the same, and how is yours to tell.`] };
+    }
+    const step = (squares) => formatStep(squares * rules.square, measures.units, measures.imperial);
+    const side = sideOf(world, rules, scene, move.who);
+    const footprint = (square) => ({ square, side });
+    const others = move.others.filter(isAlive).flatMap((one) => (one.square === undefined ? [] : [{ name: one.name, foe: isParty(one) !== isParty(move.who), footprint: { square: one.square, side: sideOf(world, rules, scene, one) } }]));
+    const besideAny = (squares) => others.filter((one) => squares.some((square) => isNextTo(footprint(square), one.footprint)));
+    const now = besideAny([move.to]).map((one) => one.name);
+    // Only the side of one on the other side counts: the party, or everyone else.
+    const left = besideAny([move.from, ...way.squares.slice(0, -1)]).filter((one) => one.foe && !now.includes(one.name)).map((one) => one.name);
+    const covered = coveredSquares(footprint(move.to));
+    const shut = covered.map((square) => closedSquare(move.grid, square)).find((closed) => closed !== undefined);
+    const turn = turnFacts(world, rules, measures, scene, move.who, way.cost, step);
+    return {
+        distance: step(way.cost),
+        notes: [
+            ...(now.length === 0 ? [] : [`Next to ${name} now: ${now.join(", ")}.`]),
+            ...(left.length === 0 ? [] : [`Along the shortest way ${name} leaves the side of ${left.join(", ")}${rules.leaving === undefined ? "" : `: read ${rules.leaving}`}.`]),
+            ...(shut === undefined ? [] : [`${name} fills ${squareName(move.to)} to ${squareName(covered.at(-1) ?? move.to)}, but ${shut}.`]),
+            ...turn.notes,
+        ],
+        ...(turn.moved === undefined ? {} : { moved: turn.moved }),
+    };
+}
+/** The side in squares of what one fills on the map (GRD-4): from the size of its page, or of its copy's creature; 1 when the game says nothing of it. */
+export function sideOf(world, rules, scene, one) {
+    const page = standingPage(scene, one);
+    const size = page === undefined || rules.size === undefined ? undefined : valueNamed(effectiveFields(world, page), rules.size);
+    return (typeof size === "string" ? Object.entries(rules.footprints).find(([name]) => comparableText(name) === comparableText(size))?.[1] : undefined) ?? 1;
+}
+/** Whether it is one's turn in the open scene, which has turns (GRD-5). */
+export function isTurnOf(scene, name) {
+    return scene?.order !== undefined && scene.turn !== undefined && comparableText(scene.turn) === comparableText(name);
+}
+/** How many squares the one whose turn it is has moved in it, as the scene keeps it (GRD-5): 0 at the start of a turn. */
+export function movedThisTurn(scene) {
+    const counted = scene.moved !== undefined && scene.turn !== undefined && scene.moved.round === (scene.round ?? 1) && comparableText(scene.moved.turn) === comparableText(scene.turn);
+    return counted ? (scene.moved?.squares ?? 0) : 0;
+}
+/** One's walking speed (GRD-5): the field the system names as written, and its first length in metres, when it gives one. */
+export function walkingSpeed(world, rules, measures, scene, one) {
+    const page = standingPage(scene, one);
+    const written = page === undefined ? undefined : valueNamed(effectiveFields(world, page), rules.speed);
+    const metres = readFirstLength(written, measures.imperial);
+    return { written, ...(metres === undefined ? {} : { metres }) };
+}
+/** On the turn of who moves, in a scene with turns: how far they have moved in it and what is left of their speed, and the scene's new count (GRD-5). */
+function turnFacts(world, rules, measures, scene, who, cost, step) {
+    if (scene === undefined || scene.turn === undefined || !isTurnOf(scene, who.name)) {
+        return { notes: [] };
+    }
+    const moved = { round: scene.round ?? 1, turn: scene.turn, squares: movedThisTurn(scene) + cost };
+    const { written, metres: speed } = walkingSpeed(world, rules, measures, scene, who);
+    if (speed === undefined) {
+        const how = `write ${rules.speed} as 30 ft or 9 m`;
+        return { notes: [isEmptyField(written) ? `${who.name} has no ${rules.speed} to count this turn with: ${how}.` : `${who.name}'s ${rules.speed}, ${String(written)}, does not read as a walking speed: ${how}.`], moved };
+    }
+    const metres = (value) => formatStep(value, measures.units, measures.imperial);
+    const left = Math.round((speed - moved.squares * rules.square) * 100) / 100;
+    const note = left >= 0
+        ? `This turn ${who.name} has moved ${step(moved.squares)} of ${metres(speed)}: ${metres(left)} left.`
+        : `This turn ${who.name} has moved ${step(moved.squares)}, ${metres(-left)} beyond the ${metres(speed)} of ${who.name}'s speed: yours to judge, with what lets one go farther.`;
+    return { notes: [note], moved };
+}
+/** The page of one on the map: a copy's as a page of its creature. */
+function standingPage(scene, one) {
+    const copy = one.copy === undefined ? undefined : scene?.copies[one.copy];
+    return copy === undefined || one.copy === undefined ? one.page : copyPage(one.copy, copy);
+}
+/** Whether one on the map is of the party: the player's character or a companion; a copy never is. */
+function isParty(one) {
+    return one.page !== undefined && isPartyMember(one.page);
+}
+/** Whether one on the map is someone whose side counts: a copy of the scene, or a living character; never a thing, nor the dead. */
+function isAlive(one) {
+    return one.copy !== undefined || (one.page?.type === "character" && one.page.fields.status !== "dead");
+}