semif-api-rocm

room-rules.js (21113B)

---

 "use strict";
 
 // Shared by the browser and offline tests: room facts come from the rules.
 // Turn-based puzzle room on a grid. The player has a position and a facing;
 // each decision is ONE action — step forward, turn left, turn right. The model
 // never sees the map: the FPP state text reports what is adjacent (touch
 // range), what the FOV cone sees (bearings) and carry status, so navigation
 // is dead-reckoning from prose.
 const RoomRules = (() => {
   const W = 11, H = 9;
   const DIV = 5;               // dividing wall column; the locked door is its only gap
   const MAX_STEPS = 80;        // step budget per attempt (turns count)
 
   const DIRS = [
     { dx: 0, dy: -1, name: "NORTH", arrow: "^" },
     { dx: 1, dy: 0, name: "EAST", arrow: ">" },
     { dx: 0, dy: 1, name: "SOUTH", arrow: "v" },
     { dx: -1, dy: 0, name: "WEST", arrow: "<" },
   ];
 
 
   // mulberry32: small, deterministic, good enough for shuffling wall bits.
   function rng(seed) {
     let a = seed >>> 0;
     return () => {
       a = (a + 0x6D2B79F5) | 0;
       let t = Math.imul(a ^ (a >>> 15), 1 | a);
       t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
       return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
     };
   }
   const randInt = (r, lo, hi) => lo + Math.floor(r() * (hi - lo + 1)); // inclusive
 
   const blocked = (cell, doorPassable) =>
     cell === "#" || (cell === "D" && !doorPassable);
 
   // BFS over floor cells; K/E passable, D passable only when doorPassable.
   function reachable(grid, from, to, doorPassable) {
     if (from.x === to.x && from.y === to.y) return true;
     const seen = new Set([from.x + "," + from.y]);
     const queue = [from];
     while (queue.length) {
       const cur = queue.shift();
       for (const d of DIRS) {
         const nx = cur.x + d.dx, ny = cur.y + d.dy;
         const id = nx + "," + ny;
         if (seen.has(id) || ny < 0 || ny >= H || nx < 0 || nx >= W) continue;
         if (blocked(grid[ny][nx], doorPassable)) continue;
         if (nx === to.x && ny === to.y) return true;
         seen.add(id);
         queue.push({ x: nx, y: ny });
       }
     }
     return false;
   }
 
   // Hand-authored layout used if seeded generation ever fails all attempts.
   // start (1,1) · key (2,7) · door (5,5) · exit (9,7); always solvable.
   const FALLBACK = {
     grid: [
       "###########",
       "#.....#...#",
       "#.....#...#",
       "#..#..#...#",
       "#..#..#...#",
       "#..#..D...#",
       "#..#..#...#",
       "#.K#..#..E#",
       "###########",
     ],
     start: { x: 1, y: 1 }, key: { x: 2, y: 7 },
     exit: { x: 9, y: 7 }, doorRow: 5,
   };
 
   // Seeded layout: border + a dividing wall with one locked door, a few random
   // wall segments inside each zone, then entities. Accepted only when the key
   // is reachable without the door AND the exit is reachable with it — so the
   // intended solve (key → door → exit) always exists.
   function makeLayout(seed) {
     for (let attempt = 0; attempt < 200; attempt++) {
       const r = rng((seed + attempt * 0x9E3779B9) >>> 0);
       const grid = Array.from({ length: H }, (_, y) =>
         Array.from({ length: W }, (_, x) =>
           (x === 0 || y === 0 || x === W - 1 || y === H - 1 || x === DIV) ? "#" : "."));
       const doorRow = randInt(r, 1, H - 2);
       grid[doorRow][DIV] = "D";
       const segs = randInt(r, 3, 5);
       for (let s = 0; s < segs; s++) {
         const horiz = r() < 0.5;
         const len = randInt(r, 1, 3);
         const [zx0, zx1] = r() < 0.5 ? [1, DIV - 1] : [DIV + 1, W - 2];
         const x0 = randInt(r, zx0, zx1 - (horiz ? len - 1 : 0));
         const y0 = randInt(r, 1, H - 2 - (horiz ? 0 : len - 1));
         for (let i = 0; i < len; i++) {
           const x = x0 + (horiz ? i : 0), y = y0 + (horiz ? 0 : i);
           if (grid[y][x] === ".") grid[y][x] = "#";
         }
       }
       const cellsIn = (x0, x1) => {
         const out = [];
         for (let y = 1; y < H - 1; y++)
           for (let x = x0; x <= x1; x++)
             if (grid[y][x] === ".") out.push({ x, y });
         return out;
       };
       const left = cellsIn(1, DIV - 1), right = cellsIn(DIV + 1, W - 2);
       if (left.length < 2 || right.length < 1) continue;
       const start = left[randInt(r, 0, left.length - 1)];
       const keyPool = left.filter((c) => c.x !== start.x || c.y !== start.y);
       const key = keyPool[randInt(r, 0, keyPool.length - 1)];
       const exit = right[randInt(r, 0, right.length - 1)];
       grid[key.y][key.x] = "K";
       grid[exit.y][exit.x] = "E";
       if (!reachable(grid, start, key, false)) continue;  // key on the near side
       if (!reachable(grid, start, exit, true)) continue;  // exit via the door
       return { grid: grid.map((row) => row.join("")), start, key, exit, doorRow, seed };
     }
     return { ...FALLBACK, seed };
   }
 
   function newState(layout) {
     return {
       x: layout.start.x, y: layout.start.y, dir: 0, // 0 = NORTH
       hasKey: false, doorOpen: false, steps: 0,
     };
   }
 
   // side: "left" | "right". Turning costs a step. There is deliberately no
   // event log in the observation: for a single-pass reader a list of recent
   // actions is few-shot imitation bait — the list ends with what was just
   // done, which is the pattern to continue. Outcomes reach the PLANNER via
   // the transcript, which is a different reader with different machinery.
   function turn(state, side) {
     const next = { ...state };
     next.dir = (state.dir + (side === "left" ? 3 : 1)) % 4;
     next.steps += 1;
     return next;
   }
 
   // Step into the faced cell. Outcomes: moved | bump | locked | opened | key | win
   function forward(state, layout) {
     const next = { ...state };
     const d = DIRS[state.dir];
     const nx = state.x + d.dx, ny = state.y + d.dy;
     const cell = layout.grid[ny][nx];
     next.steps += 1;
     if (cell === "#") return { state: next, outcome: "bump" };
     if (cell === "D" && !next.hasKey) return { state: next, outcome: "locked" };
     next.x = nx; next.y = ny;
     if (cell === "D" && !next.doorOpen) next.doorOpen = true;
     if (cell === "K" && !next.hasKey) {
       next.hasKey = true;
       return { state: next, outcome: "key" };
     }
     if (cell === "E") return { state: next, outcome: "win" };
     return { state: next, outcome: cell === "D" ? "opened" : "moved" };
   }
 
   // Camera geometry shared by the first-person renderer and the FPP state
   // text: PLANE = tan(60°) gives a 120° FOV (2*atan(PLANE)), so an object
   // projects into view within ±60° of facing — the same cone the canvas
   // draws. Wide on purpose: the decision model should almost never be
   // looking at "nothing".
   const PLANE = Math.tan(Math.PI / 3);
   // 8-way egocentric bearing of a cell: index 0 is always dead ahead, 2 is
   // always to the right, whatever the actor's orientation.
   const SECTORS = ["ahead", "ahead-right", "right", "behind-right",
     "behind", "behind-left", "left", "ahead-left"];
 
   // DDA cast from the player's cell center along (rdx, rdy). Returns the
   // distance to, side of, and content of the first sight-blocking cell — a
   // wall, or the door while locked (an open door is transparent). This is
   // the single definition of "what blocks sight": the renderer's wall
   // columns, sprite clipping, and the text state's visibility all use it.
   // Classic tie-break (y-step at exact corner ties): corner handling lives
   // in occluded(), which samples several rays — one per point of the
   // target cell — the way the renderer samples one per screen column.
   function cast(state, layout, rdx, rdy) {
     const px = state.x + 0.5, py = state.y + 0.5;
     let mx = Math.floor(px), my = Math.floor(py);
     const ddx = Math.abs(rdx) < 1e-9 ? 1e30 : Math.abs(1 / rdx);
     const ddy = Math.abs(rdy) < 1e-9 ? 1e30 : Math.abs(1 / rdy);
     let stepX, stepY, sdx, sdy;
     if (rdx < 0) { stepX = -1; sdx = (px - mx) * ddx; } else { stepX = 1; sdx = (mx + 1.0 - px) * ddx; }
     if (rdy < 0) { stepY = -1; sdy = (py - my) * ddy; } else { stepY = 1; sdy = (my + 1.0 - py) * ddy; }
     let side = 0, cell = ".", x = mx, y = my;
     for (let n = 0; n < 64; n++) {
       if (sdx < sdy) { sdx += ddx; mx += stepX; side = 0; }
       else { sdy += ddy; my += stepY; side = 1; }
       cell = (my >= 0 && my < H && mx >= 0 && mx < W) ? layout.grid[my][mx] : "#";
       x = mx; y = my;
       if (cell === "#" || (cell === "D" && !state.doorOpen)) break;
     }
     return { dist: Math.max(0.05, side === 0 ? sdx - ddx : sdy - ddy), side, cell, x, y };
   }
 
   // Camera-plane projection of a cell center: tx = lateral offset, ty =
   // depth along facing (ty <= 0.15 means behind the view plane).
   function project(state, cell) {
     const dir = DIRS[state.dir];
     const planeX = -dir.dy * PLANE, planeY = dir.dx * PLANE;
     const relX = cell.x + 0.5 - (state.x + 0.5), relY = cell.y + 0.5 - (state.y + 0.5);
     const invDet = 1 / (planeX * dir.dy - dir.dx * planeY || 1e-9);
     return { tx: invDet * (dir.dy * relX - dir.dx * relY),
              ty: invDet * (-planeY * relX + planeX * relY) };
   }
 
   // 8-way egocentric bearing of a cell: "ahead" is always dead ahead,
   // "right" is always to the right, whatever the actor's orientation.
   function sector(state, cell) {
     const eighth = Math.round(Math.atan2(cell.x - state.x, -(cell.y - state.y)) / (Math.PI / 4));
     return SECTORS[(((eighth - state.dir * 2) % 8) + 8) % 8];
   }
 
   // Bearing for the In-view/Known lines, with exact-cardinal precision: when
   // the cell lies exactly on a cardinal line in the facing frame ("directly
   // ahead/behind/left/right"), say so — under tank controls that means one
   // turn and then forward closes distance. Otherwise the plain eighth.
   function bearing(state, cell) {
     const dx = cell.x - state.x, dy = cell.y - state.y;
     const dir = DIRS[state.dir], right = DIRS[(state.dir + 1) % 4];
     const fwdC = dx * dir.dx + dy * dir.dy;
     const rightC = dx * right.dx + dy * right.dy;
     if (rightC === 0) return "directly " + (fwdC > 0 ? "ahead" : "behind");
     if (fwdC === 0) return "directly " + (rightC > 0 ? "right" : "left");
     return sector(state, cell);
   }
 
   // One sightline to a point inside the target cell: clear if it enters the
   // target strictly before the first blocker, or if the target itself is
   // that blocker (the locked door is visible — it must not occlude itself).
   // Entry is the box crossing — the MAX of the two slab crossings — because
   // min() credits entry at a corner the ray merely touches from the side.
   function lineClear(state, layout, tx, ty, cell) {
     const px = state.x + 0.5, py = state.y + 0.5;
     const rx = tx - px, ry = ty - py;
     const norm = Math.hypot(rx, ry);
     const rdx = rx / norm, rdy = ry / norm;
     const hit = cast(state, layout, rdx, rdy);
     const blocking = hit.cell === "#" || (hit.cell === "D" && !state.doorOpen);
     if (!blocking) return true;                       // no blocker: ran past the target
     if (hit.x === cell.x && hit.y === cell.y) return true;   // target itself blocks = seen
     const ex = rdx > 0 ? (cell.x - px) / rdx : rdx < 0 ? (cell.x + 1 - px) / rdx : -Infinity;
     const ey = rdy > 0 ? (cell.y - py) / rdy : rdy < 0 ? (cell.y + 1 - py) / rdy : -Infinity;
     return Math.max(ex, ey) + 1e-9 < hit.dist;       // entered the cell before the blocker
   }
 
   // True when every sightline from the actor to the cell is crossed. The
   // renderer draws a sprite when ANY of its per-column rays reaches it, so
   // the text samples a 3x3 grid of points across the cell the same way:
   // one clean ray means visible; hidden only when all nine are crossed.
   // A single center ray is stricter than the render at corner grazes (it
   // can be blocked by a wall the sprite visibly peeks past) — that mismatch
   // both hid the door standing on the key and leaked the exit in earlier
   // single-ray fixes.
   function occluded(state, layout, cell) {
     for (const fx of [0.3, 0.5, 0.7])
       for (const fy of [0.3, 0.5, 0.7])
         if (lineClear(state, layout, cell.x + fx, cell.y + fy, cell)) return false;
     return true;
   }
 
   // Objects a human would currently see: within the FOV cone and not
   // wall-occluded, nearest first. Bearing only — distances live in the
   // rays, where they serve collision. Text and canvas share cast/project,
   // and occluded() samples the cell the way the renderer samples its
   // columns, so "In view" agrees with what the renderer draws.
   function visibleObjects(state, layout) {
     const door = findDoor(layout);
     const items = [];
     if (!state.hasKey) items.push({ cell: layout.key, name: "the key" });
     if (door && !state.doorOpen) items.push({ cell: door, name: "a locked door" });
     items.push({ cell: layout.exit, name: "the exit" });
     const seen = [];
     for (const it of items) {
       const { tx, ty } = project(state, it.cell);
       if (ty <= 0.15) continue;                          // behind the view plane
       // cam = tx/ty is the renderer's column coordinate: rays span cam ∈
       // [-1, 1], so |cam| <= 1 is exactly "the sprite falls on screen".
       if (Math.abs(tx / ty) > 1) continue;               // outside the cone
       if (occluded(state, layout, it.cell)) continue;
       const norm = Math.hypot(it.cell.x - state.x, it.cell.y - state.y);
       seen.push({ name: it.name, bearing: bearing(state, it.cell), dist: norm });
     }
     seen.sort((a, b) => a.dist - b.dist);
     return seen.map(({ name, bearing: b }) => ({ name, bearing: b }));
   }
 
   function findDoor(layout) {
     for (let y = 0; y < H; y++) for (let x = 0; x < W; x++)
       if (layout.grid[y][x] === "D") return { x, y };
     return null;
   }
 
   // Adjacent-cell descriptions: one line per direction, ALWAYS all four —
   // "open floor" included, so no direction ever goes unreported. Egocentric
   // labels only — ahead/right/behind/left — matching the bearing vocabulary.
   // No compass line exists to anchor, and none is needed: "Ahead:" defines
   // the frame word itself.
   function adjacentLines(state, layout) {
     const order = [["Ahead", state.dir], ["Right", (state.dir + 1) % 4],
                    ["Behind", (state.dir + 2) % 4], ["Left", (state.dir + 3) % 4]];
     return order.map(([word, di]) => {
       const d = DIRS[di];
       const c = layout.grid[state.y + d.dy][state.x + d.dx];
       const name =
         c === "#" ? "a wall"
         : c === "K" && !state.hasKey ? "the key"
         : c === "D" && !state.doorOpen ? "a locked door"
         : c === "E" ? "the exit"
         : "open floor";
       return `${word}: ${name}`;
     });
   }
 
   // "In view" line shared by the ruled and neutral FPP texts — always
   // present (a stable schema beats a variable one for a single-pass
   // reader), bearing only, nearest first.
   function inViewLine(state, layout) {
     const seen = visibleObjects(state, layout);
     return "In view: " + (seen.length
       ? seen.map((o) => `${o.name} ${o.bearing}`).join("; ") + "."
       : "nothing.");
   }
 
   // Discovered-landmark bearings. The caller threads a `seen` set through
   // and adds whatever the cone reveals (the game loop folds each
   // observation in, so the state that first reveals a POI is also the last
   // one without its bearing). A POI appears here only while it is present
   // (key until carried, the locked door until opened, the exit always)
   // AND out of view — In view owns the visible ones, so each object is
   // described exactly once. Bearing only; no claim about why it matters.
   function knownLine(state, layout, seen = new Set()) {
     const door = findDoor(layout);
     const inView = new Set(visibleObjects(state, layout).map((o) => o.name));
     const items = [];
     if (seen.has("key") && !state.hasKey && !inView.has("the key"))
       items.push({ cell: layout.key, name: "the key" });
     if (seen.has("door") && !state.doorOpen && door && !inView.has("a locked door"))
       items.push({ cell: door, name: "a locked door" });
     if (seen.has("exit") && !inView.has("the exit"))
       items.push({ cell: layout.exit, name: "the exit" });
     if (!items.length) return "Known: nothing.";
     items.sort((a, b) =>
       Math.hypot(a.cell.x - state.x, a.cell.y - state.y) - Math.hypot(b.cell.x - state.x, b.cell.y - state.y));
     // A bearing the actor cannot actually walk reads as an instruction to a
     // single-pass reader — mark it, so a blocked compass never masquerades
     // as a walkable direction. Unblocked bearings are guaranteed clear
     // straight lines; blocked ones say "not this way, go around".
     return "Known: " + items.map((o) =>
       `${o.name} ${bearing(state, o.cell)}${occluded(state, layout, o.cell) ? " (blocked)" : ""}`).join("; ") + ".";
   }
 
   // First-person state: all four adjacent cells, the FOV cone, known-landmark
   // bearings, carry status and a step count. The model must build its own
   // map from this prose.
   // Every direction word is relative to facing — there is no compass line.
   function fppText(state, layout, guided, seen) {
     const lines = [
       "You are in a walled room. Reach the exit.",
       "You can step forward into the space you face, or turn left or right.",
       "A locked door blocks the room: find the key, then pass the door to reach the exit.",
       "",
       // 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),
     ];
     if (guided) {
       const [target, label] = !state.hasKey ? [layout.key, "the key"]
         : state.doorOpen ? [layout.exit, "the exit"]
         : [{ x: DIV, y: layout.doorRow }, "the door"];
       // Relative like everything else in this state: no compass line exists.
       lines.push("", `Hint: ${label} is roughly ${sector(state, target)} of you.`);
     }
     return lines.join("\n");
   }
 
   // The easy mode: hand the model the whole layout. Player cell is the facing
   // arrow (^ > v <) so the grid stays one glyph per cell.
   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 = ".";   // an opened door is just floor
         row.push(c);
       }
       rows.push(row.join(" "));
     }
     return [
       "Top-down map of the room. Reach the exit.",
       "Legend: [`#`: wall, `.`: floor, `D`: locked door, `K`: key, `E`: exit, `^ > v <`: you, facing that way]",
       "Stepping onto the key picks it up; the locked door opens once you carry the key.",
       "",
       ...rows,
       "",
       `Steps taken: ${state.steps}/${MAX_STEPS}`,
     ].join("\n");
   }
 
   // mode: "guided" | "fpp" | "map" — guided = FPP prose + compass hint.
   function stateText(state, layout, mode = "fpp", seen) {
     if (mode === "map") return mapText(state, layout);
     return fppText(state, layout, mode === "guided", seen);
   }
 
   // Neutral by design: the question must not leak the goal. It rides along
   // with the state into every decision prompt AND every transcript turn the
   // planner reads — "progress toward the exit" would tell the actor what the
   // rules are supposed to make it discover.
   const QUESTION = "Which action should the actor take?";
   const OPTIONS = [
     // Names only, deliberately: the mechanics (key + locked door, tank
     // controls) are the planner's job to discover and state as rules, not
     // ours to pre-chew in every decision prompt.
     { id: "forward", description: "Move one step ahead." },
     { id: "left", description: "Turn in place 90 degrees to the left." },
     { id: "right", description: "Turn in place 90 degrees to the right." },
   ];
 
   // Action options for the CURRENT state: forward is offered only when the
   // faced cell is enterable. A no-op input (a wall, or a locked door without
   // the key) is not a decision the actor can meaningfully make — and with no
   // event log it would produce no feedback either, just a silently burned
   // step. Turns and the insufficient escape hatch are always available.
   function optionsFor(state, layout) {
     const d = DIRS[state.dir];
     const cell = layout.grid[state.y + d.dy][state.x + d.dx];
     const enterable = cell !== "#" && !(cell === "D" && !state.hasKey);
     return enterable ? OPTIONS : OPTIONS.filter((o) => o.id !== "forward");
   }
 
   return { W, H, DIV, MAX_STEPS, DIRS, PLANE,
     FALLBACK, rng, randInt, reachable, makeLayout, newState, turn, forward,
     stateText, fppText, mapText, adjacentLines, cast, project, sector,
     visibleObjects, inViewLine, knownLine, QUESTION, OPTIONS, optionsFor };
 })();
 
 if (typeof module !== "undefined") module.exports = RoomRules;