@polycode-projects/the-mechanical-code-talker 5.0.5 → 5.0.6

package/src/surfaces/web/mudiii-browser-entry.mjs

@@ -6,14 +6,6 @@
 // on `{ as: character }` — the addressee is in the sentence, "@fox-1 look"),
 // and the simulation itself advances as ONE whole-world tick
 // (`runTownSquareTick`) rather than mud's per-character `autoplayTick`.
-//
-// `src/services/predator-prey.mjs` — the engine this file drives — does not
-// exist in every worktree yet; a concurrent track owns it. The import below
-// is guarded (dynamic, try/catch) so this module still loads, and every
-// test that imports mudiii-viz.mjs (which never imports this file) is
-// unaffected either way. `createMudiiiSession` throws a clear "the engine
-// isn't built yet" error if actually called before that track lands, rather
-// than a bare ERR_MODULE_NOT_FOUND with no context.
 import {
   createInMemoryStore, appendFacts, appendRule, loadMemory, readFactRows, removeFacts,
 } from "../../adapters/memory/core.mjs";
@@ -22,26 +14,21 @@ import { memoryFactGraphPayload } from "../../domain/memory-facts.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import { worldProvenanceTag } from "../../domain/worlds-pack.mjs";
 import {
-  COMPASS_POINTS, DEFAULT_FACING, layoutNamed, reverseFacing, stepCellFrom, turnedFacing,
+  COMPASS_POINTS, DEFAULT_FACING, cellId, layoutNamed, parseCellId, reverseFacing, stepCellFrom, turnedFacing,
 } from "../../domain/town-square-world.mjs";
+import { findActionPath } from "../../domain/planning.mjs";
+import { DEFAULT_GAME_CONFIG } from "../../domain/game-config.mjs";
 import { parseMudEditorText, planMudEditorSync, gridWorldEditorState } from "../../services/mud-editor.mjs";
+import { pillsForMudiii } from "../../services/mudiii-turn.mjs";
+import { relatedForTerm } from "../../domain/skos-view.mjs";
+import { classAncestorChain } from "../../domain/sprite-map.mjs";
 import { createTurnSession } from "./turn-session.mjs";
 import { publishTmctSurface } from "./tmct-surface.mjs";
 import { graphAsk, enginePlan } from "./engine-surface.mjs";
-
-let engine = null;
-async function loadEngine() {
-  if (engine) return engine;
-  try {
-    engine = await import("../../services/predator-prey.mjs");
-  } catch (err) {
-    throw new Error(
-      "mudiii's engine (src/services/predator-prey.mjs) is not built in this worktree yet "
-      + `(${err && err.message ? err.message : err})`,
-    );
-  }
-  return engine;
-}
+import {
+  foldTownSquareState, gridApplyActions, pathStateKey, placeFood as engPlaceFood, recastTownSquare,
+  roleOfId, runTownSquareTick, startTownSquareGame, townSquareBoard,
+} from "../../services/predator-prey.mjs";
 
 /** `count` entries drawn at random from `roster`, in random order, without
  *  repeats — mirrors mud-browser-entry.mjs's own `pickMudRoster`. `random` is
@@ -127,6 +114,29 @@ export function driveRequest(direction, { cell, facing = DEFAULT_FACING } = {})
   return COMPASS_POINTS.includes(press) ? { facing: press } : null;
 }
 
+/** The shortest route from `fromCell` to `toCell` over `factRows`' own exit
+ *  facts, as `{ cells, directions }` — `cells` runs from one end to the other
+ *  inclusive, `directions` names one hop each. Null when nothing connects
+ *  them, so a caller declines visibly rather than drawing a line through a
+ *  building the board would never let anyone walk through.
+ *
+ *  The exit table is the one legality answer, the same rows the engine's own
+ *  chase and forage searches read, so a route drawn here is a route the world
+ *  agrees with. */
+export function routeBetweenCells(factRows, fromCell, toCell) {
+  const from = parseCellId(fromCell);
+  const to = parseCellId(toCell);
+  if (!from || !to) return null;
+  const found = findActionPath(
+    from,
+    (searchState) => searchState.x === to.x && searchState.y === to.y,
+    gridApplyActions(factRows),
+    { stateKey: pathStateKey },
+  );
+  if (!found) return null;
+  return { cells: found.states.map((s) => cellId(s.x, s.y)), directions: found.actions };
+}
+
 /** A live, shared town-square world one visitor watches and talks over.
  *  `worldPayload` is `{ name, facts, rules, opening }`, read once at build
  *  time the same way every other viz page's world payload is. `agents` is
@@ -137,15 +147,14 @@ export function driveRequest(direction, { cell, facing = DEFAULT_FACING } = {})
  *  (`runTownSquareTick`) and its conversation is a single shared dock.
  *
  *  Returns `{ memoryDir, codeGraph, graph, refreshGraph, turn, tick, board,
- *  snapshot, applyEdit, placeFood, driveAgent }`. A reset is not a method here: the
- *  page re-opens a whole session for it, which is what a reset means when the
- *  store is in memory and belongs to one visitor. */
-export async function createMudiiiSession(worldPayload, { agents = [], epoch = 0 } = {}) {
-  const {
-    startTownSquareGame, runTownSquareTick, townSquareBoard, foldTownSquareState,
-    placeFood: engPlaceFood, roleOfId,
-  } = await loadEngine();
-
+ *  snapshot, applyEdit, placeFood, driveAgent, recast }`.
+ *
+ *  `getTeachEnabled` is read fresh on every turn, so a visitor can tick the
+ *  page's teach box mid-session and have the very next line read as a fact to
+ *  store rather than a command to run. */
+export async function createMudiiiSession(
+  worldPayload, { agents = [], epoch = 0, getTeachEnabled = () => false } = {},
+) {
   // Every engine call is layout-scoped: the world pack ships the BOARD, and
   // the layout carries the geometry plus the cast counts the engine mints the
   // animals from. Resolved once here so no call site has to remember it.
@@ -184,8 +193,11 @@ export async function createMudiiiSession(worldPayload, { agents = [], epoch = 0
 
   const turnSession = createTurnSession({
     memoryDir, graph: codeGraph, lexicon, sessionId: "town-square",
-    vocabHint: 'Try "@fox-1 look", or "what does fox-1 believe".',
-    buildExtraOptions: () => ({ planState: planHolder.state }),
+    vocabHint: 'Try "@fox the goblin is east", or "what does the fox see".',
+    buildExtraOptions: () => ({
+      planState: planHolder.state,
+      gameConfig: { ...DEFAULT_GAME_CONFIG, mudiii: { ...DEFAULT_GAME_CONFIG.mudiii, teach: getTeachEnabled() } },
+    }),
     captureExtraState: async (result, state) => {
       if ("planState" in result) planHolder.state = state.planState;
     },
@@ -233,6 +245,22 @@ export async function createMudiiiSession(worldPayload, { agents = [], epoch = 0
     };
   }
 
+  /** Re-cast this same store onto a fresh epoch and hand back the opening
+   *  board. This is what a Reset means once a store is live: the world's own
+   *  facts, everything taught into it and everything the editor changed all
+   *  stand, and only the animals are minted again. Re-opening a whole session
+   *  instead would throw away the taught facts along with the cast, which is
+   *  not what "reset the board" says.
+   *
+   *  `agents` sizes the new cast the same way `createMudiiiSession`'s own
+   *  roster does; `epoch` defaults to one past whatever the store is on. */
+  async function recast({ agents: nextAgents = [], epoch: nextEpoch = null } = {}) {
+    await recastTownSquare(memoryDir, {
+      layout, epoch: nextEpoch, ...townSquareRosterArgs(nextAgents, (id) => roleOfId(id)),
+    });
+    return townSquareBoard(memoryDir, { layout });
+  }
+
   /** The board as it stands, in the same payload shape `tick` returns, with no
    *  turn spent. A page opens a session and then draws THIS — otherwise its
    *  first sight of where anything stands is the first tick, and every mesh
@@ -285,6 +313,7 @@ export async function createMudiiiSession(worldPayload, { agents = [], epoch = 0
     turn: turnSession.turn,
     tick,
     driveAgent,
+    recast,
     board,
     snapshot,
     applyEdit,
@@ -304,5 +333,12 @@ publishTmctSurface({
   plan: enginePlan,
   page: {
     pickMudiiiRoster,
+    // pillsForMudiii closes over two other modules' bindings, so the page
+    // reaches it through this bag rather than a `.toString()` splice.
+    pillsForMudiii,
+    // What the editor's own suggestion rail reads for the word under the
+    // cursor: the lateral SKOS neighbourhood and the vertical is-a chain.
+    relatedForTerm, classAncestorChain,
+    routeBetweenCells,
   },
 });