rpg-engine 0.0.0-stage → 0.1.0

package/dist/commands/game-view-place.js

@@ -0,0 +1,388 @@
+import { formatStep } from "../core/length.js";
+import { files } from "../core/store.js";
+import { comparableText } from "../core/text.js";
+import { readCounter } from "../counters/index.js";
+import { reachable, squareName, squaresApart, withoutMapBlock } from "../grid/index.js";
+import { hiddenImageName } from "../images/index.js";
+import { environmentAt, locate, pagesWithName, pagesWithNameOrAlias, parsePageReference, placesAround } from "../pages/index.js";
+import { effectsOf } from "./effect-layer.js";
+import { conditionMark, effectParts, keptEffects } from "./game-effects.js";
+import { isTurnOf, movedThisTurn, sideOf, walkingSpeed } from "./game-grid-moves.js";
+import { placeGrid, placeLook, standing } from "./game-grids.js";
+import { imageFile, ownImage, shownImage } from "./game-images.js";
+import { knownText, knowsPage } from "./game-knowledge.js";
+import { measuresOf } from "./game-roads.js";
+import { copyPage, readOpenScene } from "./game-scene.js";
+import { campaignSystem } from "./game-world.js";
+import { pageCounters } from "./page-counters.js";
+import { tokenIcon } from "./sheet.js";
+/** Where the player character is, as it knows it; none when it is in no place it knows, as in the open on a journey. */
+export function shownPlace(sight) {
+    const { world, knowledge } = sight;
+    const places = locate(world, knowledge.pc).chain.filter((holder) => holder.type === "place" && knowsPage(knowledge, holder));
+    const place = places[0];
+    if (place === undefined) {
+        return undefined;
+    }
+    const known = (holder) => (knowsPage(knowledge, holder) ? holder.name : undefined);
+    const placed = (holder) => (known(holder) === undefined ? {} : { place: holder.name });
+    const around = [
+        ...environmentAt(world, place).map(({ entry, place: holder }) => ({ name: entry.name, value: entry.value, ...placed(holder) })),
+        ...placesAround(world, place).flatMap((holder) => effectsOf(holder).map((effect) => ({ effect: effect.name, ...(effect.end === undefined ? {} : { end: effect.end }), ...placed(holder) }))),
+    ];
+    const present = world.pages.filter((page) => page.type === "character" && page.fields.status !== "dead" && locate(world, page).chain[0] === place
+        && (sight.party.includes(page) || knowsPage(knowledge, page)));
+    const image = picture(sight, place);
+    const grid = placeGrid(place)?.grid;
+    const text = knownText(world, knowledge, place);
+    return {
+        name: place.name,
+        ...(image === undefined ? {} : { image }),
+        within: places.slice(1).map((holder) => holder.name).reverse(),
+        around,
+        // The map block is drawn, not read.
+        text: grid === undefined ? text : withoutMapBlock(text),
+        // The party first, the player character at its head.
+        here: [...sight.party.filter((page) => present.includes(page)), ...present.filter((page) => !sight.party.includes(page))].map((page) => ({
+            ...person(sight, page),
+            ...hostileMark(readOpenScene(sight.root).scene, page.name),
+            ...stateOf(sight, page),
+        })),
+        ...(grid === undefined ? {} : { map: shownGrid(sight, place, grid) }),
+    };
+}
+/**
+ * A place's map as the player sees it (GRD-6): who stands where, the party and the characters the character knows by name, the others of the open scene as
+ * someone, its copies as the scene names them; a character it does not know outside the scene is not shown, as in VIEW-6.
+ */
+function shownGrid(sight, place, written) {
+    const { grid, ground } = placeLook(sight.world, place, written);
+    // What is not found yet looks like what lies under it: a hidden door like the wall, anything else like the floor (GRD-6).
+    const hidden = new Map(grid.features.filter((feature) => feature.hidden).map((feature) => [feature.symbol, ["door", "open-door", "secret-door", "opening", "window"].includes(feature.kind) ? "#" : "."]));
+    const lines = grid.lines.map((line) => [...line].map((symbol) => hidden.get(symbol) ?? symbol).join(""));
+    const used = new Set(lines.join(""));
+    const scene = readOpenScene(sight.root).scene;
+    const here = scene?.place !== undefined && comparableText(parsePageReference(scene.place).name) === comparableText(place.name) ? scene : undefined;
+    const inScene = new Set((here?.with ?? []).map((link) => comparableText(parsePageReference(link).name)));
+    const system = campaignSystem(sight.root, sight.context);
+    const measures = measuresOf(sight.root, system);
+    const standings = standing(sight.world, place, here);
+    const self = standings.find((one) => one.page === sight.party[0] && one.square !== undefined);
+    const at = standings.flatMap((one) => {
+        const square = one.square === undefined ? undefined : squareName(one.square);
+        if (square === undefined) {
+            return [];
+        }
+        const measured = { square, ...(system?.grid === undefined ? {} : measuredFrom(sight, system.grid, measures, here, self, one)) };
+        if (one.copy !== undefined && here !== undefined) {
+            const copy = here.copies[one.copy];
+            const creature = knownPage(sight, copy?.creature);
+            const image = creature === undefined ? strangerPicture(sight, copy?.creature) : picture(sight, creature);
+            const state = copy === undefined ? {} : stateOf(sight, copyPage(one.copy, copy));
+            return [
+                creature === undefined
+                    ? { name: strangerName(here, one.copy), role: "other", stranger: true, ...(image === undefined ? {} : { image }), ...hostileMark(here, one.copy), ...state, ...measured }
+                    : { name: one.copy, role: "other", ...(image === undefined ? {} : { image }), ...hostileMark(here, one.copy), ...state, ...measured },
+            ];
+        }
+        const page = one.page;
+        if (page === undefined || page.type !== "character" || page.fields.status === "dead") {
+            return [];
+        }
+        if (sight.party.includes(page) || knowsPage(sight.knowledge, page)) {
+            return [{ ...person(sight, page), ...hostileMark(here, page.name), ...stateOf(sight, page), ...measured }];
+        }
+        const image = strangerPicture(sight, page.name);
+        return inScene.has(comparableText(page.name))
+            ? [{ name: seenName(here, page.name), role: "other", stranger: true, ...(image === undefined ? {} : { image }), ...hostileMark(here, page.name), ...strangerState(sight, here, page), ...measured }]
+            : [];
+    });
+    const reach = system?.grid === undefined || here === undefined || self === undefined || !isTurnOf(here, self.name) ? [] : reachOf(sight, system.grid, measures, here, self, { ...grid, lines });
+    return {
+        columns: grid.columns,
+        rows: grid.rows,
+        lines,
+        legend: grid.features.filter((feature) => !feature.hidden && used.has(feature.symbol)).map((feature) => ({
+            symbol: feature.symbol,
+            name: feature.name,
+            kind: feature.kind,
+            ...(feature.blocks ? { blocks: true } : {}),
+            ...(feature.difficult ? { difficult: true } : {}),
+        })),
+        ground,
+        exits: grid.exits.filter((exit) => !hidden.has(grid.lines[exit.square.row]?.[exit.square.column] ?? "")).map((exit) => {
+            const to = knownPage(sight, exit.to);
+            return { square: squareName(exit.square), ...(to === undefined ? {} : { to: to.name }) };
+        }),
+        at,
+        ...(reach.length === 0 ? {} : { reach }),
+    };
+}
+/** How big one on the map is, when more than a square, and how far from the player character, in the player's units (GRD-4, D-328). */
+function measuredFrom(sight, rules, measures, scene, self, one) {
+    const side = sideOf(sight.world, rules, scene, one);
+    const apart = self === undefined || one === self || one.square === undefined
+        ? undefined
+        : squaresApart({ square: self.square, side: sideOf(sight.world, rules, scene, self) }, { square: one.square, side }, rules);
+    // On the player character's own square no distance: the page says they are next to it.
+    return { ...(side > 1 ? { side } : {}), ...(apart === undefined || apart === 0 ? {} : { distance: formatStep(apart * rules.square, measures.units, measures.imperial) }) };
+}
+/**
+ * The squares the player character can still reach on its turn in a fight (D-328), with what is left of its speed, on the map as the player sees it: what is
+ * hidden counts as what lies under it, so that the way round a trap never gives it away (GRD-6).
+ */
+function reachOf(sight, rules, measures, scene, self, grid) {
+    const speed = walkingSpeed(sight.world, rules, measures, scene, self).metres;
+    const left = speed === undefined ? 0 : speed / rules.square - movedThisTurn(scene);
+    return left <= 0 ? [] : reachable(grid, self.square, left + 1e-9, rules).filter((one) => one.cost > 0).map((one) => squareName(one.square));
+}
+/** The open scene as the player sees it; none when no scene is open, or it cannot be read. */
+export function shownScene(sight) {
+    const { scene } = readOpenScene(sight.root);
+    if (scene === undefined) {
+        return undefined;
+    }
+    const place = knownPage(sight, scene.place);
+    const characters = scene.with.map((link) => {
+        const name = parsePageReference(link).name;
+        const page = knownPage(sight, link);
+        const hostile = hostileMark(scene, name);
+        const written = pagesWithName(sight.world, name)[0];
+        const state = written === undefined ? {} : strangerState(sight, scene, written);
+        const image = strangerPicture(sight, name);
+        return page === undefined
+            ? { name: seenName(scene, name), role: "other", stranger: true, ...(image === undefined ? {} : { image }), ...hostile, ...state }
+            : { ...person(sight, page), ...hostile, ...stateOf(sight, page) };
+    });
+    const creatures = [...new Set(Object.values(scene.copies).map((copy) => copy.creature))].map((creature) => {
+        const count = Object.values(scene.copies).filter((copy) => copy.creature === creature).length;
+        const page = knownPage(sight, creature);
+        // A kind the character does not know by the letter its copies have in the scene, as creature B, with more kinds (D-331).
+        const first = Object.keys(scene.copies).find((copy) => scene.copies[copy].creature === creature);
+        const name = first === undefined ? "creature" : strangerName(scene, first).replace(/\s*\d+$/, "");
+        // A kind is hostile when one of its copies is.
+        const hostile = Object.keys(scene.copies).some((copy) => scene.copies[copy].creature === creature && hostileMark(scene, copy).hostile === true) ? { hostile: true } : {};
+        // A kind of one copy shows its state; of more, each shows its own on the map and in Combat.
+        const state = count === 1 && first !== undefined ? stateOf(sight, copyPage(first, scene.copies[first])) : {};
+        const image = strangerPicture(sight, creature);
+        return page === undefined
+            ? { name, role: "other", stranger: true, ...(image === undefined ? {} : { image }), count, ...hostile, ...state }
+            : { ...person(sight, page), count, ...hostile, ...state };
+    });
+    const turnName = (name) => shownTurn(sight, scene, name);
+    return {
+        title: scene.title,
+        type: scene.type,
+        ...(scene.opened === undefined ? {} : { since: scene.opened }),
+        ...(scene.now === undefined ? {} : { now: scene.now }),
+        ...(place === undefined ? {} : { place: place.name }),
+        who: [...characters, ...creatures],
+        ...(scene.order === undefined ? {} : { order: scene.order.map(turnName) }),
+        ...(scene.turn === undefined ? {} : { turn: turnName(scene.turn) }),
+        ...(scene.round === undefined ? {} : { round: scene.round }),
+        ...(scene.type === "combat" ? { fighters: fightersOf(sight, scene) } : {}),
+    };
+}
+/**
+ * Who is in the open scene, by the words the page gives them (D-416): a character by name when the character knows them, else by what it sees of them, else
+ * someone; a copy by its name when it knows its creature, else by what it sees of its kind and its number, else creature 1.
+ */
+export function sceneNames(sight) {
+    const { scene } = readOpenScene(sight.root);
+    const names = scene === undefined ? [] : [...scene.with.map((link) => parsePageReference(link).name), ...Object.keys(scene.copies)];
+    return scene === undefined ? [] : names.map((name) => shownTurn(sight, scene, name));
+}
+/** Everyone in a fight, in the order of the turns when there is one, else the characters then the copies; those the view cannot name are left out. */
+function fightersOf(sight, scene) {
+    const names = scene.order ?? [...scene.with.map((link) => parsePageReference(link).name), ...Object.keys(scene.copies)];
+    return names.flatMap((name) => {
+        const fighter = fighterOf(sight, scene, name);
+        return fighter === undefined ? [] : [fighter];
+    });
+}
+/** One in the fight (D-314): a copy as the character knows its creature, a character as it knows them; the party in full, the others by what anyone sees. */
+function fighterOf(sight, scene, name) {
+    const system = campaignSystem(sight.root, sight.context);
+    const copy = Object.entries(scene.copies).find(([copyName]) => comparableText(copyName) === comparableText(name));
+    const page = copy === undefined ? pagesWithName(sight.world, parsePageReference(name).name)[0] : copyPage(copy[0], copy[1]);
+    if (page === undefined) {
+        return undefined;
+    }
+    const party = sight.party.includes(page);
+    // A copy is named when the character knows its creature; a character when it knows them.
+    const creature = copy === undefined ? undefined : knownPage(sight, copy[1].creature);
+    const stranger = copy === undefined ? !party && !knowsPage(sight.knowledge, page) : creature === undefined;
+    const shown = !stranger ? page.name : copy === undefined ? seenName(scene, page.name) : strangerName(scene, copy[0]);
+    const image = stranger ? strangerPicture(sight, copy === undefined ? page.name : copy[1].creature) : picture(sight, creature ?? page);
+    const effects = shownEffects(sight, system, page, party);
+    const health = healthOf(sight.world, system, page, party);
+    const keeps = party ? keptEffects(sight.world, readOpenScene(sight.root).scene, page.name) : [];
+    const dying = party ? dyingOf(sight.world, system, page) : undefined;
+    const icon = party ? tokenIcon(sight.world, system, page) : undefined;
+    return {
+        name: shown,
+        role: page === sight.knowledge.pc ? "pc" : party ? "companion" : "other",
+        ...(image === undefined ? {} : { image }),
+        ...(icon === undefined ? {} : { icon }),
+        ...(stranger ? { stranger: true } : {}),
+        ...hostileMark(scene, name),
+        ...(health === undefined ? {} : { health }),
+        effects,
+        ...(keepsFromActing(system, effects) ? { inactive: true } : {}),
+        ...(keeps.length === 0 ? {} : { keeps }),
+        ...(dying === undefined ? {} : { dying }),
+    };
+}
+/**
+ * The panel of the dying of someone of the party (D-310 (7), D-314): at the value of the counter the system names, as hp 0, the counters it shows, with their
+ * limits; none at any other value, nor for the dead.
+ */
+export function dyingOf(world, system, page) {
+    const counters = pageCounters(world, page);
+    const dying = system?.dying;
+    if (dying === undefined || page.fields.status === "dead" || readCounter(counters[dying.field])?.value !== dying.value) {
+        return undefined;
+    }
+    return dying.show.map((field) => ({ field, value: readCounter(counters[field] ?? page.fields[field])?.value ?? 0, ...limitOf(system?.thresholds ?? [], field) }));
+}
+/** An effect on someone of the party as the player sees it: an end at someone's turn names them as the character knows them (VIEW-4), as creature 2. */
+export function seenEffect(sight, effect) {
+    const end = effect.end;
+    const system = campaignSystem(sight.root, sight.context);
+    if (end === undefined || !("turn" in end)) {
+        return effectParts(sight.world, system, effect);
+    }
+    const scene = readOpenScene(sight.root).scene ?? { copies: {} };
+    return effectParts(sight.world, system, { ...effect, end: { ...end, turn: shownTurn(sight, scene, end.turn) } });
+}
+/**
+ * The state a token shows (D-419): what is on them, whether a condition keeps them from acting, whether they are at 0 as Combat tells it, or dead; the party in
+ * full, the others by what anyone sees (D-314).
+ */
+function stateOf(sight, page) {
+    const system = campaignSystem(sight.root, sight.context);
+    const party = sight.party.includes(page);
+    const effects = shownEffects(sight, system, page, party);
+    const dead = page.fields.status === "dead";
+    const down = !dead && (party ? dyingOf(sight.world, system, page) !== undefined : healthOf(sight.world, system, page, false) === "down");
+    return {
+        ...(effects.length === 0 ? {} : { effects }),
+        ...(keepsFromActing(system, effects) ? { inactive: true } : {}),
+        ...(down ? { down: true } : {}),
+        ...(dead ? { dead: true } : {}),
+    };
+}
+/** The state of a character in the scene the character does not know (D-419): as anyone sees it when the master said what it sees of them, none for someone. */
+function strangerState(sight, scene, page) {
+    return scene === undefined || seenOf(scene, page.name) === undefined ? {} : stateOf(sight, page);
+}
+/** What is on someone as the player sees it (D-314, D-419): the party's effects as their line gives them, with their end; of the others only the conditions anyone sees. */
+function shownEffects(sight, system, page, party) {
+    return effectsOf(page).flatMap((effect) => {
+        const mark = conditionMark(system, effect.name);
+        return party ? [seenEffect(sight, effect)] : mark.condition === true ? [{ name: effect.name, text: effect.name, ...mark }] : [];
+    });
+}
+/** Whether one of these effects is a condition the system says keeps from acting (D-314). */
+function keepsFromActing(system, effects) {
+    const inactive = new Set((system?.combat?.inactive ?? []).map(comparableText));
+    return effects.some((effect) => inactive.has(comparableText(effect.name)));
+}
+/** Someone's counter in a fight as the player may know it (D-238, D-314): the party's as numbers, a foe's in words when the system says so, else none. */
+function healthOf(world, system, page, party) {
+    const track = system?.combat === undefined ? undefined : readCounter(pageCounters(world, page)[system.combat.track]);
+    if (track === undefined) {
+        return undefined;
+    }
+    return party ? `${track.value}${track.max === undefined ? "" : `/${track.max}`}` : system?.combat?.inWords ? healthWord(track.value, track.max) : undefined;
+}
+/** A foe's counter as the player may hear it (D-238, D-314): unhurt, hurt, bloodied at half or less, down at none. */
+function healthWord(value, most) {
+    if (value <= 0) {
+        return "down";
+    }
+    if (most === undefined || value >= most) {
+        return "unhurt";
+    }
+    return value * 2 <= most ? "bloodied" : "hurt";
+}
+/** The limit a threshold of the system gives a counter, as death-failures 3. */
+function limitOf(thresholds, field) {
+    const limit = thresholds.find((threshold) => comparableText(threshold.field) === comparableText(field))?.value;
+    return limit === undefined ? {} : { limit };
+}
+/** The mark of one the master says attacks the party, in a fight (D-415); nothing for anyone else, or outside a fight. */
+function hostileMark(scene, name) {
+    const hostile = scene?.type === "combat" && (scene.hostile ?? []).some((one) => comparableText(one) === comparableText(parsePageReference(name).name));
+    return hostile ? { hostile: true } : {};
+}
+/** Someone the character knows, with their picture and their role. */
+function person(sight, page) {
+    const role = page === sight.knowledge.pc ? "pc" : sight.party.includes(page) ? "companion" : "other";
+    const image = picture(sight, page);
+    // Only the party's: what the others are, the character may not know.
+    const icon = role === "other" ? undefined : tokenIcon(sight.world, campaignSystem(sight.root, sight.context), page);
+    return { name: page.name, role, ...(image === undefined ? {} : { image }), ...(icon === undefined ? {} : { icon }) };
+}
+/** A page's picture, its own or from a base the character knows (D-267, D-277). */
+function picture(sight, page) {
+    return shownImage(sight.root, sight.context, sight.world, page, (base) => knowsPage(sight.knowledge, base));
+}
+/**
+ * The picture of one the character does not know, by their name or a copy's creature (D-420): the page's own, of the campaign, made from what is seen; never
+ * one from a page it derives from, nor a game system's, which would tell what it is.
+ */
+function strangerPicture(sight, name) {
+    return strangerImage(sight.root, sight.context, sight.world, name);
+}
+/** The picture of one the character does not know, as strangerPicture gives it, for the scene and for the rolls (D-420, D-421). */
+export function strangerImage(root, context, world, name) {
+    // A roll keeps a renamed page by its old name, among its aliases (D-417).
+    const page = name === undefined ? undefined : pagesWithNameOrAlias(world, parsePageReference(name).name)[0];
+    const file = page === undefined || page.system !== undefined ? undefined : imageFile(root, context, ownImage(page));
+    // By a name of its bytes: the file's own is the page's, which the character does not know.
+    const hidden = file === undefined ? undefined : hiddenImageName(file);
+    return file === undefined || hidden === undefined ? undefined : { file: hidden, version: Math.trunc(files().modified(file) ?? 0) };
+}
+/** The page the character knows by a link or a name, of the campaign or of the system. */
+function knownPage(sight, name) {
+    if (name === undefined) {
+        return undefined;
+    }
+    const page = pagesWithName(sight.world, parsePageReference(name).name)[0];
+    return page !== undefined && knowsPage(sight.knowledge, page) ? page : undefined;
+}
+/** Whose turn it is, as the character knows them: a character it knows by name, a copy by its own name when it knows the creature, else creature and its number. */
+function shownTurn(sight, scene, name) {
+    const copy = Object.entries(scene.copies).find(([copyName]) => comparableText(copyName) === comparableText(name));
+    if (copy === undefined) {
+        return knownPage(sight, name)?.name ?? seenName(scene, name);
+    }
+    return knownPage(sight, copy[1].creature) === undefined ? strangerName(scene, copy[0]) : copy[0];
+}
+/**
+ * The name the player hears for a copy of a creature its character does not know (D-325, D-331, D-416): what the master said the character sees of its kind and
+ * its number, brigante 2; else creature 1, and with more kinds of creature in the scene a letter for each kind, in the order of their names and counting those
+ * that left, so that it never changes: creature A1, creature B1.
+ */
+function strangerName(scene, copy) {
+    const all = { ...scene.gone, ...scene.copies };
+    const kindOf = (name) => (all[name] === undefined ? undefined : comparableText(parsePageReference(all[name].creature).name));
+    const kinds = [...new Set(Object.keys(all).map(kindOf).filter((kind) => kind !== undefined))].sort();
+    const kind = kindOf(copy);
+    const number = /\d+$/.exec(copy)?.[0] ?? "";
+    const seen = kind === undefined ? undefined : seenOf(scene, kind);
+    if (seen !== undefined) {
+        return `${seen} ${number}`.trim();
+    }
+    const letter = kinds.length > 1 && kind !== undefined ? String.fromCharCode(65 + kinds.indexOf(kind)) : "";
+    return `creature ${letter}${number}`.trim();
+}
+/** What the character sees of a character it does not know by name, as the master said (D-416); someone when the master said nothing. */
+function seenName(scene, name) {
+    return (scene === undefined ? undefined : seenOf(scene, name)) ?? "someone";
+}
+/** What the master said the character sees of a character or a kind of creature, by its name. */
+function seenOf(scene, name) {
+    return Object.entries(scene.seen ?? {}).find(([key]) => comparableText(key) === comparableText(parsePageReference(name).name))?.[1];
+}

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

@@ -0,0 +1,60 @@
+import type { Context } from "../core/context.ts";
+import type { Problem } from "../core/problem.ts";
+import { type PageType, type World } from "../pages/index.ts";
+import { type GameSystem, type SystemSetting } from "../systems/index.ts";
+/** The world of the campaign in `root`, with the pages of its game system when campaign.yaml names one that is installed (SYS-1, SYS-3). */
+export declare function campaignWorld(root: string, context: Context): World;
+/**
+ * The installed game system that campaign.yaml names, with what the campaign adds to it (CAM-1, CAM-2): alone when the additions do not read (CAM-3). Undefined
+ * when it names none, or one that is not installed (SYS-1).
+ */
+export declare function campaignSystem(root: string, context: Context): GameSystem | undefined;
+/** A setting the campaign's game system adds to the setup (DAT-10), by its name in any case; undefined when the system has none by that name. */
+export declare function systemSetting(root: string, context: Context, name: string): SystemSetting | undefined;
+/** The value campaign.yaml gives a setting of the system, when it is one the system has (DAT-10). */
+export declare function systemSettingValue(root: string, setting: SystemSetting): string | undefined;
+/** "xp is not kept with advancement milestones": said when a field the campaign's settings leave out is written or changed (DAT-10); undefined for any other. */
+export declare function leftOutNote(root: string, context: Context, field: string): string | undefined;
+/** A setting of the system written by hand with a value the system does not have (DAT-10): what it takes instead. */
+export declare function systemSettingProblems(root: string, context: Context): Problem[];
+/** "xp or milestones": the values of a setting of the system. */
+export declare function valuesText(setting: SystemSetting): string;
+/** The occasions of a game system that end effects (DAT-5): those its recipes name, such as long rest. */
+export declare function occasionsOf(system: GameSystem | undefined): string[];
+/** The occasions of the campaign's game system, with its name; undefined without one. */
+export declare function systemOccasions(root: string, context: Context): {
+    system: string;
+    names: string[];
+} | undefined;
+/** A game system named in campaign.yaml that is not installed (SYS-1, D-167): the commands go on without its pages. */
+export declare function systemProblems(root: string, context: Context): Problem[];
+/** The name of an installed game system, as it is installed; refused, with those that are, when none has it (D-167). */
+export declare function installedSystemName(name: string, context: Context, how: "init" | "config"): string;
+/** " The campaign's system, Quinta edizione, is not installed, so none of its pages can be found: validate says how to fix it.": for a name not found (SYS-1). Empty otherwise. */
+export declare function missingSystemHint(world: World): string;
+/**
+ * " find looks for the pages of the system 5e in their names and fields, in English.": how a page of the game system is found, for a name that was not (SYS-3, D-165);
+ * the language only when it is not the campaign's. Empty when there is no system.
+ */
+export declare function systemSearchHint(world: World): string;
+/** The language the game system names its pages in, such as English, when it is not the campaign's (D-165); undefined when it is, or there is no system. */
+export declare function foreignSystemLanguage(world: World): string | undefined;
+/** The language a game system writes in, such as English, when the campaign plays in another one (D-165); undefined when it is the same, or the campaign's is not set. */
+export declare function foreignLanguage(systemLanguage: string, campaignLanguage: string | undefined): string | undefined;
+/**
+ * " If it is a kind of one of the system 5e (named in English: find, type creature, with a text in English), set creature to it, and its numbers come from there.": for a page
+ * created without the base its type may have, when the game system has pages of that type (D-165, SYS-7). Empty otherwise.
+ */
+export declare function systemBaseHint(world: World, type: PageType, field: string): string;
+/**
+ * " The system 5e has 8 more creatures, named in English: find one with find, type creature and a text in English, then give its name here.": the pages of a type
+ * the game system has, for a message that lists the campaign's (SYS-3). Empty when it has none.
+ */
+export declare function systemPagesHint(world: World, type: PageType): string;
+/** The settings still missing, with the installed game systems beside system, the one to ask for among them (D-167): "system (installed: 5e)". */
+export declare function missingWithSystems(root: string, missing: string[], context: Context): string[];
+/**
+ * The campaign's system as status shows it, so that the master always knows which rules are played (D-173): "5e, the fifth edition from the SRD 5.1, the 2014 rules";
+ * one that is not installed says so, with the fix (D-167). Undefined when campaign.yaml names none.
+ */
+export declare function systemInStatus(root: string, context: Context): string | undefined;