semif-api-rocm

room-self-rules.js (4205B)

---

 "use strict";
 
 /* No-rules puzzle room: the same turn-based grid as room-rules.js with every
  * line of how-to-play prose removed. The model is never told the goal, what
  * stepping or turning does, or what the key/door/exit mean — it only sees
  * neutral observations (adjacent presences, what the view cone
  * sees, bearings to discovered landmarks, carry status, a step count,
  * or the top-down map with a neutral legend) plus the action list
  * with accurate descriptions, and an "insufficient" escape hatch. When it
  * cannot decide, or the step budget runs out, the client asks /plan for rules
  * and injects the answer into later states as "Rules".
  *
  * Mechanics are RoomRules' (this module only assembles observation text);
  * SelfRoomRules.PLAN_GOAL is the simulation's one-line statement of the goal —
  * the only game-specific input to /plan.
  */
 const SelfRoomRules = (() => {
   const { W, H, MAX_STEPS, DIRS, adjacentLines, inViewLine, knownLine } = RoomRules;
 
   // First-person state — the ruled fppText minus its three how-to-play lines
   // (the room/goal intro, the action explanation, the key/door briefing) and
   // the guided hint. Facing, presence, in-view, carry and steps stay:
   // they are observations, not rules. There is no event log: a list of the
   // actor's own recent actions is imitation bait for a single-pass reader.
   function fppText(state, layout, seen) {
     return [
       // Ordered for a single-pass reader: standing context first, immediate
       // sensory evidence last (the freshest tokens weigh most).
       "Current State:",
       `Steps taken: ${state.steps}/${MAX_STEPS}`,
       "",
       knownLine(state, layout, seen),
       `You carry: ${state.hasKey ? "the key" : "no key"}`,
       "",
       inViewLine(state, layout),
       "",
       ...adjacentLines(state, layout),
     ].join("\n");
   }
 
   // Top-down map — the ruled mapText minus the goal line and the pickup/door
   // instructions. The legend stays: it names symbols, it does not teach rules.
   function mapText(state, layout) {
     const rows = [];
     for (let y = 0; y < H; y++) {
       const row = [];
       for (let x = 0; x < W; x++) {
         if (x === state.x && y === state.y) { row.push(DIRS[state.dir].arrow); continue; }
         let c = layout.grid[y][x];
         if (c === "K" && state.hasKey) c = ".";
         if (c === "D" && state.doorOpen) c = "o";
         row.push(c);
       }
       rows.push(row.join(" "));
     }
     return [
       "Legend: [`#`: wall, `.`: floor, `D`: locked door, `o`: open door, `K`: key, `E`: exit, `^ > v <`: you, facing that way]",
       "",
       ...rows,
       "",
       `Steps taken: ${state.steps}/${MAX_STEPS}`,
     ].join("\n");
   }
 
   // mode: "fpp" | "map" — both neutral; there is deliberately no guided
   // variant: guidance was instructional prose, which this demo never sends.
   function stateText(state, layout, mode = "fpp", seen) {
     if (mode === "map") return mapText(state, layout);
     return fppText(state, layout, seen);
   }
 
   const QUESTION = "What should the player do now?";
   // Actions only, with accurate descriptions, plus the escape hatch. Unlike
   // the platformer there is no denied action here (a bump is still a
   // completed step), so insufficient is the only mid-attempt trigger.
   const OPTIONS = [
     ...RoomRules.OPTIONS,
     { id: Planner.INSUFFICIENT_ID, description: "Insufficient evidence to decide" },
   ];
 
   // Options for the CURRENT state: forward is withheld when the faced cell
   // is a no-op (wall, or a locked door without the key) — a decision that
   // cannot change anything is not a decision. Insufficient stays.
   const optionsFor = (state, layout) => [
     ...RoomRules.optionsFor(state, layout),
     OPTIONS[OPTIONS.length - 1],
   ];
 
   /* The simulation's one-line statement of the goal — the only game-specific
    * input to /plan. Planner.context() wraps it with the trigger note and the
    * rules currently in effect; the system prompt is universal. */
   const PLAN_GOAL = "Reach the exit of the room.";
 
   return { fppText, mapText, stateText, QUESTION, OPTIONS, optionsFor, PLAN_GOAL };
 })();
 
 if (typeof module !== "undefined") module.exports = SelfRoomRules;