@runmu.sh/ext-scene 1.2.0 → 1.3.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.3.1
+
+- After a reload or a reconnect the Scene shows the whole room again (description, who is here, exits), not only its title: when the room name arrives it reads the newest room look among the lines the client already holds.
+
+## 1.3.0
+
+- The room on games that send only its name. Evennia games such as Underspire send no GMCP `Room.Info` or `Room.Players` over telnet, so the Scene showed a title and nothing else. The extension now reads the room look the game prints (title, description, who is here, the exits line) and GMCP `Room.Name` and `Player.Context`, and fills the description, Present and Exits, as Underspire's own panel does. Moving fills the next room from its auto-look.
+- It steps aside as soon as a game sends GMCP `Room.Info` or MSDP `ROOM_EXITS` / `ROOM_VNUM`: those games are unchanged.
+- New setting **Read the room from the game text** (per world, default on).
+- Asks for `read-output` as well as `send-commands`: it reads the game text (an observe stage: read only, live lines only).
+- Exports `roomOf`, `exitsOf`, `peopleOf`, `roomNameOf`, `contextOf` and `TEXT_PRIORITY`.
+
 ## 1.2.0
 
 - Alt+R (*Go to scene*) is now the extension's own command, `focus.scene`, in Settings → Keys under Scene: Focus. On μClient with extension API 1.14 it focuses the Scene panel when it is open; a rebinding you made keeps working. On an older μClient the client's own Alt+R stays in place.

package/README.md

@@ -16,6 +16,24 @@ The host keeps one scene per session and fills it from:
 | GMCP `Char.Items.List` / `Add` / `Remove` with `location: "room"` | Present (items; `hostile: true` is marked) |
 | MSDP `ROOM_NAME`, `ROOM_VNUM`, `ROOM_EXITS`, `AREA_NAME` (or `ROOM.*`) | Title, exits, area |
 | Another extension: `mu.scene.set({ title, area, desc, atmosphere, pose, exits, present, items })` | Any field |
+| This extension, from the game (1.3.0): GMCP `Room.Name` (a string or `{ name }`), `Player.Context` (`room`, `pose_line`, `presence`, without your own `character`), and the room text | Title, description, pose, Present (people), exits |
+
+### Games that send only the room name (1.3.0)
+Evennia games such as Underspire send no `Room.Info` or `Room.Players` over telnet: only `Room.Name`, and `Player.Context` once at login. For those the extension reads the room look the game prints:
+
+```
+Shard intake                                        ← title (no closing punctuation)
+A vast data space, humming with virtual activity.   ← description
+                                                    
+The intake terminal is installed here.              ← things in the room (skipped)
+                                                    
+^A2PGUE is standing here. You are standing here.    ← Present (you are left out)
+There are exits to the san junipero (back).         ← exits, by name; ends the look
+```
+
+The exits line (`There are exits to …`, `There is an exit to …`, `Exits: …`) closes a look; the lines before it are read back to the nearest title line. After a reload or reconnect (the last look is then backlog), the room name arriving makes it read the newest room look among the lines the client holds, once per session. A typed command in between starts over, so the text of a `look` at a person or an item is not taken for a room. An exit button sends the exit's name (`san junipero`), which Evennia accepts as well as its alias.
+
+The text reader provides at priority 10, over the MSDP adapter's room name, and turns itself off for a session as soon as the game sends GMCP `Room.Info` or MSDP `ROOM_EXITS` / `ROOM_VNUM`; its fields are then released to the adapters. MSDP `ROOM_NAME` alone (Underspire mirrors `Room.Name` there) does not turn it off. Setting **Read the room from the game text** (per world, default on) turns it off.
 
 Package names are case-insensitive. Entering a new room clears Present. The room title is also the session's location (the world switcher shows it).
 
@@ -29,10 +47,10 @@ The panel is the region `scene`. **Alt+R** (*Go to scene*, command `focus.scene`
 - **Show panel: auto** (per world, on the extension's settings page: off / auto / on). On auto the Scene joins Views and adds itself the first time a session knows its room, whatever the room came from (GMCP, MSDP, another extension); once per world on this device, so a Scene you closed stays closed.
 - A redraw in the same room (someone arrives, an item drops) keeps your scroll position; moving to another room scrolls back to the top. When the game sends no room id, every update counts as a move.
 - Right-click (or long-press) an exit or a room item for the menus other extensions add to them. The extension registers the context kinds `scene.exit` (title *Exit*, `data: { exit }`) and `scene.item` (title *Scene item*, `data: { item: { id, name, hostile? } }`), each with a schema the host checks. On a μClient before API 1.14 it publishes the 1.12 kinds `scene-exit` and `scene-item` instead; on 1.14 an entry written for the old kinds still receives the new targets in the old shape.
-- It sends nothing to the game except the exits you click, and reads no GMCP itself: the room adapters fill the scene.
+- It sends nothing to the game except the exits you click. On a game with GMCP `Room.Info` or MSDP rooms the room adapters fill the scene; otherwise it reads `Room.Name`, `Player.Context` and the room text itself (1.3.0, above).
 
 ## Contract
-The extension reads no GMCP and sends none, so it declares no GMCP packages or payload contracts; the room adapters declare `Room 1` and feed `mu.scene` (`SceneView`). Capability: `send-commands` (the exit buttons).
+The extension sends no GMCP and declares no packages or payload contracts; the room adapters declare `Room 1` and feed `mu.scene` (`SceneView`). It listens to `Room.Name` and `Player.Context` (Evennia sends them unasked) and `Room.Info` / MSDP `ROOM_EXITS` / `ROOM_VNUM` only to step aside. Capabilities: `read-output` (the room text, an `observe` line stage: read only, live lines only) and `send-commands` (the exit buttons).
 
 ## Exported API (`@runmu.sh/ext-scene`, types in `src/types.ts`)
 No `ctx.exports` API. The module exports, for tests and other renderers:
@@ -43,11 +61,13 @@ No `ctx.exports` API. The module exports, for tests and other renderers:
 | `presentOf(scene)` | People first, then room items, each name once: `{ name, hostile? }[]`. |
 | `COPY`, `SCENE_CSS` | The drawn copy and the stylesheet (every rule under `.ext-panel[data-ext="scene"] .mu-scene`). |
 | `ITEM_KIND`, `EXIT_KIND`, `KIND_SCHEMAS` | `'scene.item'`, `'scene.exit'` and their `data` schemas. |
+| `roomOf(lines)`, `exitsOf(line)`, `peopleOf(line)` | The room text reader (1.3.0): a `ScenePatch` (`title`, `desc`, `exits`, `present`) from lines ending in an exits line, or `null`; the exit names of an exits line; the people (not you) of a who-is-here line. |
+| `roomNameOf(data)`, `contextOf(data)`, `TEXT_PRIORITY` | `Room.Name` → title; `Player.Context` → `{ title, pose, present }`; the provider priority (10). |
 
 `src/types.ts` augments the SDK's `ContextKinds` with `scene.item` (`SceneItemData`) and `scene.exit` (`SceneExitData`), so an extension that imports it gets `t.data` typed in `mu.menus.context({ target: 'scene.exit', … })`.
 
 ## SDK
-`api` `^1.12`. SDK 1.12: `mu.panels.register` with `show: 'auto'`, `mu.panels.touch`, `mu.sessions.each`, `mu.scene.watch` (and `SceneView.id`), `mu.sessions.send(dir, { sid })`, `mu.menus.target`, `h` and `mu.ui.css`, `mu.ui.style`. SDK 1.14, used when the host has them: `mu.menus.kind` (with `JsonSchema` and `ContextKinds`), `mu.panels.focus` with `mu.commands.register`. The manifest declares `focus.scene` in `contributes.commands`, so Alt+R is listed and bound before the extension activates.
+`api` `^1.12`. SDK 1.12: `mu.panels.register` with `show: 'auto'`, `mu.panels.touch`, `mu.sessions.each`, `mu.scene.watch` (and `SceneView.id`), `mu.sessions.send(dir, { sid })`, `mu.menus.target`, `h` and `mu.ui.css`, `mu.ui.style`, `mu.scene.provide`, `mu.gmcp.on` / `state`, `mu.msdp.on` / `state`, `mu.lines.stage` (phase `observe`), `mu.settings.define`. SDK 1.14, used when the host has them: `mu.menus.kind` (with `JsonSchema` and `ContextKinds`), `mu.panels.focus` with `mu.commands.register`. The manifest declares `focus.scene` in `contributes.commands`, so Alt+R is listed and bound before the extension activates.
 
 ## Develop
 Made with `npm create @runmu.sh/extension` ([the quickstart](https://runmu.sh/docs/extensions/quickstart)).

package/dist/index.js

@@ -5,7 +5,80 @@ import { defineExtension, h } from "@muclient/sdk";
 var ITEM_KIND = "scene.item";
 var EXIT_KIND = "scene.exit";
 
+// src/room.ts
+var EXITS_RE = /^(?:there (?:are|is) (?:an? )?(?:exits?|ways?(?: out)?) (?:to|leading to) |(?:obvious )?exits?: )(.+?)\.?$/i;
+var HERE_RE = /^(.+?) (?:is|are) (?:[a-z]+ )?here\.?$/i;
+var MAX_TITLE = 80;
+function exitsOf(line) {
+  const m = EXITS_RE.exec(line.trim());
+  if (!m) return null;
+  const out = [];
+  for (let part of m[1].split(/\s*,\s*(?:and\s+)?|\s+and\s+/)) {
+    part = part.replace(/\s*\([^)]*\)\s*$/, "").replace(/^the\s+/i, "").trim();
+    if (part && !out.includes(part)) out.push(part);
+  }
+  return out;
+}
+function peopleOf(line) {
+  const out = [];
+  for (const s of line.trim().split(/(?<=\.)\s+/)) {
+    const m = HERE_RE.exec(s);
+    if (!m) continue;
+    for (const n of m[1].split(/\s*,\s*(?:and\s+)?|\s+and\s+/)) {
+      const name = n.trim();
+      if (name && !/^you$/i.test(name) && !out.includes(name)) out.push(name);
+    }
+  }
+  return out;
+}
+var looksTitle = (t) => t.length > 0 && t.length <= MAX_TITLE && !/[.!?:;,"')>\]]$/.test(t);
+function roomOf(lines, maxSections = 4) {
+  if (!lines.length) return null;
+  const exits = exitsOf(lines[lines.length - 1]);
+  if (!exits) return null;
+  const sections = [[]];
+  for (const raw of lines.slice(0, -1)) {
+    const l = raw.trim();
+    if (l) sections[sections.length - 1].push(l);
+    else if (sections[sections.length - 1].length) sections.push([]);
+  }
+  if (!sections[sections.length - 1].length) sections.pop();
+  if (!sections.length) return null;
+  const tail = sections[sections.length - 1];
+  const people = tail.some((l) => peopleOf(l).length || /^you (?:are|is) [a-z ]*here\.?$/i.test(l));
+  for (let i = sections.length - 1; i >= Math.max(0, sections.length - maxSections); i--) {
+    const sec = sections[i];
+    let t = -1;
+    for (let j = sec.length - 1; j >= 0; j--) if (looksTitle(sec[j]) && !HERE_RE.test(sec[j])) {
+      t = j;
+      break;
+    }
+    if (t < 0) continue;
+    if (i === sections.length - 1 && people) continue;
+    const present = people ? [...new Set(tail.flatMap(peopleOf))] : [];
+    return { title: sec[t], desc: sec.slice(t + 1).join("\n"), exits, present };
+  }
+  return null;
+}
+function roomNameOf(data) {
+  if (typeof data === "string") return data.trim();
+  if (data && typeof data === "object" && typeof data.name === "string") return data.name.trim();
+  return "";
+}
+function contextOf(data) {
+  if (!data || typeof data !== "object") return null;
+  const d = data;
+  const me = typeof d.character === "string" ? d.character.trim().toLowerCase() : "";
+  const patch = {};
+  if (typeof d.room === "string" && d.room.trim()) patch.title = d.room.trim();
+  if (typeof d.pose_line === "string") patch.pose = d.pose_line.trim();
+  if (Array.isArray(d.presence)) patch.present = [...new Set(d.presence.filter((n) => typeof n === "string" && !!n.trim() && n.trim().toLowerCase() !== me).map((n) => n.trim()))];
+  return Object.keys(patch).length ? patch : null;
+}
+
 // src/index.ts
+var TEXT_PRIORITY = 10;
+var KEEP = 40;
 var COPY = {
   title: "Scene",
   awaiting: "No room yet",
@@ -153,6 +226,102 @@ var index_default = defineExtension({
         mu.panels.focus?.("scene");
       } });
     }
+    mu.settings.define({
+      title: "Scene",
+      items: [{
+        key: "fromText",
+        label: "Read the room from the game text",
+        default: true,
+        kind: "toggle",
+        scope: "both",
+        hint: "For games that send only the room name over GMCP (Evennia games such as Underspire): the description, who is here and the exits come from the room text. A game that sends GMCP Room.Info is unaffected."
+      }]
+    });
+    const fromText = (sid) => mu.settings.get("fromText", { sid }) !== false;
+    const hasRoom = (sid) => mu.gmcp.state("Room.Info", sid) !== void 0 || mu.msdp.state("ROOM_EXITS", sid) !== void 0 || mu.msdp.state("ROOM_VNUM", sid) !== void 0;
+    const given = /* @__PURE__ */ new Map();
+    const give = (sid, patch) => {
+      given.set(sid, mu.scene.provide(sid, patch, { priority: TEXT_PRIORITY }));
+    };
+    const release = (sid) => {
+      given.get(sid)?.();
+      given.delete(sid);
+    };
+    const seen = /* @__PURE__ */ new Map();
+    const titles = /* @__PURE__ */ new Map();
+    const seeded = /* @__PURE__ */ new Set();
+    const seed = (sid) => {
+      if (seeded.has(sid) || hasRoom(sid) || !fromText(sid)) return;
+      seeded.add(sid);
+      let lines = [];
+      try {
+        lines = mu.lines.recent(sid, { limit: 120 });
+      } catch {
+        return;
+      }
+      for (let end = lines.length - 1; end >= 0; end--) {
+        if (lines[end].kind === "echo" || !exitsOf(lines[end].text)) continue;
+        let start = end;
+        while (start > 0 && end - start < KEEP && lines[start - 1].kind !== "echo") start--;
+        const room = roomOf(lines.slice(start, end + 1).map((l) => l.text));
+        if (room) {
+          titles.set(sid, room.title ?? "");
+          give(sid, room);
+        }
+        return;
+      }
+    };
+    ctx.subscriptions.push(
+      mu.gmcp.on("Room.Info", (_d, m) => release(m.sid)),
+      mu.msdp.on("ROOM_EXITS", (_v, m) => release(m.sid)),
+      mu.msdp.on("ROOM_VNUM", (_v, m) => release(m.sid)),
+      mu.gmcp.on("Room.Name", (d, m) => {
+        const title = roomNameOf(d);
+        if (!title || hasRoom(m.sid) || !fromText(m.sid)) return;
+        if (titles.get(m.sid) !== title) {
+          titles.set(m.sid, title);
+          give(m.sid, { title });
+        }
+        seed(m.sid);
+      }),
+      mu.gmcp.on("Player.Context", (d, m) => {
+        const patch = contextOf(d);
+        if (!patch || hasRoom(m.sid) || !fromText(m.sid)) return;
+        if (patch.title) titles.set(m.sid, patch.title);
+        give(m.sid, patch);
+        seed(m.sid);
+      }),
+      // Observe: read only, live lines only (not backlog). A typed command starts a new block.
+      mu.lines.stage({
+        id: "room-text",
+        phase: "observe",
+        run: (line, c) => {
+          if (line.kind === "echo") {
+            seen.delete(c.sid);
+            return;
+          }
+          if (line.kind !== "output" && line.kind !== "prompt") return;
+          const buf = seen.get(c.sid) ?? [];
+          buf.push(line.text);
+          if (buf.length > KEEP) buf.splice(0, buf.length - KEEP);
+          seen.set(c.sid, buf);
+          const room = roomOf(buf);
+          if (!room) return;
+          seen.delete(c.sid);
+          seeded.add(c.sid);
+          if (hasRoom(c.sid) || !fromText(c.sid)) return;
+          const moved = titles.get(c.sid) !== room.title;
+          titles.set(c.sid, room.title ?? "");
+          give(c.sid, moved ? { ...room, pose: "", items: [] } : room);
+        }
+      }),
+      mu.sessions.each((s) => () => {
+        seen.delete(s.id);
+        titles.delete(s.id);
+        given.delete(s.id);
+        seeded.delete(s.id);
+      })
+    );
     ctx.subscriptions.push(mu.sessions.each((s) => {
       let done = false;
       return mu.scene.watch((v) => {
@@ -170,7 +339,13 @@ export {
   ITEM_KIND,
   KIND_SCHEMAS,
   SCENE_CSS,
+  TEXT_PRIORITY,
+  contextOf,
   index_default as default,
+  exitsOf,
+  peopleOf,
   presentOf,
-  renderScene
+  renderScene,
+  roomNameOf,
+  roomOf
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@runmu.sh/ext-scene",
-  "version": "1.2.0",
-  "description": "The Scene panel: the room you are in (title, area, atmosphere, description, pose), who is present and its exits as buttons, from GMCP Room.*, Char.Items.*, MSDP or another extension.",
+  "version": "1.3.1",
+  "description": "The Scene panel: the room you are in (title, area, atmosphere, description, pose), who is present and its exits as buttons, from GMCP Room.*, Char.Items.*, MSDP, another extension, or the room text (Evennia games such as Underspire).",
   "keywords": [
     "scene",
     "room",
@@ -49,7 +49,7 @@
     "api": "^1.12",
     "source": "src/index.ts",
     "displayName": "Scene",
-    "description": "The Scene panel: the current room, who is present and its exits as buttons, from GMCP Room.*, Char.Items.*, MSDP or another extension.",
+    "description": "The Scene panel: the current room, who is present and its exits as buttons, from GMCP Room.*, Char.Items.*, MSDP, another extension, or the room text on games that send only the room name.",
     "categories": [
       "interface",
       "mapping"
@@ -75,6 +75,7 @@
       ]
     },
     "capabilities": [
+      "read-output",
       "send-commands"
     ],
     "publisher": "bitmuse"

package/src/types.ts

@@ -1,7 +1,9 @@
 /**
- * The exported API of `@runmu.sh/ext-scene` (id `scene`). The extension reads no GMCP and sends none: it draws the
- * host's scene model (`mu.scene.watch`, `SceneView`), which the room adapters fill from GMCP `Room.*`,
- * `Char.Items.*`, MSDP and other extensions (`mu.scene.set`). This file and the README change together.
+ * The exported API of `@runmu.sh/ext-scene` (id `scene`). The extension sends no GMCP: it draws the host's scene
+ * model (`mu.scene.watch`, `SceneView`), which the room adapters fill from GMCP `Room.*`, `Char.Items.*`, MSDP and
+ * other extensions (`mu.scene.set`). On games with none of those (Evennia: only `Room.Name`) it provides the room
+ * itself from `Room.Name`, `Player.Context` and the room text (1.3.0, `src/room.ts`). This file and the README
+ * change together.
  */
 import type { SceneView } from '@muclient/sdk';