@logic-pad/core 0.1.0

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,62 @@
+import { normalizeShape, positionsToShape, shapeEquals } from '../../../shapes';
+import BTModule, { BTTile, IntArray2D, colorToBTTile, } from '../data';
+export default class RegionShapeBTModule extends BTModule {
+    constructor(instr) {
+        super();
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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/data/solver/backtrack/rules/sameShape.d.ts

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

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

@@ -0,0 +1,19 @@
+import RegionShapeBTModule from './regionShape';
+export default class SameShapeBTModule extends RegionShapeBTModule {
+    constructor(instr) {
+        super(instr);
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        const regions = this.getShapeRegions(grid);
+        return regions.length <= 1
+            ? { tilesNeedCheck: null, ratings: null }
+            : false;
+    }
+}

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

@@ -0,0 +1,10 @@
+import SymbolsPerRegionRule from '../../../rules/symbolsPerRegionRule';
+import Symbol from '../../../symbols/symbol';
+import BTModule, { BTGridData, CheckResult } from '../data';
+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/data/solver/backtrack/rules/symbolsPerRegion.js

@@ -0,0 +1,92 @@
+import { Comparison } from '../../../primitives';
+import BTModule, { BTTile, IntArray2D, colorToBTTile, } from '../data';
+export default class SymbolsPerRegionBTModule extends BTModule {
+    constructor(instr, width, height, allSymbols) {
+        super();
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "symbolCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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/data/solver/backtrack/rules/uniqueShape.d.ts

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

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

@@ -0,0 +1,19 @@
+import RegionShapeBTModule from './regionShape';
+export default class UniqueShapeBTModule extends RegionShapeBTModule {
+    constructor(instr) {
+        super(instr);
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        const regions = this.getShapeRegions(grid);
+        return regions.every(r => r.count === 1)
+            ? { tilesNeedCheck: null, ratings: null }
+            : false;
+    }
+}

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

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

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

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

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

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

@@ -0,0 +1,58 @@
+import { move } from '../../../dataHelper';
+import BTModule, { BTTile, IntArray2D, createOneTileResult, getOppositeColor, } from '../data';
+export default class DartBTModule 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 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;
+        if (!this.cachedCheckResult)
+            this.cachedCheckResult = this.buildCheckAndRating(grid);
+        return this.cachedCheckResult;
+    }
+    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/data/solver/backtrack/symbols/directionLinker.d.ts

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

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

@@ -0,0 +1,50 @@
+import BTModule, { BTTile, IntArray2D, createOneTileResult, } from '../data';
+export default class DirectionLinkerBTModule extends BTModule {
+    constructor(instr) {
+        super();
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        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 tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
+        const ratings = [];
+        const queue = [{ x: thisX, y: thisY }];
+        const visited = IntArray2D.create(grid.width, grid.height);
+        // Visit all connected tiles
+        while (queue.length > 0) {
+            const curPos = queue.pop();
+            if (visited.get(curPos.x, curPos.y))
+                continue;
+            visited.set(curPos.x, curPos.y, 1);
+            const oppoPos = this.movePos(grid, curPos.x, curPos.y);
+            if (oppoPos === null)
+                return false;
+            const oppoTile = grid.getTile(oppoPos.x, oppoPos.y);
+            if (!(oppoTile === BTTile.Empty || oppoTile === tile))
+                return false;
+            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) {
+                    tilesNeedCheck.set(edge.x, edge.y, 1);
+                    ratings.push({ pos: edge, score: 1 });
+                }
+                else if (edgeTile === tile) {
+                    queue.push(edge);
+                }
+            }
+        }
+        return { tilesNeedCheck, ratings };
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+import DirectionLinkerBTModule from './directionLinker';
+export default class GalaxyBTModule 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 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;
+    }
+}