rpg-engine 0.0.0-stage → 0.1.0

package/dist/commands/roll.js

@@ -0,0 +1,302 @@
+import { z } from "zod";
+import { requireCampaign } from "../campaign/index.js";
+import { numberOf } from "../core/formula.js";
+import { appendLogEntry, readLog } from "../core/log.js";
+import { defineCommand } from "../core/registry.js";
+import { comparableText, sameName, valueNamed } from "../core/text.js";
+import { readCounter } from "../counters/index.js";
+import { createProof, DiceError, fingerprint, rollDice, sha256 } from "../dice/index.js";
+import { declaredKind, findPage, pagesWithName, writePage } from "../pages/index.js";
+import { effectiveFields, effectsOf } from "./effect-layer.js";
+import { copyPage, readOpenScene } from "./game-scene.js";
+import { newDatedLogEntry } from "./game-time.js";
+import { campaignSystem, campaignWorld, missingSystemHint } from "./game-world.js";
+import { itemList, signedText, workedFields } from "./worked-out.js";
+// Faces arrive as "14,7" or "14 7" from a shell (PowerShell turns 14,7 into "14 7"), or as an array.
+const faceValues = z.preprocess((value) => (typeof value === "string" ? value.split(/[\s,;]+/).filter(Boolean).map(Number) : value), z.array(z.number()));
+// A name in a notation, at the start of a term: a field of the sheet of who rolls, such as athletics or sleight-of-hand (DAT-8). A hyphen inside a name is the
+// name's, as in formulas (FOR-2); a die such as d20 or dF is no name.
+const namePattern = /(^|[+-])(\s*)(\p{L}[\p{L}0-9]*(?:-[\p{L}0-9]+)*)/gu;
+const diePattern = /^\d*d(\d+|%|F)/i;
+export const roll = defineCommand({
+    name: "roll",
+    description: "Roll dice and log the roll. "
+        + "Give why and, if it belongs to someone, who; for a roll the player sees, check names it for them, while why stays yours. "
+        + "When the player rolls physical dice, pass their faces as values. Make it hidden when the player must not see the result. "
+        + "keep stores the dice rolled for later, such as the two d20 of a diviner's Portent, rolled by the player for the player character, by you for a companion; "
+        + "use takes one of those instead of the die and logs which roll it replaced. "
+        + 'Example: notation 1d20+perception, why "notice the trap", who Lena.',
+    group: "game",
+    positionals: ["notation"],
+    input: z.object({
+        notation: z.string().optional().describe("dice to roll: 1d20+5, 2d20kh1 (keep the highest), 4d6dl1 (drop the lowest), 2d6ro<=2 (reroll once), 1d6! (exploding), 6d10>=8 (count successes), 4dF, d%; "
+            + "with who, a field of their sheet stands for its value, such as 1d20+athletics"),
+        why: z.string().optional().describe("what the roll is for"),
+        check: z.string().optional().describe("what the roll is, as the player sees it in the dashboard's rolls, such as Bite or Stealth: never what only you know"),
+        who: z.string().optional().describe("character the roll belongs to, or a copy in the open scene; leave it out for a free roll of the master"),
+        values: faceValues.optional().describe("faces rolled by the player with physical dice, separated by commas; on the command line write --values=-1,0,1 for negative faces"),
+        hidden: z.boolean().optional().describe("only the master sees the result; its fingerprint goes to the player only if they ask for it"),
+        reveal: z.string().optional().describe("id of a hidden roll whose proof to show, later"),
+        keep: z.string().optional().describe("a field of who that keeps rolls for later, such as portent: the dice rolled go there, in place of what it held"),
+        use: z.string().optional().describe("a kept roll to use instead of the die, as field=value, such as portent=3: the notation has one die"),
+        from: z.string().optional().describe("who keeps the roll that use takes, when it is not who rolls"),
+    }),
+    run(input, context) {
+        const root = requireCampaign(context.folder);
+        if (input.reveal !== undefined) {
+            if (input.notation !== undefined) {
+                throw new Error("Give either the dice to roll or the id of a hidden roll to reveal, not both.");
+            }
+            return revealHiddenRoll(input.reveal, root, context);
+        }
+        if (input.notation === undefined) {
+            throw new Error("Give the dice to roll, for example 1d20+5.");
+        }
+        if (input.values && input.hidden) {
+            throw new Error("Physical dice are rolled by the player, so they cannot be hidden.");
+        }
+        if (input.use !== undefined && (input.keep !== undefined || input.values !== undefined || input.hidden === true)) {
+            throw new Error("A kept roll takes the place of the die: give use without keep or values, and not hidden.");
+        }
+        const physical = input.values !== undefined;
+        const system = campaignSystem(root, context);
+        const roller = rollerOf(root, context, input.who, hasNames(input.notation));
+        const named = withSheetValues(input.notation, roller, input.who, system);
+        const keeper = input.keep === undefined ? undefined : keptField(root, context, input.who, input.keep);
+        const used = input.use === undefined ? undefined : keptRoll(root, context, input.from ?? input.who, input.use);
+        const diceRoll = rollWith(named.notation, used, input.values ? { values: input.values } : { random: context.random });
+        // The notation as it was given, with the values its names took from the sheet (DAT-8).
+        const taken = Object.entries(named.taken).map(([field, value]) => `${field} ${roller === undefined ? value : signedText(roller.world, field, value)}`);
+        const text = taken.length === 0 ? diceRoll.text : `${input.notation}${diceRoll.text.slice(diceRoll.notation.length)} (${taken.join(", ")})`;
+        const sheet = taken.length === 0 ? {} : { sheet: named.taken };
+        const keeping = keeper === undefined ? {} : { kept: { field: keeper.field, values: diceRoll.faces } };
+        const using = used === undefined ? {} : { used: { from: used.page.name, field: used.field, value: used.value } };
+        const checked = input.check === undefined ? {} : { check: input.check };
+        const data = { notation: input.notation, total: diceRoll.total, result: text, ...sheet, why: input.why, who: input.who, ...checked, physical, ...keeping, ...using, dice: diceRoll.dice };
+        const entry = newDatedLogEntry(root, context, "roll", input.hidden ? "hidden" : "public", data);
+        let shownFingerprint;
+        if (input.hidden) {
+            const proof = createProof(entry.id, text, context.newSalt());
+            shownFingerprint = fingerprint(proof);
+            Object.assign(entry.data, { proof, fingerprint: shownFingerprint });
+        }
+        // The page first: a page that cannot be written leaves no line in the log saying it was (KEP-2, KEP-3).
+        const kept = keeper !== undefined ? keepFaces(keeper, diceRoll.faces) : used !== undefined ? takeKept(used) : undefined;
+        appendLogEntry(root, entry);
+        const note = roller === undefined ? undefined : rollerNote(roller.world, system, roller.page);
+        return { kind: "roll", id: entry.id, text, total: diceRoll.total, why: input.why, who: input.who, check: input.check, physical, hidden: input.hidden === true, fingerprint: shownFingerprint, note, kept };
+    },
+    format(output) {
+        if (output.kind === "reveal") {
+            const tell = "Tell the player what it was for and what came out, in the story's words; give the proof only if they ask how to check it.";
+            return `Hidden roll ${output.id} revealed: ${output.text}. ${tell}\nProof: ${output.proof}\nSHA-256 of the proof: ${output.sha256} (it starts with the fingerprint ${output.fingerprint})`;
+        }
+        const note = [output.kept, output.note].filter((line) => line !== undefined).map((line) => `\n${line}`).join("");
+        if (output.hidden) {
+            return `Hidden roll ${output.id}, only for the master: ${output.text}\nIts fingerprint, only if the player asks for it: ${output.fingerprint}${note}`;
+        }
+        const label = [output.who, output.check, output.why].filter(Boolean).join(", ");
+        return `${output.id} ${label ? label + ": " : ""}${output.text}${output.physical ? " (physical dice)" : ""}${note}`;
+    },
+});
+/** The field of who rolls that keep writes to (KEP-2): a page's, declared as kept rolls. */
+function keptField(root, context, who, field) {
+    if (who === undefined) {
+        throw new Error(`Give who rolls, whose ${field} keeps the dice, such as who Elara. Nothing rolled.`);
+    }
+    return keptOn(campaignWorld(root, context), who, field);
+}
+/** The kept roll that use names, such as portent=3, on who keeps it (KEP-3); refused, with the numbers the field holds, when it holds no such number. */
+function keptRoll(root, context, holder, use) {
+    const match = /^\s*([^=]+?)\s*=\s*([+-]?\d+)\s*$/.exec(use);
+    if (match === null) {
+        throw new Error(`Give use as the field and the kept number, such as portent=3, not "${use}". Nothing rolled.`);
+    }
+    if (holder === undefined) {
+        throw new Error(`Give who keeps the roll, with from or who, such as from Elara. Nothing rolled.`);
+    }
+    const world = campaignWorld(root, context);
+    const kept = keptOn(world, holder, match[1]);
+    const value = Number(match[2]);
+    if (!kept.values.includes(value)) {
+        throw new Error(`${kept.page.name} keeps no ${value} in ${kept.field}: it keeps ${kept.values.length === 0 ? "none" : kept.values.join(", ")}.${otherKeepers(world, kept, value)} Nothing rolled.`);
+    }
+    return { ...kept, value };
+}
+/**
+ * A page's field of kept rolls, with the numbers it holds; refused for a copy in the scene, for a field the system does not declare as kept rolls, and for one
+ * that holds something other than numbers.
+ */
+function keptOn(world, name, field) {
+    const page = findPage(world, name);
+    if (page === undefined) {
+        throw new Error(`There is no page named ${name} to keep rolls: kept rolls go on a character's page, not on a copy in the scene. Nothing rolled.`);
+    }
+    const written = Object.entries(effectiveFields(world, page)).find(([key]) => comparableText(key) === comparableText(field));
+    if (declaredKind(world, field) !== "rolls") {
+        throw new Error(`${notRollsText(world, field, written?.[1])} Nothing rolled.`);
+    }
+    const items = Array.isArray(written?.[1]) ? written[1] : written?.[1] === undefined ? [] : [written[1]];
+    const wrong = items.find((item) => !Number.isFinite(numberOf(item)));
+    if (wrong !== undefined) {
+        throw new Error(`${field} on ${page.name} holds ${JSON.stringify(wrong)}, which is no roll: write its numbers only, such as ${field}=[14, 3]. Nothing rolled.`);
+    }
+    return { world, page, field: written?.[0] ?? field, values: items.map((item) => numberOf(item)) };
+}
+/** Why a field keeps no rolls: a counter or another field of the system is something else; a field of no system must first be declared as kept rolls (KEP-1). */
+function notRollsText(world, field, value) {
+    if (world.system === undefined) {
+        return `${field} keeps no rolls, and the campaign has no installed game system to declare it in.${missingSystemHint(world)}`;
+    }
+    const kind = declaredKind(world, field) ?? (readCounter(value) === undefined ? undefined : "counter");
+    return kind === undefined
+        ? `${field} keeps no rolls: declare it so first, such as config, setting fields, value "${field}: rolls".`
+        : `${field} is ${kind === "counter" ? "a counter" : `a field of kind ${kind}`}, not kept rolls: keep and use take a field declared as rolls, such as portent.`;
+}
+/** " Elara keeps 3, 4 in portent: give from Elara.": the characters whose field holds the number use asked for, when the page asked does not (KEP-3). */
+function otherKeepers(world, kept, value) {
+    const others = world.pages.filter((page) => page !== kept.page && page.system === undefined).flatMap((page) => {
+        const written = valueNamed(page.fields, kept.field);
+        const values = (Array.isArray(written) ? written : written === undefined ? [] : [written]).map(numberOf).filter((number) => number !== undefined);
+        return values.includes(value) ? [`${page.name} keeps ${values.join(", ")} in ${kept.field}: give from ${page.name}.`] : [];
+    });
+    return others.length === 0 ? "" : ` ${others.join(" ")}`;
+}
+/** The roll, with a kept number in place of its one die when use gives one (KEP-3). */
+function rollWith(notation, used, source) {
+    if (used === undefined) {
+        return rollDice(notation, source);
+    }
+    try {
+        return rollDice(notation, { values: [used.value] });
+    }
+    catch (error) {
+        // A kept number is not a face rolled now: there is nothing to roll again.
+        const why = (error instanceof DiceError ? error.message : String(error)).replace(/: ask the player to roll it again\.$/, "");
+        throw new Error(`A kept roll takes the place of one die, of the kind it was rolled with: give a notation with that one die, such as 1d20+2 (${why}). Nothing rolled.`);
+    }
+}
+/** Writes the dice rolled in the field of kept rolls, in place of what it held (KEP-2), and says so. */
+function keepFaces(kept, faces) {
+    writePage(kept.world, kept.page.name, undefined, { set: { [kept.field]: faces } });
+    return `${kept.page.name} keeps in ${kept.field}: ${faces.join(", ")}${kept.values.length === 0 ? "" : `, in place of ${kept.values.join(", ")}`}.`;
+}
+/** Takes the kept number used from its field (KEP-3), and says what is left. */
+function takeKept(kept) {
+    const left = [...kept.values];
+    left.splice(left.indexOf(kept.value), 1);
+    writePage(kept.world, kept.page.name, undefined, left.length === 0 ? { unset: [kept.field] } : { set: { [kept.field]: left } });
+    return `${kept.value} from ${kept.page.name}'s ${kept.field} took the place of the die; ${left.length === 0 ? "none is left" : `left: ${left.join(", ")}`}.`;
+}
+/**
+ * The page of who rolls, a character or a copy in the open scene, with its world; undefined when who names neither, as a free label does. Without names to
+ * read, a name two pages share is a label too: the roll needs no sheet.
+ */
+export function rollerOf(root, context, who, readsSheet) {
+    if (who === undefined) {
+        return undefined;
+    }
+    const world = campaignWorld(root, context);
+    const named = pagesWithName(world, who);
+    const page = readsSheet ? findPage(world, who) : named.length === 1 ? named[0] : undefined;
+    if (page !== undefined) {
+        return { world, page };
+    }
+    const { scene } = readOpenScene(root);
+    const copy = scene === undefined ? undefined : sameName(Object.keys(scene.copies), who);
+    return scene === undefined || copy === undefined ? undefined : { world, page: copyPage(copy, scene.copies[copy]) };
+}
+/** Whether a notation names a field, such as athletics in 1d20+athletics (DAT-8). */
+export function hasNames(notation) {
+    return [...notation.matchAll(namePattern)].some((match) => !diePattern.test(notation.slice((match.index ?? 0) + match[1].length + match[2].length)));
+}
+/** The notation with each name of a field as 0, to tell whether it is dice before a sheet is read: 1d20+athletics as 1d20+0. */
+export function namesAsZero(notation) {
+    return notation.replace(namePattern, (whole, sign, space, name, offset) => (diePattern.test(notation.slice(offset + sign.length + space.length)) ? whole : whole.replace(name, "0")));
+}
+/** The notation with each name of a field replaced by its value on the sheet of who rolls, effects and formulas included, and the values taken (DAT-8). */
+export function withSheetValues(notation, roller, who, system) {
+    const taken = {};
+    const fields = roller === undefined ? undefined : effectiveFields(roller.world, roller.page);
+    const replaced = notation.replace(namePattern, (whole, sign, space, name, offset) => {
+        if (diePattern.test(notation.slice(offset + sign.length + space.length))) {
+            return whole;
+        }
+        // "sleight of hand": a name of several words, which a notation cannot hold.
+        const words = /^\s+[A-Za-z]/.test(notation.slice(offset + whole.length));
+        checkNotScore(roller, system, fields, name);
+        const value = sheetValue(roller, fields, name, who, words);
+        taken[name] = value;
+        const negative = (sign === "-") !== (value < 0);
+        return `${negative ? "-" : sign === "" ? "" : "+"}${Math.abs(value)}`;
+    });
+    return { notation: replaced, taken };
+}
+/** Refuses a score the system shows with a modifier beside it, such as str with str-mod (DAT-2): a roll adds the modifier, and 1d20+str would add the score. */
+function checkNotScore(roller, system, fields, name) {
+    const entry = system?.sheet.flatMap((group) => group.entries).find((candidate) => candidate.beside !== undefined && comparableText(candidate.field) === comparableText(name));
+    const read = (field) => Object.entries(fields ?? {}).find(([key]) => comparableText(key) === comparableText(field))?.[1];
+    const modifier = entry?.beside === undefined ? undefined : numberOf(read(entry.beside));
+    if (roller !== undefined && entry?.beside !== undefined && modifier !== undefined) {
+        const worked = `${entry.beside} ${signedText(roller.world, entry.beside, modifier)}`;
+        throw new Error(`${name} ${String(read(name))} is a score: the system ${system?.name ?? ""} works out ${worked} from it, which is what a roll adds, such as 1d20+${entry.beside}. Nothing rolled.`);
+    }
+}
+/** The whole number a field holds on the sheet of who rolls; refused, with the numbers it has, when there is no sheet or it holds none. */
+function sheetValue(roller, fields, name, who, words) {
+    const page = roller?.page;
+    if (roller === undefined || fields === undefined || page === undefined) {
+        throw new Error(who === undefined
+            ? `"${name}" is no die: to take it from a sheet, give who rolls, such as who Bruna; or give the number, such as 1d20+5.`
+            : `There is no page named ${who}, nor a copy of that name in the open scene, to take ${name} from: give who as the name of a character, or the number in the notation.`);
+    }
+    const value = valueNamed(fields, name);
+    const number = numberOf(value);
+    if (value === undefined) {
+        // Only numbers: a class's martial-arts 1d6 or its features are no bonus (PRO-2).
+        const numbers = workedFields(roller.world, fields).filter((worked) => numberOf(worked.value) !== undefined).map((worked) => `${worked.field} ${signedText(roller.world, worked.field, worked.value)}`);
+        const has = numbers.length === 0 ? "" : ` Its numbers: ${numbers.join(", ")}.`;
+        const subtraction = /-\d+$/.test(name) ? " To subtract, put spaces around the minus, such as 1d20+athletics - 1." : "";
+        const hyphens = words ? " A name of several words is written with hyphens, such as sleight-of-hand." : "";
+        throw new Error(`${page.name} has no ${name}.${has} Give one of them, or the number, such as 1d20+5.${subtraction}${hyphens}${missingSystemHint(roller.world)}`);
+    }
+    // One value for each item of a list, as the attacks of two weapons (PRO-5): the roll takes the number of the one used.
+    const list = itemList(roller.world, name);
+    const first = typeof value === "string" ? /[+-]\d+/.exec(value)?.[0] : undefined;
+    if (number === undefined && list !== undefined && first !== undefined) {
+        throw new Error(`${name} on ${page.name} is ${JSON.stringify(value)}, one for each item in its ${list}: give the number of the one used, such as 1d20${first}.`);
+    }
+    if (number === undefined || !Number.isInteger(number)) {
+        throw new Error(`${name} on ${page.name} is ${JSON.stringify(value)}, not a whole number: give the number in the notation.`);
+    }
+    return number;
+}
+/**
+ * "Lena has Poisoned, Bless, exhaustion 1: see whether they change this roll.": the effects on who rolls that are not already in their numbers, being no more
+ * than a name, and the conditions (DAT-6); then the fields of their line written with ?, when they are not at zero (DAT-8).
+ */
+function rollerNote(world, system, page) {
+    const fields = effectiveFields(world, page);
+    const effects = effectsOf(page).filter((effect) => effect.values.length === 0 || sameName(system?.conditions ?? [], effect.name) !== undefined);
+    // Kept rolls are no number that changes a roll: use takes them.
+    const marked = (system?.statusLine ?? []).filter((entry) => entry.whenSet && declaredKind(world, entry.field) !== "rolls").flatMap((entry) => {
+        const value = valueNamed(fields, entry.field);
+        const number = readCounter(value)?.value ?? numberOf(value);
+        return number === undefined || number === 0 ? [] : [`${entry.field} ${number}`];
+    });
+    const all = [...effects.map((effect) => effect.name), ...marked];
+    return all.length === 0 ? undefined : `${page.name} has ${all.join(", ")}: if they change this roll, complete it: roll only what they add, such as one more die, and keep this one; never roll it again.`;
+}
+function revealHiddenRoll(rollId, root, context) {
+    const log = readLog(root);
+    const hiddenRoll = log.find((entry) => entry.id === rollId && entry.type === "roll" && entry.visibility === "hidden");
+    if (!hiddenRoll) {
+        throw new Error(`There is no hidden roll with id ${rollId}.`);
+    }
+    const proof = String(hiddenRoll.data.proof);
+    const alreadyRevealed = log.some((entry) => entry.type === "roll-revealed" && entry.data.roll === rollId);
+    if (!alreadyRevealed) {
+        appendLogEntry(root, newDatedLogEntry(root, context, "roll-revealed", "public", { roll: rollId, proof }));
+    }
+    return { kind: "reveal", id: rollId, text: String(hiddenRoll.data.result), proof, sha256: sha256(proof), fingerprint: String(hiddenRoll.data.fingerprint) };
+}

package/dist/commands/route.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const route: import("../core/registry.ts").Command<z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodOptional<z.ZodString>;
+    pace: z.ZodOptional<z.ZodString>;
+    across: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, {
+    kind: "way";
+    way: string;
+    going: string;
+    time: string;
+    then?: string;
+} | {
+    kind: "there";
+    text: string;
+} | {
+    kind: "none";
+    text: string;
+}>;

package/dist/commands/route.js

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import { requireCampaign } from "../campaign/index.js";
+import { defineCommand } from "../core/registry.js";
+import { distanceBetween } from "../map/index.js";
+import { locate, pageNamed, parsePageReference } from "../pages/index.js";
+import { journeyStart, moversPosition, readJourney } from "./game-journey.js";
+import { playerCharacter } from "./game-knowledge.js";
+import { mapKey } from "./game-maps.js";
+import { acrossHint, openLegs } from "./game-open.js";
+import { pointText, positionOf } from "./game-positions.js";
+import { dayHours, durationText, goingText, lengthText, measuresOf, moversOf, noWayText, paceOf, roadsOf, sameSpot, stopOf, travellingParty, unknownOnRoad, wayFor, wayText } from "./game-roads.js";
+import { campaignSystem, campaignWorld, missingSystemHint } from "./game-world.js";
+export const route = defineCommand({
+    name: "route",
+    description: "How far a place is by road, and how long the journey takes: the stops and roads of the quickest way, the distance and the days, at the party's pace or another. "
+        + "With across, straight across country, through the regions and their terrain. It moves no one and lets no time pass: to make the journey, use travel. "
+        + "Example: to Rocca, from Guadoscuro, pace fast; or to Torre, across.",
+    group: "game",
+    readOnly: true,
+    positionals: ["to"],
+    input: z.object({
+        to: z.string().describe("where to: a place"),
+        from: z.string().optional().describe("where from: a place, or a character; if left out, where the party is, or where its journey stopped"),
+        pace: z.string().optional().describe("one of the game's paces, such as fast, or a speed, such as 4.5 km; if left out, the game's usual pace"),
+        across: z.boolean().optional().describe("straight across country, off the roads, when both places have a position"),
+    }),
+    run(input, context) {
+        const root = requireCampaign(context.folder);
+        const world = campaignWorld(root, context);
+        const system = campaignSystem(root, context);
+        const roads = roadsOf(world);
+        const measures = measuresOf(root, system);
+        const destination = placeNamed(world, input.to, "where to");
+        const travellers = input.from === undefined ? travellingParty(world, playerCharacter(world), readJourney(root)?.movers ?? []) : [];
+        const origin = input.from === undefined ? travellers[0] : placeNamed(world, input.from, "where from", true);
+        if (origin === undefined) {
+            throw new Error("There is no player character to start from: give from, a place.");
+        }
+        const { movers, vehicle } = travellers.length === 0 ? { movers: [origin], vehicle: undefined } : moversOf(world, travellers);
+        const journey = input.from === undefined ? readJourney(root) : undefined;
+        const onRoad = journey === undefined ? undefined : journeyStart(world, roads, journey, movers);
+        const departure = stopOf(world, roads, origin);
+        const arrival = stopOf(world, roads, destination);
+        if (input.across === true) {
+            return acrossRoute(world, system, measures, journey === undefined ? positionOf(world, origin) : moversPosition(world, roads, journey, movers), origin, destination, input.pace);
+        }
+        const lost = onRoad === undefined ? unknownOnRoad(world, roads, origin) : undefined;
+        if (lost !== undefined) {
+            return { kind: "none", text: lost };
+        }
+        if (onRoad === undefined && departure === undefined) {
+            return { kind: "none", text: `${offRoadText(world, origin)}${acrossHint(world, origin, destination, measures)}` };
+        }
+        if (arrival === undefined) {
+            return { kind: "none", text: `${offRoadText(world, destination)}${acrossHint(world, origin, destination, measures)}` };
+        }
+        const spot = onRoad === undefined && departure !== undefined ? sameSpot(world, departure, arrival) : undefined;
+        if (spot !== undefined) {
+            return { kind: "there", text: `${origin.name} and ${destination.name} are one spot for a journey, in ${spot.name}: no road to travel, move is enough.` };
+        }
+        const going = { pace: paceOf(system, input.pace, vehicle), vehicle };
+        const start = onRoad ?? { stop: departure?.name ?? "" };
+        const way = wayFor(world, system, roads, start, arrival, going);
+        if (way === undefined) {
+            return { kind: "none", text: `${noWayText(world, system, roads, start, arrival, going)}${acrossHint(world, origin, destination, measures)}` };
+        }
+        const from = "stop" in start ? start.stop : `${start.stretch.road}, ${lengthText(start.done, measures)} past ${start.stretch.from}`;
+        const down = arrival === destination ? "" : `, then into ${destination.name}`;
+        return { kind: "way", way: `${wayText(way, from, measures)}${down}`, going: goingText(world, system, going, measures), time: durationText(way.minutes, dayHours(system, roads, way, going, undefined)) };
+    },
+    format(result) {
+        return result.kind === "way" ? [`${result.way}.`, `${result.going[0].toUpperCase()}${result.going.slice(1)}: ${result.time}.`, result.then ?? ""].filter((line) => line !== "").join("\n") : result.text;
+    },
+});
+/** The way straight across country (TRV-12): the regions it goes through, the distance and the time at the pace; or why there is none, with how to give a position. */
+function acrossRoute(world, system, measures, from, origin, destination, pace) {
+    const to = positionOf(world, destination);
+    const missing = from === undefined ? origin : to === undefined ? destination : undefined;
+    if (from === undefined || to === undefined) {
+        return { kind: "none", text: `${missing?.name} has no position on the map: give it one, such as write ${missing?.name}, set position="12 km NE of [[<a place with one>]]".` };
+    }
+    // Across country one stays on one map (POS-8): to another, a passage leads.
+    const map = mapKey(world, origin);
+    if (mapKey(world, destination) !== map) {
+        return { kind: "none", text: `${destination.name} is on another map than ${origin.name}: across country one stays on one map. A passage, a road of kind portal, leads from one to the other.` };
+    }
+    const going = { pace: paceOf(system, pace, undefined) };
+    const legs = openLegs(world, system, from, to, going.pace?.speed ?? 0, map);
+    const through = legs.map((leg) => `${leg.region?.name ?? "the open"} (${lengthText(leg.length, measures)})`).join(", ");
+    const minutes = legs.reduce((sum, leg) => sum + leg.length / leg.metresAMinute, 0);
+    const way = `Straight from ${pointText(world, from, measures, map)} to ${destination.name}, ${lengthText(distanceBetween(from, to), measures)} through ${through || "nothing"}`;
+    return { kind: "way", way, going: goingText(world, system, going, measures), time: durationText(minutes, system?.travel?.hours ?? 8), then: `To go: travel to ${destination.name}, across.` };
+}
+/** A place by name or alias, for where a journey goes or starts; a character too, where it starts, for the place it is in. */
+function placeNamed(world, name, role, characterToo = false) {
+    const reference = parsePageReference(name);
+    const page = pageNamed(world, reference.name);
+    if (page === undefined) {
+        throw new Error(`There is no page named ${reference.name}, ${role}. Look for it with find.${missingSystemHint(world)}`);
+    }
+    if (page.type !== "place" && !(characterToo && page.type === "character")) {
+        throw new Error(`${page.name} is not a place: give a place ${role}${characterToo ? ", or a character" : ""}.`);
+    }
+    return page;
+}
+/** Why a place has no road (ROA-5): no place of its chain is a stop. */
+function offRoadText(world, page) {
+    const chain = [page, ...locate(world, page).chain].filter((holder) => holder.type === "place").map((holder) => holder.name);
+    return `No road reaches ${page.name}: none of ${chain.join(" › ")} is a stop of a road. Write one, a place with stops, such as write "Strada del passo", type place, set stops=[[A]], 8 km, [[${chain.at(-1) ?? page.name}]].`;
+}

package/dist/commands/rules.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+/** A section of a page that a search names, with where the page comes from. */
+interface PageSection {
+    page: string;
+    section: string;
+    type?: string;
+    system?: string;
+}
+/** What an answer shows of one source of rules, the house rules or the game system's: some sections with their text, the others by their path. */
+interface Answer {
+    shown: {
+        path: string[];
+        text: string;
+        parts: string[];
+    }[];
+    others: string[];
+    used: number;
+}
+export declare const rules: import("../core/registry.ts").Command<z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    house: undefined;
+    found: undefined;
+    precedents: string[];
+    text: string;
+    system: string | undefined;
+    missingSystem: string | undefined;
+    language: string | undefined;
+    houseRules: string[];
+    chapters: string[];
+} | {
+    house: Answer;
+    found: Answer;
+    precedents: string[];
+    page: {
+        name: string;
+        type?: string;
+        system?: string;
+    } | undefined;
+    pageSections: PageSection[];
+    text: string;
+    system: string | undefined;
+    missingSystem: string | undefined;
+    language: string | undefined;
+    houseRules: string[];
+    chapters: string[];
+}>;
+export {};