@johnmorrisdotca/kazu 1.2.0 → 1.3.0

package/dist/slitherlinkSolve.js

@@ -1,6 +1,8 @@
 import { SLITHERLINK_MOST_NODES } from "./slitherlink.constants.js";
-import { checkSlitherlink, edgeVertices, isSlitherlinkBoard, slitherlinkCellEdges, slitherlinkEdgeCount, slitherlinkVertexEdges, } from "./slitherlinkBoard.js";
-/** Counts loop solutions with clue and vertex propagation under explicit work bounds. */
+import { isSlitherlinkBoard, slitherlinkEdgeCount } from "./slitherlinkBoard.js";
+import { slitherlinkModel } from "./slitherlinkLogic.js";
+import { openSlots, solveCsp } from "./csp.js";
+/** Counts loop solutions with the pruning in `slitherlinkLogic.ts` under explicit work bounds. */
 export function solveSlitherlink(board, options = {}) {
     if (!isSlitherlinkBoard(board))
         throw new RangeError("Invalid Slitherlink board");
@@ -9,119 +11,9 @@ export function solveSlitherlink(board, options = {}) {
     if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1) {
         throw new RangeError("Invalid search bounds");
     }
-    const edgeCount = slitherlinkEdgeCount(board);
-    const vertices = Array.from({ length: (board.width + 1) * (board.height + 1) }, (_, vertex) => slitherlinkVertexEdges(board, vertex));
-    const cells = board.clues.flatMap((clue, cell) => clue === null ? [] : [slitherlinkCellEdges(board, cell)]);
-    let count = 0;
-    let nodes = 0;
-    let complete = true;
-    let solution = null;
-    const search = (start) => {
-        if (!complete)
-            return;
-        nodes += 1;
-        if (nodes > budget) {
-            complete = false;
-            return;
-        }
-        const state = start.slice();
-        let changed = true;
-        while (changed) {
-            changed = false;
-            for (const group of vertices) {
-                const on = group.filter(edge => state[edge] === 1).length;
-                const unknown = group.filter(edge => state[edge] < 0);
-                if (on > 2 || on === 1 && !unknown.length)
-                    return;
-                if (on === 2) {
-                    for (const edge of unknown) {
-                        state[edge] = 0;
-                        changed = true;
-                    }
-                }
-                else if (on === 1 && unknown.length === 1) {
-                    state[unknown[0]] = 1;
-                    changed = true;
-                }
-                else if (on === 0 && unknown.length === 1) {
-                    state[unknown[0]] = 0;
-                    changed = true;
-                }
-            }
-            let clueIndex = 0;
-            for (const clue of board.clues) {
-                if (clue === null)
-                    continue;
-                const group = cells[clueIndex++];
-                const on = group.filter(edge => state[edge] === 1).length;
-                const unknown = group.filter(edge => state[edge] < 0);
-                if (on > clue || on + unknown.length < clue)
-                    return;
-                if (on === clue) {
-                    for (const edge of unknown) {
-                        state[edge] = 0;
-                        changed = true;
-                    }
-                }
-                else if (on + unknown.length === clue) {
-                    for (const edge of unknown) {
-                        state[edge] = 1;
-                        changed = true;
-                    }
-                }
-            }
-        }
-        const selected = Array.from(state).flatMap((value, edge) => value === 1 ? [edge] : []);
-        const closed = closedComponents(board, selected);
-        if (closed.length > 1)
-            return;
-        if (closed.length === 1 && closed[0].length !== selected.length)
-            return;
-        const branch = state.findIndex(value => value < 0);
-        if (branch < 0) {
-            if (!checkSlitherlink(board, selected).ok)
-                return;
-            count += 1;
-            solution ?? (solution = selected);
-            if (count >= limit)
-                complete = false;
-            return;
-        }
-        for (const value of [1, 0]) {
-            const next = state.slice();
-            next[branch] = value;
-            search(next);
-            if (!complete)
-                return;
-        }
-    };
-    search(new Int8Array(edgeCount).fill(-1));
-    return { count, solution, complete, nodes };
-}
-function closedComponents(board, selected) {
-    const unseen = new Set(selected);
-    const components = [];
-    while (unseen.size) {
-        const first = unseen.values().next().value;
-        const component = [first];
-        const queue = [first];
-        unseen.delete(first);
-        while (queue.length) {
-            const edge = queue.pop();
-            for (const vertex of edgeVertices(board, edge)) {
-                for (const adjacent of slitherlinkVertexEdges(board, vertex)) {
-                    if (!unseen.has(adjacent))
-                        continue;
-                    unseen.delete(adjacent);
-                    component.push(adjacent);
-                    queue.push(adjacent);
-                }
-            }
-        }
-        const vertices = new Set(component.flatMap(edge => edgeVertices(board, edge)));
-        if ([...vertices].every(vertex => slitherlinkVertexEdges(board, vertex)
-            .filter(edge => component.includes(edge)).length === 2))
-            components.push(component);
-    }
-    return components;
+    const { csp } = slitherlinkModel(board);
+    const found = solveCsp(csp, openSlots(csp), limit, budget);
+    const edges = slitherlinkEdgeCount(board);
+    const solution = found.solution ? Array.from({ length: edges }, (_, edge) => edge).filter(edge => found.solution[2 * edge + 1] === 1) : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
 }

package/dist/slitherlinkTemplate.d.ts

@@ -0,0 +1,3 @@
+import type { SlitherlinkPuzzle } from "./slitherlink.types.ts";
+/** The first generator, kept as the fallback that cannot fail: a proved puzzle from a seeded rectangle or L-shaped tile-region loop. */
+export declare function templateSlitherlink(width?: number, height?: number, seed?: number): Omit<SlitherlinkPuzzle, "level">;

package/dist/slitherlinkTemplate.js

@@ -0,0 +1,101 @@
+import { SLITHERLINK_MOST_SIDE } from "./slitherlink.constants.js";
+import { checkSlitherlink, isSlitherlinkBoard, slitherlinkCellEdges, } from "./slitherlinkBoard.js";
+import { solveSlitherlink } from "./slitherlinkSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/** The first generator, kept as the fallback that cannot fail: a proved puzzle from a seeded rectangle or L-shaped tile-region loop. */
+export function templateSlitherlink(width = 5, height = width, seed = 1) {
+    if (![width, height].every(side => Number.isInteger(side) && side >= 2 && side <= SLITHERLINK_MOST_SIDE)
+        || !isKazuSeed(seed))
+        throw new RangeError("Invalid Slitherlink settings");
+    const random = seededRandom(seed);
+    const useL = width >= 3 && height >= 3 && random() < .5;
+    const region = [];
+    let x0;
+    let y0;
+    let blockWidth;
+    let blockHeight;
+    if (useL) {
+        blockWidth = 2 + Math.floor(random() * (width - 1));
+        blockHeight = 2 + Math.floor(random() * (height - 1));
+        x0 = Math.floor(random() * (width - blockWidth + 1));
+        y0 = Math.floor(random() * (height - blockHeight + 1));
+        for (let y = 0; y < blockHeight; y += 1) {
+            for (let x = 0; x < blockWidth; x += 1) {
+                if (x === 0 || y === 0)
+                    region.push((y0 + y) * width + x0 + x);
+            }
+        }
+    }
+    else {
+        blockWidth = 1 + Math.floor(random() * width);
+        blockHeight = 1 + Math.floor(random() * height);
+        if (blockWidth === 1 && blockHeight === 1)
+            blockWidth = 2;
+        x0 = Math.floor(random() * (width - blockWidth + 1));
+        y0 = Math.floor(random() * (height - blockHeight + 1));
+        for (let y = 0; y < blockHeight; y += 1) {
+            for (let x = 0; x < blockWidth; x += 1)
+                region.push((y0 + y) * width + x0 + x);
+        }
+    }
+    const blank = { width, height, clues: Array(width * height).fill(null) };
+    const regionSet = new Set(region);
+    const edges = new Set();
+    for (const cell of region) {
+        const [top, right, bottom, left] = slitherlinkCellEdges(blank, cell);
+        const x = cell % width;
+        if (!regionSet.has(cell - width))
+            edges.add(top);
+        if (x === width - 1 || !regionSet.has(cell + 1))
+            edges.add(right);
+        if (!regionSet.has(cell + width))
+            edges.add(bottom);
+        if (x === 0 || !regionSet.has(cell - 1))
+            edges.add(left);
+    }
+    let board = {
+        width,
+        height,
+        clues: Array.from({ length: width * height }, (_, cell) => slitherlinkCellEdges(blank, cell).filter(edge => edges.has(edge)).length),
+    };
+    let answer = [...edges];
+    // Seeded axis reflections give each selected shape more than one orientation.
+    const reflectX = random() < .5;
+    const reflectY = random() < .5;
+    if (reflectX || reflectY) {
+        const horizontalCount = width * (height + 1);
+        const mapEdge = (edge) => {
+            if (edge < horizontalCount) {
+                const x = edge % width;
+                const y = Math.floor(edge / width);
+                const nextX = reflectX ? width - 1 - x : x;
+                const nextY = reflectY ? height - y : y;
+                return nextY * width + nextX;
+            }
+            const local = edge - horizontalCount;
+            const x = local % (width + 1);
+            const y = Math.floor(local / (width + 1));
+            const nextX = reflectX ? width - x : x;
+            const nextY = reflectY ? height - 1 - y : y;
+            return horizontalCount + nextY * (width + 1) + nextX;
+        };
+        const reflected = Array(width * height).fill(null);
+        board.clues.forEach((clue, cell) => {
+            const x = cell % width;
+            const y = Math.floor(cell / width);
+            const nextX = reflectX ? width - 1 - x : x;
+            const nextY = reflectY ? height - 1 - y : y;
+            reflected[nextY * width + nextX] = clue;
+        });
+        board = { width, height, clues: reflected };
+        answer = answer.map(mapEdge);
+    }
+    if (!isSlitherlinkBoard(board) || !checkSlitherlink(board, answer).ok) {
+        throw new Error("Unable to construct Slitherlink loop");
+    }
+    const proof = solveSlitherlink(board, { limit: 2 });
+    if (!proof.complete || proof.count !== 1 || !proof.solution) {
+        throw new Error("No uniquely solvable Slitherlink found within the generation budget");
+    }
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version. */
-export declare const VERSION = "1.2.0";
+export declare const VERSION = "1.3.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version. */
-export const VERSION = "1.2.0";
+export const VERSION = "1.3.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kazu",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Grid number and logic puzzles for JavaScript and TypeScript: Sudoku and its variants, Futoshiki, Skyscrapers, Shikaku, Hitori, Nurikabe, Akari, Juosan, Slitherlink, Masyu, Yajilin, Ripple Effect, Kakuro, Fillomino and Heyawake. Dedicated typed engines, independently checked puzzles, SVG boards and bilingual touch and keyboard players. Zero runtime dependencies.",
   "keywords": [
     "puzzle",