@logic-pad/core 0.1.0

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

@@ -0,0 +1,92 @@
+import EventIterator from 'event-iterator';
+import { instance as banPatternInstance } from '../../rules/banPatternRule';
+import { instance as cellCountInstance } from '../../rules/cellCountRule';
+import { instance as regionAreaInstance } from '../../rules/regionAreaRule';
+import { instance as sameShapeInstance } from '../../rules/sameShapeRule';
+import { instance as symbolsPerRegionInstance } from '../../rules/symbolsPerRegionRule';
+import { instance as undercluedInstance } from '../../rules/undercluedRule';
+import { instance as uniqueShapeInstance } from '../../rules/uniqueShapeRule';
+import { Serializer } from '../../serializer/allSerializers';
+import { instance as areaNumberInstance } from '../../symbols/areaNumberSymbol';
+import { instance as dartInstance } from '../../symbols/dartSymbol';
+import { instance as galaxyInstance } from '../../symbols/galaxySymbol';
+import { instance as letterInstance } from '../../symbols/letterSymbol';
+import { instance as lotusInstance } from '../../symbols/lotusSymbol';
+import { instance as minesweeperInstance } from '../../symbols/minesweeperSymbol';
+import { instance as myopiaInstance } from '../../symbols/myopiaSymbol';
+import { instance as viewpointInstance } from '../../symbols/viewpointSymbol';
+import Solver from '../solver';
+import { instance as connectAllInstance } from '../z3/modules/connectAllModule';
+class BacktrackSolver extends Solver {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'backtrack'
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Solves puzzles using backtracking with optimizations (blazingly fast). Support most rules and symbols (including underclued).'
+        });
+    }
+    async *solve(grid) {
+        const worker = new Worker(new URL('./backtrackWorker.js', import.meta.url), {
+            type: 'module',
+        });
+        try {
+            const iterator = new EventIterator(({ push, stop, fail }) => {
+                worker.postMessage(Serializer.stringifyGrid(grid.resetTiles()));
+                worker.addEventListener('message', (e) => {
+                    if (e.data) {
+                        push(Serializer.parseGrid(e.data));
+                    }
+                    else {
+                        stop();
+                    }
+                });
+                worker.addEventListener('error', (e) => {
+                    alert(`Error while solving!\n${e.message}`);
+                    fail(new Error(e.message));
+                });
+            });
+            for await (const solution of iterator) {
+                yield solution;
+            }
+            yield null;
+        }
+        finally {
+            worker.terminate();
+        }
+    }
+    isInstructionSupported(instructionId) {
+        return BacktrackSolver.supportedInstrs.includes(instructionId);
+    }
+}
+Object.defineProperty(BacktrackSolver, "supportedInstrs", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        areaNumberInstance.id,
+        viewpointInstance.id,
+        dartInstance.id,
+        galaxyInstance.id,
+        lotusInstance.id,
+        myopiaInstance.id,
+        minesweeperInstance.id,
+        letterInstance.id,
+        undercluedInstance.id,
+        connectAllInstance.id,
+        banPatternInstance.id,
+        regionAreaInstance.id,
+        symbolsPerRegionInstance.id,
+        cellCountInstance.id,
+        sameShapeInstance.id,
+        uniqueShapeInstance.id,
+    ]
+});
+export default BacktrackSolver;

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

@@ -0,0 +1,2 @@
+declare const _default: null;
+export default _default;

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

@@ -0,0 +1,295 @@
+import { array } from '../../dataHelper';
+import { Color } from '../../primitives';
+import { instance as banPatternInstance, } from '../../rules/banPatternRule';
+import { instance as cellCountInstance, } from '../../rules/cellCountRule';
+import { instance as regionAreaInstance, } from '../../rules/regionAreaRule';
+import { instance as sameShapeInstance, } from '../../rules/sameShapeRule';
+import { instance as symbolsPerRegionInstance, } from '../../rules/symbolsPerRegionRule';
+import { instance as undercluedInstance } from '../../rules/undercluedRule';
+import { instance as uniqueShapeInstance, } from '../../rules/uniqueShapeRule';
+import { Serializer } from '../../serializer/allSerializers';
+import { instance as areaNumberInstance, } from '../../symbols/areaNumberSymbol';
+import { instance as dartInstance } from '../../symbols/dartSymbol';
+import { instance as galaxyInstance, } from '../../symbols/galaxySymbol';
+import { instance as letterInstance, } from '../../symbols/letterSymbol';
+import { instance as lotusInstance, } from '../../symbols/lotusSymbol';
+import { instance as minesweeperInstance, } from '../../symbols/minesweeperSymbol';
+import { instance as myopiaInstance, } from '../../symbols/myopiaSymbol';
+import { instance as viewpointInstance, } from '../../symbols/viewpointSymbol';
+import { instance as connectAllInstance } from '../z3/modules/connectAllModule';
+import { BTGridData, BTTile } from './data';
+import BanPatternBTModule from './rules/banPattern';
+import CellCountBTModule from './rules/cellCount';
+import ConnectAllBTModule from './rules/connectAll';
+import RegionAreaBTModule from './rules/regionArea';
+import SameShapeBTModule from './rules/sameShape';
+import SymbolsPerRegionBTModule from './rules/symbolsPerRegion';
+import UniqueShapeBTModule from './rules/uniqueShape';
+import AreaNumberBTModule from './symbols/areaNumber';
+import DartBTModule from './symbols/dart';
+import GalaxyBTModule from './symbols/galaxy';
+import LetterBTModule from './symbols/letter';
+import LotusBTModule from './symbols/lotus';
+import MinesweeperBTModule from './symbols/minesweeper';
+import MyopiaBTModule from './symbols/myopia';
+import ViewpointBTModule from './symbols/viewpoint';
+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 === letterInstance.id) {
+                continue;
+            }
+            if (!module)
+                throw new Error('Symbol not supported.');
+            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));
+            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 };
+            }
+            if (!fallback)
+                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.setTile(x, y, tile.withColor(color));
+        // 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.setTile(x, y, tile.withColor(Color.Dark));
+            if (!darkPossible && lightPossible)
+                grid = grid.setTile(x, y, tile.withColor(Color.Light));
+        }
+    }
+    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');
+        postMessage(Serializer.stringifyGrid(solution));
+        count += 1;
+        return count < 2;
+    });
+    console.timeEnd('Solve time');
+    postMessage(null);
+};
+// make typescript happy
+// eslint-disable-next-line import/no-anonymous-default-export
+export default null;

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

@@ -0,0 +1,46 @@
+import { Color, Position } from '../../primitives';
+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;

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

@@ -0,0 +1,140 @@
+import { Color } from '../../primitives';
+export var BTTile;
+(function (BTTile) {
+    BTTile[BTTile["Empty"] = 0] = "Empty";
+    BTTile[BTTile["Dark"] = 1] = "Dark";
+    BTTile[BTTile["Light"] = 2] = "Light";
+    BTTile[BTTile["NonExist"] = 3] = "NonExist";
+})(BTTile || (BTTile = {}));
+export class BTGridData {
+    constructor(tiles, connections, modules, width, height) {
+        Object.defineProperty(this, "tiles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tiles
+        });
+        Object.defineProperty(this, "connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: connections
+        });
+        Object.defineProperty(this, "modules", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: modules
+        });
+        Object.defineProperty(this, "width", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: width
+        });
+        Object.defineProperty(this, "height", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: height
+        });
+        this.tiles = tiles;
+        this.connections = connections;
+        this.modules = modules;
+        this.width = width;
+        this.height = height;
+    }
+    getTile(x, y) {
+        return this.tiles[y][x];
+    }
+    setTileWithConnection(x, y, tile) {
+        for (const pos of this.connections[y][x]) {
+            this.tiles[pos.y][pos.x] = tile;
+        }
+    }
+    isInBound(x, y) {
+        return x >= 0 && x < this.width && y >= 0 && y < this.height;
+    }
+    getEdges(pos) {
+        const positions = [];
+        if (pos.x > 0) {
+            if (this.getTile(pos.x - 1, pos.y) !== BTTile.NonExist)
+                positions.push({ x: pos.x - 1, y: pos.y });
+        }
+        if (pos.x + 1 < this.width) {
+            if (this.getTile(pos.x + 1, pos.y) !== BTTile.NonExist)
+                positions.push({ x: pos.x + 1, y: pos.y });
+        }
+        if (pos.y > 0) {
+            if (this.getTile(pos.x, pos.y - 1) !== BTTile.NonExist)
+                positions.push({ x: pos.x, y: pos.y - 1 });
+        }
+        if (pos.y + 1 < this.height) {
+            if (this.getTile(pos.x, pos.y + 1) !== BTTile.NonExist)
+                positions.push({ x: pos.x, y: pos.y + 1 });
+        }
+        return positions;
+    }
+    clone() {
+        return new BTGridData(this.tiles.map(arr => [...arr]), this.connections, this.modules, this.width, this.height);
+    }
+}
+export class IntArray2D {
+    constructor(array, width, height) {
+        Object.defineProperty(this, "array", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: array
+        });
+        Object.defineProperty(this, "width", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: width
+        });
+        Object.defineProperty(this, "height", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: height
+        });
+        this.array = array;
+        this.width = width;
+        this.height = height;
+    }
+    static create(width, height) {
+        return new IntArray2D(new Uint8Array(width * height), width, height);
+    }
+    set(x, y, value) {
+        this.array[y * this.width + x] = value;
+    }
+    get(x, y) {
+        return this.array[y * this.width + x];
+    }
+    clone() {
+        return new IntArray2D(new Uint8Array(this.array), this.width, this.height);
+    }
+}
+export default class BTModule {
+    checkLocal(grid, _) {
+        return this.checkGlobal(grid);
+    }
+}
+export function getOppositeColor(color) {
+    return color === BTTile.Dark ? BTTile.Light : BTTile.Dark;
+}
+export function colorToBTTile(color) {
+    if (color === Color.Gray)
+        return BTTile.Empty;
+    else if (color === Color.Light)
+        return BTTile.Light;
+    else
+        return BTTile.Dark;
+}
+export function createOneTileResult(grid, pos, score = 1) {
+    const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
+    tilesNeedCheck.set(pos.x, pos.y, 1);
+    const ratings = [{ pos, score }];
+    return { tilesNeedCheck, ratings };
+}

package/dist/data/solver/backtrack/rules/banPattern.d.ts

@@ -0,0 +1,9 @@
+import { Position } from '../../../primitives';
+import BanPatternRule from '../../../rules/banPatternRule';
+import BTModule, { BTGridData, CheckResult } from '../data';
+export default class BanPatternBTModule extends BTModule {
+    instr: BanPatternRule;
+    constructor(instr: BanPatternRule);
+    checkGlobal(_: BTGridData): CheckResult | false;
+    checkLocal(grid: BTGridData, positions: Position[]): CheckResult | false;
+}

package/dist/data/solver/backtrack/rules/banPattern.js

@@ -0,0 +1,66 @@
+import BTModule, { BTTile, colorToBTTile, } from '../data';
+export default class BanPatternBTModule extends BTModule {
+    constructor(instr) {
+        super();
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.instr = instr;
+    }
+    checkGlobal(_) {
+        // TODO: Impl this properly
+        return { tilesNeedCheck: null, ratings: null };
+    }
+    checkLocal(grid, positions) {
+        const ratings = [];
+        // TODO: Do not iterate positions
+        for (const { x, y } of positions) {
+            const tile = grid.getTile(x, y);
+            for (const shape of this.instr.cache) {
+                for (const origin of shape.elements) {
+                    if (colorToBTTile(origin.color) !== tile)
+                        continue;
+                    if (origin.x > x ||
+                        origin.y > y ||
+                        shape.width - origin.x + x > grid.width ||
+                        shape.height - origin.y + y > grid.height)
+                        continue;
+                    // We add a tile into ratings if that tile is the only mismatched tile
+                    let match = true;
+                    let mismatchPos = null;
+                    for (const element of shape.elements) {
+                        const eleTile = grid.getTile(element.x - origin.x + x, element.y - origin.y + y);
+                        if (eleTile === BTTile.Empty) {
+                            if (match) {
+                                match = false;
+                                mismatchPos = {
+                                    x: element.x - origin.x + x,
+                                    y: element.y - origin.y + y,
+                                };
+                            }
+                            else {
+                                mismatchPos = null;
+                                break;
+                            }
+                        }
+                        else if (eleTile !== colorToBTTile(element.color)) {
+                            match = false;
+                            mismatchPos = null;
+                            break;
+                        }
+                    }
+                    if (match)
+                        return false;
+                    if (mismatchPos)
+                        ratings.push({ pos: mismatchPos, score: 10000 });
+                }
+            }
+        }
+        // TODO: Redesign API - This is not the best!
+        // Ratings refresh on every backtrack! Ratings should be appended on the previous result instead of over-writing!
+        return { tilesNeedCheck: null, ratings };
+    }
+}

package/dist/data/solver/backtrack/rules/cellCount.d.ts

@@ -0,0 +1,7 @@
+import CellCountRule from '../../../rules/cellCountRule';
+import BTModule, { BTGridData, CheckResult } from '../data';
+export default class CellCountBTModule extends BTModule {
+    instr: CellCountRule;
+    constructor(instr: CellCountRule);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+}