semif-api-rocm

self-rules.js (4795B)

---

 "use strict";
 
 /* No-rules platformer: the same three terrain encodings as game-rules.js
  * (prose counts, run-length segments, ASCII row) with every line of how-to-play
  * prose removed. The model is never told the goal, what running or jumping do,
  * or which outcomes fail — it only sees neutral observations (its own state,
  * jumps remaining, the terrain) plus the action list with accurate one-word
  * descriptions, and an "insufficient" escape hatch. When play stalls or a run
  * fails, the client asks /plan for rules and injects the answer into later
  * states as "Rules".
  *
  * Physics is GameRules' (this module reads GameRules.floorAt/GOAL and only
  * assembles observation text); SelfRules.PLAN_GOAL is the simulation's
  * one-line statement of the goal — the only game-specific input to /plan.
  */
 const SelfRules = (() => {
   const { GOAL, floorAt } = GameRules;
 
   // Terrain ahead as prose counts — identical listing to GameRules.stateText,
   // minus the goal/rules lines and the hint.
   function terrainLines(player) {
     const terrain = [];
     for (let x = player.x + 1; x < GOAL; x++) {
       const kind = floorAt(x) ? "ground" : "hole";
       const last = terrain[terrain.length - 1];
       if (last && last.kind === kind) last.count++;
       else terrain.push({ kind, count: 1 });
     }
     return terrain.map(({ kind, count }) => `${count} ${kind} space${count === 1 ? "" : "s"}`);
   }
 
   function proseText(player, jumpsLeft) {
     return [
       `Player: ${player.onGround ? "standing on ground" : "airborne"}, facing right`,
       `Jumps remaining: ${jumpsLeft}`,
       "",
       // When the flag is the very next space, the enumeration would be an
       // empty list under a header — say the useful thing instead.
       player.x + 1 === GOAL ? "The flag is right in front of you!"
         : "Ahead, from nearest to farthest (starting with the next space):",
       ...terrainLines(player),
       player.x < GOAL ? "" : "Flag reached",
     ].join("\n");
   }
 
   // Run-length segments — same encoding as GameRules.runLengthText, with a
   // neutral legend (a `#` names the terrain, it does not announce a failure).
   function runLengthText(player, jumpsLeft) {
     const terrain = [];
     for (let x = player.x + 1; x < GOAL; x++) {
       const kind = floorAt(x) ? "ground" : "hole";
       const last = terrain[terrain.length - 1];
       if (last && last.kind === kind) last.count++;
       else terrain.push({ kind, count: 1 });
     }
     const segs = terrain.map(({ kind, count }) => `${kind === "ground" ? "-" : "#"}${count}`);
     segs.push("[!]");
     return [
       "Legend: [`*`: player, `>`: facing right, `-N`: N ground tiles, `#N`: N hole tiles, `!`: flag]",
       `Jumps remaining: ${jumpsLeft}`,
       "",
       `[*] > ${segs.join(" | ")}`,
     ].join("\n");
   }
 
   // Whole level as one symbolic row — same glyph layout as GameRules.asciiText,
   // same neutral legend, no goal line and no rules. Cells stay space-separated
   // so every glyph is its own token.
   function asciiText(player, jumpsLeft) {
     const here = Math.floor(player.x);
     const row = [];
     for (let x = 0; x <= GOAL; x++) {
       if (x === here) row.push("*");
       else if (x === GOAL) row.push("!");
       else row.push(floorAt(x) ? "-" : "#");
     }
     return [
       "Legend: [`*`: player, `-`: ground, `#`: hole, `!`: flag]",
       `Jumps remaining: ${jumpsLeft}`,
       "",
       row.join(" "),
     ].join("\n");
   }
 
   // mode: "prose" | "runlength" | "ascii". There is deliberately no guided
   // variant: guidance was instructional prose, which this demo never sends.
   function stateText(player, jumpsLeft, mode = "prose") {
     if (mode === "runlength") return runLengthText(player, jumpsLeft);
     if (mode === "ascii") return asciiText(player, jumpsLeft);
     return proseText(player, jumpsLeft);
   }
 
   const QUESTION = "What should the player do now?";
   // Actions only, with accurate one-word descriptions, plus the escape hatch
   // that gates the /plan trigger (Planner.INSUFFICIENT_THRESHOLD on its prob).
   const OPTIONS = [
     { id: "run", description: "Run" },
     { id: "jump", description: "Jump" },
     { id: Planner.INSUFFICIENT_ID, description: "Insufficient evidence to decide" },
   ];
 
   /* 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 demanding lean, committal
    * instructions is universal and lives in the backend. */
   const PLAN_GOAL = "Reach the flag at the far right end of the level.";
 
   return { stateText, proseText, runLengthText, asciiText, terrainLines,
     QUESTION, OPTIONS, PLAN_GOAL };
 })();
 
 if (typeof module !== "undefined") module.exports = SelfRules;