@johnmorrisdotca/kazu 1.1.0 → 1.2.0

package/dist/akariBoard.js

@@ -0,0 +1,96 @@
+import { AKARI_MOST_SIDE } from "./akari.constants.js";
+/** Validates dimensions and the three public square kinds. */
+export function isAkariBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    return Number.isInteger(board.width) && board.width >= 2 && board.width <= AKARI_MOST_SIDE
+        && Number.isInteger(board.height) && board.height >= 2 && board.height <= AKARI_MOST_SIDE
+        && Array.isArray(board.cells) && board.cells.length === board.width * board.height
+        && board.cells.every(cell => cell === null || cell === false
+            || Number.isInteger(cell) && cell >= 0 && cell <= 4)
+        && board.cells.some(cell => cell === null);
+}
+/** Returns the orthogonally adjacent cells to a board position. */
+export function akariNeighbours(board, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= board.cells.length)
+        return [];
+    const x = cell % board.width;
+    const y = Math.floor(cell / board.width);
+    const coordinates = [[x, y - 1], [x + 1, y], [x, y + 1], [x - 1, y]];
+    return coordinates
+        .filter(([cx, cy]) => cx >= 0 && cx < board.width && cy >= 0 && cy < board.height)
+        .map(([cx, cy]) => cy * board.width + cx);
+}
+/** White squares visible from a cell, including itself, stopping at black squares and edges. */
+export function akariVisible(board, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= board.cells.length || board.cells[cell] !== null)
+        return [];
+    const x = cell % board.width;
+    const y = Math.floor(cell / board.width);
+    const visible = [cell];
+    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+        let cx = x + dx;
+        let cy = y + dy;
+        while (cx >= 0 && cx < board.width && cy >= 0 && cy < board.height) {
+            const next = cy * board.width + cx;
+            if (board.cells[next] !== null)
+                break;
+            visible.push(next);
+            cx += dx;
+            cy += dy;
+        }
+    }
+    return visible;
+}
+function evaluate(board, bulbs, complete) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    const errors = [];
+    const conflicts = [];
+    const numbered = [];
+    const dark = [];
+    const unique = new Set();
+    bulbs.forEach((cell, index) => {
+        if (!Number.isInteger(cell) || cell < 0 || cell >= board.cells.length
+            || board.cells[cell] !== null || unique.has(cell)) {
+            errors.push(index);
+        }
+        else {
+            unique.add(cell);
+        }
+    });
+    const lit = new Set();
+    for (const bulb of unique) {
+        const ray = akariVisible(board, bulb);
+        ray.forEach(cell => lit.add(cell));
+        if (ray.some(cell => cell !== bulb && unique.has(cell)))
+            conflicts.push(bulb);
+    }
+    for (let cell = 0; cell < board.cells.length; cell += 1) {
+        if (board.cells[cell] === null && !lit.has(cell))
+            dark.push(cell);
+        const clue = board.cells[cell];
+        if (typeof clue !== "number")
+            continue;
+        const adjacent = akariNeighbours(board, cell).filter(neighbour => unique.has(neighbour)).length;
+        if (complete ? adjacent !== clue : adjacent > clue)
+            numbered.push(cell);
+    }
+    return {
+        ok: !errors.length && !conflicts.length && !numbered.length && (!complete || !dark.length),
+        illuminated: lit.size,
+        errors,
+        dark,
+        numbered,
+        conflicts,
+    };
+}
+/** Checks a complete placement from the public rules, without consulting a stored answer. */
+export function checkAkari(board, bulbs) {
+    return evaluate(board, bulbs, true);
+}
+/** Reports immediate contradictions while allowing required clues to remain unsatisfied during play. */
+export function progressAkari(board, bulbs) {
+    return evaluate(board, bulbs, false);
+}

package/dist/akariDraw.d.ts

@@ -0,0 +1,4 @@
+import type { AkariBoard } from "./akari.types.ts";
+import type { AkariDrawOptions } from "./akariPlay.types.ts";
+/** Draws the public clues and current bulbs as SVG. */
+export declare function drawAkari(board: AkariBoard, options?: AkariDrawOptions): string;

package/dist/akariDraw.js

@@ -0,0 +1,38 @@
+import { akariVisible, isAkariBoard } from "./akariBoard.js";
+import { akariWords } from "./akariStrings.js";
+/** Draws the public clues and current bulbs as SVG. */
+export function drawAkari(board, options = {}) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    const words = akariWords(options.language);
+    const size = 48;
+    const palettes = {
+        ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)", "#252923"],
+        wood: ["#e5cda6", "#493e2f", "#bca582", "#493e2f"],
+        slate: ["#262a27", "#ece8dc", "#454a44", "#111412"],
+    };
+    const [paper, ink, grid, black] = palettes[options.material ?? "ivory"];
+    const bulbs = new Set(options.bulbs ?? []);
+    const lit = new Set();
+    bulbs.forEach(cell => akariVisible(board, cell).forEach(illuminated => lit.add(illuminated)));
+    const cells = board.cells.map((clue, cell) => {
+        const x = cell % board.width * size;
+        const y = Math.floor(cell / board.width) * size;
+        const active = cell === options.selected;
+        const bad = options.errors?.includes(cell);
+        const bulb = bulbs.has(cell)
+            ? `${options.pieces === "tiles" ? `<rect x="${x + 10}" y="${y + 10}" width="28" height="28" rx="6" fill="${paper}" stroke="${grid}"/>` : ""}
+          <circle cx="${x + 24}" cy="${y + 24}" r="11" fill="${ink}"/>
+          <path d="M${x + 18} ${y + 31}h12m-10 4h8" stroke="${ink}" stroke-width="2"/>`
+            : "";
+        const body = clue === null
+            ? `<rect x="${x}" y="${y}" width="48" height="48" fill="${lit.has(cell) ? paper : "var(--kz-grid,#cfc6b2)"}" fill-opacity=".95"/>${bulb}`
+            : `<rect x="${x}" y="${y}" width="48" height="48" fill="${black}"/>${typeof clue === "number"
+                ? `<text x="${x + 24}" y="${y + 25}" dominant-baseline="middle" text-anchor="middle" fill="${paper}" font-size="21" font-weight="700" font-family="system-ui,sans-serif">${clue}</text>`
+                : ""}`;
+        const stroke = bad ? "var(--kz-bad,#b5452c)" : grid;
+        const strokeWidth = bad ? 3 : 1;
+        return `<g data-akari-cell="${cell}">${body}<rect x="${x}" y="${y}" width="48" height="48" fill="${active ? ink : "transparent"}" fill-opacity="${active ? ".16" : "1"}" stroke="${stroke}" stroke-width="${strokeWidth}"/></g>`;
+    }).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -2 ${board.width * size + 4} ${board.height * size + 4}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${cells}<rect width="${board.width * size}" height="${board.height * size}" fill="none" stroke="var(--kz-frame,#a98954)" stroke-width="2"/></svg>`;
+}

package/dist/akariGame.d.ts

@@ -0,0 +1,15 @@
+import type { AkariBoard, AkariGame } from "./akari.types.ts";
+/** Starts a game with only its public board data. */
+export declare function newAkari(board: AkariBoard): AkariGame;
+/** Toggles a bulb on a white square and keeps one prior turn for undo. */
+export declare function toggleAkari(game: AkariGame, cell: number): AkariGame;
+/** Restores the last bulb placement. */
+export declare function undoAkari(game: AkariGame): AkariGame;
+/** A game is finished only when its bulbs satisfy every rule and light every white square. */
+export declare function akariFinished(game: AkariGame): boolean;
+/** Returns a missing bulb, or an extra bulb to remove, only after uniqueness is proved. */
+export declare function hintAkari(game: AkariGame): number | null;
+/** Encodes only public clues and player placements. */
+export declare function encodeAkari(game: AkariGame): string;
+/** Decodes a bounded save after validating the board and each placement. */
+export declare function decodeAkari(code: string): AkariGame | null;

package/dist/akariGame.js

@@ -0,0 +1,71 @@
+import { checkAkari, isAkariBoard } from "./akariBoard.js";
+import { solveAkari } from "./akariSolve.js";
+/** Starts a game with only its public board data. */
+export function newAkari(board) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    return {
+        board: { width: board.width, height: board.height, cells: [...board.cells] },
+        bulbs: [],
+        history: [],
+        helped: false,
+    };
+}
+/** Toggles a bulb on a white square and keeps one prior turn for undo. */
+export function toggleAkari(game, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.board.cells.length || game.board.cells[cell] !== null) {
+        return game;
+    }
+    const bulbs = game.bulbs.includes(cell)
+        ? game.bulbs.filter(placed => placed !== cell)
+        : [...game.bulbs, cell];
+    return { ...game, bulbs, history: [...game.history, [...game.bulbs]] };
+}
+/** Restores the last bulb placement. */
+export function undoAkari(game) {
+    const previous = game.history.at(-1);
+    return previous
+        ? { ...game, bulbs: [...previous], history: game.history.slice(0, -1) }
+        : game;
+}
+/** A game is finished only when its bulbs satisfy every rule and light every white square. */
+export function akariFinished(game) {
+    return checkAkari(game.board, game.bulbs).ok;
+}
+/** Returns a missing bulb, or an extra bulb to remove, only after uniqueness is proved. */
+export function hintAkari(game) {
+    const solved = solveAkari(game.board);
+    if (!solved.complete || solved.count !== 1 || !solved.solution)
+        return null;
+    return solved.solution.find(cell => !game.bulbs.includes(cell))
+        ?? game.bulbs.find(cell => !solved.solution.includes(cell))
+        ?? null;
+}
+/** Encodes only public clues and player placements. */
+export function encodeAkari(game) {
+    return JSON.stringify({ version: 1, board: game.board, bulbs: game.bulbs, helped: game.helped });
+}
+/** Decodes a bounded save after validating the board and each placement. */
+export function decodeAkari(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isAkariBoard(value.board) || !Array.isArray(value.bulbs)
+            || value.bulbs.length > value.board.cells.length || typeof value.helped !== "boolean")
+            return null;
+        if (new Set(value.bulbs).size !== value.bulbs.length)
+            return null;
+        let game = newAkari(value.board);
+        for (const cell of value.bulbs) {
+            const next = toggleAkari(game, cell);
+            if (next === game)
+                return null;
+            game = next;
+        }
+        return { ...game, history: [], helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/akariGenerate.d.ts

@@ -0,0 +1,7 @@
+import type { AkariPuzzle } from "./akari.types.ts";
+/**
+ * Makes a seeded board from two original room-grid families: horizontal or vertical paired
+ * corridors, with isolated singleton rooms at the edges. Seeded bulb direction and reflections
+ * vary each layout. Generation returns only after the independent counter proves uniqueness.
+ */
+export declare function generateAkari(width?: number, height?: number, seed?: number): AkariPuzzle;

package/dist/akariGenerate.js

@@ -0,0 +1,78 @@
+import { AKARI_MOST_SIDE } from "./akari.constants.js";
+import { checkAkari, isAkariBoard } from "./akariBoard.js";
+import { solveAkari } from "./akariSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/**
+ * Makes a seeded board from two original room-grid families: horizontal or vertical paired
+ * corridors, with isolated singleton rooms at the edges. Seeded bulb direction and reflections
+ * vary each layout. Generation returns only after the independent counter proves uniqueness.
+ */
+export function generateAkari(width = 7, height = width, seed = 1) {
+    if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= AKARI_MOST_SIDE)
+        || !isKazuSeed(seed))
+        throw new RangeError("Invalid Akari settings");
+    const random = seededRandom(seed);
+    const cells = Array(width * height).fill(false);
+    const bulbs = [];
+    const horizontal = random() < .5;
+    if (horizontal) {
+        const firstRow = height > 2 ? 1 : 0;
+        for (let y = firstRow; y < height; y += 3) {
+            const clueY = y > 0 ? y - 1 : y + 1;
+            for (let x = 0; x < width; x += 3) {
+                const room = y * width + x;
+                if (x + 1 < width) {
+                    const bulbX = random() < .5 ? x : x + 1;
+                    cells[room] = null;
+                    cells[room + 1] = null;
+                    cells[clueY * width + bulbX] = 1;
+                    bulbs.push(y * width + bulbX);
+                }
+                else {
+                    cells[room] = null;
+                    cells[clueY * width + x] = 1;
+                    bulbs.push(room);
+                }
+            }
+        }
+    }
+    else {
+        const firstColumn = width > 2 ? 1 : 0;
+        for (let x = firstColumn; x < width; x += 3) {
+            const clueX = x > 0 ? x - 1 : x + 1;
+            for (let y = 0; y < height; y += 3) {
+                const room = y * width + x;
+                if (y + 1 < height) {
+                    const bulbY = random() < .5 ? y : y + 1;
+                    cells[room] = null;
+                    cells[room + width] = null;
+                    cells[bulbY * width + clueX] = 1;
+                    bulbs.push(bulbY * width + x);
+                }
+                else {
+                    cells[room] = null;
+                    cells[y * width + clueX] = 1;
+                    bulbs.push(room);
+                }
+            }
+        }
+    }
+    // Reflections are applied to the board and the construction answer together.
+    const reflectX = random() < .5, reflectY = random() < .5;
+    const original = [...cells];
+    const map = (cell) => {
+        const x = cell % width, y = Math.floor(cell / width);
+        return (reflectY ? height - 1 - y : y) * width + (reflectX ? width - 1 - x : x);
+    };
+    for (let cell = 0; cell < original.length; cell += 1)
+        cells[map(cell)] = original[cell];
+    const answer = bulbs.map(map);
+    const board = { width, height, cells };
+    if (!isAkariBoard(board) || !checkAkari(board, answer).ok)
+        throw new Error("Unable to construct Akari puzzle");
+    const proof = solveAkari(board, { limit: 2 });
+    if (!proof.complete || proof.count !== 1 || !proof.solution) {
+        throw new Error("No uniquely solvable Akari found within the generation budget");
+    }
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/akariMount.d.ts

@@ -0,0 +1,3 @@
+import type { AkariMount, AkariMountOptions } from "./akariPlay.types.ts";
+/** Mounts the player in a host element; call destroy when the host is removed. */
+export declare function mountAkari(host: HTMLElement, initial: AkariMountOptions): AkariMount;

package/dist/akariMount.js

@@ -0,0 +1,214 @@
+import { akariVisible, checkAkari } from "./akariBoard.js";
+import { akariFinished, decodeAkari, encodeAkari, hintAkari, newAkari, toggleAkari, undoAkari, } from "./akariGame.js";
+import { drawAkari } from "./akariDraw.js";
+import { KAZU_STYLE } from "./style.js";
+import { AKARI_PLAY_STYLE } from "./akariStyle.js";
+import { akariWords } from "./akariStrings.js";
+/** Mounts the player in a host element; call destroy when the host is removed. */
+export function mountAkari(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial };
+    let game = initial.progress ? decodeAkari(initial.progress) : null;
+    game ?? (game = newAkari(initial.board));
+    let selected = game.board.cells.findIndex(cell => cell === null);
+    let errors = [];
+    let message = "";
+    let finished = akariFinished(game);
+    let dead = false;
+    const root = doc.createElement("div");
+    const style = doc.createElement("style");
+    const board = doc.createElement("div");
+    const status = doc.createElement("p");
+    const tools = doc.createElement("div");
+    const help = doc.createElement("p");
+    root.className = "ka-root";
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".ka-palette") + AKARI_PLAY_STYLE;
+    board.className = "ka-board";
+    status.className = "ka-status";
+    status.setAttribute("role", "status");
+    tools.className = "ka-tools";
+    help.className = "ka-help";
+    root.append(style, board, status, tools, help);
+    host.append(root);
+    const copy = () => ({
+        ...game,
+        board: { ...game.board, cells: [...game.board.cells] },
+        bulbs: [...game.bulbs],
+        history: game.history.map(turn => [...turn]),
+    });
+    const words = () => akariWords(options.language);
+    const button = (label, action, disabled = false) => {
+        const control = doc.createElement("button");
+        control.type = "button";
+        control.textContent = label;
+        control.disabled = disabled;
+        control.onclick = action;
+        tools.append(control);
+    };
+    const changed = () => {
+        errors = [];
+        message = "";
+        const won = akariFinished(game);
+        render();
+        options.onChange?.(copy());
+        root.dispatchEvent(new CustomEvent("akari-change", { detail: copy(), bubbles: true }));
+        if (won && !finished) {
+            options.onFinish?.(copy());
+            root.dispatchEvent(new CustomEvent("akari-finish", { detail: copy(), bubbles: true }));
+        }
+        finished = won;
+    };
+    const toggle = (cell) => {
+        if (finished || game.board.cells[cell] !== null)
+            return;
+        selected = cell;
+        game = toggleAkari(game, cell);
+        changed();
+    };
+    const restart = () => {
+        game = newAkari(game.board);
+        finished = false;
+        selected = game.board.cells.findIndex(cell => cell === null);
+        changed();
+    };
+    const render = () => {
+        if (dead)
+            return;
+        const w = words();
+        const current = game.board;
+        const focused = board.contains(doc.activeElement);
+        const check = checkAkari(current, game.bulbs);
+        board.classList.toggle("ka-palette", (options.material ?? "ivory") === "ivory");
+        board.innerHTML = drawAkari(current, { ...options, bulbs: game.bulbs, selected, errors });
+        const cells = doc.createElement("div");
+        cells.className = "ka-cells";
+        cells.setAttribute("role", "grid");
+        cells.style.gridTemplateColumns = `repeat(${current.width},1fr)`;
+        for (let cellIndex = 0; cellIndex < current.cells.length; cellIndex += 1) {
+            const white = current.cells[cellIndex] === null;
+            const bulb = game.bulbs.includes(cellIndex);
+            const lit = white && game.bulbs.some(on => akariVisible(current, on).includes(cellIndex));
+            const control = doc.createElement("button");
+            const row = Math.floor(cellIndex / current.width) + 1;
+            const column = cellIndex % current.width + 1;
+            control.type = "button";
+            control.className = "ka-cell";
+            control.dataset.cell = String(cellIndex);
+            control.tabIndex = white && cellIndex === selected ? 0 : -1;
+            control.disabled = !white;
+            control.setAttribute("role", "gridcell");
+            control.setAttribute("aria-pressed", String(bulb));
+            control.setAttribute("aria-label", cellLabel(w, current.cells[cellIndex], row, column, lit, bulb, white));
+            control.onclick = () => toggle(cellIndex);
+            control.onkeydown = event => handleKey(event, cellIndex, current.width, current.cells);
+            cells.append(control);
+        }
+        board.append(cells);
+        if (focused)
+            board.querySelector(`[data-cell="${selected}"]`)?.focus();
+        status.textContent = check.ok ? (game.helped ? w.helped : w.won) : message || w.checked;
+        help.textContent = w.help;
+        tools.replaceChildren();
+        button(w.undo, () => {
+            game = undoAkari(game);
+            finished = akariFinished(game);
+            changed();
+        }, !game.history.length);
+        button(w.check, () => {
+            errors = [...new Set([...check.dark, ...check.numbered, ...check.conflicts])];
+            message = check.ok ? w.won : w.wrong;
+            render();
+        });
+        button(w.hint, () => {
+            const cell = hintAkari(game);
+            if (cell === null) {
+                message = w.noHint;
+                render();
+                return;
+            }
+            game = { ...toggleAkari(game, cell), helped: true };
+            changed();
+            message = w.hintWhy;
+            render();
+        }, finished);
+        button(w.restart, restart);
+        button(w.expand, expand);
+    };
+    function cellLabel(w, value, row, column, lit, bulb, white) {
+        const position = `${w.row} ${row}, ${w.column} ${column}`;
+        if (!white)
+            return `${position}: ${w.black}${typeof value === "number" && value ? ` ${value}` : ""}`;
+        return `${position}: ${w.white}${lit ? `, ${w.lit}` : `, ${w.dark}`}${bulb ? `, ${w.bulb}` : ""}`;
+    }
+    function handleKey(event, cell, width, values) {
+        const steps = {
+            ArrowLeft: -1,
+            ArrowRight: 1,
+            ArrowUp: -width,
+            ArrowDown: width,
+        };
+        if (event.key in steps) {
+            event.preventDefault();
+            const delta = steps[event.key];
+            let next = cell;
+            while (true) {
+                const candidate = next + delta;
+                if (candidate < 0 || candidate >= values.length)
+                    break;
+                if (Math.abs(delta) === 1 && Math.floor(candidate / width) !== Math.floor(next / width))
+                    break;
+                next = candidate;
+                if (values[next] === null)
+                    break;
+            }
+            if (values[next] === null) {
+                selected = next;
+                render();
+            }
+        }
+        else if (event.key === "Enter" || event.key === " ") {
+            event.preventDefault();
+            toggle(cell);
+        }
+        else if (event.key === "Delete" || event.key === "Backspace") {
+            event.preventDefault();
+            if (game.bulbs.includes(cell))
+                toggle(cell);
+        }
+    }
+    function expand() {
+        if (root.parentElement !== host)
+            return;
+        const dialog = doc.createElement("dialog");
+        const close = doc.createElement("button");
+        dialog.className = "ka-dialog";
+        close.className = "ka-close";
+        close.textContent = words().close;
+        close.onclick = () => dialog.close();
+        dialog.append(close, root);
+        host.append(dialog);
+        dialog.onclose = () => {
+            host.append(root);
+            dialog.remove();
+        };
+        dialog.showModal();
+    }
+    render();
+    return {
+        game: copy,
+        progress: () => encodeAkari(game),
+        restart,
+        set: (next) => {
+            if (next.language && next.language !== options.language)
+                message = "";
+            options = { ...options, ...next };
+            render();
+        },
+        destroy: () => {
+            dead = true;
+            const dialog = root.closest("dialog");
+            root.remove();
+            dialog?.remove();
+        },
+    };
+}

package/dist/akariPlay.types.d.ts

@@ -0,0 +1,25 @@
+import type { AkariBoard, AkariGame } from "./akari.types.ts";
+export type AkariMaterial = "ivory" | "wood" | "slate";
+export type AkariPieces = "ink" | "tiles";
+export type AkariLanguage = "en" | "ja";
+export type AkariDrawOptions = {
+    bulbs?: AkariGame["bulbs"];
+    selected?: number | null;
+    errors?: readonly number[];
+    material?: AkariMaterial;
+    pieces?: AkariPieces;
+    language?: AkariLanguage;
+};
+export type AkariMountOptions = AkariDrawOptions & {
+    board: AkariBoard;
+    progress?: string;
+    onChange?: (game: AkariGame) => void;
+    onFinish?: (game: AkariGame) => void;
+};
+export type AkariMount = {
+    game: () => AkariGame;
+    progress: () => string;
+    set: (options: AkariDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/akariPlay.types.js

@@ -0,0 +1 @@
+export {};

package/dist/akariSolve.d.ts

@@ -0,0 +1,6 @@
+import type { AkariBoard, AkariSolve } from "./akari.types.ts";
+/** Bounded binary constraint search; a stopped proof is always marked incomplete. */
+export declare function solveAkari(board: AkariBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): AkariSolve;