@logic-pad/core 0.1.0

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

@@ -0,0 +1,9 @@
+import LetterSymbol from '../../../symbols/letterSymbol';
+import BTModule, { BTGridData, CheckResult } from '../data';
+export default class LetterBTModule extends BTModule {
+    private letters;
+    private letterGrid;
+    constructor(instrs: LetterSymbol[], width: number, height: number);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+    private visitArea;
+}

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

@@ -0,0 +1,100 @@
+import BTModule, { BTTile, IntArray2D } from '../data';
+export default class LetterBTModule extends BTModule {
+    constructor(instrs, width, height) {
+        super();
+        Object.defineProperty(this, "letters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "letterGrid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.letters = [];
+        this.letterGrid = IntArray2D.create(width, height);
+        const letterMap = new Map();
+        let letterCount = 0;
+        for (const instr of instrs) {
+            if (!letterMap.has(instr.letter)) {
+                letterMap.set(instr.letter, letterCount);
+                this.letters[letterCount] = [];
+                letterCount += 1;
+            }
+            const id = letterMap.get(instr.letter);
+            this.letters[id].push(instr);
+            this.letterGrid.set(Math.floor(instr.x), Math.floor(instr.y), id + 1);
+        }
+    }
+    checkGlobal(grid) {
+        const visited = IntArray2D.create(grid.width, grid.height);
+        for (let id = 0; id < this.letters.length; id++) {
+            for (const symbol of this.letters[id]) {
+                const symbolX = Math.floor(symbol.x);
+                const symbolY = Math.floor(symbol.y);
+                if (grid.getTile(symbolX, symbolY) === BTTile.Empty)
+                    continue;
+                if (!this.visitArea(grid, visited, { x: symbolX, y: symbolY }, id + 1))
+                    return false;
+                break;
+            }
+        }
+        return { tilesNeedCheck: null, ratings: null };
+    }
+    visitArea(grid, visited, pos, id) {
+        const tile = grid.getTile(pos.x, pos.y);
+        const sameTileQueue = [pos];
+        const usableTileQueue = [];
+        let letterVisited = 0;
+        visited.set(pos.x, pos.y, id);
+        // Count same tile
+        while (sameTileQueue.length > 0) {
+            const curPos = sameTileQueue.pop();
+            const letterId = this.letterGrid.get(curPos.x, curPos.y);
+            if (letterId === id) {
+                letterVisited += 1;
+            }
+            else if (letterId !== 0) {
+                return false;
+            }
+            for (const edge of grid.getEdges(curPos)) {
+                if ((visited.get(edge.x, edge.y) & 0b01111111) === id)
+                    continue;
+                const edgeTile = grid.getTile(edge.x, edge.y);
+                if (edgeTile === BTTile.Empty) {
+                    usableTileQueue.push(edge);
+                    visited.set(edge.x, edge.y, id | 0b10000000);
+                }
+                else if (edgeTile === tile) {
+                    sameTileQueue.push(edge);
+                    visited.set(edge.x, edge.y, id);
+                }
+            }
+        }
+        if (letterVisited === this.letters[id - 1].length)
+            return true;
+        // Count usable tile
+        while (usableTileQueue.length > 0) {
+            const curPos = usableTileQueue.pop();
+            const letterId = this.letterGrid.get(curPos.x, curPos.y);
+            if (letterId === id) {
+                letterVisited += 1;
+                if (letterVisited === this.letters[id - 1].length)
+                    return true;
+            }
+            for (const edge of grid.getEdges(curPos)) {
+                if ((visited.get(edge.x, edge.y) & 0b01111111) === id)
+                    continue;
+                const edgeTile = grid.getTile(edge.x, edge.y);
+                if (edgeTile === BTTile.Empty || edgeTile === tile) {
+                    usableTileQueue.push(edge);
+                    visited.set(edge.x, edge.y, id | 0b10000000);
+                }
+            }
+        }
+        return letterVisited === this.letters[id - 1].length;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Position } from '../../../primitives';
+import LotusSymbol from '../../../symbols/lotusSymbol';
+import { BTGridData } from '../data';
+import DirectionLinkerBTModule from './directionLinker';
+export default class LotusBTModule extends DirectionLinkerBTModule {
+    instr: LotusSymbol;
+    constructor(instr: LotusSymbol);
+    protected movePos(grid: BTGridData, x: number, y: number): Position | null;
+}

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

@@ -0,0 +1,36 @@
+import { Orientation } from '../../../primitives';
+import DirectionLinkerBTModule from './directionLinker';
+export default class LotusBTModule extends DirectionLinkerBTModule {
+    constructor(instr) {
+        super(instr);
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.instr = instr;
+    }
+    // Translate a position in relative to a lotus symbol
+    movePos(grid, x, y) {
+        const symbol = this.instr;
+        let pos;
+        if (symbol.orientation === Orientation.Up ||
+            symbol.orientation === Orientation.Down) {
+            pos = { x: 2 * symbol.x - x, y };
+        }
+        else if (symbol.orientation === Orientation.UpRight ||
+            symbol.orientation === Orientation.DownLeft) {
+            pos = { x: symbol.y + symbol.x - y, y: symbol.y + symbol.x - x };
+        }
+        else if (symbol.orientation === Orientation.Right ||
+            symbol.orientation === Orientation.Left) {
+            pos = { x, y: 2 * symbol.y - y };
+        }
+        else if (symbol.orientation === Orientation.DownRight ||
+            symbol.orientation === Orientation.UpLeft) {
+            pos = { x: symbol.x - symbol.y + y, y: symbol.y - symbol.x + x };
+        }
+        return grid.isInBound(pos.x, pos.y) ? pos : null;
+    }
+}

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

@@ -0,0 +1,9 @@
+import MinesweeperSymbol from '../../../symbols/minesweeperSymbol';
+import BTModule, { BTGridData, CheckResult } from '../data';
+export default class MinesweeperBTModule extends BTModule {
+    instr: MinesweeperSymbol;
+    private cachedCheckResult?;
+    constructor(instr: MinesweeperSymbol);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+    private buildCheckAndRating;
+}

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

@@ -0,0 +1,55 @@
+import BTModule, { BTTile, IntArray2D, createOneTileResult, getOppositeColor, } from '../data';
+export default class MinesweeperBTModule extends BTModule {
+    constructor(instr) {
+        super();
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cachedCheckResult", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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 });
+        let gray = 0;
+        let opposite = 0;
+        for (let y = this.instr.y - 1; y <= this.instr.y + 1; y++) {
+            for (let x = this.instr.x - 1; x <= this.instr.x + 1; x++) {
+                if (!grid.isInBound(x, y) || (x === this.instr.x && y === this.instr.y))
+                    continue;
+                const checkTile = grid.getTile(x, y);
+                if (checkTile === BTTile.Empty)
+                    gray++;
+                else if (checkTile === getOppositeColor(tile))
+                    opposite++;
+            }
+        }
+        if (opposite > this.instr.number || opposite + gray < this.instr.number)
+            return false;
+        if (!this.cachedCheckResult)
+            this.cachedCheckResult = this.buildCheckAndRating(grid);
+        return this.cachedCheckResult;
+    }
+    buildCheckAndRating(grid) {
+        const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
+        const ratings = [];
+        for (let y = this.instr.y - 1; y <= this.instr.y + 1; y++) {
+            for (let x = this.instr.x - 1; x <= this.instr.x + 1; x++) {
+                if (!grid.isInBound(x, y) || (x === this.instr.x && y === this.instr.y))
+                    continue;
+                tilesNeedCheck.set(x, y, 1);
+                ratings.push({ pos: { x, y }, score: 1 });
+            }
+        }
+        return { tilesNeedCheck, ratings };
+    }
+}

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

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

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

@@ -0,0 +1,79 @@
+import { move } from '../../../dataHelper';
+import { ORIENTATIONS, Orientation } from '../../../primitives';
+import BTModule, { BTTile, createOneTileResult, getOppositeColor, } from '../data';
+export default class MyopiaBTModule extends BTModule {
+    constructor(instr) {
+        super();
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        // TODO: Optimize myopia symbol
+        // TODO: What to do if a non-existence tile is in front?
+        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 traverse = (dir) => {
+            let min = 0;
+            let max = 0;
+            let connected = true;
+            let stopped = false;
+            let pos = move(this.instr, dir);
+            while (grid.isInBound(pos.x, pos.y)) {
+                const curTile = grid.getTile(pos.x, pos.y);
+                if (connected) {
+                    if (tile === curTile) {
+                        min += 1;
+                    }
+                    else {
+                        connected = false;
+                    }
+                }
+                if (getOppositeColor(tile) === curTile ||
+                    curTile === BTTile.NonExist) {
+                    stopped = true;
+                    break;
+                }
+                max += 1;
+                pos = move(pos, dir);
+            }
+            return [min, stopped ? max : Number.MAX_SAFE_INTEGER, connected];
+        };
+        const allDirections = this.instr.diagonals
+            ? ORIENTATIONS
+            : [Orientation.Up, Orientation.Down, Orientation.Left, Orientation.Right];
+        const pointedDirections = [];
+        const otherDirections = [];
+        for (const dir of allDirections) {
+            const res = traverse(dir);
+            if (this.instr.directions[dir]) {
+                pointedDirections.push(res);
+            }
+            else {
+                otherDirections.push(res);
+            }
+        }
+        for (let i = 0; i < pointedDirections.length; i++) {
+            const direction1 = pointedDirections[i];
+            for (let j = i + 1; j < pointedDirections.length; j++) {
+                const direction2 = pointedDirections[j];
+                if (direction1[0] > direction2[1] || direction2[0] > direction1[1])
+                    return false;
+            }
+        }
+        if (Math.min(...otherDirections.map(d => d[1])) <=
+            Math.max(...pointedDirections.map(d => d[0])))
+            return false;
+        if (pointedDirections.length === 0 &&
+            otherDirections.some(d => d[1] !== Number.MAX_SAFE_INTEGER))
+            return false;
+        if (pointedDirections.some(d => d[2] && d[1] === Number.MAX_SAFE_INTEGER))
+            return false;
+        return { tilesNeedCheck: null, ratings: null };
+    }
+}

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

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

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

@@ -0,0 +1,56 @@
+import BTModule, { BTTile, IntArray2D, createOneTileResult, getOppositeColor, } from '../data';
+export default class ViewpointBTModule extends BTModule {
+    constructor(instr) {
+        super();
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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/data/solver/solver.d.ts

@@ -0,0 +1,61 @@
+import GridData from '../grid';
+/**
+ * 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;
+    /**
+     * A short paragraph describing when the user should use this solver.
+     */
+    abstract get description(): string;
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    abstract solve(grid: GridData): 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.
+     */
+    isEnvironmentSupported(): 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(instructionId: string): 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;
+}

package/dist/data/solver/solver.js

@@ -0,0 +1,55 @@
+import { allRules } from '../rules';
+import { allSymbols } from '../symbols';
+/**
+ * Base class that all solvers must extend.
+ */
+export default class Solver {
+    /**
+     * 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.
+     */
+    isEnvironmentSupported() {
+        return Promise.resolve(true);
+    }
+    /**
+     * 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(instructionId) {
+        const symbol = allSymbols.get(instructionId);
+        if (symbol) {
+            return !symbol.validateWithSolution;
+        }
+        const rule = allRules.get(instructionId);
+        if (rule) {
+            return !rule.validateWithSolution;
+        }
+        return false;
+    }
+    /**
+     * 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) {
+        if (grid.rules.some(rule => rule.necessaryForCompletion && !this.isInstructionSupported(rule.id))) {
+            return false;
+        }
+        if ([...grid.symbols.keys()].some(id => !this.isInstructionSupported(id))) {
+            return false;
+        }
+        return true;
+    }
+}

package/dist/data/solver/underclued/undercluedSolver.d.ts

@@ -0,0 +1,8 @@
+import GridData from '../../grid';
+import Solver from '../solver';
+export default class UndercluedSolver extends Solver {
+    readonly id = "underclued";
+    readonly description = "Solves every puzzle as if it were underclued. Supports all rules and symbols and is decently fast for small puzzles. Very slow for large puzzles.";
+    solve(grid: GridData): AsyncGenerator<GridData | null>;
+    isInstructionSupported(instructionId: string): boolean;
+}

package/dist/data/solver/underclued/undercluedSolver.js

@@ -0,0 +1,55 @@
+import { Color } from '../../primitives';
+import { instance as undercluedInstance } from '../../rules/undercluedRule';
+import { Serializer } from '../../serializer/allSerializers';
+import Solver from '../solver';
+export default class UndercluedSolver extends Solver {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'underclued'
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Solves every puzzle as if it were underclued. Supports all rules and symbols and is decently fast for small puzzles. Very slow for large puzzles.'
+        });
+    }
+    async *solve(grid) {
+        const worker = new Worker(new URL('./undercluedWorker.js', import.meta.url), {
+            type: 'module',
+        });
+        try {
+            const solved = await new Promise(resolve => {
+                worker.addEventListener('message', e => {
+                    const solution = Serializer.parseGrid(e.data);
+                    console.timeEnd('Solve time');
+                    if (solution.resetTiles().equals(solution))
+                        resolve(null);
+                    else
+                        resolve(solution);
+                });
+                worker.postMessage(Serializer.stringifyGrid(grid));
+                console.time('Solve time');
+            });
+            yield solved;
+            if (solved) {
+                if (solved.getTileCount(true, undefined, Color.Gray) === 0) {
+                    yield null; // the grid is completely filled, which means the solution is unique
+                }
+            }
+        }
+        finally {
+            worker.terminate();
+        }
+    }
+    isInstructionSupported(instructionId) {
+        if (super.isInstructionSupported(instructionId)) {
+            return true;
+        }
+        return instructionId === undercluedInstance.id;
+    }
+}

package/dist/data/solver/underclued/undercluedWorker.d.ts

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