@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/yajilin-play-entry.d.ts

@@ -0,0 +1,4 @@
+export { mountYajilin } from "./yajilinMount.ts";
+export { YAJILIN_PLAY_STYLE } from "./yajilinStyle.ts";
+export { YAJILIN_STRINGS } from "./yajilinStrings.ts";
+export type * from "./yajilinPlay.types.ts";

package/dist/yajilin-play-entry.js

@@ -0,0 +1,3 @@
+export { mountYajilin } from "./yajilinMount.js";
+export { YAJILIN_PLAY_STYLE } from "./yajilinStyle.js";
+export { YAJILIN_STRINGS } from "./yajilinStrings.js";

package/dist/yajilin.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const YAJILIN_SIZES: readonly [5, 7];
+export declare const YAJILIN_NODE_BUDGET = 250000;

package/dist/yajilin.constants.js

@@ -0,0 +1,2 @@
+export const YAJILIN_SIZES = [5, 7];
+export const YAJILIN_NODE_BUDGET = 250000;

package/dist/yajilin.types.d.ts

@@ -0,0 +1,63 @@
+export type YajilinDirection = "up" | "right" | "down" | "left";
+export type YajilinClue = {
+    direction: YajilinDirection;
+    count: number;
+};
+export type YajilinBoard = {
+    width: number;
+    height: number;
+    clues: readonly (YajilinClue | null)[];
+};
+export type YajilinPuzzle = YajilinBoard & {
+    seed: number;
+    solution: {
+        shaded: readonly boolean[];
+        edges: readonly number[];
+    };
+};
+export type YajilinCheck = {
+    ok: boolean;
+    errors: readonly number[];
+};
+export type YajilinSolution = {
+    shaded: readonly boolean[];
+    edges: readonly number[];
+};
+export type YajilinSolve = {
+    count: number;
+    solution: YajilinSolution | null;
+    complete: boolean;
+    nodes: number;
+};
+export type YajilinGame = {
+    board: YajilinBoard;
+    shaded: readonly boolean[];
+    edges: readonly number[];
+    history: readonly {
+        shaded: readonly boolean[];
+        edges: readonly number[];
+    }[];
+    helped: boolean;
+};
+export type YajilinDrawOptions = {
+    shaded?: readonly boolean[];
+    edges?: readonly number[];
+    selected?: number;
+    errors?: readonly number[];
+    material?: "ivory" | "wood" | "slate";
+    pieces?: "plain" | "tiles";
+    language?: "en" | "ja";
+};
+export type YajilinMountOptions = YajilinDrawOptions & {
+    board: YajilinBoard;
+    progress?: string;
+    onChange?: (game: YajilinGame) => void;
+    onFinish?: (game: YajilinGame) => void;
+};
+export type YajilinMount = {
+    game: () => YajilinGame;
+    progress: () => string;
+    set: (options: YajilinDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/yajilin.types.js

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

package/dist/yajilinBoard.d.ts

@@ -0,0 +1,9 @@
+import type { YajilinBoard, YajilinCheck, YajilinDirection } from "./yajilin.types.ts";
+export declare const yajilinEdgeCount: (board: YajilinBoard) => number;
+export declare function isYajilinBoard(value: unknown): value is YajilinBoard;
+export declare function yajilinNeighbors(board: YajilinBoard, cell: number): {
+    cell: number;
+    edge: number;
+}[];
+export declare function checkYajilin(board: YajilinBoard, shaded: readonly boolean[], lines: readonly number[]): YajilinCheck;
+export declare function yajilinRay(board: YajilinBoard, cell: number, direction: YajilinDirection): number[];

package/dist/yajilinBoard.js

@@ -0,0 +1,91 @@
+import { YAJILIN_SIZES } from "./yajilin.constants.js";
+const directionDelta = { up: [0, -1], right: [1, 0], down: [0, 1], left: [-1, 0] };
+export const yajilinEdgeCount = (board) => board.height * (board.width - 1) + board.width * (board.height - 1);
+export function isYajilinBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    if (!YAJILIN_SIZES.includes(board.width) || board.width !== board.height
+        || !Array.isArray(board.clues) || board.clues.length !== board.width * board.height)
+        return false;
+    return board.clues.every(clue => clue === null || (!!clue && typeof clue === "object"
+        && Object.hasOwn(directionDelta, clue.direction) && Number.isInteger(clue.count) && clue.count >= 0 && clue.count < board.width));
+}
+export function yajilinNeighbors(board, cell) {
+    const x = cell % board.width, y = Math.floor(cell / board.width), horizontal = board.height * (board.width - 1), result = [];
+    if (y > 0)
+        result.push({ cell: cell - board.width, edge: horizontal + (y - 1) * board.width + x });
+    if (x < board.width - 1)
+        result.push({ cell: cell + 1, edge: y * (board.width - 1) + x });
+    if (y < board.height - 1)
+        result.push({ cell: cell + board.width, edge: horizontal + y * board.width + x });
+    if (x > 0)
+        result.push({ cell: cell - 1, edge: y * (board.width - 1) + x - 1 });
+    return result;
+}
+function ray(board, cell, direction) {
+    const [dx, dy] = directionDelta[direction], cells = [];
+    let x = cell % board.width + dx, y = Math.floor(cell / board.width) + dy;
+    while (x >= 0 && x < board.width && y >= 0 && y < board.height) {
+        cells.push(y * board.width + x);
+        x += dx;
+        y += dy;
+    }
+    return cells;
+}
+export function checkYajilin(board, shaded, lines) {
+    if (!isYajilinBoard(board))
+        throw new RangeError("Invalid Yajilin board");
+    const size = board.width, total = size * size, edges = new Set(lines), errors = new Set();
+    if (shaded.length !== total || !shaded.every(value => typeof value === "boolean"))
+        return { ok: false, errors: [] };
+    if (edges.size !== lines.length || lines.some(edge => !Number.isInteger(edge) || edge < 0 || edge >= yajilinEdgeCount(board)))
+        return { ok: false, errors: [] };
+    for (let cell = 0; cell < total; cell += 1) {
+        const clue = board.clues[cell];
+        if (clue && shaded[cell])
+            errors.add(cell);
+        if (shaded[cell]) {
+            if (cell % size < size - 1 && shaded[cell + 1]) {
+                errors.add(cell);
+                errors.add(cell + 1);
+            }
+            if (cell + size < total && shaded[cell + size]) {
+                errors.add(cell);
+                errors.add(cell + size);
+            }
+        }
+        if (clue && ray(board, cell, clue.direction).filter(next => shaded[next]).length !== clue.count)
+            errors.add(cell);
+    }
+    const degrees = board.clues.map((clue, cell) => {
+        const degree = yajilinNeighbors(board, cell).filter(next => edges.has(next.edge)).length;
+        if ((clue || shaded[cell]) && degree > 0)
+            errors.add(cell);
+        if (!clue && !shaded[cell] && degree !== 2)
+            errors.add(cell);
+        return degree;
+    });
+    if (edges.size) {
+        const first = degrees.findIndex(degree => degree > 0), reached = new Set([first]), stack = [first];
+        while (stack.length) {
+            const cell = stack.pop();
+            for (const next of yajilinNeighbors(board, cell))
+                if (edges.has(next.edge) && !reached.has(next.cell)) {
+                    reached.add(next.cell);
+                    stack.push(next.cell);
+                }
+        }
+        const loopCells = degrees.filter(degree => degree > 0).length;
+        if (reached.size !== loopCells || edges.size !== loopCells)
+            for (const cell of reached)
+                errors.add(cell);
+    }
+    const playable = board.clues.filter((clue, cell) => !clue && !shaded[cell]).length;
+    const ok = playable >= 4 && edges.size === playable && errors.size === 0
+        && degrees.every((degree, cell) => board.clues[cell] || shaded[cell] ? degree === 0 : degree === 2);
+    return { ok, errors: [...errors] };
+}
+export function yajilinRay(board, cell, direction) {
+    return ray(board, cell, direction);
+}

package/dist/yajilinDraw.d.ts

@@ -0,0 +1,2 @@
+import type { YajilinBoard, YajilinDrawOptions } from "./yajilin.types.ts";
+export declare function drawYajilin(board: YajilinBoard, options?: YajilinDrawOptions): string;

package/dist/yajilinDraw.js

@@ -0,0 +1,33 @@
+import { isYajilinBoard, yajilinNeighbors } from "./yajilinBoard.js";
+import { YAJILIN_STRINGS } from "./yajilinStrings.js";
+const arrows = { up: "↑", right: "→", down: "↓", left: "←" };
+export function drawYajilin(board, options = {}) {
+    if (!isYajilinBoard(board))
+        throw new RangeError("Invalid Yajilin board");
+    const words = YAJILIN_STRINGS[options.language ?? "en"], size = 52, pad = 14;
+    const palette = { ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)"], wood: ["#e5cda6", "#493e2f", "#bca582"], slate: ["#262a27", "#ece8dc", "#454a44"] };
+    const [paper, ink, grid] = palette[options.material ?? "ivory"], edges = new Set(options.edges ?? []), parts = [];
+    for (let cell = 0; cell < board.clues.length; cell += 1) {
+        const x = pad + cell % board.width * size, y = pad + Math.floor(cell / board.width) * size, clue = board.clues[cell];
+        const bad = options.errors?.includes(cell), active = options.selected === cell;
+        parts.push(`<rect x="${x - size / 2}" y="${y - size / 2}" width="${size}" height="${size}" fill="${active ? ink : "transparent"}" fill-opacity="${active ? ".08" : "1"}" stroke="${grid}" stroke-width="1"/>`);
+        if (options.shaded?.[cell])
+            parts.push(`<rect x="${x - 17}" y="${y - 17}" width="34" height="34" rx="2" fill="${bad ? "var(--kz-bad,#b5452c)" : ink}"/>`);
+        if (clue) {
+            if (options.pieces === "tiles")
+                parts.push(`<rect x="${x - 19}" y="${y - 19}" width="38" height="38" rx="5" fill="${paper}" stroke="${grid}"/>`);
+            parts.push(`<text x="${x - 2}" y="${y + 1}" text-anchor="middle" dominant-baseline="middle" fill="${bad ? "var(--kz-bad,#b5452c)" : ink}" font-size="20" font-weight="700" font-family="system-ui,sans-serif">${arrows[clue.direction]}</text>`);
+            parts.push(`<text x="${x + 11}" y="${y + 14}" text-anchor="middle" dominant-baseline="middle" fill="${ink}" font-size="12" font-weight="700" font-family="system-ui,sans-serif">${clue.count}</text>`);
+        }
+        for (const next of yajilinNeighbors(board, cell))
+            if (cell < next.cell && edges.has(next.edge)) {
+                const nx = pad + next.cell % board.width * size, ny = pad + Math.floor(next.cell / board.width) * size;
+                parts.push(`<line x1="${x}" y1="${y}" x2="${nx}" y2="${ny}" stroke="${bad ? "var(--kz-bad,#b5452c)" : ink}" stroke-width="5" stroke-linecap="round"/>`);
+            }
+    }
+    for (let y = 0; y < board.height; y += 1)
+        for (let x = 0; x < board.width; x += 1) {
+            parts.push(`<circle cx="${pad + x * size}" cy="${pad + y * size}" r="2" fill="${grid}"/>`);
+        }
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${pad * 2 + (board.width - 1) * size} ${pad * 2 + (board.height - 1) * size}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${parts.join("")}</svg>`;
+}

package/dist/yajilinGame.d.ts

@@ -0,0 +1,15 @@
+import type { YajilinBoard, YajilinGame } from "./yajilin.types.ts";
+export declare function newYajilin(board: YajilinBoard): YajilinGame;
+export declare function toggleYajilinShade(game: YajilinGame, cell: number): YajilinGame;
+export declare function toggleYajilinEdge(game: YajilinGame, edge: number): YajilinGame;
+export declare function undoYajilin(game: YajilinGame): YajilinGame;
+export declare function restartYajilin(game: YajilinGame): YajilinGame;
+export declare function hintYajilin(game: YajilinGame): {
+    type: "shade";
+    cell: number;
+} | {
+    type: "edge";
+    edge: number;
+} | null;
+export declare function encodeYajilin(game: YajilinGame): string;
+export declare function decodeYajilin(code: string): YajilinGame | null;

package/dist/yajilinGame.js

@@ -0,0 +1,58 @@
+import { isYajilinBoard, yajilinEdgeCount } from "./yajilinBoard.js";
+import { solveYajilin } from "./yajilinSolve.js";
+export function newYajilin(board) {
+    if (!isYajilinBoard(board))
+        throw new RangeError("Invalid Yajilin board");
+    return { board: { width: board.width, height: board.height, clues: board.clues.map(clue => clue ? { ...clue } : null) }, shaded: Array(board.width * board.height).fill(false), edges: [], history: [], helped: false };
+}
+function snapshot(game) { return { shaded: [...game.shaded], edges: [...game.edges] }; }
+export function toggleYajilinShade(game, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.shaded.length || game.board.clues[cell])
+        return game;
+    const shaded = [...game.shaded];
+    shaded[cell] = !shaded[cell];
+    return { ...game, shaded, history: [...game.history, snapshot(game)] };
+}
+export function toggleYajilinEdge(game, edge) {
+    if (!Number.isInteger(edge) || edge < 0 || edge >= yajilinEdgeCount(game.board))
+        return game;
+    const edges = game.edges.includes(edge) ? game.edges.filter(value => value !== edge) : [...game.edges, edge].sort((a, b) => a - b);
+    return { ...game, edges, history: [...game.history, snapshot(game)] };
+}
+export function undoYajilin(game) {
+    const previous = game.history.at(-1);
+    return previous ? { ...game, shaded: [...previous.shaded], edges: [...previous.edges], history: game.history.slice(0, -1) } : game;
+}
+export function restartYajilin(game) { return { ...newYajilin(game.board), helped: false }; }
+export function hintYajilin(game) {
+    const result = solveYajilin(game.board);
+    if (!result.complete || result.count !== 1)
+        return null;
+    const cell = result.solution.shaded.findIndex((value, index) => value !== game.shaded[index]);
+    if (cell >= 0)
+        return { type: "shade", cell };
+    const edge = result.solution.edges.find(value => !game.edges.includes(value));
+    return edge === undefined ? null : { type: "edge", edge };
+}
+export function encodeYajilin(game) {
+    return JSON.stringify({ version: 1, board: game.board, shaded: game.shaded, edges: game.edges, helped: game.helped });
+}
+export function decodeYajilin(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isYajilinBoard(value.board) || !Array.isArray(value.shaded)
+            || value.shaded.length !== value.board.width * value.board.height || !value.shaded.every((cell) => typeof cell === "boolean")
+            || !Array.isArray(value.edges) || !value.edges.every((edge) => Number.isInteger(edge))
+            || typeof value.helped !== "boolean")
+            return null;
+        const edges = [...new Set(value.edges)].sort((a, b) => a - b);
+        if (edges.length !== value.edges.length || edges.some(edge => edge < 0 || edge >= yajilinEdgeCount(value.board)))
+            return null;
+        return { ...newYajilin(value.board), shaded: [...value.shaded], edges, helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/yajilinGenerate.d.ts

@@ -0,0 +1,3 @@
+import type { YajilinPuzzle } from "./yajilin.types.ts";
+/** Seeded original 5×5 families, accepted only after a completed uniqueness proof. */
+export declare function generateYajilin(size?: 5, seed?: number): YajilinPuzzle;

package/dist/yajilinGenerate.js

@@ -0,0 +1,224 @@
+import { isKazuSeed, seededRandom } from "./random.js";
+import { checkYajilin, isYajilinBoard, yajilinNeighbors } from "./yajilinBoard.js";
+import { solveYajilin } from "./yajilinSolve.js";
+const layouts = [
+    {
+        loop: [6, 7, 8, 13, 18, 17, 16, 11],
+        shaded: [1, 22, 5, 9, 24, 12, 20],
+        clues: [
+            [0, "left", 0],
+            [2, "up", 0],
+            [3, "up", 0],
+            [4, "down", 2],
+            [10, "up", 1],
+            [14, "down", 1],
+            [15, "left", 0],
+            [19, "up", 1],
+            [21, "down", 0],
+            [23, "up", 0],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 17, 16, 11],
+        shaded: [0, 21, 15, 2, 14, 4, 12],
+        clues: [
+            [1, "right", 2],
+            [3, "left", 2],
+            [5, "down", 1],
+            [9, "right", 0],
+            [10, "down", 1],
+            [19, "up", 2],
+            [20, "left", 0],
+            [22, "up", 2],
+            [23, "right", 0],
+            [24, "down", 0],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 17, 16, 11],
+        shaded: [24, 12, 22, 4, 15, 0, 2],
+        clues: [
+            [1, "right", 2],
+            [3, "down", 0],
+            [5, "down", 1],
+            [9, "right", 0],
+            [10, "left", 0],
+            [14, "up", 1],
+            [19, "left", 1],
+            [20, "left", 0],
+            [21, "down", 0],
+            [23, "right", 1],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 17, 16, 11],
+        shaded: [12, 9, 2, 21, 0, 19, 10],
+        clues: [
+            [1, "right", 1],
+            [3, "up", 0],
+            [4, "down", 2],
+            [5, "up", 1],
+            [14, "left", 2],
+            [15, "right", 1],
+            [20, "down", 0],
+            [22, "up", 2],
+            [23, "up", 0],
+            [24, "up", 2],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 17, 16, 11],
+        shaded: [20, 3, 22, 14, 1, 12, 24],
+        clues: [
+            [0, "left", 0],
+            [2, "down", 2],
+            [4, "up", 0],
+            [5, "right", 0],
+            [9, "down", 2],
+            [10, "up", 0],
+            [15, "right", 0],
+            [19, "up", 1],
+            [21, "right", 2],
+            [23, "up", 1],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 17, 16, 11],
+        shaded: [14, 3, 21, 15, 24, 0, 12],
+        clues: [
+            [1, "up", 0],
+            [2, "right", 1],
+            [4, "left", 2],
+            [5, "right", 0],
+            [9, "left", 0],
+            [10, "down", 1],
+            [19, "left", 1],
+            [20, "right", 2],
+            [22, "right", 1],
+            [23, "left", 1],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 17, 16, 11],
+        shaded: [15, 24, 9, 21, 5, 3, 1],
+        clues: [
+            [0, "left", 0],
+            [2, "right", 1],
+            [4, "right", 0],
+            [10, "up", 1],
+            [12, "down", 0],
+            [14, "right", 0],
+            [19, "left", 1],
+            [20, "down", 0],
+            [22, "up", 0],
+            [23, "down", 0],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 17, 16, 11],
+        shaded: [4, 2, 0, 10, 23, 21, 19],
+        clues: [
+            [1, "right", 2],
+            [3, "left", 2],
+            [5, "up", 1],
+            [9, "down", 1],
+            [12, "down", 0],
+            [14, "up", 1],
+            [15, "right", 1],
+            [20, "right", 2],
+            [22, "right", 1],
+            [24, "up", 2],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 23, 22, 21, 16, 11],
+        shaded: [10, 4, 2, 17, 0, 24],
+        clues: [
+            [1, "right", 2],
+            [3, "up", 0],
+            [5, "down", 1],
+            [9, "down", 1],
+            [12, "down", 1],
+            [14, "up", 1],
+            [15, "right", 1],
+            [19, "left", 1],
+            [20, "down", 0],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 23, 22, 21, 16, 11],
+        shaded: [3, 15, 19, 17, 1, 5],
+        clues: [
+            [0, "left", 0],
+            [2, "right", 1],
+            [4, "down", 1],
+            [9, "down", 1],
+            [10, "down", 1],
+            [12, "right", 0],
+            [14, "down", 1],
+            [20, "left", 0],
+            [24, "up", 1],
+        ],
+    },
+    {
+        loop: [6, 7, 8, 13, 18, 23, 22, 21, 16, 11],
+        shaded: [2, 17, 4, 0, 20, 10],
+        clues: [
+            [1, "left", 1],
+            [3, "right", 1],
+            [5, "up", 1],
+            [9, "left", 0],
+            [12, "up", 1],
+            [14, "down", 0],
+            [15, "up", 2],
+            [19, "right", 0],
+            [24, "down", 0],
+        ],
+    },
+];
+function transformCell(cell, turns, reflect) {
+    let x = cell % 5, y = Math.floor(cell / 5);
+    if (reflect)
+        x = 4 - x;
+    for (let turn = 0; turn < turns; turn += 1)
+        [x, y] = [4 - y, x];
+    return y * 5 + x;
+}
+function transformDirection(direction, turns, reflect) {
+    const vector = { up: [0, -1], right: [1, 0], down: [0, 1], left: [-1, 0] };
+    let [x, y] = vector[direction];
+    if (reflect)
+        x = -x;
+    for (let turn = 0; turn < turns; turn += 1)
+        [x, y] = [-y, x];
+    return (Object.entries(vector).find(([, value]) => value[0] === x && value[1] === y)?.[0] ?? "up");
+}
+function edgesFromLoop(board, loop) {
+    return loop.map((cell, index) => {
+        const next = loop[(index + 1) % loop.length];
+        return yajilinNeighbors(board, cell).find(item => item.cell === next).edge;
+    }).sort((a, b) => a - b);
+}
+/** Seeded original 5×5 families, accepted only after a completed uniqueness proof. */
+export function generateYajilin(size = 5, seed = 1) {
+    if (size !== 5 || !isKazuSeed(seed))
+        throw new RangeError("Invalid Yajilin settings");
+    const random = seededRandom(seed), layout = layouts[Math.floor(random() * layouts.length)];
+    const turns = Math.floor(random() * 4), reflect = random() < 0.5;
+    const clues = Array(25).fill(null);
+    for (const [cell, direction, count] of layout.clues) {
+        const transformed = transformCell(cell, turns, reflect);
+        clues[transformed] = { direction: transformDirection(direction, turns, reflect), count };
+    }
+    const board = { width: 5, height: 5, clues };
+    const shaded = Array(25).fill(false);
+    for (const cell of layout.shaded)
+        shaded[transformCell(cell, turns, reflect)] = true;
+    const expectedEdges = edgesFromLoop(board, layout.loop.map(cell => transformCell(cell, turns, reflect)));
+    if (!isYajilinBoard(board) || !checkYajilin(board, shaded, expectedEdges).ok)
+        throw new Error("Invalid Yajilin layout");
+    const proof = solveYajilin(board);
+    if (!proof.complete || proof.count !== 1 || !proof.solution)
+        throw new Error("No uniquely proved Yajilin found within the generation budget; try another seed");
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/yajilinMount.d.ts

@@ -0,0 +1,2 @@
+import type { YajilinMount, YajilinMountOptions } from "./yajilin.types.ts";
+export declare function mountYajilin(element: HTMLElement, initial: YajilinMountOptions): YajilinMount;