@logic-pad/core 0.26.2 → 0.27.0

package/dist/src/data/solver/auto/autoSolver.js

@@ -0,0 +1,156 @@
+import { Color, State } from '../../primitives.js';
+import { instance as lyingSymbolInstance } from '../../rules/lyingSymbolRule.js';
+import { instance as offByXInstance } from '../../rules/offByXRule.js';
+import { instance as wrapAroundInstance } from '../../rules/wrapAroundRule.js';
+import { instance as areaNumberInstance } from '../../symbols/areaNumberSymbol.js';
+import { instance as letterInstance } from '../../symbols/letterSymbol.js';
+import { allSolvers } from '../allSolvers.js';
+import Solver from '../solver.js';
+import UndercluedRule from '../../rules/undercluedRule.js';
+import validateGrid from '../../validate.js';
+import UnsupportedSymbol from '../../symbols/unsupportedSymbol.js';
+export default class AutoSolver extends Solver {
+    id = 'auto';
+    author = 'various contributors';
+    description = 'Automatically select the fastest solver based on supported instructions and environment.';
+    supportsCancellation = true;
+    static nonAdditiveInstructions = new Set([
+        offByXInstance.id,
+        lyingSymbolInstance.id,
+        wrapAroundInstance.id,
+    ]);
+    isGridSupported(grid) {
+        for (const solver of allSolvers.values()) {
+            if (solver.id === this.id)
+                continue;
+            if (solver.isGridSupported(grid)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isInstructionSupported(grid, instruction) {
+        for (const solver of allSolvers.values()) {
+            if (solver.id === this.id)
+                continue;
+            if (solver.isInstructionSupported(grid, instruction)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async isEnvironmentSupported() {
+        for (const solver of allSolvers.values()) {
+            if (solver.id === this.id)
+                continue;
+            if (await solver.environmentCheck.value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    fillSolution(grid, solution) {
+        return grid.withTiles(tiles => {
+            return tiles.map((row, y) => row.map((tile, x) => {
+                if (!tile.exists || tile.fixed)
+                    return tile;
+                const solutionTile = solution.tiles[y][x];
+                return tile.withColor(solutionTile.color);
+            }));
+        });
+    }
+    fixGrid(grid) {
+        return grid.withTiles(tiles => {
+            return tiles.map(row => row.map(tile => {
+                if (tile.fixed)
+                    return tile;
+                return tile.withFixed(tile.color !== Color.Gray);
+            }));
+        });
+    }
+    async *solveWithProgress(solver, grid, progress, abortSignal) {
+        for await (const updatedGrid of solver.solve(progress, abortSignal)) {
+            if (abortSignal?.aborted)
+                return;
+            if (!updatedGrid) {
+                yield updatedGrid;
+                return;
+            }
+            yield this.fillSolution(grid, updatedGrid);
+        }
+    }
+    async solveOne(generator) {
+        for await (const grid of generator) {
+            return grid;
+        }
+        return null;
+    }
+    async *solve(grid, abortSignal) {
+        if (!!grid.findRule(r => AutoSolver.nonAdditiveInstructions.has(r.id)) ||
+            !!grid.findSymbol(s => AutoSolver.nonAdditiveInstructions.has(s.id))) {
+            for (const solver of allSolvers.values()) {
+                if (solver.id === this.id)
+                    continue;
+                if (solver.isGridSupported(grid)) {
+                    yield* solver.solve(grid, abortSignal);
+                    return;
+                }
+            }
+            throw new Error('No solver supports the given grid');
+        }
+        else {
+            let progressGrid = grid;
+            for (const solver of allSolvers.values()) {
+                if (solver.id === this.id)
+                    continue;
+                if (solver.isGridSupported(progressGrid)) {
+                    yield* this.solveWithProgress(solver, grid, progressGrid, abortSignal);
+                    return;
+                }
+                else if (solver.isGridSupported(grid)) {
+                    yield* solver.solve(grid, abortSignal);
+                    return;
+                }
+                else {
+                    const undercluedGrid = progressGrid
+                        .withRules(rules => rules.filter(r => solver.isInstructionSupported(progressGrid, r)))
+                        .withSymbols(symbols => {
+                        for (const [id, symbolList] of symbols.entries()) {
+                            symbols.set(id, symbolList.map(symbol => {
+                                // special handling: do not delete area number and letter symbols as they can be solved
+                                // underclued even if the solver doesn't fully support them
+                                if (symbol.id === areaNumberInstance.id ||
+                                    symbol.id === letterInstance.id)
+                                    return symbol;
+                                if (solver.isInstructionSupported(progressGrid, symbol))
+                                    return symbol;
+                                return new UnsupportedSymbol(symbol.x, symbol.y);
+                            }));
+                        }
+                        return symbols;
+                    })
+                        .addRule(new UndercluedRule());
+                    if (!solver.isGridSupported(undercluedGrid))
+                        continue;
+                    const undercluedSolution = await this.solveOne(this.solveWithProgress(solver, progressGrid, undercluedGrid, abortSignal));
+                    if (undercluedSolution === null)
+                        continue;
+                    if (undercluedSolution.getTileCount(true, false, Color.Gray) === 0) {
+                        const result = this.fillSolution(grid, undercluedSolution);
+                        if (validateGrid(result, null).final !== State.Error) {
+                            yield result;
+                            yield null;
+                            return;
+                        }
+                        else {
+                            yield null;
+                            return;
+                        }
+                    }
+                    progressGrid = this.fixGrid(undercluedSolution);
+                }
+            }
+            yield this.fillSolution(grid, progressGrid);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import EventIteratingSolver from '../eventIteratingSolver.js';
+import Instruction from '../../instruction.js';
+import GridData from '../../grid.js';
+export default class BacktrackSolver extends EventIteratingSolver {
+    private static readonly supportedInstrs;
+    readonly id = "backtrack";
+    readonly author = "ALaggyDev";
+    readonly description = "Solves puzzles pretty fast using backtracking with optimizations. Support most rules and symbols (including underclued).";
+    protected createWorker(): Worker;
+    isInstructionSupported(_grid: GridData, instruction: Instruction): boolean;
+}

package/dist/src/data/solver/backtrack/backtrackSolver.js

@@ -0,0 +1,54 @@
+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 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 focusInstance } from '../../symbols/focusSymbol.js';
+import { instance as myopiaInstance } from '../../symbols/myopiaSymbol.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';
+// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+('vite-apply-code-mod');
+export default class BacktrackSolver extends EventIteratingSolver {
+    static supportedInstrs = [
+        areaNumberInstance.id,
+        viewpointInstance.id,
+        dartInstance.id,
+        galaxyInstance.id,
+        lotusInstance.id,
+        myopiaInstance.id,
+        minesweeperInstance.id,
+        focusInstance.id,
+        letterInstance.id,
+        undercluedInstance.id,
+        connectAllInstance.id,
+        banPatternInstance.id,
+        regionAreaInstance.id,
+        symbolsPerRegionInstance.id,
+        cellCountInstance.id,
+        sameShapeInstance.id,
+        uniqueShapeInstance.id,
+        unsupportedInstance.id,
+    ];
+    id = 'backtrack';
+    author = 'ALaggyDev';
+    description = 'Solves puzzles pretty fast using backtracking with optimizations. Support most rules and symbols (including underclued).';
+    createWorker() {
+        return new Worker(new URL(`./backtrackWorker.js`, import.meta.url), {
+            type: 'module',
+        });
+    }
+    isInstructionSupported(_grid, instruction) {
+        return BacktrackSolver.supportedInstrs.includes(instruction.id);
+    }
+}

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

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

package/dist/src/data/solver/backtrack/backtrackWorker.js

@@ -0,0 +1,312 @@
+import { array } from '../../dataHelper.js';
+import { Color } from '../../primitives.js';
+import { instance as banPatternInstance, } from '../../rules/banPatternRule.js';
+import { instance as cellCountInstance, } from '../../rules/cellCountRule.js';
+import { instance as connectAllInstance, } from '../../rules/connectAllRule.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 { Serializer } from '../../serializer/allSerializers.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 focusInstance, } from '../../symbols/focusSymbol.js';
+import { instance as myopiaInstance, } from '../../symbols/myopiaSymbol.js';
+import { instance as viewpointInstance, } from '../../symbols/viewpointSymbol.js';
+import { instance as unsupportedInstance } from '../../symbols/unsupportedSymbol.js';
+import { BTGridData, BTTile } from './data.js';
+import BanPatternBTModule from './rules/banPattern.js';
+import CellCountBTModule from './rules/cellCount.js';
+import ConnectAllBTModule from './rules/connectAll.js';
+import RegionAreaBTModule from './rules/regionArea.js';
+import SameShapeBTModule from './rules/sameShape.js';
+import SymbolsPerRegionBTModule from './rules/symbolsPerRegion.js';
+import UniqueShapeBTModule from './rules/uniqueShape.js';
+import AreaNumberBTModule from './symbols/areaNumber.js';
+import DartBTModule from './symbols/dart.js';
+import GalaxyBTModule from './symbols/galaxy.js';
+import LetterBTModule from './symbols/letter.js';
+import LotusBTModule from './symbols/lotus.js';
+import MinesweeperBTModule from './symbols/minesweeper.js';
+import MyopiaBTModule from './symbols/myopia.js';
+import ViewpointBTModule from './symbols/viewpoint.js';
+import FocusBTModule from './symbols/focus.js';
+function translateToBTGridData(grid) {
+    const tiles = array(grid.width, grid.height, (x, y) => {
+        const tile = grid.getTile(x, y);
+        if (!tile.exists)
+            return BTTile.NonExist;
+        else if (tile.color === Color.Dark)
+            return BTTile.Dark;
+        else if (tile.color === Color.Light)
+            return BTTile.Light;
+        else
+            return BTTile.Empty;
+    });
+    const connections = array(grid.width, grid.height, (x, y) => grid.connections.getConnectedTiles({ x, y }));
+    const modules = [];
+    for (const [id, symbolList] of grid.symbols) {
+        for (const symbol of symbolList) {
+            let module;
+            if (id === areaNumberInstance.id) {
+                module = new AreaNumberBTModule(symbol);
+            }
+            else if (id === dartInstance.id) {
+                module = new DartBTModule(symbol);
+            }
+            else if (id === viewpointInstance.id) {
+                module = new ViewpointBTModule(symbol);
+            }
+            else if (id === galaxyInstance.id) {
+                module = new GalaxyBTModule(symbol);
+            }
+            else if (id === lotusInstance.id) {
+                module = new LotusBTModule(symbol);
+            }
+            else if (id === myopiaInstance.id) {
+                module = new MyopiaBTModule(symbol);
+            }
+            else if (id === minesweeperInstance.id) {
+                module = new MinesweeperBTModule(symbol);
+            }
+            else if (id === focusInstance.id) {
+                module = new FocusBTModule(symbol);
+            }
+            else if (id === letterInstance.id) {
+                continue;
+            }
+            else if (id === unsupportedInstance.id) {
+                continue;
+            }
+            if (!module && symbol.necessaryForCompletion)
+                throw new Error('Symbol not supported.');
+            if (module)
+                modules.push(module);
+        }
+    }
+    const letterSymbols = grid.symbols.get(letterInstance.id);
+    if (letterSymbols) {
+        modules.push(new LetterBTModule(letterSymbols, grid.width, grid.height));
+    }
+    for (const rule of grid.rules) {
+        if (!rule.necessaryForCompletion)
+            continue;
+        let module;
+        if (rule.id === connectAllInstance.id) {
+            module = new ConnectAllBTModule(rule);
+        }
+        else if (rule.id === regionAreaInstance.id) {
+            module = new RegionAreaBTModule(rule);
+        }
+        else if (rule.id === banPatternInstance.id) {
+            module = new BanPatternBTModule(rule);
+        }
+        else if (rule.id === symbolsPerRegionInstance.id) {
+            const allSymbols = [];
+            grid.symbols.forEach(symbols => allSymbols.push(...symbols.filter(symbol => symbol.necessaryForCompletion)));
+            module = new SymbolsPerRegionBTModule(rule, grid.width, grid.height, allSymbols);
+        }
+        else if (rule.id === cellCountInstance.id) {
+            module = new CellCountBTModule(rule);
+        }
+        else if (rule.id === sameShapeInstance.id) {
+            module = new SameShapeBTModule(rule);
+        }
+        else if (rule.id === uniqueShapeInstance.id) {
+            module = new UniqueShapeBTModule(rule);
+        }
+        else if (rule.id === undercluedInstance.id) {
+            continue;
+        }
+        if (!module)
+            throw new Error('Rule not supported.');
+        modules.push(module);
+    }
+    return new BTGridData(tiles, connections, modules, grid.width, grid.height);
+}
+function translateBackGridData(grid, btGrid) {
+    const tiles = array(grid.width, grid.height, (x, y) => {
+        const origTile = grid.getTile(x, y);
+        if (!origTile.exists || origTile.fixed || origTile.color !== Color.Gray)
+            return origTile;
+        else
+            return origTile.withColor(btGrid.getTile(x, y) === BTTile.Dark ? Color.Dark : Color.Light);
+    });
+    return grid.withTiles(tiles);
+}
+function isValid(grid, places, checkable, ratings) {
+    const newCheckable = [...checkable];
+    const newRatings = [...ratings];
+    for (let i = 0; i < grid.modules.length; i++) {
+        const module = grid.modules[i];
+        // Check if skippable
+        if (checkable[i] && !places.some(pos => checkable[i].get(pos.x, pos.y)))
+            continue;
+        const result = module.checkLocal(grid, places);
+        if (!result)
+            return false;
+        // If returns true, it means do not change checkable and ratings
+        if (result === true)
+            continue;
+        newCheckable[i] = result.tilesNeedCheck;
+        newRatings[i] = result.ratings;
+    }
+    return [newCheckable, newRatings];
+}
+// This function chooses the next empty tile to search.
+function getNextTile(grid, ratings) {
+    const scores = [];
+    // TODO: Sum up all the scores of connected tiles without overcounting
+    for (let y = 0; y < grid.height; y++) {
+        scores[y] = [];
+        for (let x = 0; x < grid.width; x++) {
+            scores[y][x] = 0;
+        }
+    }
+    for (const rating of ratings) {
+        if (!rating)
+            continue;
+        for (const score of rating) {
+            scores[score.pos.y][score.pos.x] += score.score;
+        }
+    }
+    let highest = 0;
+    let pos = null;
+    let fallback = null;
+    for (let y = 0; y < grid.height; y++) {
+        for (let x = 0; x < grid.width; x++) {
+            if (grid.getTile(x, y) !== BTTile.Empty)
+                continue;
+            if (scores[y][x] > highest) {
+                highest = scores[y][x];
+                pos = { x, y };
+            }
+            fallback ??= { x, y };
+        }
+    }
+    return pos ?? fallback;
+}
+function backtrack(grid, checkable, ratings, solutionFn) {
+    // Find the best empty cell to guess
+    const pos = getNextTile(grid, ratings);
+    // Found a solution
+    if (!pos)
+        return !solutionFn(grid.clone());
+    for (let i = 0; i <= 1; i++) {
+        // TODO: Use a better method to determine the order
+        const tile = i === 0 ? BTTile.Light : BTTile.Dark;
+        grid.setTileWithConnection(pos.x, pos.y, tile);
+        const places = grid.connections[pos.y][pos.x];
+        const result = isValid(grid, places, checkable, ratings);
+        if (result && backtrack(grid, result[0], result[1], solutionFn))
+            return true;
+    }
+    // If both fail, returns to initial state
+    grid.setTileWithConnection(pos.x, pos.y, BTTile.Empty);
+    return false;
+}
+function solveNormal(input, solutionFn) {
+    // Translate to BT data types
+    const grid = translateToBTGridData(input);
+    const checkable = [];
+    const ratings = [];
+    for (const module of grid.modules) {
+        const res = module.checkGlobal(grid);
+        if (!res)
+            return [];
+        checkable.push(res.tilesNeedCheck);
+        ratings.push(res.ratings);
+    }
+    // Call backtrack
+    backtrack(grid, checkable, ratings, sol => solutionFn(translateBackGridData(input, sol)));
+}
+function solveUnderclued(input) {
+    let grid = input;
+    // let count = 0;
+    const possibles = array(grid.width, grid.height, () => ({
+        dark: false,
+        light: false,
+    }));
+    function search(x, y, tile, color) {
+        // count++;
+        // console.log(`Trying (${x}, ${y}) with ${color}`);
+        const newGrid = grid.copyWith({
+            tiles: grid.setTile(x, y, tile.withColor(color)),
+        }, false, false);
+        // Solve
+        let solution;
+        solveNormal(newGrid, sol => {
+            solution = sol;
+            return false;
+        });
+        if (!solution)
+            return false;
+        // Update the new possible states
+        solution.forEach((solTile, solX, solY) => {
+            if (solTile.color === Color.Dark) {
+                possibles[solY][solX].dark = true;
+            }
+            else {
+                possibles[solY][solX].light = true;
+            }
+        });
+        return true;
+    }
+    for (let y = 0; y < grid.height; y++) {
+        for (let x = 0; x < grid.width; x++) {
+            const tile = grid.getTile(x, y);
+            if (!tile.exists || tile.color !== Color.Gray)
+                continue;
+            // We can skip this solve if it is proved to be solvable
+            const darkPossible = possibles[y][x].dark || search(x, y, tile, Color.Dark);
+            const lightPossible = possibles[y][x].light || search(x, y, tile, Color.Light);
+            // No solution
+            if (!darkPossible && !lightPossible)
+                return null;
+            if (darkPossible && !lightPossible)
+                grid = grid.copyWith({
+                    tiles: grid.setTile(x, y, tile.withColor(Color.Dark)),
+                }, false, false);
+            if (!darkPossible && lightPossible)
+                grid = grid.copyWith({
+                    tiles: grid.setTile(x, y, tile.withColor(Color.Light)),
+                }, false, false);
+        }
+    }
+    // console.log(`Solve count: ${count}`);
+    return grid;
+}
+function solve(grid, solutionFn) {
+    if (grid.findRule(rule => rule.id === undercluedInstance.id)) {
+        const res = solveUnderclued(grid);
+        if (res)
+            solutionFn(res);
+    }
+    else {
+        solveNormal(grid, solutionFn);
+    }
+}
+onmessage = e => {
+    const grid = Serializer.parseGrid(e.data);
+    // console.time('Solve time');
+    let count = 0;
+    solve(grid, solution => {
+        // if (count === 0) console.timeLog('Solve time', 'First solution');
+        // if (solution) {
+        //   if (solution.resetTiles().colorEquals(solution)) {
+        //     postMessage(null);
+        //     return false;
+        //   }
+        // }
+        postMessage(Serializer.stringifyGrid(solution));
+        count += 1;
+        return count < 2;
+    });
+    // console.timeEnd('Solve time');
+    postMessage(null);
+};

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

@@ -0,0 +1,47 @@
+import { Color, Position } from '../../primitives.js';
+export declare enum BTTile {
+    Empty = 0,
+    Dark = 1,
+    Light = 2,
+    NonExist = 3
+}
+export type BTColor = BTTile.Dark | BTTile.Light;
+export declare class BTGridData {
+    readonly tiles: BTTile[][];
+    readonly connections: Position[][][];
+    readonly modules: BTModule[];
+    readonly width: number;
+    readonly height: number;
+    constructor(tiles: BTTile[][], connections: Position[][][], modules: BTModule[], width: number, height: number);
+    getTile(x: number, y: number): BTTile;
+    setTileWithConnection(x: number, y: number, tile: BTTile): void;
+    isInBound(x: number, y: number): boolean;
+    getEdges(pos: Position): Position[];
+    clone(): BTGridData;
+}
+export declare class IntArray2D {
+    private readonly array;
+    readonly width: number;
+    readonly height: number;
+    private constructor();
+    static create(width: number, height: number): IntArray2D;
+    set(x: number, y: number, value: number): void;
+    get(x: number, y: number): number;
+    clone(): IntArray2D;
+}
+export interface CheckResult {
+    tilesNeedCheck: IntArray2D | null;
+    ratings: Rating[] | null;
+}
+export interface Rating {
+    pos: Position;
+    score: number;
+}
+export default abstract class BTModule {
+    abstract checkGlobal(grid: BTGridData): CheckResult | false;
+    checkLocal(grid: BTGridData, _: Position[]): CheckResult | boolean;
+}
+export declare function getOppositeColor(color: BTColor): BTColor;
+export declare function colorToBTTile(color: Color): BTTile;
+export declare function createOneTileResult(grid: BTGridData, pos: Position, score?: number | undefined): CheckResult;
+export declare function checkSubtilePlacement(grid: BTGridData, pos: Position): CheckResult | false | undefined;