semif-api-rocm

game-rules.js (9331B)

---

 "use strict";
 
 // Shared by the browser and offline tests: prompt facts come from the physics.
 const GameRules = (() => {
   const W = 68, H = 8, GROUND = 7;
   const GOAL = 64, START_X = 3;
   const RUN_VX = 1, JUMP_VY = -2.3, GRAV = 0.9;
 
   // Level shape. Width and count are deliberately fixed; only pit *positions*
   // are randomisable. A 3-wide pit is what the jump arc clears with two safe
   // takeoff tiles (the edge, and one back), and 3 pits => MAX_JUMPS 4. Changing
   // width or count would change the difficulty class and the solvability proof,
   // so the generator never does it. Positions vary within boundaries that keep
   // the standard "jump at the edge" strategy a guaranteed solve.
   const PIT_W = 3;                 // every pit is exactly PIT_W tiles wide
   const MIN_FIRST = START_X + 3;   // earliest left edge (runway after the start)
   const STEP = PIT_W + 3;          // min left-edge gap between pits (>=3 solid tiles)
   const MAX_LAST = GOAL - 6;       // latest left edge (landing + runway before the flag)
 
   const DEFAULT_PITS = [[14, 16], [31, 33], [48, 50]]; // seed-free baseline the UI boots on
   let pits = DEFAULT_PITS.map(([a, b]) => [a, b]);     // current mutable layout
 
   const floorAt = (col) => !pits.some(([a, b]) => col >= a && col <= b);
 
   // mulberry32: small, deterministic, good enough for shuffling 3 positions.
   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
 
   // Three width-PIT_W pits at seeded positions, always valid by construction:
   // draw the first left edge, then each next edge at least STEP ahead, clamped
   // so the last edge can never exceed MAX_LAST.
   function makePits(seed) {
     const r = rng(seed);
     const a1 = randInt(r, MIN_FIRST, MAX_LAST - 2 * STEP);
     const a2 = randInt(r, a1 + STEP, MAX_LAST - STEP);
     const a3 = randInt(r, a2 + STEP, MAX_LAST);
     return [a1, a2, a3].map((a) => [a, a + PIT_W - 1]);
   }
 
   // Returns human-readable problems; an empty array means the layout is valid.
   function validatePits(p) {
     const errs = [];
     if (p.length !== 3) errs.push("exactly 3 pits required");
     let prev = null;
     for (const [a, b] of p) {
       if (b - a + 1 !== PIT_W) errs.push(`pit ${a}-${b} must be ${PIT_W} tiles wide`);
       if (a <= START_X) errs.push(`pit at ${a} is on or behind the start`);
       if (b >= GOAL) errs.push(`pit at ${b} covers the goal`);
       if (prev !== null && a - prev < STEP) errs.push(`pits at ${prev} and ${a} are too close`);
       prev = a;
     }
     if (p.length && p[0][0] < MIN_FIRST) errs.push(`first pit left of ${MIN_FIRST}`);
     if (p.length && p[p.length - 1][0] > MAX_LAST) errs.push(`last pit right of ${MAX_LAST}`);
     return errs;
   }
 
   // Swaps the live layout (floorAt, the prompts and the renderer all read it).
   function setPits(next) {
     const errs = validatePits(next);
     if (errs.length) throw new Error("Invalid pit layout: " + errs.join("; "));
     pits = next.map(([a, b]) => [a, b]);
     return pits;
   }
 
   function airborneStep(y, vy) {
     vy += GRAV;
     return { y: y + vy, vy };
   }
 
   function jumpTicks() {
     let y = GROUND, vy = JUMP_VY, ticks = 0;
     do {
       ({ y, vy } = airborneStep(y, vy));
       ticks++;
     } while (y < GROUND);
     return ticks;
   }
   const JUMP_TICKS = jumpTicks();
   const JUMP_DISTANCE = JUMP_TICKS * RUN_VX;
 
   // Returns a new state. Once below the surface, moving under a solid tile
   // cannot teleport the player back onto it.
   function advance(player, moveRight) {
     const next = { ...player };
     if (!next.onGround || moveRight) next.x += RUN_VX;
     if (next.onGround && !floorAt(Math.floor(next.x))) {
       next.onGround = false;
       next.vy = 0;
     }
     if (!next.onGround) {
       const previousY = next.y;
       Object.assign(next, airborneStep(next.y, next.vy));
       if (next.vy > 0 && previousY <= GROUND && next.y >= GROUND && floorAt(Math.floor(next.x))) {
         next.y = GROUND;
         next.vy = 0;
         next.onGround = true;
       }
     }
     return { player: next, fell: next.y > H + 2 };
   }
 
   function guidedJump(player, jumpsLeft) {
     return player.onGround && jumpsLeft > 0 && !floorAt(Math.floor(player.x + RUN_VX));
   }
 
   // Whole level as one row of symbols: - floor, # pit, * you, ! flag.
   // Cells are joined with spaces so every glyph is its own token — without
   // them BPE merges runs like "------" into few meaningless tokens and the
   // model's failures are perception (tokenization) errors, not reasoning ones.
   // Still harder than prose: the model must decode the symbols and locate
   // itself, the pits and the flag on the row before deciding.
   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 [
       "Reach the flag without falling into a pit.",
       "Legend: [`*`: player, `-`: safe floor, `#`: fail pit, `!`: goal flag]",
       "Run moves the `*` one space forward",
       "If the next space is a pit, run will make you fail.",
       "Jump at the edge of a pit to cross it.",
       `Jumps remaining: ${jumpsLeft}`,
       "",
       row.join(" "),
     ].join("\n");
   }
 
   // Run-length symbolic: terrain ahead of the player as run-length segments.
   // Easier to parse than the raw ASCII row (no counting columns) but still
   // symbolic, so the model must read the legend and act on the next segment.
   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 [
       "Reach the flag without falling into a pit.",
       "Legend: [`*`: player, `>`: facing right, `-N`: run of N safe floor, `#N`: run of N fail pit, `!`: goal flag]",
       "Run moves the `[*]` one space forward.",
       "If the next segment is a pit, run will make you fail.",
       "Jump at the edge of a pit to cross it.",
       `Jumps remaining: ${jumpsLeft}`,
       "",
       `[*] > ${segs.join(" | ")}`,
     ].join("\n");
   }
 
   // mode: "guided" | "unguided" | "runlength" | "ascii". Booleans are accepted
   // for callers that predate the newer modes: true => guided, false => unguided.
   function stateText(player, jumpsLeft, mode = "unguided") {
     const m = mode === true ? "guided" : mode === false ? "unguided" : mode;
     if (m === "ascii") return asciiText(player, jumpsLeft);
     if (m === "runlength") return runLengthText(player, jumpsLeft);
     const guided = m === "guided";
     // Describe destination spaces, starting one move ahead. The flag occupies
     // its own ground space; don't count it twice in the preceding ground run.
     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 lines = [
       "Reach the flag without falling into a pit.",
       "Run moves you one space forward.",
       "If the next space is a hole, running makes you fall.",
       "Jump at the edge of a pit to cross it.",
       "You can act again after running or landing.",
       "",
       `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):",
       ...terrain.map(({ kind, count }) => `${count} ${kind} space${count === 1 ? "" : "s"}`),
       player.x < GOAL ? "" : "Flag reached",
 
     ];
     if (guided) {
       lines.push(!player.onGround ? "Hint: wait for the current jump to finish."
         : guidedJump(player, jumpsLeft) ? "Hint: jump now; the next running tick would enter a pit."
         : "Hint: run for one tick, then reassess.");
     }
     return lines.join("\n");
   }
 
   const QUESTION = "What should the player do now?";
   const OPTIONS = [
     { id: "run", description: "Run" },
     { id: "jump", description: "Jump" },
   ];
   return { W, H, GROUND,
     get PITS() { return pits; },
     get MAX_JUMPS() { return pits.length + 1; },
     GOAL, START_X, RUN_VX, JUMP_VY, GRAV,
     JUMP_TICKS, JUMP_DISTANCE, floorAt, advance, guidedJump, stateText, asciiText, runLengthText,
     DEFAULT_PITS, PIT_W, MIN_FIRST, STEP, MAX_LAST, makePits, validatePits, setPits,
     QUESTION, OPTIONS };
 })();
 
 if (typeof module !== "undefined") module.exports = GameRules;