@logic-pad/core 0.26.0 → 0.26.2

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

@@ -1,51 +0,0 @@
-import BTModule, { BTTile, IntArray2D, createOneTileResult, getOppositeColor, } from '../data.js';
-export default class ViewpointBTModule 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 });
-        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/src/data/solver/cspuz/cspuzSolver.d.ts

@@ -1,13 +0,0 @@
-import EventIteratingSolver from '../eventIteratingSolver.js';
-import GridData from '../../grid.js';
-import Instruction from '../../instruction.js';
-export default class CspuzSolver extends EventIteratingSolver {
-    private static readonly supportedInstrs;
-    readonly id = "cspuz";
-    readonly author = "semiexp";
-    readonly description = "A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued).";
-    protected createWorker(): Worker;
-    isGridSupported(grid: GridData): boolean;
-    isInstructionSupported(grid: GridData, instruction: Instruction): boolean;
-    isEnvironmentSupported(): Promise<boolean>;
-}

package/dist/src/data/solver/cspuz/cspuzSolver.js

@@ -1,117 +0,0 @@
-import { instance as banPatternInstance } from '../../rules/banPatternRule.js';
-import { instance as cellCountInstance } from '../../rules/cellCountRule.js';
-import { instance as regionAreaInstance } from '../../rules/regionAreaRule.js';
-import { instance as sameShapeInstance } from '../../rules/sameShapeRule.js';
-import { instance as symbolsPerRegionInstance } from '../../rules/symbolsPerRegionRule.js';
-import { instance as undercluedInstance } from '../../rules/undercluedRule.js';
-import { instance as uniqueShapeInstance } from '../../rules/uniqueShapeRule.js';
-import { instance as offByXInstance } from '../../rules/offByXRule.js';
-import AreaNumberSymbol, { instance as areaNumberInstance, } from '../../symbols/areaNumberSymbol.js';
-import { instance as dartInstance } from '../../symbols/dartSymbol.js';
-import GalaxySymbol, { instance as galaxyInstance, } from '../../symbols/galaxySymbol.js';
-import LetterSymbol, { instance as letterInstance, } from '../../symbols/letterSymbol.js';
-import LotusSymbol, { instance as lotusInstance, } from '../../symbols/lotusSymbol.js';
-import { instance as minesweeperInstance } from '../../symbols/minesweeperSymbol.js';
-import { instance as viewpointInstance } from '../../symbols/viewpointSymbol.js';
-import { instance as connectAllInstance } from '../../rules/connectAllRule.js';
-import EventIteratingSolver from '../eventIteratingSolver.js';
-import GridData from '../../grid.js';
-import { Color } from '../../primitives.js';
-// eslint-disable-next-line @typescript-eslint/no-unused-expressions
-('vite-apply-code-mod');
-export default class CspuzSolver extends EventIteratingSolver {
-    static supportedInstrs = [
-        minesweeperInstance.id,
-        areaNumberInstance.id,
-        letterInstance.id,
-        dartInstance.id,
-        viewpointInstance.id,
-        lotusInstance.id,
-        galaxyInstance.id,
-        connectAllInstance.id,
-        banPatternInstance.id,
-        sameShapeInstance.id,
-        uniqueShapeInstance.id,
-        regionAreaInstance.id,
-        cellCountInstance.id,
-        offByXInstance.id,
-        undercluedInstance.id,
-        symbolsPerRegionInstance.id,
-    ];
-    id = 'cspuz';
-    author = 'semiexp';
-    description = 'A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued).';
-    createWorker() {
-        return new Worker(new URL('./cspuzWorker.js', import.meta.url), {
-            type: 'module',
-        });
-    }
-    isGridSupported(grid) {
-        if (!super.isGridSupported(grid)) {
-            return false;
-        }
-        // special handling for fixed gray tiles
-        if (grid.getTileCount(true, true, Color.Gray) > 0) {
-            return false;
-        }
-        return true;
-    }
-    isInstructionSupported(grid, instruction) {
-        if (instruction instanceof LotusSymbol ||
-            instruction instanceof GalaxySymbol) {
-            if (instruction.x % 1 !== 0 && instruction.y % 1 !== 0) {
-                return false;
-            }
-        }
-        if (instruction instanceof LotusSymbol ||
-            instruction instanceof GalaxySymbol ||
-            instruction instanceof AreaNumberSymbol ||
-            instruction instanceof LetterSymbol) {
-            if (instruction.x % 1 !== 0 || instruction.y % 1 !== 0) {
-                const minX = Math.floor(instruction.x);
-                const minY = Math.floor(instruction.y);
-                const maxX = Math.ceil(instruction.x);
-                const maxY = Math.ceil(instruction.y);
-                const connectedTiles = grid.connections.getConnectedTiles({
-                    x: minX,
-                    y: minY,
-                });
-                if (connectedTiles.some(tile => tile.x === minX && tile.y === maxY) &&
-                    connectedTiles.some(tile => tile.x === maxX && tile.y === minY) &&
-                    connectedTiles.some(tile => tile.x === maxX && tile.y === maxY)) {
-                    return true;
-                }
-                let color = Color.Gray;
-                for (let i = 0; i < 4; i++) {
-                    const x = i % 2 === 0 ? minX : maxX;
-                    const y = i < 2 ? minY : maxY;
-                    const tile = grid.getTile(x, y);
-                    if (!tile.fixed || !tile.exists) {
-                        return false;
-                    }
-                    if (tile.color !== Color.Gray) {
-                        if (color === Color.Gray) {
-                            color = tile.color;
-                        }
-                        else if (color !== tile.color) {
-                            return false;
-                        }
-                    }
-                }
-                return true;
-            }
-        }
-        return CspuzSolver.supportedInstrs.includes(instruction.id);
-    }
-    async isEnvironmentSupported() {
-        try {
-            for await (const _ of this.solve(GridData.create(['.']))) {
-                // do nothing
-            }
-            return true;
-        }
-        catch (_ex) {
-            return false;
-        }
-    }
-}

package/dist/src/data/solver/cspuz/cspuzWorker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/data/solver/cspuz/cspuzWorker.js

@@ -1,82 +0,0 @@
-import { solveLogicPad } from 'logic-pad-solver-core';
-import { Serializer } from '../../serializer/allSerializers.js';
-import { gridToJson } from './jsonify.js';
-import { instance as undercluedInstance } from '../../rules/undercluedRule.js';
-import { Color } from '../../primitives.js';
-function stringToColor(str) {
-    if (str === 'dark') {
-        return Color.Dark;
-    }
-    else if (str === 'light') {
-        return Color.Light;
-    }
-    else {
-        return Color.Gray;
-    }
-}
-function postSolution(grid, solverResult) {
-    if (solverResult === null) {
-        postMessage(null);
-    }
-    else if ('error' in solverResult) {
-        throw new Error(solverResult.error);
-    }
-    else {
-        const solution = grid.withTiles(tiles => {
-            for (const [y, row] of solverResult.entries()) {
-                for (const [x, color] of row.entries()) {
-                    tiles[y][x] = tiles[y][x].withColor(stringToColor(color));
-                }
-            }
-            return tiles;
-        });
-        postMessage(Serializer.stringifyGrid(solution));
-    }
-}
-onmessage = e => {
-    const grid = Serializer.parseGrid(e.data);
-    const isUnderclued = !!grid.findRule(r => r.id === undercluedInstance.id);
-    const puzzleData = gridToJson(grid);
-    const solverResult = solveLogicPad(puzzleData, isUnderclued);
-    postSolution(grid, solverResult);
-    if (isUnderclued) {
-        postMessage(null);
-        return;
-    }
-    // Make use of the underclued mode to determine solution uniqueness
-    if (solverResult !== null && !('error' in solverResult) && !isUnderclued) {
-        const undercluedResult = solveLogicPad(puzzleData, true);
-        if (undercluedResult === null) {
-            postMessage(undefined); // Shouldn't happen because underclued grids should always be solvable
-        }
-        else if ('error' in undercluedResult) {
-            throw new Error(undercluedResult.error);
-        }
-        else if (undercluedResult.every((row, y) => row.every((cell, x) => cell !== null || !grid.getTile(x, y).exists))) {
-            postMessage(null);
-        }
-        else {
-            let tweaked = false;
-            for (const [y, row] of undercluedResult.entries()) {
-                for (const [x, color] of row.entries()) {
-                    if (color !== null) {
-                        puzzleData.tiles[y][x].fixed = true;
-                        puzzleData.tiles[y][x].color = color;
-                    }
-                    else if (!tweaked && puzzleData.tiles[y][x].exists) {
-                        const positions = grid.connections.getConnectedTiles({ x, y });
-                        const newColor = solverResult[y][x] === 'dark' ? 'light' : 'dark';
-                        positions.forEach(({ x: px, y: py }) => {
-                            puzzleData.tiles[py][px].fixed = true;
-                            puzzleData.tiles[py][px].color = newColor;
-                        });
-                        tweaked = true;
-                    }
-                }
-            }
-            const secondResult = solveLogicPad(puzzleData, false);
-            postSolution(grid, secondResult);
-        }
-    }
-    postMessage(undefined);
-};

package/dist/src/data/solver/cspuz/jsonify.d.ts

@@ -1,3 +0,0 @@
-import { PuzzleData } from 'logic-pad-solver-core';
-import GridData from '../../grid.js';
-export declare function gridToJson(grid: GridData): PuzzleData;

package/dist/src/data/solver/cspuz/jsonify.js

@@ -1,211 +0,0 @@
-import { Color, Comparison } from '../../primitives.js';
-import BanPatternRule from '../../rules/banPatternRule.js';
-import CellCountRule from '../../rules/cellCountRule.js';
-import ConnectAllRule from '../../rules/connectAllRule.js';
-import OffByXRule from '../../rules/offByXRule.js';
-import RegionAreaRule from '../../rules/regionAreaRule.js';
-import SameShapeRule from '../../rules/sameShapeRule.js';
-import SymbolsPerRegionRule from '../../rules/symbolsPerRegionRule.js';
-import UndercluedRule from '../../rules/undercluedRule.js';
-import UniqueShapeRule from '../../rules/uniqueShapeRule.js';
-import { instance as areaNumberInstance, } from '../../symbols/areaNumberSymbol.js';
-import { instance as dartInstance, } from '../../symbols/dartSymbol.js';
-import { instance as galaxyInstance, } from '../../symbols/galaxySymbol.js';
-import { instance as letterInstance, } from '../../symbols/letterSymbol.js';
-import { instance as lotusInstance, } from '../../symbols/lotusSymbol.js';
-import { instance as minesweeperInstance, } from '../../symbols/minesweeperSymbol.js';
-import { instance as viewpointInstance, } from '../../symbols/viewpointSymbol.js';
-import TileData from '../../tile.js';
-function canonizeTiles(tileData) {
-    const ret = [];
-    for (const row of tileData) {
-        const newRow = [];
-        for (const tile of row) {
-            if (tile.exists) {
-                newRow.push(tile);
-            }
-            else {
-                newRow.push(new TileData(true, false, Color.Gray));
-            }
-        }
-        ret.push(newRow);
-    }
-    return ret;
-}
-export function gridToJson(grid) {
-    const rules = [];
-    for (const rule of grid.rules) {
-        if (rule instanceof ConnectAllRule) {
-            rules.push({
-                type: 'connectAll',
-                color: rule.color,
-            });
-        }
-        else if (rule instanceof BanPatternRule) {
-            rules.push({
-                type: 'forbiddenPattern',
-                pattern: canonizeTiles(rule.pattern.tiles),
-            });
-        }
-        else if (rule instanceof SameShapeRule) {
-            rules.push({
-                type: 'sameShape',
-                color: rule.color,
-            });
-        }
-        else if (rule instanceof UniqueShapeRule) {
-            rules.push({
-                type: 'uniqueShape',
-                color: rule.color,
-            });
-        }
-        else if (rule instanceof RegionAreaRule) {
-            rules.push({
-                type: 'regionArea',
-                color: rule.color,
-                size: rule.size,
-            });
-        }
-        else if (rule instanceof CellCountRule) {
-            rules.push({
-                type: 'cellCount',
-                color: rule.color,
-                count: rule.count,
-            });
-        }
-        else if (rule instanceof OffByXRule) {
-            rules.push({
-                type: 'offByX',
-                number: rule.number,
-            });
-        }
-        else if (rule instanceof UndercluedRule) {
-            continue;
-        }
-        else if (rule instanceof SymbolsPerRegionRule) {
-            let kind;
-            if (rule.comparison === Comparison.Equal) {
-                kind = 'exactly';
-            }
-            else if (rule.comparison === Comparison.AtLeast) {
-                kind = 'atLeast';
-            }
-            else if (rule.comparison === Comparison.AtMost) {
-                kind = 'atMost';
-            }
-            else {
-                throw new Error(`Unknown comparison (${rule.comparison})`);
-            }
-            rules.push({
-                type: 'symbolCount',
-                number: rule.count,
-                kind,
-                color: rule.color,
-            });
-        }
-        else if (rule.necessaryForCompletion) {
-            throw new Error(`Unknown rule type (${rule.explanation})`);
-        }
-    }
-    for (const [rule, symbols] of grid.symbols) {
-        if (rule === minesweeperInstance.id) {
-            rules.push({
-                type: 'minesweeper',
-                tiles: symbols.map(s => ({
-                    x: Math.floor(s.x),
-                    y: Math.floor(s.y),
-                    number: s.number,
-                })),
-            });
-        }
-        else if (rule === areaNumberInstance.id) {
-            rules.push({
-                type: 'number',
-                tiles: symbols.map(s => ({
-                    x: Math.floor(s.x),
-                    y: Math.floor(s.y),
-                    number: s.number,
-                })),
-            });
-        }
-        else if (rule === letterInstance.id) {
-            rules.push({
-                type: 'letter',
-                tiles: symbols.map(s => ({
-                    x: Math.floor(s.x),
-                    y: Math.floor(s.y),
-                    letter: s.letter,
-                })),
-            });
-        }
-        else if (rule === dartInstance.id) {
-            rules.push({
-                type: 'dart',
-                tiles: symbols.map(s => ({
-                    x: Math.floor(s.x),
-                    y: Math.floor(s.y),
-                    orientation: s.orientation,
-                    number: s.number,
-                })),
-            });
-        }
-        else if (rule === viewpointInstance.id) {
-            rules.push({
-                type: 'viewpoint',
-                tiles: symbols.map(s => ({
-                    x: Math.floor(s.x),
-                    y: Math.floor(s.y),
-                    number: s.number,
-                })),
-            });
-        }
-        else if (rule === lotusInstance.id) {
-            const tiles = symbols.map(s => ({
-                x: Math.round(s.x * 2),
-                y: Math.round(s.y * 2),
-                orientation: s.orientation,
-            }));
-            rules.push({
-                type: 'lotus',
-                tiles,
-            });
-        }
-        else if (rule === galaxyInstance.id) {
-            const tiles = symbols.map(s => ({
-                x: Math.round(s.x * 2),
-                y: Math.round(s.y * 2),
-            }));
-            rules.push({
-                type: 'galaxy',
-                tiles,
-            });
-        }
-        else if (symbols.some(s => s.necessaryForCompletion)) {
-            throw new Error(`Unknown symbol type: ${rule}`);
-        }
-    }
-    const connections = grid.connections.edges.map(edge => {
-        return {
-            x1: edge.x1,
-            y1: edge.y1,
-            x2: edge.x2,
-            y2: edge.y2,
-        };
-    });
-    const tiles = grid.tiles.map(row => {
-        return row.map(tile => {
-            return {
-                exists: tile.exists,
-                fixed: tile.fixed,
-                color: tile.color,
-            };
-        });
-    });
-    return {
-        width: grid.width,
-        height: grid.height,
-        connections,
-        tiles,
-        rules,
-    };
-}

package/dist/src/data/solver/eventIteratingSolver.d.ts

@@ -1,8 +0,0 @@
-import GridData from '../grid.js';
-import Solver from './solver.js';
-export default abstract class EventIteratingSolver extends Solver {
-    readonly supportsCancellation = true;
-    protected abstract createWorker(): Worker;
-    protected isEnvironmentSupported(): Promise<boolean>;
-    solve(grid: GridData, abortSignal?: AbortSignal): AsyncGenerator<GridData | null>;
-}

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

@@ -1,54 +0,0 @@
-import { Serializer } from '../serializer/allSerializers.js';
-import Solver from './solver.js';
-import { EventIterator } from 'event-iterator';
-export default class EventIteratingSolver extends Solver {
-    supportsCancellation = true;
-    isEnvironmentSupported() {
-        try {
-            const worker = this.createWorker();
-            worker.terminate();
-            return Promise.resolve(true);
-        }
-        catch (_ex) {
-            return Promise.resolve(false);
-        }
-    }
-    async *solve(grid, abortSignal) {
-        const worker = this.createWorker();
-        let terminateHandler;
-        try {
-            const iterator = new EventIterator(({ push, stop, fail }) => {
-                terminateHandler = () => {
-                    worker.terminate();
-                    stop();
-                };
-                abortSignal?.addEventListener('abort', terminateHandler);
-                worker.postMessage(Serializer.stringifyGrid(grid.resetTiles()));
-                worker.addEventListener('message', (e) => {
-                    if (e.data) {
-                        push(Serializer.parseGrid(e.data));
-                    }
-                    else if (e.data === null) {
-                        push(null);
-                        stop(); // Stop after the first signal for out of solutions
-                    }
-                    else {
-                        stop();
-                    }
-                });
-                worker.addEventListener('error', (e) => {
-                    alert(`Error while solving!\n${e.message}`);
-                    fail(e);
-                });
-            });
-            for await (const solution of iterator) {
-                yield solution;
-            }
-        }
-        finally {
-            worker.terminate();
-            if (terminateHandler)
-                abortSignal?.removeEventListener('abort', terminateHandler);
-        }
-    }
-}

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

@@ -1,77 +0,0 @@
-import { CachedAccess } from '../dataHelper.js';
-import GridData from '../grid.js';
-import { Instruction } from '../../index.js';
-/**
- * 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;
-    /**
-     * The author(s) of the solver.
-     */
-    abstract get author(): string;
-    /**
-     * A short paragraph describing when the user should use this solver.
-     */
-    abstract get description(): string;
-    /**
-     * Whether the solver supports cancellation. If `true`, the solver must respond to the abort signal if it is provided.
-     */
-    abstract get supportsCancellation(): boolean;
-    /**
-     * 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.
-     *
-     * If the solve finds the trivial solution of not filling any tiles, such as in the case of an underclued grid with
-     * too many alternate solutions, it must yield the solution instead of yielding `null`.
-     *
-     * 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.
-     * @param abortSignal An optional signal that the solver should subscribe to in order to cancel the operation. If the
-     * solver does not support cancellation, it should ignore this parameter.
-     */
-    abstract solve(grid: GridData, abortSignal?: AbortSignal): 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.
-     */
-    protected isEnvironmentSupported(): Promise<boolean>;
-    readonly environmentCheck: CachedAccess<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(_grid: GridData, instruction: Instruction): 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/src/data/solver/solver.js

@@ -1,59 +0,0 @@
-import { CachedAccess } from '../dataHelper.js';
-import { allRules } from '../rules/index.js';
-import { allSymbols } from '../symbols/index.js';
-import { instance as undercluedInstance } from '../rules/undercluedRule.js';
-/**
- * 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);
-    }
-    environmentCheck = CachedAccess.of(() => this.isEnvironmentSupported());
-    /**
-     * 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(_grid, instruction) {
-        const symbol = allSymbols.get(instruction.id);
-        if (symbol) {
-            return !symbol.validateWithSolution;
-        }
-        const rule = allRules.get(instruction.id);
-        if (rule) {
-            return !rule.validateWithSolution || rule.id === undercluedInstance.id;
-        }
-        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(grid, rule))) {
-            return false;
-        }
-        if ([...grid.symbols.values()].some(symbols => symbols.some(s => s.necessaryForCompletion && !this.isInstructionSupported(grid, s)))) {
-            return false;
-        }
-        return true;
-    }
-}