Spaces:
Running
Running
| // Pathmoor core: pure puzzle logic (no DOM), shared by the game and the tests. (c) 2026 CyberMax. All rights reserved. | |
| // A board is an n×n grid of path stones. Each stone is a 4-bit mask of its openings: N=1, E=2, S=4, W=8. | |
| // The solution is a random spanning tree grown from the lantern stone, so every stone joins the lantern by exactly one | |
| // route. The board is shuffled by turning stones; the player turns them back. Solved = every stone lit by the lantern | |
| // and no opening points at the edge or at a closed side (any arrangement that does that counts, not only ours). | |
| import { rng } from './cmx.js'; | |
| export const N = 1, E = 2, S = 4, W = 8; | |
| const DIRS = [[N, 0, -1, S], [E, 1, 0, W], [S, 0, 1, N], [W, -1, 0, E]]; | |
| /** Turn a stone a quarter clockwise, k times. */ | |
| export function turn(m, k = 1) { | |
| let r = m; | |
| for (let i = 0; i < ((k % 4) + 4) % 4; i++) r = ((r << 1) | (r >> 3)) & 15; | |
| return r; | |
| } | |
| export const bits = (m) => (m & 1) + ((m >> 1) & 1) + ((m >> 2) & 1) + ((m >> 3) & 1); | |
| /** Fewest clockwise turns that take stone `from` to `to` (Infinity if impossible). */ | |
| export function turnsTo(from, to) { | |
| for (let k = 0; k < 4; k++) if (turn(from, k) === to) return k; | |
| return Infinity; | |
| } | |
| /** | |
| * Build a puzzle from a seed string. Returns { n, src, sol, start } where sol and start are arrays of n*n masks. | |
| * Grown with a randomised Prim tree; boards with too many straight runs or too few branches are re-rolled so every | |
| * board has real choices. The shuffle turns each stone 0-3 times and is never already solved. | |
| */ | |
| export function generate(seed, n = 6) { | |
| const rand = rng(`pathmoor:${n}:${seed}`); | |
| for (let attempt = 0; attempt < 40; attempt++) { | |
| const sol = new Array(n * n).fill(0); | |
| const c = Math.floor((n - 1) / 2); | |
| const src = (c + Math.floor(rand() * 2)) * n + c + Math.floor(rand() * 2); // one of the 4 middle stones | |
| const inTree = new Array(n * n).fill(false); | |
| inTree[src] = true; | |
| let frontier = []; | |
| const addEdges = (i) => { | |
| const x = i % n, y = (i / n) | 0; | |
| for (const [b, dx, dy, back] of DIRS) { | |
| const nx = x + dx, ny = y + dy; | |
| if (nx >= 0 && ny >= 0 && nx < n && ny < n && !inTree[ny * n + nx]) frontier.push([i, ny * n + nx, b, back]); | |
| } | |
| }; | |
| addEdges(src); | |
| let count = 1; | |
| while (count < n * n) { | |
| frontier = frontier.filter(([, j]) => !inTree[j]); | |
| const [i, j, b, back] = frontier[Math.floor(rand() * frontier.length)]; | |
| if (inTree[j]) continue; | |
| sol[i] |= b; sol[j] |= back; inTree[j] = true; count++; | |
| addEdges(j); | |
| } | |
| const straights = sol.filter((m) => m === (N | S) || m === (E | W)).length; | |
| const branches = sol.filter((m) => bits(m) >= 3).length; | |
| if (straights > n * n * 0.34 || branches < Math.max(3, Math.floor(n * n / 9))) continue; | |
| const start = sol.map((m) => turn(m, Math.floor(rand() * 4))); | |
| if (isSolved(n, src, start)) continue; | |
| return { n, src, sol, start }; | |
| } | |
| // extremely unlikely fallback: keep the last rules but accept the board | |
| const b = generate(`${seed}~`, n); | |
| return b; | |
| } | |
| /** Stones reachable from the lantern through matching openings. Returns a Uint8Array (1 = lit). */ | |
| export function lit(n, src, cur) { | |
| const on = new Uint8Array(n * n); | |
| const q = [src]; | |
| on[src] = 1; | |
| while (q.length) { | |
| const i = q.pop(); | |
| const x = i % n, y = (i / n) | 0; | |
| for (const [b, dx, dy, back] of DIRS) { | |
| if (!(cur[i] & b)) continue; | |
| const nx = x + dx, ny = y + dy; | |
| if (nx < 0 || ny < 0 || nx >= n || ny >= n) continue; | |
| const j = ny * n + nx; | |
| if (!on[j] && (cur[j] & back)) { on[j] = 1; q.push(j); } | |
| } | |
| } | |
| return on; | |
| } | |
| /** Openings that lead nowhere (edge, or a neighbour without the matching opening). */ | |
| export function looseEnds(n, cur) { | |
| let loose = 0; | |
| for (let i = 0; i < n * n; i++) { | |
| const x = i % n, y = (i / n) | 0; | |
| for (const [b, dx, dy, back] of DIRS) { | |
| if (!(cur[i] & b)) continue; | |
| const nx = x + dx, ny = y + dy; | |
| if (nx < 0 || ny < 0 || nx >= n || ny >= n || !(cur[ny * n + nx] & back)) loose++; | |
| } | |
| } | |
| return loose; | |
| } | |
| export function isSolved(n, src, cur) { | |
| if (looseEnds(n, cur)) return false; | |
| const on = lit(n, src, cur); | |
| for (let i = 0; i < on.length; i++) if (!on[i]) return false; | |
| return true; | |
| } | |
| /** Par = the fewest taps that solve the board from its shuffle (each tap turns one stone a quarter clockwise). */ | |
| export function par(board) { | |
| return board.start.reduce((s, m, i) => s + turnsTo(m, board.sol[i]), 0); | |
| } | |
| /** | |
| * Share grid (no spoilers): one square per stone. 🟩 stone ended in par turns or fewer, 🟨 a few extra turns, | |
| * 🟧 many extra turns, ⬜ stone you never needed to touch. | |
| */ | |
| export function shareGrid(board, taps) { | |
| const rows = []; | |
| for (let y = 0; y < board.n; y++) { | |
| let r = ''; | |
| for (let x = 0; x < board.n; x++) { | |
| const i = y * board.n + x; | |
| const need = turnsTo(board.start[i], board.sol[i]); | |
| const used = taps[i] || 0; | |
| r += need === 0 && used === 0 ? '⬜' : used <= Math.max(need, 1) ? '🟩' : used <= need + 4 ? '🟨' : '🟧'; | |
| } | |
| rows.push(r); | |
| } | |
| return rows.join('\n'); | |
| } | |
| export function fmtTime(ms) { | |
| const s = Math.max(0, Math.round(ms / 1000)); | |
| return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`; | |
| } | |
| /** Packs: the free daily is 6×6; the Fun Pass adds numbered packs. */ | |
| export const PACKS = [ | |
| { id: 'daily', name: 'Daily', n: 6, free: true }, | |
| { id: 'sprout', name: 'Sprout 5×5', n: 5, levels: 30, freeLevels: 3 }, | |
| { id: 'moorland', name: 'Moorland 7×7', n: 7, levels: 100 }, | |
| { id: 'highland', name: 'Highland 8×8', n: 8, levels: 100 }, | |
| { id: 'summit', name: 'Summit 10×10', n: 10, levels: 50 }, | |
| ]; | |
| // ------------------------------------------------------------------ levels (30 hand-tuned boards + twists) | |
| // Twists, one new idea about every 5 levels: holes (shaped boards), twin stones (tap one, both turn), fog (you only | |
| // see stones next to the light), reverse stones (turn anticlockwise) and bigger boards. Every 10th level is a | |
| // challenge level with a tap budget: run out of taps and the board resets. | |
| // Level boards use their own seed space, so the daily board above is unchanged. | |
| /** n = size, mix = share of stones shuffled (early levels), holes = empty cells, twins = twin pairs, fog, rev = reverse stones, budget = par + slack (challenge). */ | |
| export const LEVELS = [ | |
| { n: 3, mix: 0.35, name: 'First light' }, { n: 4, mix: 0.45, name: 'Crossroads' }, { n: 4, mix: 0.7, name: 'Moor gate' }, { n: 5, mix: 0.6, name: 'Bracken' }, { n: 5, mix: 0.7, name: 'Lantern walk' }, | |
| { n: 5, holes: 3, name: 'Broken ground', twist: 'Holes in the moor' }, { n: 5, holes: 4, name: 'Bog pools' }, { n: 6, name: 'Long dusk' }, { n: 6, holes: 5, name: 'Peat cuts' }, | |
| { n: 6, holes: 3, budget: 6, name: 'Lantern trial', boss: true }, | |
| { n: 5, twins: 2, name: 'Twin stones', twist: 'Twin stones turn together' }, { n: 6, twins: 3, name: 'Paired path' }, { n: 6, twins: 3, holes: 3, name: 'Old wall' }, { n: 6, twins: 4, name: 'Mirror field' }, { n: 7, twins: 3, name: 'Wide moor' }, | |
| { n: 6, fog: true, name: 'Moor fog', twist: 'Fog: only stones near the light show' }, { n: 6, fog: true, twins: 2, name: 'Grey morning' }, { n: 7, fog: true, holes: 4, name: 'Mist pools' }, { n: 7, twins: 4, holes: 4, name: 'Heather maze' }, | |
| { n: 7, fog: true, twins: 3, budget: 10, name: 'Fog trial', boss: true }, | |
| { n: 6, rev: 5, name: 'Backwards stones', twist: 'Purple stones turn the other way' }, { n: 7, rev: 7, name: 'Turnabout' }, { n: 7, rev: 6, twins: 3, name: 'Crossed wires' }, { n: 8, name: 'Highland' }, { n: 8, holes: 6, fog: true, name: 'Cloud tops' }, | |
| { n: 9, name: 'Great moor', twist: 'Bigger boards' }, { n: 8, rev: 8, twins: 4, holes: 5, name: 'Tangle' }, { n: 9, fog: true, rev: 8, name: 'Night walk' }, { n: 9, rev: 9, twins: 5, holes: 6, name: 'Summit path' }, | |
| { n: 10, rev: 10, twins: 5, holes: 6, fog: true, budget: 14, name: 'Summit trial', boss: true }, | |
| ]; | |
| /** Stones reachable from the lantern (holes are walls). */ | |
| export function litB(b, cur) { return lit(b.n, b.src, cur); } | |
| /** Solved: no loose ends and every stone that is not a hole is lit. */ | |
| export function isSolvedB(b, cur) { | |
| if (looseEnds(b.n, cur)) return false; | |
| const on = lit(b.n, b.src, cur); | |
| for (let i = 0; i < on.length; i++) if (!on[i] && !b.hole[i]) return false; | |
| return true; | |
| } | |
| /** The stones one tap on stone i turns (its twin too). */ | |
| export const groupOf = (b, i) => (b.twin[i] >= 0 ? [i, b.twin[i]] : [i]); | |
| /** Turn direction of stone i: 1 clockwise, 3 (= one anticlockwise quarter) for reverse stones. */ | |
| export const dirOf = (b, i) => (b.rev[i] ? 3 : 1); | |
| /** Apply one tap on stone i to cur (in place). k = 1 forward, 3 = back (undo / shift-tap). */ | |
| export function tapB(b, cur, i, k = 1) { | |
| if (b.hole[i]) return false; | |
| for (const j of groupOf(b, i)) cur[j] = turn(cur[j], dirOf(b, j) * k); | |
| return true; | |
| } | |
| /** Fewest taps on the group of stone i that bring it from start back to the solution. */ | |
| function groupTaps(b, start, i) { | |
| const g = groupOf(b, i); | |
| for (let k = 0; k < 4; k++) if (g.every((j) => turn(start[j], dirOf(b, j) * k) === b.sol[j])) return k; | |
| return 0; | |
| } | |
| /** Par for a level board: the fewest taps from the shuffle to our solution. */ | |
| export function parB(b) { | |
| let s = 0; | |
| const seen = new Set(); | |
| for (let i = 0; i < b.n * b.n; i++) { | |
| if (b.hole[i] || seen.has(i)) continue; | |
| groupOf(b, i).forEach((j) => seen.add(j)); | |
| s += groupTaps(b, b.start, i); | |
| } | |
| return s; | |
| } | |
| /** Stars: 3 = par or better, 2 = within about a third over par, 1 = solved. */ | |
| export function levelStars(taps, p) { | |
| return taps <= p ? 3 : taps <= p + Math.ceil(p * 0.34) + 1 ? 2 : 1; | |
| } | |
| /** Build level `num` (1-based) from LEVELS. Deterministic: the same level is the same board for everyone. */ | |
| export function generateLevel(num) { | |
| const L = LEVELS[num - 1]; | |
| const n = L.n, rand = rng(`pathmoor:lv:${num}`); | |
| for (let attempt = 0; attempt < 400; attempt++) { | |
| const hole = new Uint8Array(n * n); | |
| const c = Math.floor((n - 1) / 2); | |
| const src = (c + Math.floor(rand() * 2)) * n + c + Math.floor(rand() * 2); | |
| let holes = L.holes || 0; | |
| for (let tries = 0; holes > 0 && tries < 200; tries++) { | |
| const i = Math.floor(rand() * n * n); | |
| if (i === src || hole[i]) continue; | |
| hole[i] = 1; holes--; | |
| } | |
| const sol = new Array(n * n).fill(0); | |
| const inTree = new Uint8Array(n * n); | |
| inTree[src] = 1; | |
| let frontier = []; | |
| const addEdges = (i) => { | |
| const x = i % n, y = (i / n) | 0; | |
| for (const [bt, dx, dy, back] of DIRS) { | |
| const nx = x + dx, ny = y + dy, j = ny * n + nx; | |
| if (nx >= 0 && ny >= 0 && nx < n && ny < n && !inTree[j] && !hole[j]) frontier.push([i, j, bt, back]); | |
| } | |
| }; | |
| addEdges(src); | |
| let count = 1; | |
| const need = n * n - (L.holes || 0); | |
| while (frontier.length) { | |
| const k = Math.floor(rand() * frontier.length); | |
| const [i, j, bt, back] = frontier[k]; | |
| frontier.splice(k, 1); | |
| if (inTree[j]) continue; | |
| sol[i] |= bt; sol[j] |= back; inTree[j] = 1; count++; | |
| addEdges(j); | |
| } | |
| if (count < need) continue; // holes cut the moor in two: re-roll | |
| const cells = [...Array(n * n).keys()].filter((i) => !hole[i]); | |
| const straights = cells.filter((i) => sol[i] === (N | S) || sol[i] === (E | W)).length; | |
| if (n >= 5 && straights > cells.length * 0.4) continue; | |
| // twins: pairs of stones (not crosses, not the lantern) that turn together | |
| const twin = new Int16Array(n * n).fill(-1); | |
| const pool = cells.filter((i) => i !== src && bits(sol[i]) < 4); | |
| for (let t = 0; t < (L.twins || 0) && pool.length > 1; t++) { | |
| const a = pool.splice(Math.floor(rand() * pool.length), 1)[0]; | |
| const bb = pool.splice(Math.floor(rand() * pool.length), 1)[0]; | |
| twin[a] = bb; twin[bb] = a; | |
| } | |
| const rev = new Uint8Array(n * n); | |
| const rpool = cells.filter((i) => twin[i] < 0 && bits(sol[i]) < 4 && !(sol[i] === (N | S) || sol[i] === (E | W))); | |
| for (let t = 0; t < (L.rev || 0) && rpool.length; t++) rev[rpool.splice(Math.floor(rand() * rpool.length), 1)[0]] = 1; | |
| const b = { n, src, sol, hole, twin, rev, fog: !!L.fog, level: num }; | |
| // shuffle by tapping: every group gets 0-3 backward taps, so the board is always solvable | |
| const start = sol.slice(); | |
| const done = new Set(); | |
| for (const i of cells) { | |
| if (done.has(i)) continue; | |
| groupOf(b, i).forEach((j) => done.add(j)); | |
| const k = rand() < (L.mix || 0.75) ? 1 + Math.floor(rand() * 3) : 0; | |
| for (const j of groupOf(b, i)) start[j] = turn(start[j], dirOf(b, j) * 3 * k); | |
| } | |
| b.start = start; | |
| if (isSolvedB(b, start)) continue; | |
| const p = parB(b); | |
| if (p < Math.max(3, Math.floor(cells.length * 0.35 * (L.mix || 0.75)))) continue; // too few taps needed: not a real puzzle | |
| b.par = p; | |
| b.budget = L.budget ? p + L.budget : 0; | |
| return b; | |
| } | |
| throw new Error(`level ${num}: no board`); | |
| } | |