rpg-engine 0.0.0-stage → 0.1.0

package/dist/commands/instructions.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { findCampaign, readSettings } from "../campaign/index.js";
+import { defineCommand } from "../core/registry.js";
+import { buttonsInstructions, dashboardInstructions, masterInstructions } from "../instructions/index.js";
+import { campaignMode, modePart } from "./game-mode.js";
+import { readOpenScene } from "./game-scene.js";
+import { campaignSystem, campaignWorld } from "./game-world.js";
+import { mentorPart, situationPart, stylePart } from "./parts.js";
+export const instructions = defineCommand({
+    name: "instructions",
+    description: "Your instructions as game master, in full: how to run this campaign and use these tools. They end with the part of the mode the campaign is in. "
+        + "Call it before your first reply in every chat, and again after the conversation has been summarized; then call status. Read-only, no parameters.",
+    group: "game",
+    readOnly: true,
+    alwaysLoad: true,
+    input: z.object({}),
+    run(_input, context) {
+        // A chat that starts, or follows a summary, gets every part of the instructions again when its situation opens (D-97).
+        context.told?.clear();
+        // Where the host shows the player forms, or the dashboard shows its buttons, they take the place of the stop in words (D-148, D-279).
+        const buttons = context.player !== undefined || context.page !== undefined;
+        const parts = [
+            masterInstructions(),
+            modeText(context.folder, context),
+            mentorText(context.folder, context),
+            styleText(context.folder, context),
+            sceneText(context.folder, context),
+            buttons ? buttonsInstructions(physicalDice(context.folder)) : "",
+            // The dashboard, where the MCP server serves one, so that the master can tell the player how to use it (D-404).
+            context.dashboard === undefined ? "" : dashboardInstructions(context.dashboard),
+        ];
+        return { text: parts.filter((part) => part !== "").join("\n\n") };
+    },
+    format(result) {
+        return result.text;
+    },
+});
+/**
+ * The part of the open scene's type, such as combat, for a chat that starts in the middle of a scene, where scene open will not give it (MOD-5, D-266); then it
+ * counts as told. None without a scene, or with one that does not read.
+ */
+function sceneText(folder, context) {
+    const root = findCampaign(folder);
+    const scene = root === undefined ? undefined : readOpenScene(root).scene;
+    if (root === undefined || scene === undefined) {
+        return "";
+    }
+    try {
+        return situationPart(scene.type, context, campaignSystem(root, context));
+    }
+    catch {
+        return "";
+    }
+}
+/** The mentor's part, for the way the player wants the game taught (D-347); none when off, outside a campaign, or in one that does not read. */
+function mentorText(folder, context) {
+    const root = findCampaign(folder);
+    try {
+        return root === undefined ? "" : mentorPart(root, context, readSettings(root).mentor);
+    }
+    catch {
+        return "";
+    }
+}
+/** How the master writes, as the player chose it (D-395), in session zero and in play; none in the setup, outside a campaign, or in one that does not read. */
+function styleText(folder, context) {
+    const root = findCampaign(folder);
+    try {
+        return root === undefined || campaignMode(root, campaignWorld(root, context)) === "setup" ? "" : stylePart(root, context);
+    }
+    catch {
+        return "";
+    }
+}
+/** Whether the player rolls their own dice (ASK-8): then the buttons are for choices alone. */
+function physicalDice(folder) {
+    const root = findCampaign(folder);
+    try {
+        return root !== undefined && readSettings(root).dice === "physical";
+    }
+    catch {
+        return false;
+    }
+}
+/** The part of the mode the campaign is in, with its layers (MOD-5); none outside a campaign, or in one that does not read, where status says why. */
+function modeText(folder, context) {
+    const root = findCampaign(folder);
+    if (root === undefined) {
+        return "";
+    }
+    try {
+        return modePart(campaignMode(root, campaignWorld(root, context)), campaignSystem(root, context)) ?? "";
+    }
+    catch {
+        return "";
+    }
+}

package/dist/commands/mode.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { type Mode } from "./game-mode.ts";
+import { type ResetPoint } from "./game-saves.ts";
+export declare const mode: import("../core/registry.ts").Command<z.ZodObject<{
+    to: z.ZodEnum<{
+        setup: "setup";
+        "session zero": "session zero";
+        play: "play";
+    }>;
+}, z.core.$strip>, {
+    to: Mode;
+    changed: boolean;
+    dateless: boolean;
+    part: string;
+    start?: StartSave;
+}>;
+/** The save of a start, made or not, and which. */
+type StartSave = {
+    point: ResetPoint;
+    saved?: string;
+    unsaved?: string;
+};
+export {};

package/dist/commands/mode.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { changeState, requireCampaign } from "../campaign/index.js";
+import { appendLogEntry } from "../core/log.js";
+import { defineCommand } from "../core/registry.js";
+import { blockingMode, campaignMode, missingText, modePart, modes } from "./game-mode.js";
+import { campaignSaves, makeSave, savesWhy, saveText } from "./game-saves.js";
+import { newDatedLogEntry, readPresent } from "./game-time.js";
+import { campaignSystem, campaignWorld } from "./game-world.js";
+export const mode = defineCommand({
+    name: "mode",
+    description: "Move the campaign to another mode: setup (the settings, out of the game), session zero (the player character and the companions, made in play) or play. "
+        + "It refuses while that mode's checklist is incomplete, saying what is missing; otherwise it gives the new mode's instructions. "
+        + "Call it when status says nothing is missing and the player confirms; back to session zero to make a new player character. "
+        + 'Example: to "session zero".',
+    group: "game",
+    positionals: ["to"],
+    input: z.object({
+        to: z.enum(modes).describe(`the mode to enter: ${modes.join(", ")}`),
+    }),
+    run(input, context) {
+        const root = requireCampaign(context.folder);
+        const world = campaignWorld(root, context);
+        const from = campaignMode(root, world);
+        if (from === input.to) {
+            return { to: input.to, changed: false, dateless: false, part: "" };
+        }
+        // Into the setup always; into session zero and play, even back from play, only with the checklists before them complete (MOD-2).
+        const blocked = blockingMode(input.to, root, context, world);
+        if (blocked !== undefined) {
+            throw new Error(`The campaign cannot enter ${input.to} yet: ${missingText(blocked)}. Then call mode again. Nothing changed.`);
+        }
+        changeState(root, { mode: input.to });
+        appendLogEntry(root, newDatedLogEntry(root, context, "mode-changed", "public", { from, to: input.to }));
+        const start = startSave(root, context, input.to);
+        return {
+            to: input.to,
+            changed: true,
+            dateless: readPresent(root).date === undefined,
+            part: modePart(input.to, campaignSystem(root, context)) ?? "",
+            ...(start === undefined ? {} : { start }),
+        };
+    },
+    format(result) {
+        if (!result.changed) {
+            return `The campaign is already in ${result.to}.`;
+        }
+        // The game starts with its first scene, and its date when it has none (D-103).
+        const start = result.to !== "play" ? "" : ` Open the first scene${result.dateless ? ", and set the game date with advance to, at its hour, such as day 1, 18:00" : ""}.`;
+        const saved = result.start === undefined ? "" : ` ${startText(result.start)}`;
+        return [`The campaign is now in ${result.to}.${saved}${start}`, result.part].filter((block) => block !== "").join("\n\n");
+    },
+});
+/**
+ * The saves the campaign starts over from (SAV-3, D-361): the first time it enters session zero with no save, the one before it; the first time it enters play,
+ * with none made since, the start of play. A save that cannot be written never stops the mode, which is already changed: it says why.
+ */
+function startSave(root, context, to) {
+    const saves = campaignSaves(root);
+    const why = savesWhy(root);
+    const point = to === "session zero" && saves.length === 0
+        ? "session zero"
+        : to === "play" && saves.every((save) => why.get(save.number) === "session zero")
+            ? "start"
+            : undefined;
+    if (point === undefined) {
+        return undefined;
+    }
+    try {
+        return { point, saved: saveText(makeSave(root, context, point, point)) };
+    }
+    catch (error) {
+        return { point, unsaved: error instanceof Error ? error.message : String(error) };
+    }
+}
+function startText(start) {
+    const which = start.point === "start" ? "Its start" : "Its state before session zero";
+    const back = start.point === "start"
+        ? "the save reset goes back to, if the player wants to start over"
+        : "the save reset to session zero goes back to, if the player wants to start over with a new character";
+    if (start.saved === undefined) {
+        return `${which} could not be saved (${start.unsaved ?? ""}): make .saves a folder that can be written, then save make with saves free, if the player wants a point to start over from.`;
+    }
+    return `${which} is saved, ${start.saved}: ${back}.`;
+}

package/dist/commands/mood.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { type Mood } from "../core/mood.ts";
+interface MoodResult {
+    /** The master, or the character's page. */
+    who: string;
+    master: boolean;
+    /** The character's role: the party's moods show on their sheets (D-419). */
+    role?: "pc" | "companion" | "npc";
+    mood: Mood;
+    /** The mood before; for a moment, the one the master goes back to. */
+    from: Mood;
+    moment: boolean;
+    changed: boolean;
+}
+export declare const mood: import("../core/registry.ts").Command<z.ZodObject<{
+    who: z.ZodString;
+    mood: z.ZodEnum<{
+        neutral: "neutral";
+        happy: "happy";
+        delighted: "delighted";
+        curious: "curious";
+        focused: "focused";
+        determined: "determined";
+        worried: "worried";
+        surprised: "surprised";
+        afraid: "afraid";
+        sad: "sad";
+        angry: "angry";
+        disgusted: "disgusted";
+        mischievous: "mischievous";
+    }>;
+    moment: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, MoodResult>;
+export {};

package/dist/commands/mood.js

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { changeStateAt, requireCampaign } from "../campaign/index.js";
+import { appendLogEntry } from "../core/log.js";
+import { moods } from "../core/mood.js";
+import { defineCommand } from "../core/registry.js";
+import { isPartyMember, ownField, pageNamed, writePage } from "../pages/index.js";
+import { masterMood, masterMoodKey, moodChanged, moodMoment, pageMood } from "./game-moods.js";
+import { readOpenScene } from "./game-scene.js";
+import { newDatedLogEntry } from "./game-time.js";
+import { campaignWorld } from "./game-world.js";
+// What a character's new mood asks of the master, by their role.
+const moodAdvice = {
+    pc: "the dashboard shows it on their sheet. It mirrors what the player writes and plays, never what you narrate or what a spell or condition does to them: "
+        + "when the player says they feel otherwise, follow the player.",
+    companion: "the dashboard shows it on their sheet. Let it colour how they speak and act.",
+    npc: "only you know it. Show it in how they speak and act, and the player reads it from that; a check your game has for reading someone only when they hide it.",
+};
+export const mood = defineCommand({
+    name: "mood",
+    description: "Set a mood: yours as the master, which the dashboard's robot shows, or a character's when it changes for a while: the party's show on their sheets, "
+        + "anyone else's only you see, in status. Set yours when the story's tone turns as the player lives it, and let your voice follow it. "
+        + "moment: a reaction to what the player has just seen happen, what a roll decides or a bold choice, a few times a session; the dashboard already reacts to the dice's highs and lows. "
+        + "Your face never shows what the player does not know yet: no grin before the trap is sprung. "
+        + "Mirror the player character's mood from how the player plays them, never decide it for them. neutral takes a mood away. "
+        + "Example: master worried; master surprised, moment; Lena afraid.",
+    group: "game",
+    positionals: ["who", "mood"],
+    input: z.object({
+        who: z.string().describe("master for yours, or a character's page: the player character, a companion, anyone"),
+        mood: z.enum(moods).describe(`the mood: ${moods.join(", ")}`),
+        moment: z.boolean().optional().describe("yours only: show it for a few seconds, then go back to your mood, which stays as it is"),
+    }),
+    run(input, context) {
+        const root = requireCampaign(context.folder);
+        if (input.who.trim().toLowerCase() === "master") {
+            return setMasterMood(root, context, input.mood, input.moment === true);
+        }
+        const world = campaignWorld(root, context);
+        const page = characterPage(root, world, input.who.trim());
+        if (input.moment === true) {
+            throw new Error(`Only your mood has moments, as the master. Give ${page.name} a mood that stays, without moment, and set it again when it passes. Nothing changed.`);
+        }
+        const from = pageMood(page);
+        const role = page.fields.role === "pc" || page.fields.role === "companion" ? page.fields.role : "npc";
+        const result = { who: page.name, master: false, role, mood: input.mood, from, moment: false, changed: from !== input.mood };
+        if (!result.changed) {
+            return result;
+        }
+        const field = ownField(page, "mood");
+        writePage(world, page.name, undefined, input.mood === "neutral" ? { unset: [field ?? "mood"] } : { set: { [field ?? "mood"]: input.mood } });
+        // What someone outside the party feels is the master's alone (MOOD-5, MOOD-6).
+        appendLogEntry(root, newDatedLogEntry(root, context, moodChanged, isPartyMember(page) ? "public" : "hidden", { who: page.name, mood: input.mood, from }));
+        return result;
+    },
+    format(result) {
+        if (result.master) {
+            return masterText(result);
+        }
+        if (!result.changed) {
+            return `${result.who}'s mood is already ${result.mood}: nothing changed.`;
+        }
+        if (result.mood === "neutral") {
+            return `${result.who} has no mood any more.`;
+        }
+        return `${result.who}'s mood is now ${result.mood}: ${moodAdvice[result.role ?? "npc"]}`;
+    },
+});
+/** Sets the master's mood, or shows one for a moment without changing it (MOOD-4); either way a public line of the log. */
+function setMasterMood(root, context, wanted, moment) {
+    const from = masterMood(root);
+    const result = { who: "master", master: true, mood: wanted, from, moment, changed: moment || from !== wanted };
+    if (moment) {
+        appendLogEntry(root, newDatedLogEntry(root, context, moodMoment, "public", { who: "master", mood: wanted, back: from }));
+        return result;
+    }
+    if (result.changed) {
+        changeStateAt(root, [[[masterMoodKey], wanted === "neutral" ? undefined : wanted]]);
+        appendLogEntry(root, newDatedLogEntry(root, context, moodChanged, "public", { who: "master", mood: wanted, from }));
+    }
+    return result;
+}
+function masterText(result) {
+    if (result.moment) {
+        return `The robot on the dashboard shows ${result.mood} for a moment, then goes back to ${result.from}.`;
+    }
+    if (!result.changed) {
+        return `Your mood is already ${result.mood}: nothing changed.`;
+    }
+    return result.mood === "neutral"
+        ? "Your mood is neutral again: the robot on the dashboard shows a calm face."
+        : `Your mood is now ${result.mood}: the robot on the dashboard shows it. Let your voice follow it, until the story's tone turns again.`;
+}
+/** The character a mood is for, of the campaign; anything else is refused with what to do instead (MOOD-2). */
+function characterPage(root, world, name) {
+    const page = pageNamed(world, name);
+    if (page === undefined) {
+        const copy = Object.keys(readOpenScene(root).scene?.copies ?? {}).find((copyName) => copyName.toLowerCase() === name.toLowerCase());
+        throw new Error(copy !== undefined
+            ? `${copy} is a copy of a creature in the open scene: moods are for characters. Tell how it feels in the story. Nothing changed.`
+            : `There is no page ${name}: write the character first, or look for its name with find. Nothing changed.`);
+    }
+    if (page.type === "character" && page.system === undefined) {
+        return page;
+    }
+    if (page.type === "creature") {
+        throw new Error(`${page.name} is a creature, a kind of being: moods are for characters. Make one from it, such as with write "Name", type character, set creature=[[${page.name}]]; `
+            + "then give that one its mood. Nothing changed.");
+    }
+    if (page.type === "character") {
+        throw new Error(`${page.name} is a character of the game system, read-only: give the mood to one of the campaign. Nothing changed.`);
+    }
+    throw new Error(`${page.name} is ${page.type === undefined ? "a free page" : `a ${page.type}`}, not a character: only you and the characters have moods. Nothing changed.`);
+}

package/dist/commands/move.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { Context } from "../core/context.ts";
+/** What move did, as its output tells it (CON-8, ENV-5). */
+interface MoveResult {
+    moved: string[];
+    /** Those that were already only there. */
+    already: string[];
+    to: string;
+    /** The destination and what holds it, nearest first. */
+    chain: string[];
+    /** The other characters right in the destination. */
+    there: string[];
+    /** What changes around the characters who moved. */
+    here: string[];
+    noLonger: string[];
+    notes: string[];
+    problems: string[];
+    /** Who stands on a square of the place's map now (GRD-3), and the place; how far they went, and from where, when the game counts it (GRD-5). */
+    placed?: {
+        who: string;
+        square: string;
+        place: string;
+        distance?: string;
+        from?: string;
+    };
+}
+export declare const move: import("../core/registry.ts").Command<z.ZodObject<{
+    page: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    to: z.ZodOptional<z.ZodString>;
+    at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, MoveResult>;
+/** Puts one on a square of the map of the place it is right in, as move with at, and what move says of it (ASK-11). */
+export declare function placeOnMap(root: string, context: Context, name: string, square: string): string;
+export {};