@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/slitherlinkGenerate.js

@@ -0,0 +1,182 @@
+import { SLITHERLINK_LEVELS, SLITHERLINK_MOST_ATTEMPTS, SLITHERLINK_MOST_SIDE } from "./slitherlink.constants.js";
+import { checkSlitherlink, slitherlinkCellEdges } from "./slitherlinkBoard.js";
+import { slitherlinkModel } from "./slitherlinkLogic.js";
+import { solveSlitherlink } from "./slitherlinkSolve.js";
+import { templateSlitherlink } from "./slitherlinkTemplate.js";
+import { countCsp, logicCsp, openSlots } from "./csp.js";
+import { isKazuSeed, seededRandom, shuffled } from "./random.js";
+/**
+ * Makes a seeded puzzle and proves it has one answer. A random winding loop is grown cell by cell, every square is
+ * numbered with how many of its edges the loop uses, and then numbers are taken away for as long as the puzzle can
+ * still be solved the way the level asks: easy and medium by the rules alone (easy keeps most numbers), hard by
+ * supposing one edge at a time, extra-hard the most-supposing of several such boards. Numbers that say 0 are
+ * taken away first, because they say least. If no board of the level is found within the attempts the next level
+ * down is tried, and the first generator, which cannot fail, is the last.
+ */
+export function generateSlitherlink(width = 5, height = width, seed = 1, level = "medium") {
+    if (![width, height].every(side => Number.isInteger(side) && side >= 2 && side <= SLITHERLINK_MOST_SIDE)
+        || !isKazuSeed(seed) || !SLITHERLINK_LEVELS.includes(level))
+        throw new RangeError("Invalid Slitherlink settings");
+    const random = seededRandom(seed);
+    // The work an attempt does is counted in rule runs, never in time, so a seed makes the same puzzle on every machine. When a level has used its share the next one down is tried.
+    const work = { calls: 0, limit: width * height * 900 };
+    for (let aim = SLITHERLINK_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        work.calls = 0;
+        const aimed = SLITHERLINK_LEVELS[aim];
+        const wanted = 1;
+        let best = null, found = 0;
+        for (let attempt = 0; attempt < SLITHERLINK_MOST_ATTEMPTS && found < wanted && work.calls < work.limit; attempt += 1) {
+            const made = attemptSlitherlink(width, height, aimed, random, work);
+            if (!made)
+                continue;
+            found += 1;
+            if (!best || made.probes > best.probes)
+                best = made;
+        }
+        if (best) {
+            const proof = solveSlitherlink(best.board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkSlitherlink(best.board, proof.solution).ok) {
+                return { ...best.board, seed, level, solution: proof.solution };
+            }
+        }
+    }
+    return { ...templateSlitherlink(width, height, seed), level };
+}
+/** The loop of a random region of squares: connected, without a hole, and never touching itself at a corner. */
+function growRegion(width, height, share, thin, random) {
+    const stride = width + 2, inside = new Uint8Array(stride * (height + 2));
+    const at = (x, y) => (y + 1) * stride + x + 1;
+    const target = Math.max(2, Math.round(width * height * share));
+    const start = at(Math.floor(random() * width), Math.floor(random() * height));
+    inside[start] = 1;
+    let size = 1;
+    const outsideReaches = () => {
+        // Every square not in the region must still be reachable from beyond the board.
+        const seen = new Uint8Array(inside.length), stack = [0];
+        seen[0] = 1;
+        let reached = 1;
+        while (stack.length) {
+            const cell = stack.pop();
+            for (const next of [cell - 1, cell + 1, cell - stride, cell + stride]) {
+                if (next < 0 || next >= inside.length || seen[next] || inside[next])
+                    continue;
+                seen[next] = 1;
+                reached += 1;
+                stack.push(next);
+            }
+        }
+        return reached === inside.length - size;
+    };
+    while (size < target) {
+        const options = [];
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                const cell = at(x, y);
+                if (inside[cell])
+                    continue;
+                const touching = (inside[cell - 1] + inside[cell + 1] + inside[cell - stride] + inside[cell + stride]);
+                if (!touching)
+                    continue;
+                // Two squares touching only at a corner would pinch the loop where it passes itself.
+                if ([[cell - 1, cell - stride, cell - stride - 1], [cell + 1, cell - stride, cell - stride + 1], [cell - 1, cell + stride, cell + stride - 1], [cell + 1, cell + stride, cell + stride + 1]]
+                    .some(([a, b, diagonal]) => inside[diagonal] && !inside[a] && !inside[b]))
+                    continue;
+                inside[cell] = 1;
+                size += 1;
+                const fine = outsideReaches();
+                inside[cell] = 0;
+                size -= 1;
+                if (!fine)
+                    continue;
+                options.push({ cell, touching });
+            }
+        if (!options.length)
+            break;
+        const thinnest = options.filter(option => option.touching === 1);
+        const pool = thinnest.length && random() < thin ? thinnest : options;
+        inside[pool[Math.floor(random() * pool.length)].cell] = 1;
+        size += 1;
+    }
+    const region = new Uint8Array(width * height);
+    for (let y = 0; y < height; y += 1)
+        for (let x = 0; x < width; x += 1)
+            region[y * width + x] = inside[at(x, y)];
+    return region;
+}
+function loopOf(width, height, region) {
+    const blank = { width, height, clues: Array(width * height).fill(null) };
+    const edges = new Set();
+    for (let cell = 0; cell < region.length; cell += 1) {
+        if (!region[cell])
+            continue;
+        const [top, right, bottom, left] = slitherlinkCellEdges(blank, cell);
+        const x = cell % width;
+        if (cell < width || !region[cell - width])
+            edges.add(top);
+        if (x === width - 1 || !region[cell + 1])
+            edges.add(right);
+        if (cell >= width * (height - 1) || !region[cell + width])
+            edges.add(bottom);
+        if (x === 0 || !region[cell - 1])
+            edges.add(left);
+    }
+    return edges;
+}
+function attemptSlitherlink(width, height, level, random, work) {
+    const share = { easy: .45, medium: .5, hard: .55, "extra-hard": .6 }[level] * (.9 + random() * .2);
+    const region = growRegion(width, height, share, .75, random);
+    const edges = loopOf(width, height, region);
+    const blank = { width, height, clues: Array(width * height).fill(null) };
+    const full = Array.from({ length: width * height }, (_, cell) => slitherlinkCellEdges(blank, cell).filter(edge => edges.has(edge)).length);
+    const clues = [...full];
+    let calls = 0;
+    const csp = () => {
+        const { csp: model } = slitherlinkModel({ width, height, clues });
+        return { ...model, propagate: (alive, decided) => { calls += 1; work.calls += 1; return model.propagate(alive, decided); } };
+    };
+    const byRules = () => { const c = csp(); return logicCsp(c, openSlots(c), 0).solved; };
+    const bySupposing = () => {
+        const c = csp();
+        const count = countCsp(c, openSlots(c), 2, 800);
+        if (!count.exhausted && count.count !== 1)
+            return false;
+        return logicCsp(c, openSlots(c), 1).solved;
+    };
+    if (!byRules())
+        return null;
+    const order = shuffled(clues.map((_, cell) => cell), random).sort((a, b) => (full[a] === 0 ? 0 : 1) - (full[b] === 0 ? 0 : 1));
+    const keepAtLeast = level === "easy" ? Math.ceil(width * height * .7) : 0;
+    let left = clues.length;
+    /** Takes numbers away while `test` still passes, until `spent` says the work is used up or `done` says the board is hard enough. */
+    const thin = (test, spent, done = () => false) => {
+        for (const cell of order) {
+            if (clues[cell] === null)
+                continue;
+            if (left <= keepAtLeast || spent())
+                return;
+            const was = clues[cell];
+            clues[cell] = null;
+            if (!test()) {
+                clues[cell] = was;
+                continue;
+            }
+            left -= 1;
+            if (done())
+                return;
+        }
+    };
+    thin(byRules, () => false);
+    // Hard stops thinning when its share of work is used; extra-hard is given four times as much and so ends sparser.
+    const budget = width * height * (level === "extra-hard" ? 420 : 120);
+    const from = calls;
+    if (level === "hard" || level === "extra-hard")
+        thin(bySupposing, () => calls - from > budget);
+    const board = { width, height, clues };
+    const c = csp();
+    if (logicCsp(c, openSlots(c), 0).solved)
+        return level === "easy" || level === "medium" ? { board, probes: 0 } : null;
+    if (level === "easy" || level === "medium")
+        return null;
+    const probing = logicCsp(c, openSlots(c), 1);
+    return probing.solved ? { board, probes: probing.probes } : level === "extra-hard" ? { board, probes: 1000 } : null;
+}

package/dist/slitherlinkLogic.d.ts

@@ -0,0 +1,10 @@
+import type { Csp } from "./csp.ts";
+import type { SlitherlinkBoard } from "./slitherlink.types.ts";
+/**
+ * Slitherlink as variables: one per edge, slot 0 for off and slot 1 for on. The pruning rules are the ones
+ * a person uses first: a number counts the edges round its square, every corner has none or two edges, and
+ * a loop may not close while any other part of it is still to be drawn or while a number is not yet met.
+ */
+export declare function slitherlinkModel(board: SlitherlinkBoard): {
+    csp: Csp;
+};

package/dist/slitherlinkLogic.js

@@ -0,0 +1,267 @@
+import { edgeVertices, slitherlinkCellEdges, slitherlinkEdgeCount, slitherlinkVertexEdges } from "./slitherlinkBoard.js";
+/**
+ * Slitherlink as variables: one per edge, slot 0 for off and slot 1 for on. The pruning rules are the ones
+ * a person uses first: a number counts the edges round its square, every corner has none or two edges, and
+ * a loop may not close while any other part of it is still to be drawn or while a number is not yet met.
+ */
+export function slitherlinkModel(board) {
+    const edges = slitherlinkEdgeCount(board), vertexCount = (board.width + 1) * (board.height + 1);
+    const at = Array.from({ length: vertexCount }, (_, vertex) => Int32Array.from(slitherlinkVertexEdges(board, vertex)));
+    const endA = new Int32Array(edges), endB = new Int32Array(edges);
+    for (let edge = 0; edge < edges; edge += 1) {
+        const [a, b] = edgeVertices(board, edge);
+        endA[edge] = a;
+        endB[edge] = b;
+    }
+    const clues = board.clues.flatMap((clue, cell) => clue === null ? [] : [{ need: clue, edges: Int32Array.from(slitherlinkCellEdges(board, cell)) }]);
+    const cluesOf = Array.from({ length: edges }, () => []);
+    clues.forEach((clue, index) => clue.edges.forEach(edge => cluesOf[edge].push(index)));
+    const starts = Int32Array.from({ length: edges + 1 }, (_, i) => i * 2);
+    const endList = new Int32Array(vertexCount), parent = new Int32Array(vertexCount), degree = new Uint8Array(vertexCount), componentEdges = new Int32Array(vertexCount), openEnds = new Int32Array(vertexCount);
+    const vertexQueue = new Int32Array(vertexCount * 8), clueQueue = new Int32Array(clues.length * 8 + 8);
+    const vertexQueued = new Uint8Array(vertexCount), clueQueued = new Uint8Array(clues.length);
+    const reachable = new Int32Array(vertexCount);
+    const findIn = (table, v) => { while (table[v] !== v) {
+        table[v] = table[table[v]];
+        v = table[v];
+    } return v; };
+    const find = (v) => { while (parent[v] !== v) {
+        parent[v] = parent[parent[v]];
+        v = parent[v];
+    } return v; };
+    const propagate = (alive, decided) => {
+        let vertexHead = 0, vertexTail = 0, clueHead = 0, clueTail = 0;
+        const touch = (e) => {
+            const a = endA[e], b = endB[e];
+            if (!vertexQueued[a]) {
+                vertexQueued[a] = 1;
+                vertexQueue[vertexTail++ % vertexQueue.length] = a;
+            }
+            if (!vertexQueued[b]) {
+                vertexQueued[b] = 1;
+                vertexQueue[vertexTail++ % vertexQueue.length] = b;
+            }
+            for (const index of cluesOf[e])
+                if (!clueQueued[index]) {
+                    clueQueued[index] = 1;
+                    clueQueue[clueTail++ % clueQueue.length] = index;
+                }
+        };
+        const clear = () => { vertexQueued.fill(0); clueQueued.fill(0); return false; };
+        if (decided === undefined)
+            for (let e = 0; e < edges; e += 1)
+                touch(e);
+        else
+            touch(decided);
+        for (;;) {
+            while (vertexHead < vertexTail || clueHead < clueTail) {
+                while (vertexHead < vertexTail) {
+                    const v = vertexQueue[vertexHead++ % vertexQueue.length];
+                    vertexQueued[v] = 0;
+                    const around = at[v];
+                    let on = 0, open = 0, lastOpen = -1;
+                    for (let k = 0; k < around.length; k += 1) {
+                        const e = around[k], off = alive[2 * e], onSlot = alive[2 * e + 1];
+                        if (!off && !onSlot)
+                            return clear();
+                        if (onSlot && !off)
+                            on += 1;
+                        else if (off && onSlot) {
+                            open += 1;
+                            lastOpen = e;
+                        }
+                    }
+                    if (on > 2 || on === 1 && !open)
+                        return clear();
+                    if (on === 2 && open) {
+                        for (let k = 0; k < around.length; k += 1) {
+                            const e = around[k];
+                            if (alive[2 * e] && alive[2 * e + 1]) {
+                                alive[2 * e + 1] = 0;
+                                touch(e);
+                            }
+                        }
+                    }
+                    else if (open === 1 && on < 2) {
+                        if (on === 1)
+                            alive[2 * lastOpen] = 0;
+                        else
+                            alive[2 * lastOpen + 1] = 0;
+                        touch(lastOpen);
+                    }
+                }
+                while (clueHead < clueTail) {
+                    const index = clueQueue[clueHead++ % clueQueue.length], clue = clues[index];
+                    clueQueued[index] = 0;
+                    let on = 0, open = 0;
+                    for (let k = 0; k < 4; k += 1) {
+                        const e = clue.edges[k];
+                        if (!alive[2 * e] && !alive[2 * e + 1])
+                            return clear();
+                        if (alive[2 * e + 1] && !alive[2 * e])
+                            on += 1;
+                        else if (alive[2 * e] && alive[2 * e + 1])
+                            open += 1;
+                    }
+                    if (on > clue.need || on + open < clue.need)
+                        return clear();
+                    if (open && on === clue.need) {
+                        for (let k = 0; k < 4; k += 1) {
+                            const e = clue.edges[k];
+                            if (alive[2 * e] && alive[2 * e + 1]) {
+                                alive[2 * e + 1] = 0;
+                                touch(e);
+                            }
+                        }
+                    }
+                    else if (open && on + open === clue.need) {
+                        for (let k = 0; k < 4; k += 1) {
+                            const e = clue.edges[k];
+                            if (alive[2 * e] && alive[2 * e + 1]) {
+                                alive[2 * e] = 0;
+                                touch(e);
+                            }
+                        }
+                    }
+                }
+            }
+            // Loops: join the drawn edges into pieces, then forbid an edge that would close a piece too early.
+            for (let v = 0; v < vertexCount; v += 1) {
+                parent[v] = v;
+                degree[v] = 0;
+                componentEdges[v] = 0;
+                openEnds[v] = 0;
+            }
+            let drawn = 0;
+            for (let e = 0; e < edges; e += 1) {
+                if (!(alive[2 * e + 1] && !alive[2 * e]))
+                    continue;
+                drawn += 1;
+                const a = endA[e], b = endB[e];
+                degree[a] += 1;
+                degree[b] += 1;
+                parent[find(a)] = find(b);
+            }
+            if (!drawn) {
+                // No loop yet: a fully decided empty drawing is not an answer.
+                for (let e = 0; e < edges; e += 1)
+                    if (alive[2 * e] && alive[2 * e + 1])
+                        return true;
+                return false;
+            }
+            for (let e = 0; e < edges; e += 1)
+                if (alive[2 * e + 1] && !alive[2 * e])
+                    componentEdges[find(endA[e])] += 1;
+            // Everything drawn must still be able to join up: the edges not ruled out have to connect all of it.
+            for (let v = 0; v < vertexCount; v += 1)
+                reachable[v] = v;
+            for (let e = 0; e < edges; e += 1)
+                if (alive[2 * e + 1])
+                    reachable[findIn(reachable, endA[e])] = findIn(reachable, endB[e]);
+            let anchor = -1;
+            for (let e = 0; e < edges; e += 1) {
+                if (!(alive[2 * e + 1] && !alive[2 * e]))
+                    continue;
+                const root = findIn(reachable, endA[e]);
+                if (anchor < 0)
+                    anchor = root;
+                else if (root !== anchor)
+                    return clear();
+            }
+            let ends = 0;
+            for (let v = 0; v < vertexCount; v += 1)
+                if (degree[v] === 1) {
+                    openEnds[find(v)] += 1;
+                    endList[ends++] = v;
+                }
+            let moved = false;
+            for (let v = 0; v < vertexCount; v += 1) {
+                if (degree[v] === 0 || find(v) !== v || openEnds[v])
+                    continue;
+                if (componentEdges[v] !== drawn)
+                    return clear();
+                // A finished loop is the whole answer: nothing else may be drawn.
+                for (let e = 0; e < edges; e += 1)
+                    if (alive[2 * e] && alive[2 * e + 1]) {
+                        alive[2 * e + 1] = 0;
+                        touch(e);
+                        moved = true;
+                    }
+            }
+            // An edge joining the two ends of one piece would close it.
+            for (let k = 0; k < ends; k += 1) {
+                const a = endList[k], around = at[a];
+                for (let j = 0; j < around.length; j += 1) {
+                    const e = around[j];
+                    if (!(alive[2 * e] && alive[2 * e + 1]))
+                        continue;
+                    const b = endA[e] === a ? endB[e] : endA[e];
+                    if (degree[b] !== 1 || find(a) !== find(b))
+                        continue;
+                    // Closing this edge finishes the loop: allowed only when it is the whole drawing and every number is met.
+                    let whole = componentEdges[find(a)] === drawn;
+                    if (whole) {
+                        for (const clue of clues) {
+                            let on = 0;
+                            for (let k2 = 0; k2 < 4; k2 += 1) {
+                                const x = clue.edges[k2];
+                                if (x === e || alive[2 * x + 1] && !alive[2 * x])
+                                    on += 1;
+                            }
+                            if (on !== clue.need) {
+                                whole = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (!whole) {
+                        alive[2 * e + 1] = 0;
+                        touch(e);
+                        moved = true;
+                    }
+                }
+            }
+            if (!moved)
+                return true;
+        }
+    };
+    const choose = (alive) => {
+        // Branch where the board is most pinned down: next to a loose end of the drawing, else on the numbered square with the fewest edges left.
+        let best = -1, bestScore = 99;
+        for (let v = 0; v < vertexCount; v += 1) {
+            const around = at[v];
+            let on = 0, first = -1;
+            for (let k = 0; k < around.length; k += 1) {
+                const e = around[k];
+                if (alive[2 * e + 1] && !alive[2 * e])
+                    on += 1;
+                else if (alive[2 * e] && alive[2 * e + 1] && first < 0)
+                    first = e;
+            }
+            if (first >= 0 && on === 1)
+                return first;
+        }
+        for (const clue of clues) {
+            let open = 0, first = -1;
+            for (let k = 0; k < 4; k += 1) {
+                const e = clue.edges[k];
+                if (alive[2 * e] && alive[2 * e + 1]) {
+                    open += 1;
+                    if (first < 0)
+                        first = e;
+                }
+            }
+            if (open && open < bestScore) {
+                bestScore = open;
+                best = first;
+            }
+        }
+        if (best >= 0)
+            return best;
+        for (let e = 0; e < edges; e += 1)
+            if (alive[2 * e] && alive[2 * e + 1])
+                return e;
+        return -1;
+    };
+    return { csp: { starts, propagate, choose } };
+}

package/dist/slitherlinkMount.d.ts

@@ -0,0 +1,3 @@
+import type { SlitherlinkMount, SlitherlinkMountOptions } from "./slitherlinkPlay.types.ts";
+/** Mounts an accessible dot-and-edge loop player in the given host element. */
+export declare function mountSlitherlink(host: HTMLElement, initial: SlitherlinkMountOptions): SlitherlinkMount;