rpg-engine 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,266 @@
+// The world map as the player character knows it, for the dashboard (VIEW-7, D-316, D-318, D-320): the maps it knows; on each, the places it knows with their
+// kind and where they are, the regions with their biome, the roads as far as it knows their stops, the party and its trail. Never a place it does not know,
+// neither its name nor its point.
+import { formatLength, trueImperialUnits } from "../core/length.js";
+import { readLog } from "../core/log.js";
+import { comparableText } from "../core/text.js";
+import { directionName, directionTo, distanceBetween } from "../map/index.js";
+import { environmentAt, locate, pagesWithName, parsePageReference, readStops } from "../pages/index.js";
+import { shownImage } from "./game-images.js";
+import { moversMap, moversNamed, moversPosition, readJourney } from "./game-journey.js";
+import { knowsPage } from "./game-knowledge.js";
+import { mapKey, mapOf } from "./game-maps.js";
+import { placedPosition, positionOf, regionsOf } from "./game-positions.js";
+import { kindOf, roadsOf, travellingParty } from "./game-roads.js";
+import { campaignSystem } from "./game-world.js";
+// How far a road toward a stop the character does not know is drawn, at most: a beginning, never where the stop is.
+const stubMetres = 3000;
+// How many places the chat lists.
+const mostListed = 20;
+export function shownMap(sight, measures, campaign) {
+    const { world, knowledge } = sight;
+    const roads = roadsOf(world);
+    const known = (page) => page.system === undefined && knowsPage(knowledge, page);
+    const journey = readJourney(sight.root);
+    const movers = journey === undefined ? travellingParty(world, knowledge.pc, []) : moversNamed(world, journey);
+    const partyAt = moversPosition(world, roads, journey, movers) ?? positionOf(world, knowledge.pc);
+    const partyMap = moversMap(world, journey, movers);
+    const partyPlace = locate(world, knowledge.pc).chain.find((holder) => isDrawn(world, roads, holder) && known(holder));
+    const party = partyAt === undefined ? undefined : { at: partyAt, map: partyMap?.path ?? "" };
+    const places = world.pages.filter((page) => page.type === "place" && known(page) && !roads.pages.has(page.name)).flatMap((page) => {
+        const shown = mapPlace(sight, roads, page, known, party);
+        return shown === undefined ? [] : [shown];
+    });
+    const system = campaignSystem(sight.root, sight.context);
+    return {
+        unit: measures.units === "imperial" ? { name: "mi", km: measures.imperial.mile / 1000, foot: measures.imperial.foot } : { name: "km", km: 1 },
+        maps: knownMaps(world, places, known, campaign),
+        places: nearestFirst(places, partyAt, partyMap?.name),
+        roads: [...roads.pages.values()].filter(known).flatMap((road) => {
+            const course = roadCourse(world, road, known);
+            return course === undefined ? [] : [{ name: road.name, kind: kindOf(system, road).name, ...course }];
+        }),
+        ...(partyAt === undefined ? {} : { party: { ...mapPoint(partyAt, partyMap), ...(partyPlace === undefined ? {} : { place: partyPlace.name }) } }),
+        trail: trailOf(sight, roads).map(({ at, page }) => mapPoint(at, mapOf(world, page).root)),
+    };
+}
+/**
+ * The map in the chat (VIEW-7): the places drawn on the party's map, nearest it first, with their kind and where they are; the regions with their biome; then
+ * the places of the other maps the character knows, by map.
+ */
+export function mapText(map) {
+    const partyMap = map.party?.map;
+    const drawn = map.places.filter((place) => place.x !== undefined && place.radius === undefined);
+    const points = drawn.filter((place) => place.map === partyMap);
+    const shown = points.slice(0, mostListed);
+    const regions = map.places.filter((place) => place.radius !== undefined && place.map === partyMap);
+    const where = map.party === undefined ? "" : `, nearest first, from where the party is${map.party.place === undefined ? "" : ` (${map.party.place})`}`;
+    const line = (place) => `- ${place.name}${place.kind === undefined ? "" : ` (${place.kind})`}${place.from === undefined ? "" : `: ${fromText(place.from, map.unit)}`}`;
+    const others = map.maps.filter((known) => (known.main ? undefined : known.name) !== partyMap).flatMap((known) => {
+        const there = drawn.filter((place) => place.map === (known.main ? undefined : known.name));
+        return there.length === 0 ? [] : [`On ${known.main ? "the main map" : `the map of ${known.name}`}: ${there.map((place) => place.name).join(", ")}.`];
+    });
+    return [
+        points.length === 0 ? "The character knows no place on this map yet." : `Places on the map${where}:\n${shown.map(line).join("\n")}`,
+        points.length > shown.length ? `…and ${points.length - shown.length} more, on the dashboard's map.` : "",
+        regions.length === 0 ? "" : `Regions: ${regions.map((region) => `${region.name}${region.biome === undefined ? "" : ` (${region.biome})`}`).join(", ")}.`,
+        ...others,
+    ].filter((block) => block !== "").join("\n");
+}
+/** A place as the map shows it; none for one neither drawn nor held by a place that is. Its distance from the party only on the party's map. */
+function mapPlace(sight, roads, page, known, party) {
+    const { world } = sight;
+    const at = placedPosition(world, page);
+    const holders = locate(world, page).chain.filter((holder) => holder.type === "place" && known(holder));
+    if (at === undefined && !holders.some((holder) => isDrawn(world, roads, holder))) {
+        return undefined;
+    }
+    const region = regionsOf(world).find((candidate) => candidate.page === page);
+    const kind = typeof page.fields.kind === "string" && page.fields.kind.trim() !== "" ? page.fields.kind.trim() : undefined;
+    const voice = (name) => environmentAt(world, page).find(({ entry }) => comparableText(entry.name) === name)?.entry.value;
+    const image = shownImage(sight.root, sight.context, world, page, (base) => knowsPage(sight.knowledge, base));
+    const map = mapOf(world, page).root;
+    const near = at !== undefined && party !== undefined && mapKey(world, page) === party.map;
+    return {
+        name: page.name,
+        ...(kind === undefined ? {} : { kind }),
+        ...(at === undefined ? {} : mapPoint(at, map)),
+        ...(at !== undefined || map === undefined ? {} : { map: map.name }),
+        within: holders.map((holder) => holder.name),
+        ...(region === undefined ? {} : { radius: km(region.radius) }),
+        ...(region === undefined || voice("biome") === undefined ? {} : { biome: voice("biome") }),
+        ...(region === undefined || voice("terrain") === undefined ? {} : { terrain: voice("terrain") }),
+        ...(near ? { from: relationFrom(party.at, at) } : {}),
+        ...(image === undefined ? {} : { image }),
+    };
+}
+/**
+ * The maps the character knows (POS-8): the main one, the campaign's, when it knows a place drawn there; each held by a place it knows, or where it knows a
+ * place drawn; with the map each lies under or mirrors.
+ */
+function knownMaps(world, places, known, campaign) {
+    const roots = world.pages.filter((page) => page.type === "place" && page.system === undefined && mapOf(world, page).root === page);
+    const drawnOn = new Set(places.filter((place) => place.x !== undefined).map((place) => place.map ?? ""));
+    const name = (page) => mapOf(world, page).root?.name ?? campaign;
+    return [
+        ...(drawnOn.has("") ? [{ name: campaign, main: true }] : []),
+        ...roots.filter((root) => known(root) || drawnOn.has(root.name)).map((root) => {
+            const aligned = mapOf(world, root).aligned;
+            return { name: root.name, ...(aligned === undefined ? {} : aligned.how === "under" ? { under: name(aligned.of) } : { mirror: name(aligned.of) }) };
+        }),
+    ];
+}
+/** Whether a page is drawn on the map as a point or an area: a place of the campaign, not a road, with a position of its own or from its road. */
+function isDrawn(world, roads, page) {
+    return page.type === "place" && !roads.pages.has(page.name) && placedPosition(world, page) !== undefined;
+}
+/** The places drawn on the party's map, nearest it first; then those of the other maps and those held by them; as they come without a party on a map. */
+function nearestFirst(places, partyAt, partyMap) {
+    const distance = (place) => place.x === undefined || place.y === undefined || place.map !== partyMap
+        ? Number.MAX_SAFE_INTEGER
+        : partyAt === undefined
+            ? 0
+            : distanceBetween(partyAt, { east: place.x * 1000, north: place.y * 1000 });
+    return [...places].sort((first, second) => distance(first) - distance(second));
+}
+/** A known road's course from its first known stop with a point to its last, an unknown stop as a point alone, and the beginnings toward unknown ones beyond. */
+function roadCourse(world, road, known) {
+    const read = readStops(road.fields.stops);
+    if ("problem" in read) {
+        return undefined;
+    }
+    const stops = read.stops.map((name, index) => {
+        const page = pagesWithName(world, name)[0];
+        return { page, at: page === undefined ? undefined : placedPosition(world, page), metres: index === 0 ? 0 : read.lengths[index - 1] ?? 0 };
+    });
+    const isKnownPoint = (stop) => stop.page !== undefined && stop.at !== undefined && known(stop.page);
+    const first = stops.findIndex(isKnownPoint);
+    const last = stops.findLastIndex(isKnownPoint);
+    if (first < 0) {
+        return undefined;
+    }
+    const points = [];
+    let metres = 0;
+    for (const [index, stop] of stops.entries()) {
+        if (index > first && index <= last) {
+            metres += stop.metres;
+        }
+        if (index >= first && index <= last && stop.at !== undefined && stop.page !== undefined) {
+            points.push({ ...(known(stop.page) ? { name: stop.page.name } : {}), ...mapPoint(stop.at, mapOf(world, stop.page).root), km: km(metres) });
+            metres = 0;
+        }
+    }
+    // From an end of the course toward the next stop beyond it with a point on the same map, a beginning only.
+    const beyond = (end, others) => {
+        const next = others.find((stop) => stop.at !== undefined && stop.page !== undefined && end.page !== undefined && mapKey(world, stop.page) === mapKey(world, end.page))?.at;
+        return end.at === undefined || end.page === undefined || next === undefined ? undefined : stub(end.at, next, mapOf(world, end.page).root);
+    };
+    const before = beyond(stops[first], stops.slice(0, first).reverse());
+    const after = beyond(stops[last], stops.slice(last + 1));
+    return { points, ...(before === undefined ? {} : { before }), ...(after === undefined ? {} : { after }) };
+}
+/** The beginning of a road from a point toward another: at most stubMetres, at most half the way. */
+function stub(from, toward, map) {
+    const distance = distanceBetween(from, toward);
+    if (distance === 0) {
+        return undefined;
+    }
+    const share = Math.min(stubMetres, distance / 2) / distance;
+    return mapPoint({ east: from.east + (toward.east - from.east) * share, north: from.north + (toward.north - from.north) * share }, map);
+}
+/**
+ * Where the party has been (VIEW-7): the places the player character moved from and to, as the public lines of the log keep them, in order; along a road
+ * between the places it joined it at and left it at, by its stops; else in a straight line. A region is an area, not a point of the trail. Each point with the
+ * place that gives it, for its map.
+ */
+function trailOf(sight, roads) {
+    const { world, knowledge } = sight;
+    const pc = comparableText(knowledge.pc.name);
+    const regions = new Set(regionsOf(world).map((region) => region.page));
+    const names = readLog(sight.root).filter((entry) => entry.type === "moved" && entry.visibility === "public").flatMap((entry) => {
+        const pages = Array.isArray(entry.data.pages) ? entry.data.pages.map(String) : [];
+        if (!pages.some((name) => comparableText(name) === pc)) {
+            return [];
+        }
+        const from = Object.entries((entry.data.from ?? {})).find(([name]) => comparableText(name) === pc)?.[1];
+        return [typeof from === "string" ? from : undefined, typeof entry.data.to === "string" ? entry.data.to : undefined];
+    });
+    const points = [];
+    let road;
+    let last;
+    for (const name of names) {
+        const page = name === undefined ? undefined : pagesWithName(world, parsePageReference(name).name)[0];
+        if (page === undefined || regions.has(page)) {
+            continue;
+        }
+        if (roads.pages.has(page.name)) {
+            road = page;
+            continue;
+        }
+        const at = trailPoint(world, page, regions);
+        if (at === undefined) {
+            continue;
+        }
+        if (road !== undefined && last !== undefined) {
+            points.push(...stopsBetween(world, road, last, page));
+        }
+        points.push({ at, page });
+        [road, last] = [undefined, page];
+    }
+    return points.filter((point, index) => index === 0 || distanceBetween(point.at, points[index - 1].at) > 0 || mapKey(world, point.page) !== mapKey(world, points[index - 1].page));
+}
+/**
+ * Where a place is on the trail: its own point, or that of the nearest place holding it that has one; none when a region comes first, an area where the party
+ * was somewhere, never at its centre.
+ */
+function trailPoint(world, page, regions) {
+    for (const holder of [page, ...locate(world, page).chain]) {
+        if (regions.has(holder)) {
+            return undefined;
+        }
+        const position = placedPosition(world, holder);
+        if (position !== undefined) {
+            return position;
+        }
+    }
+    return undefined;
+}
+/** The points of a road's stops strictly between the stops two places are at, or are held by, in the order of the way; none when either is not on it. */
+function stopsBetween(world, road, from, to) {
+    const read = readStops(road.fields.stops);
+    if ("problem" in read) {
+        return [];
+    }
+    const indexOf = (page) => {
+        const names = [page, ...locate(world, page).chain].map((holder) => comparableText(holder.name));
+        return read.stops.findIndex((stop) => names.includes(comparableText(stop)));
+    };
+    const [start, end] = [indexOf(from), indexOf(to)];
+    if (start < 0 || end < 0) {
+        return [];
+    }
+    const between = start < end ? read.stops.slice(start + 1, end) : read.stops.slice(end + 1, start).reverse();
+    return between.flatMap((name) => {
+        const page = pagesWithName(world, name)[0];
+        const at = page === undefined ? undefined : placedPosition(world, page);
+        return at === undefined || page === undefined ? [] : [{ at, page }];
+    });
+}
+/** A point in km with its map, none for the main one. */
+function mapPoint(point, map) {
+    return { x: km(point.east), y: km(point.north), ...(map === undefined ? {} : { map: map.name }) };
+}
+/** Where a place is from the party (D-318): the km and the point of the compass; none of them closer than 50 m. */
+function relationFrom(from, to) {
+    const metres = distanceBetween(from, to);
+    return metres < 50 ? { km: 0 } : { km: km(metres), direction: directionName(directionTo(from, to)) };
+}
+/** "12 km north-east", "60 m north" or "200 feet south", in the player's units, or "here": where a place is from the party, in the chat's words. */
+function fromText(from, unit) {
+    const imperial = { mile: unit.km * 1000, foot: unit.foot ?? trueImperialUnits.foot };
+    return from.direction === undefined ? "here" : `${formatLength(from.km * 1000, unit.name === "mi" ? "imperial" : "metric", imperial)} ${from.direction}`;
+}
+/** Metres as km with two decimals. */
+function km(metres) {
+    return Math.round(metres / 10) / 100;
+}

package/dist/commands/game-view-place.d.ts

@@ -0,0 +1,160 @@
+import type { Context } from "../core/context.ts";
+import type { Effect, EffectEnd } from "../effects/index.ts";
+import { type Page, type World } from "../pages/index.ts";
+import type { GameSystem } from "../systems/index.ts";
+import { type SeenEffect } from "./game-effects.ts";
+import { type Knowledge } from "./game-knowledge.ts";
+/** Someone at the place or in the scene as the player sees them: a name, or someone; their role and picture; for copies of a creature, how many. */
+export interface ShownPerson {
+    name: string;
+    role: "pc" | "companion" | "other";
+    image?: {
+        file: string;
+        version: number;
+    };
+    /** The icon on the token of one of the party, as their class (D-414). */
+    icon?: string;
+    /** In a fight, marked by the master as attacking the party (D-415). */
+    hostile?: true;
+    /** Someone the character does not know, shown without a name. */
+    stranger?: true;
+    /** How many copies of a creature, in the open scene. */
+    count?: number;
+    /** What is on them (D-419): the party's effects with their end, of others only the conditions anyone sees (D-314). */
+    effects?: SeenEffect[];
+    /** A condition keeps them from acting (D-314). */
+    inactive?: true;
+    /** At 0, as Combat tells it (D-314): one of the party at the system's dying point, another when a foe's counter in words says down. */
+    down?: true;
+    dead?: true;
+}
+/** Where the player character is, as it knows it (VIEW-6). */
+export interface ShownPlace {
+    name: string;
+    image?: {
+        file: string;
+        version: number;
+    };
+    /** The places that hold it, the outermost first, of those the character knows. */
+    within: string[];
+    /** What holds there, nearest first: the environment's entries, then the places' effects with their end; each with its place, when the character knows it. */
+    around: ({
+        name: string;
+        value: string;
+        place?: string;
+    } | {
+        effect: string;
+        end?: EffectEnd;
+        place?: string;
+    })[];
+    /** Its text as the character knows it (VIEW-3). */
+    text: string;
+    /** The party and the characters the character knows who are there; never someone it does not know, who would give themselves away. */
+    here: ShownPerson[];
+    /** Its map, when it has one (GRD-6). */
+    map?: ShownGrid;
+}
+/**
+ * The map of the place where the party is (GRD-6, D-323): its squares as written, its legend, where its squares lead, the places the character does not know
+ * left unnamed, and who stands where as the scene and VIEW-4 name them.
+ */
+export interface ShownGrid {
+    columns: number;
+    rows: number;
+    lines: string[];
+    /** Each symbol of the map, those every map has too, by the kind it is drawn as; never one not found yet. */
+    legend: {
+        symbol: string;
+        name: string;
+        kind: string;
+        blocks?: true;
+        difficult?: true;
+    }[];
+    /** How its ground looks (D-325): floor, cave, paving, a biome, or plain. */
+    ground: string;
+    exits: {
+        square: string;
+        to?: string;
+    }[];
+    /** Who stands where: the side of what they fill, when more than a square, and how far from the player character, in the player's units (GRD-4, D-328). */
+    at: (ShownPerson & {
+        square: string;
+        side?: number;
+        distance?: string;
+    })[];
+    /** On the player character's turn in a fight, the squares it can still reach with what is left of its speed (D-328). */
+    reach?: string[];
+}
+/**
+ * Someone in a fight as the player sees them (D-314): their counter, the party's as numbers and a foe's in words, or none; what is on them, the party's as their
+ * line gives it, with its end, for others only the conditions anyone sees, by name; whether they cannot act; what they keep alive; the panel of the dying.
+ */
+export interface Fighter {
+    name: string;
+    role: "pc" | "companion" | "other";
+    image?: {
+        file: string;
+        version: number;
+    };
+    /** The icon on the token of one of the party, as their class (D-414). */
+    icon?: string;
+    /** In a fight, marked by the master as attacking the party (D-415). */
+    hostile?: true;
+    stranger?: true;
+    health?: string;
+    effects: SeenEffect[];
+    inactive?: true;
+    keeps?: string[];
+    dying?: DyingCounter[];
+}
+/** A counter of the panel of the dying (D-314): its value, and the limit the system's thresholds give it. */
+export interface DyingCounter {
+    field: string;
+    value: number;
+    limit?: number;
+}
+/** The open scene as the player sees it (VIEW-6): who is in it as in VIEW-4, and the order of the turns. */
+export interface ShownScene {
+    title: string;
+    type: string;
+    /** The game date it opened. */
+    since?: string;
+    /** What is happening now, as the master wrote it for the player (SCN-11). */
+    now?: string;
+    place?: string;
+    who: ShownPerson[];
+    order?: string[];
+    turn?: string;
+    round?: number;
+    /** In a fight, each one in it, in the order of the turns when there is one (D-314). */
+    fighters?: Fighter[];
+}
+/** What the view reads to show the place and the scene: the campaign, the world, what the character knows, and who the party are. */
+export interface PlaceSight {
+    root: string;
+    context: Context;
+    world: World;
+    knowledge: Knowledge;
+    party: Page[];
+}
+/** 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 declare function shownPlace(sight: PlaceSight): ShownPlace | undefined;
+/** The open scene as the player sees it; none when no scene is open, or it cannot be read. */
+export declare function shownScene(sight: PlaceSight): ShownScene | undefined;
+/**
+ * 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 declare function sceneNames(sight: PlaceSight): string[];
+/**
+ * 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 declare function dyingOf(world: World, system: GameSystem | undefined, page: Page): DyingCounter[] | undefined;
+/** 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 declare function seenEffect(sight: PlaceSight, effect: Effect): SeenEffect;
+/** 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 declare function strangerImage(root: string, context: Context, world: World, name: string | undefined): {
+    file: string;
+    version: number;
+} | undefined;