rpg-engine 0.0.0-stage → 0.1.1

package/dist/commands/game-advance.js

@@ -0,0 +1,103 @@
+// Time passing in the story (TIM-5, TIM-6, EFF-8, EVT-8), as advance and travel do it: up to the first planned event that comes due, with what ends and what comes.
+import { changeState } from "../campaign/index.js";
+import { appendLogEntry } from "../core/log.js";
+import { isEmptyField } from "../pages/index.js";
+import { addDuration, formatGameDate, minutesBetween } from "../time/index.js";
+import { endedByDate, endEffects } from "./game-effects.js";
+import { surroundings, surroundingsText } from "./game-environment.js";
+import { clocksToMove, dueAdvice, dueEvents, dueText, isDated, plannedEvents, plannedText } from "./game-events.js";
+import { readOpenScene } from "./game-scene.js";
+import { newDatedLogEntry } from "./game-time.js";
+import { campaignSystem, campaignWorld } from "./game-world.js";
+import { shortList, skippedPagesNote } from "./notes.js";
+import { situationPart } from "./parts.js";
+// An hour or more passing usually ends a scene: then advance reminds that one is still open.
+const sceneReminderMinutes = 60;
+/**
+ * Lets `wanted` minutes pass from `now` (TIM-5), stopping at the first planned event whose date comes (TIM-6): writes the new date and a public line with `why`,
+ * ends the effects whose time came (EFF-8), and says the clocks to move on a new day (EVT-8).
+ */
+export function passTime(root, context, world, now, wanted, why, requested) {
+    const events = plannedEvents(world);
+    const dated = events.filter(isDated);
+    const stop = dated.find((event) => minutesBetween(now, event.date) > 0 && minutesBetween(now, event.date) <= wanted);
+    const passed = stop === undefined ? wanted : minutesBetween(now, stop.date);
+    const reached = addDuration(now, passed);
+    const result = {
+        from: formatGameDate(now),
+        to: formatGameDate(reached),
+        passed,
+        wanted,
+        due: stop === undefined ? [] : dated.filter((event) => minutesBetween(stop.date, event.date) === 0).map(dueText),
+        stillDue: dueEvents(world, now).map(dueText),
+        next: stop === undefined ? nextAfter(dated, reached) : undefined,
+        openScene: passed >= sceneReminderMinutes ? openSceneText(root) : undefined,
+        newDays: reached.day - now.day,
+        clocks: reached.day > now.day ? clocksToMove(world, reached) : [],
+        ...unreadNotes(world),
+    };
+    if (passed > 0) {
+        changeState(root, { date: result.to });
+        appendLogEntry(root, newDatedLogEntry(root, context, "time-advanced", "public", { from: result.from, to: result.to, requested, why }));
+    }
+    const ended = passed > 0 ? endEffects(root, context, world, readOpenScene(root).scene, (effect) => endedByDate(effect, reached), "time passed") : [];
+    // Read again only when effects ended, which may have been on the places around.
+    const around = passed >= sceneReminderMinutes ? aroundLead(ended.length === 0 ? world : campaignWorld(root, context)) : undefined;
+    // A new day with clocks to move is the world's turn: its part of the instructions says how (EVT-8, D-134).
+    const newDayPart = result.clocks.length === 0 ? "" : situationPart("new-day", context, campaignSystem(root, context));
+    return { ...result, ended, around, newDayPart };
+}
+/**
+ * What outputs say after time passed, line by line: the effects ended, the events due with how to play them and `then`, what to do after them, those still due,
+ * the next, the open scene, what holds around, the clocks of a new day, and what could not be read.
+ */
+export function passedLines(result, then) {
+    return [
+        result.ended.length === 0 ? "" : `Ended: ${result.ended.join(" · ")}.`,
+        result.due.length === 0 ? "" : `Due: ${result.due.join(" · ")}. ${dueAdvice(result.due.length)}${then}`,
+        stillDueLine(result.stillDue, result.due.length > 0),
+        result.next === undefined ? "" : `Next: ${result.next}.`,
+        result.openScene === undefined ? "" : `A scene is still open: ${result.openScene}. Close it if this time ends it.`,
+        result.around === undefined ? "" : `Around ${result.around}.`,
+        clocksLine(result.newDays, result.to, result.clocks),
+        result.newDayPart,
+        result.unreadable.length === 0 ? "" : `Time does not stop at these planned events, whose date is not a game date: ${result.unreadable.join(" · ")}. Give each one a game date with write.`,
+        skippedPagesNote(result.skipped),
+    ].filter((line) => line !== "");
+}
+/** The planned events whose date is not a game date, and the files that are no pages: what an advance says it could not read. */
+export function unreadNotes(world) {
+    const events = plannedEvents(world);
+    return { unreadable: events.filter((event) => !isDated(event) && !isEmptyField(event.page.fields.date)).map((event) => event.page.name), skipped: world.problems };
+}
+/** The first events after `date`: all those at the same moment. */
+export function nextAfter(events, date) {
+    const next = events.find((event) => minutesBetween(date, event.date) > 0);
+    return next === undefined ? undefined : events.filter((event) => minutesBetween(next.date, event.date) === 0).map((event) => plannedText(event, date)).join(" · ");
+}
+/** A new day is the world's turn (EVT-8): the clocks to move as the time moved them, which they never do by themselves; how, the part new-day says (D-134). */
+function clocksLine(newDays, to, clocks) {
+    if (clocks.length === 0) {
+        return "";
+    }
+    const days = newDays === 1 ? `A new day (${to.replace(/,.*$/, "")})` : `${newDays} new days (to ${to.replace(/,.*$/, "")})`;
+    return `${days}, with clocks to move: ${shortList(clocks, " · ")}.`;
+}
+/** The events already due before time passed; with new ones due too, the advice above covers them. */
+function stillDueLine(events, afterDue) {
+    if (events.length === 0) {
+        return "";
+    }
+    return afterDue ? `Still due as well: ${events.join(" · ")}.` : `Still due: ${events.join(" · ")}. ${dueAdvice(events.length)}`;
+}
+/** "Alla locanda (since day 1, 18:00)": the open scene, if any; a scene that cannot be read is left to validate. */
+function openSceneText(root) {
+    const { scene } = readOpenScene(root);
+    return scene === undefined ? undefined : `${scene.title}${scene.opened === undefined ? "" : ` (since ${scene.opened})`}`;
+}
+/** "Ettore: light: dark (Cripta)": what holds around the player character, for rules that count the hours spent there (ENV-5); undefined when nothing does. */
+export function aroundLead(world) {
+    const lead = world.pages.find((page) => page.type === "character" && page.fields.role === "pc");
+    const around = surroundingsText(surroundings(world, lead));
+    return lead === undefined || around === "" ? undefined : `${lead.name}: ${around}`;
+}

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

@@ -0,0 +1,68 @@
+import type { Context } from "../core/context.ts";
+import type { Problem } from "../core/problem.ts";
+import { type Effect, type EffectEnd } from "../effects/index.ts";
+import { type Page, type World } from "../pages/index.ts";
+import type { Scene } from "../scene/index.ts";
+import type { GameSystem } from "../systems/index.ts";
+import { type GameDate } from "../time/index.ts";
+/** Who holds effects: a page, or a copy in the open scene seen as a page (INH-14). */
+export interface EffectHolder {
+    page: Page;
+    copy: boolean;
+}
+/**
+ * Writes a holder's effects; the field goes when none is left. What a current has above its written maximum that the maximum, as these effects leave it, no
+ * longer allows goes, as when Aid ends, with a line in the log (FOR-6). Returns the page as written, or undefined for a copy.
+ */
+export declare function saveEffects(root: string, context: Context, world: World, holder: EffectHolder, effects: Effect[]): Page | undefined;
+/** An effects field that does not read is never written over: what was written by hand would be lost (EFF-12). */
+export declare function checkEffectsReadable(page: Page): void;
+/**
+ * Ends, on every page and on the copies of `scene`, the effects that `ends` picks (EFF-8, EFF-9, EFF-13), with a line in the log for each, public when it concerns
+ * the player (EFF-11). Returns what ended, with the values that come back, "Scudo della fede on Ennio (ac 15 → 13)", ten at most. It never fails halfway:
+ * a page that two pages' names share, or that cannot be written, is said, not written.
+ */
+export declare function endEffects(root: string, context: Context, world: World, scene: Scene | undefined, ends: (effect: Effect) => boolean, why: string | ((effect: Effect) => string)): string[];
+/** Whether an effect's end in game time has come (EFF-8). */
+export declare function endedByDate(effect: Effect, now: GameDate): boolean;
+/** Whether an effect counted in rounds ends when the turn passes to `turn` in `round` (EFF-9). */
+export declare function endedByTurn(effect: Effect, round: number, turn: string, order: string[]): boolean;
+/** Whether an effect ends with the scene: counted in rounds, which exist only in it, or lasting until it ends (EFF-9). */
+export declare function endsWithScene(effect: Effect): boolean;
+/** Whether someone keeps an effect alive (D-138). */
+export declare function keptBy(effect: Effect, name: string): boolean;
+/** "Spaventato until round 3, Lena": an effect as status names it, as its line writes it but its values. */
+export declare function effectText(effect: Effect): string;
+/** An effect as status shows it: its name, the values it gives that no counter shows, such as ac 18, and its end (SYS-8). */
+export declare function effectShown(world: World, effect: Effect): string;
+/** An effect as the dashboard shows it on someone of the party (D-276, D-314): its name, its end as data, which the dashboard writes in its language, and the line status gives. */
+export interface SeenEffect {
+    name: string;
+    end?: EffectEnd;
+    text: string;
+    /** One of the system's conditions (D-186, D-419). */
+    condition?: true;
+    /** The condition's drawing, when the system gives one (D-419): the d of an SVG path on a grid of 24. */
+    icon?: string;
+}
+/** An effect as the dashboard shows it on someone of the party: its name, its end, the line status gives, and whether it is a condition (D-276, D-314, D-419). */
+export declare function effectParts(world: World, system: GameSystem | undefined, effect: Effect): SeenEffect;
+/** Whether an effect's name is one of the system's conditions, whatever its case, and the drawing the system gives it (D-419); nothing for any other effect. */
+export declare function conditionMark(system: GameSystem | undefined, name: string): Pick<SeenEffect, "condition" | "icon">;
+/** "Benedizione (Ennio, Bruno)": what someone keeps alive, on whom (D-138). */
+export declare function keptEffects(world: World, scene: Scene | undefined, name: string): string[];
+/** What someone keeps alive, each effect with the pages and copies that have it (D-138). */
+export declare function keptEffectHolders(world: World, scene: Scene | undefined, name: string): {
+    effect: string;
+    holders: string[];
+}[];
+/** The effects on whoever has this name, a page or a copy in the open scene, the copy first as change finds it (INH-14). */
+export declare function effectsOn(world: World, scene: Scene | undefined, name: string): Effect[];
+/**
+ * The problems of effects (EFF-12): fields that do not read, ends that are neither game dates nor occasions of the game system (DAT-5), effects ended and still there,
+ * effects that end with a scene when none is open. `sceneProblem` says why the open scene cannot be read, if it cannot.
+ */
+export declare function effectProblems(world: World, scene: Scene | undefined, now: GameDate | undefined, occasions: {
+    system: string;
+    names: string[];
+} | undefined, sceneProblem?: string): Problem[];

package/dist/commands/game-effects.js

@@ -0,0 +1,196 @@
+import { appendLogEntry } from "../core/log.js";
+import { comparableText } from "../core/text.js";
+import { formatCounter, readCounter } from "../counters/index.js";
+import { endsAtTurn, formatEffect, formatEnd, keeperOf, readEffects } from "../effects/index.js";
+import { concernsPlayer, isDeclaredUncounted, isEmptyField, systemFirstFix, writePage } from "../pages/index.js";
+import { minutesBetween, readGameDate } from "../time/index.js";
+import { effectiveFields, effectsField, effectsOf, valuesChanged, withEffects } from "./effect-layer.js";
+import { copyPage, updateScene } from "./game-scene.js";
+import { newDatedLogEntry } from "./game-time.js";
+import { shortList } from "./notes.js";
+import { computedField, effectBonuses } from "./worked-out.js";
+/**
+ * Writes a holder's effects; the field goes when none is left. What a current has above its written maximum that the maximum, as these effects leave it, no
+ * longer allows goes, as when Aid ends, with a line in the log (FOR-6). Returns the page as written, or undefined for a copy.
+ */
+export function saveEffects(root, context, world, holder, effects) {
+    const lines = effects.length === 0 ? undefined : effects.map(formatEffect);
+    if (holder.copy) {
+        updateScene(root, [[["copies", holder.page.name, "effects"], lines]]);
+        return undefined;
+    }
+    const lowered = currentsAsRead(world, holder.page, effects);
+    const set = { ...lowered, ...(lines === undefined ? {} : { effects: lines }) };
+    const page = writePage(world, holder.page.name, undefined, lines === undefined ? { set, unset: ["effects"] } : { set }).page;
+    const visibility = concernsPlayer(world, holder.page) ? "public" : "hidden";
+    for (const [field, after] of Object.entries(lowered)) {
+        const data = { page: holder.page.name, field, before: String(holder.page.fields[field]), after, why: "an effect that allowed it ended" };
+        appendLogEntry(root, newDatedLogEntry(root, context, "counter-changed", visibility, data));
+    }
+    return page;
+}
+/** The counters a page writes above their written maximum and above the maximum it reads with these effects, brought down to it, no lower than the written one (FOR-6). */
+function currentsAsRead(world, page, effects) {
+    const read = effectiveFields(world, withEffects(page, effects));
+    return Object.fromEntries(Object.entries(page.fields).flatMap(([field, value]) => {
+        const written = readCounter(value);
+        const now = isDeclaredUncounted(world, field) ? undefined : readCounter(read[field]);
+        // Only what is above the written maximum, which only an effect allows, as Aid's: a form that lowers the maximum leaves the page's own (FOR-6).
+        const excess = written?.max !== undefined && now?.max !== undefined && written.value > written.max && written.value > now.max;
+        return written?.max === undefined || now?.max === undefined || !excess ? [] : [[field, String(formatCounter({ value: Math.max(now.max, written.max), max: written.max }))]];
+    }));
+}
+/** An effects field that does not read is never written over: what was written by hand would be lost (EFF-12). */
+export function checkEffectsReadable(page) {
+    const read = readEffects(effectsField(page));
+    if ("problem" in read) {
+        throw new Error(`${page.name}'s effects do not read: ${read.problem} Write each line in quotes by hand, or remove them all with write ${page.name}, unset effects, and add again those that still hold. Nothing changed.`);
+    }
+}
+/**
+ * Ends, on every page and on the copies of `scene`, the effects that `ends` picks (EFF-8, EFF-9, EFF-13), with a line in the log for each, public when it concerns
+ * the player (EFF-11). Returns what ended, with the values that come back, "Scudo della fede on Ennio (ac 15 → 13)", ten at most. It never fails halfway:
+ * a page that two pages' names share, or that cannot be written, is said, not written.
+ */
+export function endEffects(root, context, world, scene, ends, why) {
+    const ended = [];
+    const whyOf = typeof why === "string" ? () => why : why;
+    for (const holder of effectHolders(world, scene)) {
+        const effects = effectsOf(holder.page);
+        const ending = effects.filter(ends);
+        if (ending.length === 0) {
+            continue;
+        }
+        const remaining = effects.filter((effect) => !ending.includes(effect));
+        const values = [...new Set(ending.flatMap((effect) => valuesChanged(world, holder.page, withEffects(holder.page, remaining), effect)))];
+        const named = `${ending.map((effect) => effect.name).join(", ")} on ${holder.page.name}`;
+        try {
+            saveEffects(root, context, world, holder, remaining);
+        }
+        catch (error) {
+            ended.push(`${named}: not written, ${error instanceof Error ? error.message : String(error)}`);
+            continue;
+        }
+        const visibility = !holder.copy && concernsPlayer(world, holder.page) ? "public" : "hidden";
+        for (const effect of ending) {
+            appendLogEntry(root, newDatedLogEntry(root, context, "effect-ended", visibility, { page: holder.page.name, copy: holder.copy ? true : undefined, effect: effect.name, why: whyOf(effect) }));
+        }
+        ended.push(`${named}${values.length === 0 ? "" : ` (${values.join(", ")})`}`);
+    }
+    return ended.length <= 10 ? ended : [shortList(ended, " · ")];
+}
+/** Whether an effect's end in game time has come (EFF-8). */
+export function endedByDate(effect, now) {
+    const date = effect.end !== undefined && "date" in effect.end ? readGameDate(effect.end.date) : undefined;
+    return date !== undefined && minutesBetween(now, date) <= 0;
+}
+/** Whether an effect counted in rounds ends when the turn passes to `turn` in `round` (EFF-9). */
+export function endedByTurn(effect, round, turn, order) {
+    return effect.end !== undefined && "round" in effect.end && endsAtTurn(effect.end, round, turn, order);
+}
+/** Whether an effect ends with the scene: counted in rounds, which exist only in it, or lasting until it ends (EFF-9). */
+export function endsWithScene(effect) {
+    return effect.end !== undefined && ("round" in effect.end || "scene" in effect.end);
+}
+/** Whether someone keeps an effect alive (D-138). */
+export function keptBy(effect, name) {
+    const keeper = keeperOf(effect);
+    return keeper !== undefined && comparableText(keeper) === comparableText(name);
+}
+/** "Spaventato until round 3, Lena": an effect as status names it, as its line writes it but its values. */
+export function effectText(effect) {
+    return effect.end === undefined ? effect.name : `${effect.name} until ${formatEnd(effect.end)}`;
+}
+/** An effect as status shows it: its name, the values it gives that no counter shows, such as ac 18, and its end (SYS-8). */
+export function effectShown(world, effect) {
+    const values = effect.values.filter(([field]) => isDeclaredUncounted(world, field)).map(([field, value]) => `${field} ${value}`);
+    const end = effect.end === undefined ? "" : ` until ${formatEnd(effect.end)}`;
+    return `${effect.name}${values.length === 0 ? "" : ` (${values.join(", ")})`}${end}`;
+}
+/** An effect as the dashboard shows it on someone of the party: its name, its end, the line status gives, and whether it is a condition (D-276, D-314, D-419). */
+export function effectParts(world, system, effect) {
+    return { name: effect.name, ...(effect.end === undefined ? {} : { end: effect.end }), text: effectShown(world, effect), ...conditionMark(system, effect.name) };
+}
+/** Whether an effect's name is one of the system's conditions, whatever its case, and the drawing the system gives it (D-419); nothing for any other effect. */
+export function conditionMark(system, name) {
+    const condition = (system?.conditions ?? []).find((named) => comparableText(named) === comparableText(name));
+    if (condition === undefined) {
+        return {};
+    }
+    const icon = Object.entries(system?.conditionIcons ?? {}).find(([named]) => comparableText(named) === comparableText(condition))?.[1];
+    return { condition: true, ...(icon === undefined ? {} : { icon }) };
+}
+/** "Benedizione (Ennio, Bruno)": what someone keeps alive, on whom (D-138). */
+export function keptEffects(world, scene, name) {
+    return keptEffectHolders(world, scene, name).map((kept) => `${kept.effect} (${kept.holders.join(", ")})`);
+}
+/** What someone keeps alive, each effect with the pages and copies that have it (D-138). */
+export function keptEffectHolders(world, scene, name) {
+    const kept = new Map();
+    for (const holder of effectHolders(world, scene)) {
+        for (const effect of effectsOf(holder.page).filter((candidate) => keptBy(candidate, name))) {
+            kept.set(effect.name, [...(kept.get(effect.name) ?? []), holder.page.name]);
+        }
+    }
+    return [...kept].map(([effect, holders]) => ({ effect, holders }));
+}
+/** The effects on whoever has this name, a page or a copy in the open scene, the copy first as change finds it (INH-14). */
+export function effectsOn(world, scene, name) {
+    const holders = effectHolders(world, scene).filter((holder) => comparableText(holder.page.name) === comparableText(name));
+    const holder = holders.find((candidate) => candidate.copy) ?? holders[0];
+    return holder === undefined ? [] : effectsOf(holder.page);
+}
+/**
+ * The problems of effects (EFF-12): fields that do not read, ends that are neither game dates nor occasions of the game system (DAT-5), effects ended and still there,
+ * effects that end with a scene when none is open. `sceneProblem` says why the open scene cannot be read, if it cannot.
+ */
+export function effectProblems(world, scene, now, occasions, sceneProblem) {
+    return effectHolders(world, scene).flatMap(({ page, copy }) => {
+        const path = copy ? "state.yaml" : page.path;
+        const read = readEffects(effectsField(page));
+        if ("problem" in read) {
+            const fix = `write each line of effects in quotes, such as - "Scudo della fede (ac: 15) until day 2, 14:20", and each effect once; or remove them all with write ${page.name}, unset effects, and add again with effect add those that still hold`;
+            return [{ path, message: `${page.name}: ${read.problem}`, fix }];
+        }
+        return read.effects.flatMap((effect) => {
+            const end = effect.end;
+            const endIt = `effect end ${page.name} "${effect.name}"`;
+            if (end !== undefined && "date" in end && readGameDate(end.date) === undefined) {
+                return [{ path, message: `${effect.name} on ${page.name} ends "${end.date}", which is not a game date.`, fix: `${endIt}, then add it again with a duration` }];
+            }
+            if (end !== undefined && "occasion" in end && !(occasions?.names ?? []).some((name) => comparableText(name) === comparableText(end.occasion))) {
+                const named = occasions === undefined || occasions.names.length === 0 ? "" : ` nor an occasion of the system ${occasions.system} (${occasions.names.join(", ")})`;
+                // Without the campaign's system, the occasion may well be one of its own: the system comes first (SYS-1).
+                const first = systemFirstFix(world, "an occasion");
+                const fix = `${first === undefined ? "" : `${first}; otherwise `}${endIt}, then add it again with a duration`;
+                return [{ path, message: `${effect.name} on ${page.name} ends "${end.occasion}", which is not a game date${named}.`, fix }];
+            }
+            if (end !== undefined && now !== undefined && endedByDate(effect, now)) {
+                return [{ path, message: `${effect.name} on ${page.name} ended at ${formatEnd(end)}, and is still there.`, fix: `let time pass with advance, which ends it, or ${endIt}` }];
+            }
+            if (endsWithScene(effect) && scene === undefined) {
+                const why = sceneProblem === undefined ? "no scene is open" : `the open scene cannot be read (${sceneProblem})`;
+                return [{ path, message: `${effect.name} on ${page.name} ends with the scene, but ${why}.`, fix: endIt }];
+            }
+            return computedValueProblems(world, page, path, effect, endIt);
+        });
+    });
+}
+/** A value an effect gives to a field the game system works out, as ac written before the system did: it does not count (FOR-7). */
+function computedValueProblems(world, page, path, effect, endIt) {
+    const fields = effectiveFields(world, page);
+    return effect.values.flatMap(([field]) => {
+        const computed = computedField(world, field, fields);
+        const instead = computed === undefined ? [] : [...effectBonuses(world, computed.from), ...computed.from];
+        return computed === undefined ? [] : [{
+                path,
+                message: `${effect.name} on ${page.name} gives ${computed.name}, which the system ${world.system?.name ?? ""} works out, so it does not count.`,
+                fix: `${endIt}, then add it again with what ${computed.name} comes from${instead.length === 0 ? "" : `, such as ${instead[0]}`}`,
+            }];
+    });
+}
+/** The pages and the copies in the open scene that hold effects. */
+function effectHolders(world, scene) {
+    const copies = scene === undefined ? [] : Object.entries(scene.copies).map(([name, copy]) => ({ page: copyPage(name, copy), copy: true }));
+    return [...world.pages.map((page) => ({ page, copy: false })), ...copies].filter((holder) => !isEmptyField(effectsField(holder.page)));
+}

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

@@ -0,0 +1,16 @@
+import { type Page, type World } from "../pages/index.ts";
+/** One thing that holds around a page, as outputs name it: "light: dark (Cripta)", "Pioggia battente until day 3, 18:00 (Palude)". */
+export interface Surrounding {
+    /** What tells it apart from the others: an entry's name, or an effect and its place. */
+    key: string;
+    text: string;
+}
+/** What holds at a page, nearest first: its places' environment, each entry with its place, then their effects, each with its end and place. Nothing for no page. */
+export declare function surroundings(world: World, page: Page | undefined): Surrounding[];
+/** "light: dark (Cripta) · Pioggia battente until day 3, 18:00 (Palude)"; empty when nothing holds. */
+export declare function surroundingsText(items: Surrounding[]): string;
+/** What changes around someone who moves (ENV-5): what holds now and did not, or differently; what held before and holds no more. */
+export declare function surroundingsChange(before: Surrounding[], after: Surrounding[]): {
+    here: Surrounding[];
+    noLonger: Surrounding[];
+};

package/dist/commands/game-environment.js

@@ -0,0 +1,24 @@
+// What holds around a page (D-153, ENV-2, ENV-3, ENV-5): the environment of the places it is in, with their effects, as outputs tell it.
+import { comparableText } from "../core/text.js";
+import { environmentAt, formatEnvironmentEntry, placesAround } from "../pages/index.js";
+import { effectsOf } from "./effect-layer.js";
+import { effectText } from "./game-effects.js";
+/** What holds at a page, nearest first: its places' environment, each entry with its place, then their effects, each with its end and place. Nothing for no page. */
+export function surroundings(world, page) {
+    if (page === undefined) {
+        return [];
+    }
+    const entries = environmentAt(world, page).map(({ entry, place }) => ({ key: `entry ${comparableText(entry.name)}`, text: `${formatEnvironmentEntry(entry)} (${place.name})` }));
+    const effects = placesAround(world, page).flatMap((place) => effectsOf(place).map((effect) => ({ key: `effect ${place.path} ${comparableText(effect.name)}`, text: `${effectText(effect)} (${place.name})` })));
+    return [...entries, ...effects];
+}
+/** "light: dark (Cripta) · Pioggia battente until day 3, 18:00 (Palude)"; empty when nothing holds. */
+export function surroundingsText(items) {
+    return items.map((item) => item.text).join(" · ");
+}
+/** What changes around someone who moves (ENV-5): what holds now and did not, or differently; what held before and holds no more. */
+export function surroundingsChange(before, after) {
+    const was = new Map(before.map((item) => [item.key, item.text]));
+    const keys = new Set(after.map((item) => item.key));
+    return { here: after.filter((item) => was.get(item.key) !== item.text), noLonger: before.filter((item) => !keys.has(item.key)) };
+}

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

@@ -0,0 +1,84 @@
+import type { Context } from "../core/context.ts";
+import type { Problem } from "../core/problem.ts";
+import { type Page, type PageType, type World } from "../pages/index.ts";
+import { type GameDate } from "../time/index.ts";
+import { type TriggerFacts } from "../triggers/index.ts";
+/** A planned event of the world, with its game date when the engine can read one. */
+export interface PlannedEvent {
+    page: Page;
+    date?: GameDate;
+}
+/** A planned event with a game date: it comes due at that date. */
+export type DatedEvent = PlannedEvent & {
+    date: GameDate;
+};
+/** What a command set off (EVT-4, EVT-5): the events it made due, with why, those set off that wait for the date it gave them, and the world as it left it. */
+export interface FiredEvents {
+    due: {
+        name: string;
+        text: string;
+    }[];
+    held: string[];
+    world: World;
+}
+/** The planned events: those with a game date first, in order of date, then those without one. */
+export declare function plannedEvents(world: World): PlannedEvent[];
+export declare function isDated(event: PlannedEvent): event is DatedEvent;
+/** The party and the containers of the world, as conditions read them (EVT-3). */
+export declare function worldFacts(world: World): TriggerFacts;
+/**
+ * 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 declare function isDue(event: PlannedEvent, now: GameDate | undefined, facts: TriggerFacts): boolean;
+/** The planned events due now (EVT-1), in the order of plannedEvents. */
+export declare function dueEvents(world: World, now: GameDate | undefined, facts?: TriggerFacts): PlannedEvent[];
+/** 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 declare function dueText(event: PlannedEvent): string;
+/** 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 declare function plannedText(event: PlannedEvent, now: GameDate | undefined): string;
+/** 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 declare function dueAdvice(count: number): string;
+/**
+ * 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 declare function fireEvents(root: string, context: Context, before: World, after: World, now: GameDate | undefined): FiredEvents;
+/**
+ * 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 declare function eventsToFire(before: World, after: World, now: GameDate | undefined): {
+    fired: {
+        event: PlannedEvent;
+        cause: string;
+        date?: string;
+    }[];
+    held: PlannedEvent[];
+};
+/** "Now due: …", with how to play them; empty when nothing came due. */
+export declare function nowDueNote(due: FiredEvents["due"]): string;
+/** The events set off that wait for the date this command gave them (EVT-4); empty when there are none. */
+export declare function heldNote(held: string[]): string;
+/**
+ * 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 declare function consequencesNotes(world: World, before: Page | undefined, after: Page, skipped: string[], now: GameDate | undefined): string[];
+/**
+ * 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 declare function linkedStoryNotes(world: World, pages: Page[], skipped: string[], now: GameDate | undefined): string[];
+/** 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 declare function clocksToMove(world: World, now: GameDate | undefined, facts?: TriggerFacts): string[];
+/** 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 declare function plannedEventDateProblem(type: PageType | undefined, fields: Record<string, unknown>): string | undefined;
+/** 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 declare function eventFieldsProblem(world: World, fields: Record<string, unknown>, changed: string[]): string | 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 declare function conditionNotes(world: World, when: unknown): string[];
+/** 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 declare function eventProblems(world: World): Problem[];