@logic-pad/core 0.4.5 → 0.5.0

package/dist/data/primitives.d.ts

@@ -17,9 +17,25 @@ export declare enum MajorRule {
     Underclued = "underclued"
 }
 export declare enum State {
+    /**
+     * Describes the violation of a rule.
+     */
     Error = "error",
+    /**
+     * Describes that a rule is satisfied and complete in the current grid.
+     */
     Satisfied = "satisfied",
-    Incomplete = "incomplete"
+    /**
+     * Describes that a rule is not violated, but is not yet complete in the current grid.
+     */
+    Incomplete = "incomplete",
+    /**
+     * Describes that a rule is violated but ignored due to the effect of another rule.
+     */
+    Ignored = "ignored"
+}
+export declare namespace State {
+    function isSatisfied(state: State): boolean;
 }
 export type RuleState = {
     readonly state: State.Error;
@@ -28,6 +44,8 @@ export type RuleState = {
     readonly state: State.Satisfied;
 } | {
     readonly state: State.Incomplete;
+} | {
+    readonly state: State.Ignored;
 };
 export interface GridState {
     final: State;

package/dist/data/primitives.js

@@ -9,9 +9,29 @@ export var MajorRule;
 })(MajorRule || (MajorRule = {}));
 export var State;
 (function (State) {
+    /**
+     * Describes the violation of a rule.
+     */
     State["Error"] = "error";
+    /**
+     * Describes that a rule is satisfied and complete in the current grid.
+     */
     State["Satisfied"] = "satisfied";
+    /**
+     * Describes that a rule is not violated, but is not yet complete in the current grid.
+     */
     State["Incomplete"] = "incomplete";
+    /**
+     * Describes that a rule is violated but ignored due to the effect of another rule.
+     */
+    State["Ignored"] = "ignored";
+})(State || (State = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (State) {
+    function isSatisfied(state) {
+        return state === State.Satisfied || state === State.Ignored;
+    }
+    State.isSatisfied = isSatisfied;
 })(State || (State = {}));
 export var Color;
 (function (Color) {

package/dist/data/rules/banPatternRule.js

@@ -26,7 +26,9 @@ class BanPatternRule extends Rule {
         });
         this.pattern = pattern
             // unlock all tiles
-            .withTiles(tiles => tiles.map(row => row.map(t => t.withFixed(false))))
+            .withTiles(tiles => tiles.map(row => row.map(t => t.exists
+            ? t.withFixed(false)
+            : t.copyWith({ exists: true, color: Color.Gray, fixed: false }))))
             // strip all symbols and rules
             .withRules([])
             .withSymbols(new Map());

package/dist/data/rules/lyingSymbolRule.d.ts

@@ -0,0 +1,30 @@
+import { AnyConfig } from '../config.js';
+import { FinalValidationHandler } from '../events/onFinalValidation.js';
+import GridData from '../grid.js';
+import { GridState, RuleState } from '../primitives.js';
+import Rule, { SearchVariant } from './rule.js';
+export default class LyingSymbolRule extends Rule implements FinalValidationHandler {
+    readonly count: number;
+    private static readonly EXAMPLE_GRID;
+    private static readonly CONFIGS;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **<count> symbols are lying and can be ignored**
+     *
+     * @param count Number of lying symbols
+     */
+    constructor(count: number);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(_: GridData): RuleState;
+    get isSingleton(): boolean;
+    onFinalValidation(grid: GridData, solution: GridData | null, state: GridState): GridState;
+    copyWith({ count }: {
+        count?: number;
+    }): this;
+    withCount(count: number): this;
+}
+export declare const instance: LyingSymbolRule;

package/dist/data/rules/lyingSymbolRule.js

@@ -0,0 +1,214 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { Color, State } from '../primitives.js';
+import Rule from './rule.js';
+import CustomIconSymbol from '../symbols/customIconSymbol.js';
+import validateGrid from '../validate.js';
+import Symbol from '../symbols/symbol.js';
+class IgnoredSymbol extends Symbol {
+    constructor(symbol) {
+        super(symbol.x, symbol.y);
+        Object.defineProperty(this, "symbol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: symbol
+        });
+        this.symbol = symbol;
+    }
+    get id() {
+        return this.symbol.id;
+    }
+    get explanation() {
+        return this.symbol.explanation;
+    }
+    get configs() {
+        return this.symbol.configs;
+    }
+    createExampleGrid() {
+        return this.symbol.createExampleGrid();
+    }
+    get necessaryForCompletion() {
+        return this.symbol.necessaryForCompletion;
+    }
+    get visibleWhenSolving() {
+        return this.symbol.visibleWhenSolving;
+    }
+    get sortOrder() {
+        return this.symbol.sortOrder;
+    }
+    validateSymbol(_grid, _solution) {
+        return State.Ignored;
+    }
+    copyWith({ symbol }) {
+        return new IgnoredSymbol(symbol ?? this.symbol);
+    }
+    withSymbol(symbol) {
+        return this.copyWith({ symbol });
+    }
+}
+class IgnoredRule extends Rule {
+    constructor(rule, state) {
+        super();
+        Object.defineProperty(this, "rule", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: rule
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+        this.rule = rule;
+        this.state = state;
+    }
+    get searchVariants() {
+        return [];
+    }
+    get id() {
+        return this.rule.id;
+    }
+    get explanation() {
+        return this.rule.explanation;
+    }
+    createExampleGrid() {
+        return this.rule.createExampleGrid();
+    }
+    get necessaryForCompletion() {
+        return this.rule.necessaryForCompletion;
+    }
+    get visibleWhenSolving() {
+        return this.rule.visibleWhenSolving;
+    }
+    get isSingleton() {
+        return this.rule.isSingleton;
+    }
+    validateGrid(_grid) {
+        if (this.state === State.Error)
+            return { state: State.Error, positions: [] };
+        else
+            return { state: this.state };
+    }
+    copyWith({ rule, state }) {
+        return new IgnoredRule(rule ?? this.rule, state ?? this.state);
+    }
+}
+class LyingSymbolRule extends Rule {
+    /**
+     * **<count> symbols are lying and can be ignored**
+     *
+     * @param count Number of lying symbols
+     */
+    constructor(count) {
+        super();
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: count
+        });
+        this.count = count;
+    }
+    get id() {
+        return `lying_symbols`;
+    }
+    get explanation() {
+        return `${this.count} symbol${this.count <= 1 ? ' is' : 's are'} *lying* and can be ignored`;
+    }
+    get configs() {
+        return LyingSymbolRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return LyingSymbolRule.EXAMPLE_GRID;
+    }
+    get searchVariants() {
+        return LyingSymbolRule.SEARCH_VARIANTS;
+    }
+    validateGrid(_) {
+        return { state: State.Incomplete };
+    }
+    get isSingleton() {
+        return true;
+    }
+    onFinalValidation(grid, solution, state) {
+        const ignoredSymbols = [];
+        state.symbols.forEach((values, key) => {
+            values.forEach((state, idx) => {
+                if (state === State.Error)
+                    ignoredSymbols.push([key, idx]);
+            });
+        });
+        if (ignoredSymbols.length > this.count) {
+            const thisIdx = grid.rules.findIndex(rule => rule.id === this.id);
+            return {
+                final: State.Error,
+                rules: state.rules.map((rule, idx) => idx === thisIdx ? { state: State.Error, positions: [] } : rule),
+                symbols: state.symbols,
+            };
+        }
+        const newSymbols = new Map();
+        grid.symbols.forEach((values, key) => {
+            values.forEach((symbol, idx) => {
+                if (!newSymbols.has(key)) {
+                    newSymbols.set(key, []);
+                }
+                if (ignoredSymbols.some(([k, i]) => k === key && i === idx)) {
+                    newSymbols.get(key).push(new IgnoredSymbol(symbol));
+                }
+                else {
+                    newSymbols.get(key).push(symbol);
+                }
+            });
+        });
+        const newRules = grid.rules.map(rule => rule.id === this.id
+            ? new IgnoredRule(this, ignoredSymbols.length === this.count
+                ? State.Satisfied
+                : grid.getTileCount(true, false, Color.Gray) === 0
+                    ? State.Error
+                    : State.Incomplete)
+            : rule);
+        return validateGrid(grid.copyWith({ rules: newRules, symbols: newSymbols }), solution);
+    }
+    copyWith({ count }) {
+        return new LyingSymbolRule(count ?? this.count);
+    }
+    withCount(count) {
+        return this.copyWith({ count });
+    }
+}
+Object.defineProperty(LyingSymbolRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['.']).addSymbol(new CustomIconSymbol('', GridData.create([]), 0, 0, 'MdOutlineDeblur')))
+});
+Object.defineProperty(LyingSymbolRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Number,
+            default: 1,
+            min: 1,
+            max: 100,
+            step: 1,
+            field: 'count',
+            description: 'Number of liars',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(LyingSymbolRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new LyingSymbolRule(1).searchVariant(),
+    ]
+});
+export default LyingSymbolRule;
+export const instance = new LyingSymbolRule(1);

package/dist/data/rules/mysteryRule.js

@@ -52,7 +52,7 @@ class MysteryRule extends Rule {
         return false;
     }
     onFinalValidation(grid, _solution, state) {
-        if (state.final === State.Satisfied)
+        if (State.isSatisfied(state.final))
             return state;
         if (grid.colorEquals(this.solution))
             return {

package/dist/data/rules/offByXRule.d.ts

@@ -20,7 +20,7 @@ export default class OffByXRule extends Rule implements SymbolValidationHandler
     get configs(): readonly AnyConfig[] | null;
     createExampleGrid(): GridData;
     get searchVariants(): SearchVariant[];
-    validateGrid(_grid: GridData): RuleState;
+    validateGrid(grid: GridData): RuleState;
     onSymbolValidation(grid: GridData, symbol: Symbol, _validator: (grid: GridData) => State): State | undefined;
     get isSingleton(): boolean;
     copyWith({ number }: {

package/dist/data/rules/offByXRule.js

@@ -1,6 +1,6 @@
 import { ConfigType } from '../config.js';
 import GridData from '../grid.js';
-import { State } from '../primitives.js';
+import { Color, State } from '../primitives.js';
 import AreaNumberSymbol from '../symbols/areaNumberSymbol.js';
 import NumberSymbol from '../symbols/numberSymbol.js';
 import Rule from './rule.js';
@@ -38,8 +38,12 @@ class OffByXRule extends Rule {
     get searchVariants() {
         return OffByXRule.SEARCH_VARIANTS;
     }
-    validateGrid(_grid) {
-        return { state: State.Incomplete };
+    validateGrid(grid) {
+        return {
+            state: grid.getTileCount(true, false, Color.Gray) === 0
+                ? State.Satisfied
+                : State.Incomplete,
+        };
     }
     onSymbolValidation(grid, symbol, _validator) {
         if (symbol instanceof NumberSymbol) {

package/dist/data/rules/rules.gen.d.ts

@@ -5,6 +5,7 @@ export { instance as CompletePatternRule } from './completePatternRule.js';
 export { instance as ConnectAllRule } from './connectAllRule.js';
 export { instance as CustomRule } from './customRule.js';
 export { instance as ForesightRule } from './foresightRule.js';
+export { instance as LyingSymbolRule } from './lyingSymbolRule.js';
 export { instance as MusicGridRule } from './musicGridRule.js';
 export { instance as MysteryRule } from './mysteryRule.js';
 export { instance as OffByXRule } from './offByXRule.js';

package/dist/data/rules/rules.gen.js

@@ -9,6 +9,7 @@ export { instance as CompletePatternRule } from './completePatternRule.js';
 export { instance as ConnectAllRule } from './connectAllRule.js';
 export { instance as CustomRule } from './customRule.js';
 export { instance as ForesightRule } from './foresightRule.js';
+export { instance as LyingSymbolRule } from './lyingSymbolRule.js';
 export { instance as MusicGridRule } from './musicGridRule.js';
 export { instance as MysteryRule } from './mysteryRule.js';
 export { instance as OffByXRule } from './offByXRule.js';

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

@@ -42,7 +42,6 @@ export default class DirectionLinkerBTModule extends BTModule {
             this.initialPositions = this.getInitialPositions();
         const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
         const ratings = [];
-        let checkable = false;
         for (const pos of this.initialPositions) {
             const tile = grid.isInBound(pos.x, pos.y)
                 ? grid.getTile(pos.x, pos.y)
@@ -53,6 +52,10 @@ export default class DirectionLinkerBTModule extends BTModule {
                     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 });
                 }
@@ -69,20 +72,18 @@ export default class DirectionLinkerBTModule extends BTModule {
                 if (oppoPos !== null) {
                     const oppoTile = grid.getTile(oppoPos.x, oppoPos.y);
                     if (oppoTile === BTTile.Empty) {
-                        tilesNeedCheck.set(pos.x, pos.y, 1);
-                        ratings.push({ pos, score: 1 });
+                        tilesNeedCheck.set(oppoPos.x, oppoPos.y, 1);
+                        ratings.push({ pos: oppoPos, score: 1 });
                     }
                     else if (oppoTile === BTTile.NonExist)
                         return false;
-                    else
-                        checkable = true;
                 }
                 else {
                     return false;
                 }
             }
         }
-        if (!checkable) {
+        if (ratings.length > 0) {
             return { tilesNeedCheck, ratings };
         }
         const queue = this.initialPositions