@logic-pad/core 0.26.1 → 0.26.2

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

@@ -1,75 +0,0 @@
-import BTModule, { BTTile, checkSubtilePlacement, IntArray2D, createOneTileResult, } from '../data.js';
-export default class AreaNumberBTModule extends BTModule {
-    instr;
-    constructor(instr) {
-        super();
-        this.instr = instr;
-    }
-    checkGlobal(grid) {
-        const checkResult = checkSubtilePlacement(grid, this.instr);
-        if (checkResult !== undefined)
-            return checkResult;
-        const thisX = Math.floor(this.instr.x);
-        const thisY = Math.floor(this.instr.y);
-        const tile = grid.getTile(thisX, thisY);
-        if (tile === BTTile.Empty)
-            return createOneTileResult(grid, { x: thisX, y: thisY });
-        const visited = IntArray2D.create(grid.width, grid.height);
-        const sameTileQueue = [{ x: thisX, y: thisY }];
-        const usableTileQueue = [];
-        let sameCellCount = 0;
-        let usableCellCount = 0;
-        visited.set(thisX, thisY, 1);
-        // Count same tile
-        while (sameTileQueue.length > 0) {
-            const curPos = sameTileQueue.pop();
-            sameCellCount += 1;
-            for (const edge of grid.getEdges(curPos)) {
-                if (visited.get(edge.x, edge.y))
-                    continue;
-                const edgeTile = grid.getTile(edge.x, edge.y);
-                if (edgeTile === BTTile.Empty) {
-                    usableTileQueue.push(edge);
-                }
-                else if (edgeTile === tile) {
-                    sameTileQueue.push(edge);
-                }
-                visited.set(edge.x, edge.y, 1);
-            }
-        }
-        if (sameCellCount > this.instr.number)
-            return false;
-        const ratings = [];
-        for (const pos of usableTileQueue) {
-            ratings.push({ pos, score: 1 });
-        }
-        // Count usable tile
-        while (usableTileQueue.length > 0) {
-            const curPos = usableTileQueue.pop();
-            usableCellCount += 1;
-            if (sameCellCount + usableCellCount >= this.instr.number)
-                return { tilesNeedCheck: null, ratings };
-            for (const edge of grid.getEdges(curPos)) {
-                if (visited.get(edge.x, edge.y))
-                    continue;
-                const edgeTile = grid.getTile(edge.x, edge.y);
-                if (edgeTile === BTTile.Empty || edgeTile === tile) {
-                    usableTileQueue.push(edge);
-                    visited.set(edge.x, edge.y, 1);
-                }
-            }
-        }
-        return sameCellCount + usableCellCount >= this.instr.number
-            ? { tilesNeedCheck: null, ratings }
-            : false;
-    }
-    checkLocal(grid, positions) {
-        // TODO: Also skip checks if color is the same and within the zone but not directly affectin
-        const thisX = Math.floor(this.instr.x);
-        const thisY = Math.floor(this.instr.y);
-        // Skip checks if it is too far to affect the symbol
-        if (positions.every(pos => Math.abs(pos.x - thisX) + Math.abs(pos.y - thisY) > this.instr.number))
-            return true;
-        return this.checkGlobal(grid);
-    }
-}

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

@@ -1,8 +0,0 @@
-import DartSymbol from '../../../symbols/dartSymbol.js';
-import BTModule, { BTGridData, CheckResult } from '../data.js';
-export default class DartBTModule extends BTModule {
-    instr: DartSymbol;
-    constructor(instr: DartSymbol);
-    checkGlobal(grid: BTGridData): CheckResult | false;
-    private buildCheckAndRating;
-}

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

@@ -1,45 +0,0 @@
-import { move } from '../../../dataHelper.js';
-import BTModule, { BTTile, IntArray2D, createOneTileResult, getOppositeColor, } from '../data.js';
-export default class DartBTModule 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 });
-        let pos = move({ x: this.instr.x, y: this.instr.y }, this.instr.orientation);
-        let completed = 0;
-        let empty = 0;
-        while (grid.isInBound(pos.x, pos.y)) {
-            // Opposite tiles
-            if (grid.getTile(pos.x, pos.y) === getOppositeColor(tile)) {
-                completed += 1;
-                if (completed > this.instr.number)
-                    return false;
-            }
-            // Empty tiles
-            if (grid.getTile(pos.x, pos.y) === BTTile.Empty)
-                empty += 1;
-            pos = move(pos, this.instr.orientation);
-        }
-        if (completed + empty < this.instr.number)
-            return false;
-        return this.buildCheckAndRating(grid);
-    }
-    buildCheckAndRating(grid) {
-        const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
-        const ratings = [];
-        let pos = { x: this.instr.x, y: this.instr.y };
-        while (grid.isInBound(pos.x, pos.y)) {
-            if (grid.getTile(pos.x, pos.y) === BTTile.Empty) {
-                tilesNeedCheck.set(pos.x, pos.y, 1);
-                ratings.push({ pos, score: 1 });
-            }
-            pos = move(pos, this.instr.orientation);
-        }
-        return { tilesNeedCheck, ratings };
-    }
-}

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

@@ -1,11 +0,0 @@
-import { Position } from '../../../primitives.js';
-import DirectionLinkerSymbol from '../../../symbols/directionLinkerSymbol.js';
-import BTModule, { BTGridData, CheckResult } from '../data.js';
-export default abstract class DirectionLinkerBTModule extends BTModule {
-    instr: DirectionLinkerSymbol;
-    constructor(instr: DirectionLinkerSymbol);
-    private initialPositions;
-    private getInitialPositions;
-    checkGlobal(grid: BTGridData): CheckResult | false;
-    protected abstract movePos(grid: BTGridData, x: number, y: number): Position | null;
-}

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

@@ -1,121 +0,0 @@
-import BTModule, { BTTile, IntArray2D, } from '../data.js';
-export default class DirectionLinkerBTModule extends BTModule {
-    instr;
-    constructor(instr) {
-        super();
-        this.instr = instr;
-    }
-    initialPositions = null;
-    getInitialPositions() {
-        if (this.instr.x % 1 !== 0 && this.instr.y % 1 !== 0)
-            return [
-                { x: Math.floor(this.instr.x), y: Math.floor(this.instr.y) },
-                { x: Math.ceil(this.instr.x), y: Math.ceil(this.instr.y) },
-                { x: Math.floor(this.instr.x), y: Math.ceil(this.instr.y) },
-                { x: Math.ceil(this.instr.x), y: Math.floor(this.instr.y) },
-            ];
-        else if (this.instr.x % 1 !== 0)
-            return [
-                { x: Math.floor(this.instr.x), y: this.instr.y },
-                { x: Math.ceil(this.instr.x), y: this.instr.y },
-            ];
-        else if (this.instr.y % 1 !== 0)
-            return [
-                { x: this.instr.x, y: Math.floor(this.instr.y) },
-                { x: this.instr.x, y: Math.ceil(this.instr.y) },
-            ];
-        else
-            return [{ x: this.instr.x, y: this.instr.y }];
-    }
-    checkGlobal(grid) {
-        this.initialPositions ??= this.getInitialPositions();
-        const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
-        const ratings = [];
-        for (const pos of this.initialPositions) {
-            const tile = grid.isInBound(pos.x, pos.y)
-                ? grid.getTile(pos.x, pos.y)
-                : BTTile.NonExist;
-            if (tile === BTTile.Empty) {
-                const oppoPos = this.movePos(grid, pos.x, pos.y);
-                if (oppoPos === null ||
-                    grid.getTile(oppoPos.x, oppoPos.y) === BTTile.NonExist)
-                    return false;
-                else {
-                    if (grid.getTile(oppoPos.x, oppoPos.y) === BTTile.Empty) {
-                        tilesNeedCheck.set(oppoPos.x, oppoPos.y, 1);
-                        ratings.push({ pos: oppoPos, score: 1 });
-                    }
-                    tilesNeedCheck.set(pos.x, pos.y, 1);
-                    ratings.push({ pos, score: 1 });
-                }
-            }
-            else if (tile === BTTile.NonExist) {
-                const oppoPos = this.movePos(grid, pos.x, pos.y);
-                if (oppoPos !== null &&
-                    grid.getTile(oppoPos.x, oppoPos.y) !== BTTile.NonExist) {
-                    return false;
-                }
-            }
-            else {
-                const oppoPos = this.movePos(grid, pos.x, pos.y);
-                if (oppoPos !== null) {
-                    const oppoTile = grid.getTile(oppoPos.x, oppoPos.y);
-                    if (oppoTile === BTTile.Empty) {
-                        tilesNeedCheck.set(oppoPos.x, oppoPos.y, 1);
-                        ratings.push({ pos: oppoPos, score: 1 });
-                    }
-                    else if (oppoTile === BTTile.NonExist)
-                        return false;
-                }
-                else {
-                    return false;
-                }
-            }
-        }
-        if (ratings.length > 0) {
-            return { tilesNeedCheck, ratings };
-        }
-        const queue = this.initialPositions
-            .filter(pos => grid.isInBound(pos.x, pos.y) &&
-            grid.getTile(pos.x, pos.y) !== BTTile.NonExist)
-            .map(pos => {
-            const oppoPos = this.movePos(grid, pos.x, pos.y);
-            return {
-                pos,
-                color: grid.getTile(pos.x, pos.y),
-                oppoColor: grid.getTile(oppoPos.x, oppoPos.y),
-            };
-        });
-        const visited = IntArray2D.create(grid.width, grid.height);
-        // Visit all connected tiles
-        while (queue.length > 0) {
-            const curPos = queue.pop();
-            if (visited.get(curPos.pos.x, curPos.pos.y))
-                continue;
-            visited.set(curPos.pos.x, curPos.pos.y, 1);
-            const oppoPos = this.movePos(grid, curPos.pos.x, curPos.pos.y);
-            if (oppoPos === null)
-                return false;
-            const oppoTile = grid.getTile(oppoPos.x, oppoPos.y);
-            if (!(oppoTile === BTTile.Empty || oppoTile === curPos.oppoColor))
-                return false;
-            for (const edge of grid.getEdges(curPos.pos)) {
-                if (visited.get(edge.x, edge.y))
-                    continue;
-                const edgeTile = grid.getTile(edge.x, edge.y);
-                if (edgeTile === BTTile.Empty) {
-                    tilesNeedCheck.set(edge.x, edge.y, 1);
-                    ratings.push({ pos: edge, score: 1 });
-                }
-                else if (edgeTile === curPos.color) {
-                    queue.push({
-                        pos: edge,
-                        color: curPos.color,
-                        oppoColor: curPos.oppoColor,
-                    });
-                }
-            }
-        }
-        return { tilesNeedCheck, ratings };
-    }
-}

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

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

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

@@ -1,48 +0,0 @@
-import BTModule, { BTTile, IntArray2D, createOneTileResult, } from '../data.js';
-export default class FocusBTModule extends BTModule {
-    instr;
-    cachedCheckResult;
-    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 });
-        let gray = 0;
-        let same = 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 (y !== this.instr.y && x !== this.instr.x)
-                    continue;
-                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 === tile)
-                    same++;
-            }
-        }
-        if (same > this.instr.number || same + gray < this.instr.number)
-            return false;
-        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 (y !== this.instr.y && x !== this.instr.x)
-                    continue;
-                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/src/data/solver/backtrack/symbols/galaxy.d.ts

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

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

@@ -1,14 +0,0 @@
-import DirectionLinkerBTModule from './directionLinker.js';
-export default class GalaxyBTModule extends DirectionLinkerBTModule {
-    instr;
-    constructor(instr) {
-        super(instr);
-        this.instr = instr;
-    }
-    // Translate a position in relative to a galaxy symbol
-    movePos(grid, x, y) {
-        const symbol = this.instr;
-        const pos = { x: 2 * symbol.x - x, y: 2 * symbol.y - y };
-        return grid.isInBound(pos.x, pos.y) ? pos : null;
-    }
-}

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

@@ -1,9 +0,0 @@
-import LetterSymbol from '../../../symbols/letterSymbol.js';
-import BTModule, { BTGridData, CheckResult } from '../data.js';
-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/src/data/solver/backtrack/symbols/letter.js

@@ -1,95 +0,0 @@
-import BTModule, { BTTile, checkSubtilePlacement, IntArray2D, } from '../data.js';
-export default class LetterBTModule extends BTModule {
-    letters;
-    letterGrid;
-    constructor(instrs, width, height) {
-        super();
-        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 checkResult = checkSubtilePlacement(grid, symbol);
-                if (checkResult !== undefined)
-                    return checkResult;
-            }
-            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/src/data/solver/backtrack/symbols/lotus.d.ts

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

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

@@ -1,55 +0,0 @@
-import { Orientation } from '../../../primitives.js';
-import { BTTile } from '../data.js';
-import DirectionLinkerBTModule from './directionLinker.js';
-export default class LotusBTModule extends DirectionLinkerBTModule {
-    instr;
-    constructor(instr) {
-        super(instr);
-        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;
-    }
-    getTileSafe(grid, x, y) {
-        return grid.isInBound(x, y) ? grid.getTile(x, y) : BTTile.NonExist;
-    }
-    checkGlobal(grid) {
-        if (this.instr.orientation === Orientation.DownLeft ||
-            this.instr.orientation === Orientation.DownRight ||
-            this.instr.orientation === Orientation.UpLeft ||
-            this.instr.orientation === Orientation.UpRight) {
-            if (this.instr.x % 1 === 0 || this.instr.y % 1 === 0)
-                if (this.instr.x % 1 !== 0 || this.instr.y % 1 !== 0) {
-                    if (this.getTileSafe(grid, Math.floor(this.instr.x), Math.floor(this.instr.y)) === BTTile.NonExist &&
-                        this.getTileSafe(grid, Math.ceil(this.instr.x), Math.ceil(this.instr.y)) === BTTile.NonExist &&
-                        this.getTileSafe(grid, Math.floor(this.instr.x), Math.ceil(this.instr.y)) === BTTile.NonExist &&
-                        this.getTileSafe(grid, Math.ceil(this.instr.x), Math.floor(this.instr.y)) === BTTile.NonExist) {
-                        return { tilesNeedCheck: null, ratings: null };
-                    }
-                    else {
-                        return false;
-                    }
-                }
-        }
-        return super.checkGlobal(grid);
-    }
-}

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

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

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

@@ -1,44 +0,0 @@
-import BTModule, { BTTile, IntArray2D, createOneTileResult, getOppositeColor, } from '../data.js';
-export default class MinesweeperBTModule extends BTModule {
-    instr;
-    cachedCheckResult;
-    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 });
-        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;
-        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/src/data/solver/backtrack/symbols/myopia.d.ts

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

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

@@ -1,73 +0,0 @@
-import { move } from '../../../dataHelper.js';
-import { ORIENTATIONS, Orientation } from '../../../primitives.js';
-import BTModule, { BTTile, createOneTileResult, getOppositeColor, } from '../data.js';
-export default class MyopiaBTModule extends BTModule {
-    instr;
-    constructor(instr) {
-        super();
-        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 || curTile === BTTile.NonExist) {
-                        min += 1;
-                    }
-                    else {
-                        connected = false;
-                    }
-                }
-                if (getOppositeColor(tile) === curTile) {
-                    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/src/data/solver/backtrack/symbols/viewpoint.d.ts

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