@logic-pad/core 0.26.2 → 0.26.3

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

@@ -0,0 +1,151 @@
+import { Color } from '../../primitives.js';
+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 {
+    tiles;
+    connections;
+    modules;
+    width;
+    height;
+    constructor(tiles, connections, modules, width, height) {
+        this.tiles = tiles;
+        this.connections = connections;
+        this.modules = modules;
+        this.width = width;
+        this.height = 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 {
+    array;
+    width;
+    height;
+    constructor(array, width, height) {
+        this.array = array;
+        this.width = width;
+        this.height = 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 };
+}
+export function checkSubtilePlacement(grid, pos) {
+    const minX = Math.floor(pos.x);
+    const minY = Math.floor(pos.y);
+    if (minX === pos.x && minY === pos.y)
+        return undefined;
+    const maxX = Math.ceil(pos.x);
+    const maxY = Math.ceil(pos.y);
+    let color = null;
+    let complete = true;
+    for (let i = 0; i < 4; i++) {
+        const x = i % 2 === 0 ? minX : maxX;
+        const y = i < 2 ? minY : maxY;
+        if (!grid.isInBound(x, y))
+            return false;
+        const tile = grid.getTile(x, y);
+        if (tile === BTTile.NonExist)
+            return false;
+        if (tile !== BTTile.Empty) {
+            if (color !== null && tile !== color)
+                return false;
+            color = tile;
+        }
+        else {
+            complete = false;
+        }
+    }
+    if (complete) {
+        return undefined;
+    }
+    else {
+        const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
+        const ratings = [];
+        for (let i = 0; i < 4; i++) {
+            const x = i % 2 === 0 ? minX : maxX;
+            const y = i < 2 ? minY : maxY;
+            if (grid.getTile(x, y) === BTTile.Empty) {
+                tilesNeedCheck.set(x, y, 1);
+                ratings.push({ pos: { x, y }, score: 1 });
+            }
+        }
+        return { tilesNeedCheck, ratings };
+    }
+}

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

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

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

@@ -0,0 +1,77 @@
+import BTModule, { BTTile, colorToBTTile, } from '../data.js';
+export default class BanPatternBTModule extends BTModule {
+    instr;
+    constructor(instr) {
+        super();
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        for (const pattern of this.instr.cache) {
+            for (let y = 0; y <= grid.height - pattern.height; y++) {
+                for (let x = 0; x <= grid.width - pattern.width; x++) {
+                    let match = true;
+                    for (const tile of pattern.elements) {
+                        const t = grid.getTile(x + tile.x, y + tile.y);
+                        if (t !== colorToBTTile(tile.color)) {
+                            match = false;
+                            break;
+                        }
+                    }
+                    if (match) {
+                        return false;
+                    }
+                }
+            }
+        }
+        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/src/data/solver/backtrack/rules/cellCount.d.ts

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

package/dist/src/data/solver/backtrack/rules/cellCount.js

@@ -0,0 +1,25 @@
+import BTModule, { BTTile, colorToBTTile, } from '../data.js';
+export default class CellCountBTModule extends BTModule {
+    instr;
+    constructor(instr) {
+        super();
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        const color = colorToBTTile(this.instr.color);
+        let colored = 0;
+        let possible = 0;
+        for (let y = 0; y < grid.height; y++) {
+            for (let x = 0; x < grid.width; x++) {
+                const tile = grid.getTile(x, y);
+                if (tile === color)
+                    colored += 1;
+                else if (tile === BTTile.Empty)
+                    possible += 1;
+            }
+        }
+        if (colored > this.instr.count || colored + possible < this.instr.count)
+            return false;
+        return { tilesNeedCheck: null, ratings: null };
+    }
+}

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

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

package/dist/src/data/solver/backtrack/rules/connectAll.js

@@ -0,0 +1,44 @@
+import BTModule, { IntArray2D, colorToBTTile, getOppositeColor, } from '../data.js';
+export default class ConnectAllBTModule extends BTModule {
+    instr;
+    constructor(instr) {
+        super();
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        const color = colorToBTTile(this.instr.color);
+        // Find all same cells
+        const sameCells = [];
+        for (let y = 0; y < grid.height; y++) {
+            for (let x = 0; x < grid.width; x++) {
+                if (grid.getTile(x, y) === color) {
+                    sameCells.push({ x, y });
+                }
+            }
+        }
+        // If there are no same cells, return true
+        if (sameCells.length === 0)
+            return { tilesNeedCheck: null, ratings: null };
+        const queue = [sameCells[0]];
+        const visited = IntArray2D.create(grid.width, grid.height);
+        // Perform flood fill
+        visited.set(sameCells[0].x, sameCells[0].y, 1);
+        while (queue.length > 0) {
+            const curPos = queue.pop();
+            for (const edge of grid.getEdges(curPos)) {
+                if (visited.get(edge.x, edge.y) ||
+                    grid.getTile(edge.x, edge.y) === getOppositeColor(color)) {
+                    continue;
+                }
+                visited.set(edge.x, edge.y, 1);
+                queue.push(edge);
+            }
+        }
+        // Check if any same cell is not reachable
+        for (const cell of sameCells) {
+            if (!visited.get(cell.x, cell.y))
+                return false;
+        }
+        return { tilesNeedCheck: null, ratings: null };
+    }
+}

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

@@ -0,0 +1,8 @@
+import RegionAreaRule from '../../../rules/regionAreaRule.js';
+import BTModule, { BTGridData, CheckResult } from '../data.js';
+export default class RegionAreaBTModule extends BTModule {
+    instr: RegionAreaRule;
+    constructor(instr: RegionAreaRule);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+    private visitArea;
+}

package/dist/src/data/solver/backtrack/rules/regionArea.js

@@ -0,0 +1,71 @@
+import BTModule, { BTTile, IntArray2D, colorToBTTile, } from '../data.js';
+export default class RegionAreaBTModule extends BTModule {
+    instr;
+    constructor(instr) {
+        super();
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        const color = colorToBTTile(this.instr.color);
+        const visited = IntArray2D.create(grid.width, grid.height);
+        let id = 0;
+        for (let y = 0; y < grid.height; y++) {
+            for (let x = 0; x < grid.width; x++) {
+                if (visited.get(x, y) & 0b01111111)
+                    continue;
+                if (grid.getTile(x, y) !== color)
+                    continue;
+                id += 1;
+                if (id > 127)
+                    throw new Error('Too many regions!');
+                if (!this.visitArea(grid, color, visited, { x, y }, id))
+                    return false;
+            }
+        }
+        return { tilesNeedCheck: null, ratings: null };
+    }
+    visitArea(grid, tile, visited, pos, id) {
+        const sameTileQueue = [pos];
+        const usableTileQueue = [];
+        let sameCellCount = 0;
+        let usableCellCount = 0;
+        visited.set(pos.x, pos.y, id);
+        // 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) & 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 (sameCellCount > this.instr.size)
+            return false;
+        // Count usable tile
+        while (usableTileQueue.length > 0) {
+            const curPos = usableTileQueue.pop();
+            usableCellCount += 1;
+            if (sameCellCount + usableCellCount >= this.instr.size)
+                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 sameCellCount + usableCellCount >= this.instr.size;
+    }
+}

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

@@ -0,0 +1,8 @@
+import RegionShapeRule, { ShapeRegions } from '../../../rules/regionShapeRule.js';
+import BTModule, { BTGridData } from '../data.js';
+export default abstract class RegionShapeBTModule extends BTModule {
+    instr: RegionShapeRule;
+    constructor(instr: RegionShapeRule);
+    protected getShapeRegions(grid: BTGridData): ShapeRegions['regions'];
+    private visitArea;
+}

package/dist/src/data/solver/backtrack/rules/regionShape.js

@@ -0,0 +1,57 @@
+import { normalizeShape, positionsToShape, shapeEquals, } from '../../../shapes.js';
+import BTModule, { BTTile, IntArray2D, colorToBTTile, } from '../data.js';
+export default class RegionShapeBTModule extends BTModule {
+    instr;
+    constructor(instr) {
+        super();
+        this.instr = instr;
+    }
+    getShapeRegions(grid) {
+        // TODO: This is extremely slow, because it doesn't check shapes when shapes are not fully enclosed
+        const visited = IntArray2D.create(grid.width, grid.height);
+        const regions = [];
+        for (let y = 0; y < grid.height; y++) {
+            for (let x = 0; x < grid.width; x++) {
+                const tile = grid.getTile(x, y);
+                if (tile !== colorToBTTile(this.instr.color) || visited.get(x, y))
+                    continue;
+                const positions = this.visitArea(grid, tile, visited, { x, y });
+                if (!positions)
+                    continue;
+                const shape = normalizeShape(positionsToShape(positions, this.instr.color));
+                const existing = regions.find(island => shapeEquals(island.shape, shape));
+                if (existing) {
+                    existing.count++;
+                }
+                else {
+                    regions.push({ positions, shape, count: 1 });
+                }
+            }
+        }
+        return regions;
+    }
+    visitArea(grid, tile, visited, pos) {
+        const positions = [pos];
+        const sameTileQueue = [pos];
+        let incomplete = false;
+        visited.set(pos.x, pos.y, 1);
+        // Count same tile
+        while (sameTileQueue.length > 0) {
+            const curPos = sameTileQueue.pop();
+            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) {
+                    incomplete = true;
+                }
+                else if (edgeTile === tile) {
+                    positions.push(edge);
+                    sameTileQueue.push(edge);
+                    visited.set(edge.x, edge.y, 1);
+                }
+            }
+        }
+        return incomplete ? null : positions;
+    }
+}

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

@@ -0,0 +1,8 @@
+import SameShapeRule from '../../../rules/sameShapeRule.js';
+import { BTGridData, CheckResult } from '../data.js';
+import RegionShapeBTModule from './regionShape.js';
+export default class SameShapeBTModule extends RegionShapeBTModule {
+    instr: SameShapeRule;
+    constructor(instr: SameShapeRule);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+}

package/dist/src/data/solver/backtrack/rules/sameShape.js

@@ -0,0 +1,14 @@
+import RegionShapeBTModule from './regionShape.js';
+export default class SameShapeBTModule extends RegionShapeBTModule {
+    instr;
+    constructor(instr) {
+        super(instr);
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        const regions = this.getShapeRegions(grid);
+        return regions.length <= 1
+            ? { tilesNeedCheck: null, ratings: null }
+            : false;
+    }
+}

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

@@ -0,0 +1,10 @@
+import SymbolsPerRegionRule from '../../../rules/symbolsPerRegionRule.js';
+import Symbol from '../../../symbols/symbol.js';
+import BTModule, { BTGridData, CheckResult } from '../data.js';
+export default class SymbolsPerRegionBTModule extends BTModule {
+    instr: SymbolsPerRegionRule;
+    private symbolCount;
+    constructor(instr: SymbolsPerRegionRule, width: number, height: number, allSymbols: Symbol[]);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+    private visitArea;
+}

package/dist/src/data/solver/backtrack/rules/symbolsPerRegion.js

@@ -0,0 +1,82 @@
+import { Comparison } from '../../../primitives.js';
+import BTModule, { BTTile, IntArray2D, colorToBTTile, } from '../data.js';
+export default class SymbolsPerRegionBTModule extends BTModule {
+    instr;
+    symbolCount;
+    constructor(instr, width, height, allSymbols) {
+        super();
+        this.instr = instr;
+        this.symbolCount = IntArray2D.create(width, height);
+        for (const symbol of allSymbols) {
+            const symbolX = Math.floor(symbol.x);
+            const symbolY = Math.floor(symbol.y);
+            this.symbolCount.set(symbolX, symbolY, this.symbolCount.get(symbolX, symbolY) + 1);
+        }
+    }
+    checkGlobal(grid) {
+        const color = colorToBTTile(this.instr.color);
+        const visited = IntArray2D.create(grid.width, grid.height);
+        let id = 0;
+        for (let y = 0; y < grid.height; y++) {
+            for (let x = 0; x < grid.width; x++) {
+                if (visited.get(x, y) & 0b01111111)
+                    continue;
+                if (grid.getTile(x, y) !== color)
+                    continue;
+                id += 1;
+                if (id > 127)
+                    throw new Error('Too many regions!');
+                if (!this.visitArea(grid, color, visited, { x, y }, id))
+                    return false;
+            }
+        }
+        return { tilesNeedCheck: null, ratings: null };
+    }
+    visitArea(grid, tile, visited, pos, id) {
+        const sameTileQueue = [pos];
+        const usableTileQueue = [];
+        let completed = 0;
+        let possible = 0;
+        visited.set(pos.x, pos.y, id);
+        // Count same tile
+        while (sameTileQueue.length > 0) {
+            const curPos = sameTileQueue.pop();
+            completed += this.symbolCount.get(curPos.x, curPos.y);
+            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 (completed > this.instr.count) {
+            return this.instr.comparison === Comparison.AtLeast;
+        }
+        if (this.instr.comparison === Comparison.AtMost)
+            return true;
+        // Count usable tile
+        while (usableTileQueue.length > 0) {
+            const curPos = usableTileQueue.pop();
+            possible += this.symbolCount.get(curPos.x, curPos.y);
+            if (completed + possible >= this.instr.count)
+                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 completed + possible >= this.instr.count;
+    }
+}

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

@@ -0,0 +1,8 @@
+import UniqueShapeRule from '../../../rules/uniqueShapeRule.js';
+import { BTGridData, CheckResult } from '../data.js';
+import RegionShapeBTModule from './regionShape.js';
+export default class UniqueShapeBTModule extends RegionShapeBTModule {
+    instr: UniqueShapeRule;
+    constructor(instr: UniqueShapeRule);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+}

package/dist/src/data/solver/backtrack/rules/uniqueShape.js

@@ -0,0 +1,14 @@
+import RegionShapeBTModule from './regionShape.js';
+export default class UniqueShapeBTModule extends RegionShapeBTModule {
+    instr;
+    constructor(instr) {
+        super(instr);
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        const regions = this.getShapeRegions(grid);
+        return regions.every(r => r.count === 1)
+            ? { tilesNeedCheck: null, ratings: null }
+            : false;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Position } from '../../../primitives.js';
+import AreaNumberSymbol from '../../../symbols/areaNumberSymbol.js';
+import BTModule, { BTGridData, CheckResult } from '../data.js';
+export default class AreaNumberBTModule extends BTModule {
+    instr: AreaNumberSymbol;
+    constructor(instr: AreaNumberSymbol);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+    checkLocal(grid: BTGridData, positions: Position[]): CheckResult | boolean;
+}