@logic-pad/core 0.26.2 → 0.27.0

package/dist/src/data/solver/backtrack/symbols/viewpoint.js

@@ -0,0 +1,51 @@
+import BTModule, { BTTile, IntArray2D, createOneTileResult, getOppositeColor, } from '../data.js';
+export default class ViewpointBTModule extends BTModule {
+    instr;
+    constructor(instr) {
+        super();
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        const tile = grid.getTile(this.instr.x, this.instr.y);
+        if (tile === BTTile.Empty)
+            return createOneTileResult(grid, { x: this.instr.x, y: this.instr.y });
+        const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
+        const ratings = [];
+        let completed = 1;
+        let possible = 1;
+        const traverse = (dirX, dirY) => {
+            let connected = true;
+            let x = this.instr.x + dirX;
+            let y = this.instr.y + dirY;
+            while (grid.isInBound(x, y)) {
+                const curTile = grid.getTile(x, y);
+                if (connected) {
+                    if (tile === curTile) {
+                        completed += 1;
+                        if (completed > this.instr.number)
+                            return true;
+                    }
+                    else {
+                        if (curTile === BTTile.Empty) {
+                            tilesNeedCheck.set(x, y, 1);
+                            ratings.push({ pos: { x, y }, score: 1 });
+                        }
+                        connected = false;
+                    }
+                }
+                if (getOppositeColor(tile) === curTile ||
+                    curTile === BTTile.NonExist)
+                    break;
+                possible += 1;
+                x += dirX;
+                y += dirY;
+            }
+            return false;
+        };
+        if (traverse(-1, 0) || traverse(1, 0) || traverse(0, -1) || traverse(0, 1))
+            return false;
+        if (possible < this.instr.number)
+            return false;
+        return { tilesNeedCheck, ratings };
+    }
+}

package/dist/src/data/solver/cspuz/cspuzSolver.d.ts

@@ -0,0 +1,13 @@
+import EventIteratingSolver from '../eventIteratingSolver.js';
+import GridData from '../../grid.js';
+import Instruction from '../../instruction.js';
+export default class CspuzSolver extends EventIteratingSolver {
+    private static readonly supportedInstrs;
+    readonly id = "cspuz";
+    readonly author = "semiexp";
+    readonly description = "A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued).";
+    protected createWorker(): Worker;
+    isGridSupported(grid: GridData): boolean;
+    isInstructionSupported(grid: GridData, instruction: Instruction): boolean;
+    isEnvironmentSupported(): Promise<boolean>;
+}

package/dist/src/data/solver/cspuz/cspuzSolver.js

@@ -0,0 +1,124 @@
+import { instance as banPatternInstance } from '../../rules/banPatternRule.js';
+import { instance as cellCountInstance } from '../../rules/cellCountRule.js';
+import { instance as regionAreaInstance } from '../../rules/regionAreaRule.js';
+import { instance as sameShapeInstance } from '../../rules/sameShapeRule.js';
+import { instance as symbolsPerRegionInstance } from '../../rules/symbolsPerRegionRule.js';
+import { instance as undercluedInstance } from '../../rules/undercluedRule.js';
+import { instance as uniqueShapeInstance } from '../../rules/uniqueShapeRule.js';
+import { instance as offByXInstance } from '../../rules/offByXRule.js';
+import AreaNumberSymbol, { instance as areaNumberInstance, } from '../../symbols/areaNumberSymbol.js';
+import { instance as dartInstance } from '../../symbols/dartSymbol.js';
+import GalaxySymbol, { instance as galaxyInstance, } from '../../symbols/galaxySymbol.js';
+import LetterSymbol, { instance as letterInstance, } from '../../symbols/letterSymbol.js';
+import LotusSymbol, { instance as lotusInstance, } from '../../symbols/lotusSymbol.js';
+import { instance as minesweeperInstance } from '../../symbols/minesweeperSymbol.js';
+import { instance as viewpointInstance } from '../../symbols/viewpointSymbol.js';
+import { instance as connectAllInstance } from '../../rules/connectAllRule.js';
+import { instance as unsupportedInstance } from '../../symbols/unsupportedSymbol.js';
+import EventIteratingSolver from '../eventIteratingSolver.js';
+import GridData from '../../grid.js';
+import { Color } from '../../primitives.js';
+// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+('vite-apply-code-mod');
+export default class CspuzSolver extends EventIteratingSolver {
+    static supportedInstrs = [
+        minesweeperInstance.id,
+        areaNumberInstance.id,
+        letterInstance.id,
+        dartInstance.id,
+        viewpointInstance.id,
+        lotusInstance.id,
+        galaxyInstance.id,
+        connectAllInstance.id,
+        banPatternInstance.id,
+        sameShapeInstance.id,
+        uniqueShapeInstance.id,
+        regionAreaInstance.id,
+        cellCountInstance.id,
+        offByXInstance.id,
+        undercluedInstance.id,
+        symbolsPerRegionInstance.id,
+        unsupportedInstance.id,
+    ];
+    id = 'cspuz';
+    author = 'semiexp';
+    description = 'A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued).';
+    createWorker() {
+        return new Worker(new URL('./cspuzWorker.js', import.meta.url), {
+            type: 'module',
+        });
+    }
+    isGridSupported(grid) {
+        if (!super.isGridSupported(grid)) {
+            return false;
+        }
+        // special handling for fixed gray tiles
+        if (grid.getTileCount(true, true, Color.Gray) > 0) {
+            return false;
+        }
+        // the solver doesn't count symbols correctly if some symbols are unsupported
+        if (grid.findSymbol(symbol => symbol.id === unsupportedInstance.id) &&
+            grid.findRule(rule => rule.id === symbolsPerRegionInstance.id)) {
+            return false;
+        }
+        return true;
+    }
+    isInstructionSupported(grid, instruction) {
+        if (instruction instanceof LotusSymbol ||
+            instruction instanceof GalaxySymbol) {
+            if (instruction.x % 1 !== 0 && instruction.y % 1 !== 0) {
+                return false;
+            }
+        }
+        if (instruction instanceof LotusSymbol ||
+            instruction instanceof GalaxySymbol ||
+            instruction instanceof AreaNumberSymbol ||
+            instruction instanceof LetterSymbol) {
+            if (instruction.x % 1 !== 0 || instruction.y % 1 !== 0) {
+                const minX = Math.floor(instruction.x);
+                const minY = Math.floor(instruction.y);
+                const maxX = Math.ceil(instruction.x);
+                const maxY = Math.ceil(instruction.y);
+                const connectedTiles = grid.connections.getConnectedTiles({
+                    x: minX,
+                    y: minY,
+                });
+                if (connectedTiles.some(tile => tile.x === minX && tile.y === maxY) &&
+                    connectedTiles.some(tile => tile.x === maxX && tile.y === minY) &&
+                    connectedTiles.some(tile => tile.x === maxX && tile.y === maxY)) {
+                    return true;
+                }
+                let color = Color.Gray;
+                for (let i = 0; i < 4; i++) {
+                    const x = i % 2 === 0 ? minX : maxX;
+                    const y = i < 2 ? minY : maxY;
+                    const tile = grid.getTile(x, y);
+                    if (!tile.fixed || !tile.exists) {
+                        return false;
+                    }
+                    if (tile.color !== Color.Gray) {
+                        if (color === Color.Gray) {
+                            color = tile.color;
+                        }
+                        else if (color !== tile.color) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+        }
+        return CspuzSolver.supportedInstrs.includes(instruction.id);
+    }
+    async isEnvironmentSupported() {
+        try {
+            for await (const _ of this.solve(GridData.create(['.']))) {
+                // do nothing
+            }
+            return true;
+        }
+        catch (_ex) {
+            return false;
+        }
+    }
+}

package/dist/src/data/solver/cspuz/cspuzWorker.d.ts

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

package/dist/src/data/solver/cspuz/cspuzWorker.js

@@ -0,0 +1,82 @@
+import { solveLogicPad } from 'logic-pad-solver-core';
+import { Serializer } from '../../serializer/allSerializers.js';
+import { gridToJson } from './jsonify.js';
+import { instance as undercluedInstance } from '../../rules/undercluedRule.js';
+import { Color } from '../../primitives.js';
+function stringToColor(str) {
+    if (str === 'dark') {
+        return Color.Dark;
+    }
+    else if (str === 'light') {
+        return Color.Light;
+    }
+    else {
+        return Color.Gray;
+    }
+}
+function postSolution(grid, solverResult) {
+    if (solverResult === null) {
+        postMessage(null);
+    }
+    else if ('error' in solverResult) {
+        throw new Error(solverResult.error);
+    }
+    else {
+        const solution = grid.withTiles(tiles => {
+            for (const [y, row] of solverResult.entries()) {
+                for (const [x, color] of row.entries()) {
+                    tiles[y][x] = tiles[y][x].withColor(stringToColor(color));
+                }
+            }
+            return tiles;
+        });
+        postMessage(Serializer.stringifyGrid(solution));
+    }
+}
+onmessage = e => {
+    const grid = Serializer.parseGrid(e.data);
+    const isUnderclued = !!grid.findRule(r => r.id === undercluedInstance.id);
+    const puzzleData = gridToJson(grid);
+    const solverResult = solveLogicPad(puzzleData, isUnderclued);
+    postSolution(grid, solverResult);
+    if (isUnderclued) {
+        postMessage(null);
+        return;
+    }
+    // Make use of the underclued mode to determine solution uniqueness
+    if (solverResult !== null && !('error' in solverResult) && !isUnderclued) {
+        const undercluedResult = solveLogicPad(puzzleData, true);
+        if (undercluedResult === null) {
+            postMessage(undefined); // Shouldn't happen because underclued grids should always be solvable
+        }
+        else if ('error' in undercluedResult) {
+            throw new Error(undercluedResult.error);
+        }
+        else if (undercluedResult.every((row, y) => row.every((cell, x) => cell !== null || !grid.getTile(x, y).exists))) {
+            postMessage(null);
+        }
+        else {
+            let tweaked = false;
+            for (const [y, row] of undercluedResult.entries()) {
+                for (const [x, color] of row.entries()) {
+                    if (color !== null) {
+                        puzzleData.tiles[y][x].fixed = true;
+                        puzzleData.tiles[y][x].color = color;
+                    }
+                    else if (!tweaked && puzzleData.tiles[y][x].exists) {
+                        const positions = grid.connections.getConnectedTiles({ x, y });
+                        const newColor = solverResult[y][x] === 'dark' ? 'light' : 'dark';
+                        positions.forEach(({ x: px, y: py }) => {
+                            puzzleData.tiles[py][px].fixed = true;
+                            puzzleData.tiles[py][px].color = newColor;
+                        });
+                        tweaked = true;
+                    }
+                }
+            }
+            const secondResult = solveLogicPad(puzzleData, false);
+            postSolution(grid, secondResult);
+        }
+    }
+    postMessage(undefined);
+};

package/dist/src/data/solver/cspuz/jsonify.d.ts

@@ -0,0 +1,3 @@
+import { PuzzleData } from 'logic-pad-solver-core';
+import GridData from '../../grid.js';
+export declare function gridToJson(grid: GridData): PuzzleData;

package/dist/src/data/solver/cspuz/jsonify.js

@@ -0,0 +1,215 @@
+import { Color, Comparison } from '../../primitives.js';
+import BanPatternRule from '../../rules/banPatternRule.js';
+import CellCountRule from '../../rules/cellCountRule.js';
+import ConnectAllRule from '../../rules/connectAllRule.js';
+import OffByXRule from '../../rules/offByXRule.js';
+import RegionAreaRule from '../../rules/regionAreaRule.js';
+import SameShapeRule from '../../rules/sameShapeRule.js';
+import SymbolsPerRegionRule from '../../rules/symbolsPerRegionRule.js';
+import UndercluedRule from '../../rules/undercluedRule.js';
+import UniqueShapeRule from '../../rules/uniqueShapeRule.js';
+import { instance as areaNumberInstance, } from '../../symbols/areaNumberSymbol.js';
+import { instance as dartInstance, } from '../../symbols/dartSymbol.js';
+import { instance as galaxyInstance, } from '../../symbols/galaxySymbol.js';
+import { instance as letterInstance, } from '../../symbols/letterSymbol.js';
+import { instance as lotusInstance, } from '../../symbols/lotusSymbol.js';
+import { instance as minesweeperInstance, } from '../../symbols/minesweeperSymbol.js';
+import { instance as viewpointInstance, } from '../../symbols/viewpointSymbol.js';
+import { instance as unsupportedInstance } from '../../symbols/unsupportedSymbol.js';
+import TileData from '../../tile.js';
+function canonizeTiles(tileData) {
+    const ret = [];
+    for (const row of tileData) {
+        const newRow = [];
+        for (const tile of row) {
+            if (tile.exists) {
+                newRow.push(tile);
+            }
+            else {
+                newRow.push(new TileData(true, false, Color.Gray));
+            }
+        }
+        ret.push(newRow);
+    }
+    return ret;
+}
+export function gridToJson(grid) {
+    const rules = [];
+    for (const rule of grid.rules) {
+        if (rule instanceof ConnectAllRule) {
+            rules.push({
+                type: 'connectAll',
+                color: rule.color,
+            });
+        }
+        else if (rule instanceof BanPatternRule) {
+            rules.push({
+                type: 'forbiddenPattern',
+                pattern: canonizeTiles(rule.pattern.tiles),
+            });
+        }
+        else if (rule instanceof SameShapeRule) {
+            rules.push({
+                type: 'sameShape',
+                color: rule.color,
+            });
+        }
+        else if (rule instanceof UniqueShapeRule) {
+            rules.push({
+                type: 'uniqueShape',
+                color: rule.color,
+            });
+        }
+        else if (rule instanceof RegionAreaRule) {
+            rules.push({
+                type: 'regionArea',
+                color: rule.color,
+                size: rule.size,
+            });
+        }
+        else if (rule instanceof CellCountRule) {
+            rules.push({
+                type: 'cellCount',
+                color: rule.color,
+                count: rule.count,
+            });
+        }
+        else if (rule instanceof OffByXRule) {
+            rules.push({
+                type: 'offByX',
+                number: rule.number,
+            });
+        }
+        else if (rule instanceof UndercluedRule) {
+            continue;
+        }
+        else if (rule instanceof SymbolsPerRegionRule) {
+            let kind;
+            if (rule.comparison === Comparison.Equal) {
+                kind = 'exactly';
+            }
+            else if (rule.comparison === Comparison.AtLeast) {
+                kind = 'atLeast';
+            }
+            else if (rule.comparison === Comparison.AtMost) {
+                kind = 'atMost';
+            }
+            else {
+                throw new Error(`Unknown comparison (${rule.comparison})`);
+            }
+            rules.push({
+                type: 'symbolCount',
+                number: rule.count,
+                kind,
+                color: rule.color,
+            });
+        }
+        else if (rule.necessaryForCompletion) {
+            throw new Error(`Unknown rule type (${rule.explanation})`);
+        }
+    }
+    for (const [rule, symbols] of grid.symbols) {
+        if (rule === minesweeperInstance.id) {
+            rules.push({
+                type: 'minesweeper',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    number: s.number,
+                })),
+            });
+        }
+        else if (rule === areaNumberInstance.id) {
+            rules.push({
+                type: 'number',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    number: s.number,
+                })),
+            });
+        }
+        else if (rule === letterInstance.id) {
+            rules.push({
+                type: 'letter',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    letter: s.letter,
+                })),
+            });
+        }
+        else if (rule === dartInstance.id) {
+            rules.push({
+                type: 'dart',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    orientation: s.orientation,
+                    number: s.number,
+                })),
+            });
+        }
+        else if (rule === viewpointInstance.id) {
+            rules.push({
+                type: 'viewpoint',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    number: s.number,
+                })),
+            });
+        }
+        else if (rule === lotusInstance.id) {
+            const tiles = symbols.map(s => ({
+                x: Math.round(s.x * 2),
+                y: Math.round(s.y * 2),
+                orientation: s.orientation,
+            }));
+            rules.push({
+                type: 'lotus',
+                tiles,
+            });
+        }
+        else if (rule === galaxyInstance.id) {
+            const tiles = symbols.map(s => ({
+                x: Math.round(s.x * 2),
+                y: Math.round(s.y * 2),
+            }));
+            rules.push({
+                type: 'galaxy',
+                tiles,
+            });
+        }
+        else if (rule === unsupportedInstance.id) {
+            continue;
+        }
+        else if (symbols.some(s => s.necessaryForCompletion)) {
+            throw new Error(`Unknown symbol type: ${rule}`);
+        }
+    }
+    const connections = grid.connections.edges.map(edge => {
+        return {
+            x1: edge.x1,
+            y1: edge.y1,
+            x2: edge.x2,
+            y2: edge.y2,
+        };
+    });
+    const tiles = grid.tiles.map(row => {
+        return row.map(tile => {
+            return {
+                exists: tile.exists,
+                fixed: tile.fixed,
+                color: tile.color,
+            };
+        });
+    });
+    return {
+        width: grid.width,
+        height: grid.height,
+        connections,
+        tiles,
+        rules,
+    };
+}

package/dist/src/data/solver/eventIteratingSolver.d.ts

@@ -0,0 +1,8 @@
+import GridData from '../grid.js';
+import Solver from './solver.js';
+export default abstract class EventIteratingSolver extends Solver {
+    readonly supportsCancellation = true;
+    protected abstract createWorker(): Worker;
+    protected isEnvironmentSupported(): Promise<boolean>;
+    solve(grid: GridData, abortSignal?: AbortSignal): AsyncGenerator<GridData | null>;
+}

package/dist/src/data/solver/eventIteratingSolver.js

@@ -0,0 +1,54 @@
+import { Serializer } from '../serializer/allSerializers.js';
+import Solver from './solver.js';
+import { EventIterator } from 'event-iterator';
+export default class EventIteratingSolver extends Solver {
+    supportsCancellation = true;
+    isEnvironmentSupported() {
+        try {
+            const worker = this.createWorker();
+            worker.terminate();
+            return Promise.resolve(true);
+        }
+        catch (_ex) {
+            return Promise.resolve(false);
+        }
+    }
+    async *solve(grid, abortSignal) {
+        const worker = this.createWorker();
+        let terminateHandler;
+        try {
+            const iterator = new EventIterator(({ push, stop, fail }) => {
+                terminateHandler = () => {
+                    worker.terminate();
+                    stop();
+                };
+                abortSignal?.addEventListener('abort', terminateHandler);
+                worker.postMessage(Serializer.stringifyGrid(grid.resetTiles()));
+                worker.addEventListener('message', (e) => {
+                    if (e.data) {
+                        push(Serializer.parseGrid(e.data));
+                    }
+                    else if (e.data === null) {
+                        push(null);
+                        stop(); // Stop after the first signal for out of solutions
+                    }
+                    else {
+                        stop();
+                    }
+                });
+                worker.addEventListener('error', (e) => {
+                    alert(`Error while solving!\n${e.message}`);
+                    fail(e);
+                });
+            });
+            for await (const solution of iterator) {
+                yield solution;
+            }
+        }
+        finally {
+            worker.terminate();
+            if (terminateHandler)
+                abortSignal?.removeEventListener('abort', terminateHandler);
+        }
+    }
+}

package/dist/src/data/solver/solver.d.ts

@@ -0,0 +1,77 @@
+import { CachedAccess } from '../dataHelper.js';
+import GridData from '../grid.js';
+import { Instruction } from '../../index.js';
+/**
+ * Base class that all solvers must extend.
+ */
+export default abstract class Solver {
+    /**
+     * The unique identifier of the solver.
+     *
+     * This is also displayed to the user when selecting a solver.
+     */
+    abstract get id(): string;
+    /**
+     * The author(s) of the solver.
+     */
+    abstract get author(): string;
+    /**
+     * A short paragraph describing when the user should use this solver.
+     */
+    abstract get description(): string;
+    /**
+     * Whether the solver supports cancellation. If `true`, the solver must respond to the abort signal if it is provided.
+     */
+    abstract get supportsCancellation(): boolean;
+    /**
+     * Solve the given grid. The implementation should delegate long-running tasks to a worker thread and yield solutions
+     * asynchronously.
+     *
+     * The solver must yield at least once, otherwise the UI will not update.
+     *
+     * If the solver finds no solution other than those already yielded, it should yield `null`. Yielding `null` on the
+     * first iteration indicates that the grid is unsolvable. Yielding `null` on the second iteration indicates that the
+     * solution is unique.
+     *
+     * If the solve finds the trivial solution of not filling any tiles, such as in the case of an underclued grid with
+     * too many alternate solutions, it must yield the solution instead of yielding `null`.
+     *
+     * In the current UI implementation, the solver will be terminated after yielding `null`, or after 2 iterations if
+     * `null` is never yielded. The solver should perform any necessary cleanup in the `finally` block of the generator.
+     *
+     * @param grid The grid to solve. The provided grid is guaranteed to be supported by the solver. Some tiles in the
+     * grid may already be filled by the user. It is up to the solver to decide whether to respect these tiles or not.
+     * @param abortSignal An optional signal that the solver should subscribe to in order to cancel the operation. If the
+     * solver does not support cancellation, it should ignore this parameter.
+     */
+    abstract solve(grid: GridData, abortSignal?: AbortSignal): AsyncGenerator<GridData | null>;
+    /**
+     * Check if the solver supports the current browser environment. This method is called once when the user first clicks
+     * the "Solve" button, and the result is cached for the duration of the editor session.
+     *
+     * The `solve` method will not be called if this method returns `false`, and a message will be displayed to the user
+     * indicating that the solver is not supported.
+     *
+     * @returns A promise that resolves to `true` if the environment is supported, or `false` otherwise.
+     */
+    protected isEnvironmentSupported(): Promise<boolean>;
+    readonly environmentCheck: CachedAccess<Promise<boolean>>;
+    /**
+     * Check if the solver supports the given instruction. This is used to render a small indication in the UI for each
+     * instruction in the editor.
+     *
+     * @param instructionId The unique identifier of the instruction.
+     */
+    isInstructionSupported(_grid: GridData, instruction: Instruction): boolean;
+    /**
+     * Check if the solver supports the given grid. This methid is frequently called when the user changes the grid, and
+     * the result is used to enable or disable the "Solve" button.
+     *
+     * The `solve` method will not be called if this method returns `false`, and a message will be displayed to the user
+     * indicating that the grid is not supported by this solver.
+     *
+     * @param grid The grid to check.
+     * @returns `true` if the grid is supported, or `false` otherwise.
+     */
+    isGridSupported(grid: GridData): boolean;
+}