@logic-pad/core 0.1.0

package/dist/data/rules/regionAreaRule.js

@@ -0,0 +1,182 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { array } from '../dataHelper';
+import { Color, State } from '../primitives';
+import TileData from '../tile';
+import Rule from './rule';
+class RegionAreaRule extends Rule {
+    /**
+     * **All <color> regions have area <size>**
+     *
+     * @param color - The color of the regions.
+     * @param size - The area of the regions.
+     */
+    constructor(color, size) {
+        super();
+        Object.defineProperty(this, "color", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: color
+        });
+        Object.defineProperty(this, "size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: size
+        });
+        this.color = color;
+        this.size = size;
+    }
+    get id() {
+        return `region_area`;
+    }
+    get explanation() {
+        return `All ${this.color} regions have area ${this.size}`;
+    }
+    get configs() {
+        return RegionAreaRule.CONFIGS;
+    }
+    createExampleGrid() {
+        if (this.size < RegionAreaRule.EXAMPLE_GRID_DARK.length) {
+            switch (this.color) {
+                case Color.Dark:
+                    return RegionAreaRule.EXAMPLE_GRID_DARK[this.size];
+                case Color.Light:
+                    return RegionAreaRule.EXAMPLE_GRID_LIGHT[this.size];
+                case Color.Gray:
+                    return RegionAreaRule.EXAMPLE_GRID_GRAY[this.size];
+            }
+        }
+        else {
+            let count = this.size;
+            const tiles = array(5, 4, (x, y) => {
+                count--;
+                return new TileData(true, false, count >= 0
+                    ? this.color
+                    : this.color === Color.Gray
+                        ? x % 2 !== y % 2
+                            ? Color.Dark
+                            : Color.Light
+                        : this.color === Color.Light
+                            ? Color.Dark
+                            : Color.Light);
+            });
+            return new GridData(5, 4, tiles);
+        }
+    }
+    get searchVariants() {
+        return RegionAreaRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        const visited = array(grid.width, grid.height, (i, j) => !(grid.getTile(i, j).exists && grid.getTile(i, j).color === this.color));
+        let complete = true;
+        while (true) {
+            const seed = grid.find((_tile, x, y) => !visited[y][x]);
+            if (!seed)
+                break;
+            const completed = [];
+            const gray = [];
+            grid.iterateArea({ x: seed.x, y: seed.y }, tile => tile.color === this.color, (_, x, y) => {
+                completed.push({ x, y });
+                visited[y][x] = true;
+            });
+            if (this.color === Color.Gray) {
+                gray.push(...completed);
+            }
+            else {
+                grid.iterateArea({ x: seed.x, y: seed.y }, tile => tile.color === Color.Gray || tile.color === this.color, (_, x, y) => {
+                    gray.push({ x, y });
+                });
+            }
+            if (completed.length > this.size) {
+                return { state: State.Error, positions: completed };
+            }
+            else if (gray.length < this.size) {
+                return { state: State.Error, positions: gray };
+            }
+            else if (completed.length !== this.size ||
+                completed.length !== gray.length) {
+                complete = false;
+            }
+        }
+        return complete ? { state: State.Satisfied } : { state: State.Incomplete };
+    }
+    copyWith({ color, size }) {
+        return new RegionAreaRule(color ?? this.color, size ?? this.size);
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+    withSize(size) {
+        return this.copyWith({ size });
+    }
+}
+Object.defineProperty(RegionAreaRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Dark,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Number,
+            default: 2,
+            min: 0,
+            field: 'size',
+            description: 'Region Size',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(RegionAreaRule, "EXAMPLE_GRID_DARK", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        GridData.create(['wwwww', 'wwwww', 'wwwww', 'wwwww']),
+        GridData.create(['bwwbw', 'wbwwb', 'bwbww', 'wbwwb']),
+        GridData.create(['bbwbb', 'wwbww', 'wwbww', 'wwwbb']),
+        GridData.create(['bbwww', 'bwbwb', 'wbbwb', 'wwwwb']),
+        GridData.create(['bwbbb', 'bbwwb', 'bwbbw', 'wwbbw']),
+        GridData.create(['bbbww', 'bbwbw', 'wwbbb', 'wwwbw']),
+        GridData.create(['bbbww', 'bbbwb', 'wwwbb', 'wwbbb']),
+        GridData.create(['bbbbb', 'bbwww', 'wwwbb', 'bbbbb']),
+        GridData.create(['bbbbw', 'bbbww', 'bwwww', 'wwwww']),
+        GridData.create(['wwwww', 'bbbbb', 'bbwbb', 'wwwww']),
+        GridData.create(['bbbbb', 'bbbww', 'bbwww', 'wwwww']),
+    ])
+});
+Object.defineProperty(RegionAreaRule, "EXAMPLE_GRID_LIGHT", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(RegionAreaRule.EXAMPLE_GRID_DARK.map(grid => new GridData(grid.width, grid.height, grid.tiles.map(row => row.map(tile => tile.withColor(tile.color === Color.Dark ? Color.Light : Color.Dark))))))
+});
+Object.defineProperty(RegionAreaRule, "EXAMPLE_GRID_GRAY", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(RegionAreaRule.EXAMPLE_GRID_DARK.map(grid => new GridData(grid.width, grid.height, grid.tiles.map((row, y) => row.map((tile, x) => tile.withColor(tile.color === Color.Dark
+        ? Color.Gray
+        : x % 2 !== y % 2
+            ? Color.Dark
+            : Color.Light))))))
+});
+Object.defineProperty(RegionAreaRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new RegionAreaRule(Color.Dark, 2).searchVariant(),
+        new RegionAreaRule(Color.Light, 2).searchVariant(),
+    ]
+});
+export default RegionAreaRule;
+export const instance = new RegionAreaRule(Color.Dark, 2);

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

@@ -0,0 +1,22 @@
+import GridData from '../grid';
+import { Color, Position } from '../primitives';
+import { Shape } from '../shapes';
+import Rule from './rule';
+export type ShapeRegions = {
+    regions: {
+        positions: Position[];
+        shape: Shape;
+        count: number;
+    }[];
+    complete: boolean;
+};
+export default abstract class RegionShapeRule extends Rule {
+    readonly color: Color;
+    /**
+     * @param color - The color of the regions to compare.
+     */
+    constructor(color: Color);
+    protected getShapeRegions(grid: GridData): ShapeRegions;
+    withColor(color: Color): this;
+}
+export declare const instance: undefined;

package/dist/data/rules/regionShapeRule.js

@@ -0,0 +1,58 @@
+import { array } from '../dataHelper';
+import { Color } from '../primitives';
+import { normalizeShape, positionsToShape, shapeEquals, } from '../shapes';
+import Rule from './rule';
+export default class RegionShapeRule extends Rule {
+    /**
+     * @param color - The color of the regions to compare.
+     */
+    constructor(color) {
+        super();
+        Object.defineProperty(this, "color", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: color
+        });
+        this.color = color;
+    }
+    getShapeRegions(grid) {
+        let complete = true;
+        const visited = array(grid.width, grid.height, (i, j) => {
+            const tile = grid.getTile(i, j);
+            if (tile.exists && tile.color === Color.Gray)
+                complete = false;
+            return !(tile.exists && tile.color === this.color);
+        });
+        const regions = [];
+        while (true) {
+            const seed = grid.find((_tile, x, y) => !visited[y][x]);
+            if (!seed)
+                break;
+            const positions = [];
+            grid.iterateArea(seed, tile => tile.color === this.color, (_, x, y) => {
+                visited[y][x] = true;
+                positions.push({ x, y });
+            });
+            const incomplete = grid.iterateArea(seed, tile => tile.color === this.color || tile.color === Color.Gray, tile => {
+                if (tile.color === Color.Gray)
+                    return true;
+            });
+            if (incomplete)
+                continue;
+            const shape = normalizeShape(positionsToShape(positions, this.color));
+            const existing = regions.find(island => shapeEquals(island.shape, shape));
+            if (existing) {
+                existing.count++;
+            }
+            else {
+                regions.push({ positions, shape, count: 1 });
+            }
+        }
+        return { regions, complete };
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+}
+export const instance = undefined;

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

@@ -0,0 +1,18 @@
+import GridData from '../grid';
+import { RuleState } from '../primitives';
+import Instruction from '../instruction';
+export interface SearchVariant {
+    description: string;
+    rule: Rule;
+}
+export default abstract class Rule extends Instruction {
+    abstract validateGrid(grid: GridData): RuleState;
+    abstract get searchVariants(): SearchVariant[];
+    searchVariant(): SearchVariant;
+    get visibleWhenSolving(): boolean;
+    /**
+     * Whether only one instance of this rule is allowed in a grid.
+     */
+    get isSingleton(): boolean;
+}
+export declare const instance: undefined;

package/dist/data/rules/rule.js

@@ -0,0 +1,19 @@
+import Instruction from '../instruction';
+export default class Rule extends Instruction {
+    searchVariant() {
+        return {
+            description: this.explanation,
+            rule: this,
+        };
+    }
+    get visibleWhenSolving() {
+        return true;
+    }
+    /**
+     * Whether only one instance of this rule is allowed in a grid.
+     */
+    get isSingleton() {
+        return false;
+    }
+}
+export const instance = undefined;

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

@@ -0,0 +1,14 @@
+export { instance as BanPatternRule } from './banPatternRule';
+export { instance as CellCountRule } from './cellCountRule';
+export { instance as CompletePatternRule } from './completePatternRule';
+export { instance as ConnectAllRule } from './connectAllRule';
+export { instance as CustomRule } from './customRule';
+export { instance as ForesightRule } from './foresightRule';
+export { instance as MusicGridRule } from './musicGridRule';
+export { instance as MysteryRule } from './mysteryRule';
+export { instance as OffByXRule } from './offByXRule';
+export { instance as RegionAreaRule } from './regionAreaRule';
+export { instance as SameShapeRule } from './sameShapeRule';
+export { instance as SymbolsPerRegionRule } from './symbolsPerRegionRule';
+export { instance as UndercluedRule } from './undercluedRule';
+export { instance as UniqueShapeRule } from './uniqueShapeRule';

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

@@ -0,0 +1,18 @@
+/* prettier-ignore-start */
+/* eslint-disable */
+// @ts-nocheck
+// noinspection JSUnusedGlobalSymbols
+export { instance as BanPatternRule } from './banPatternRule';
+export { instance as CellCountRule } from './cellCountRule';
+export { instance as CompletePatternRule } from './completePatternRule';
+export { instance as ConnectAllRule } from './connectAllRule';
+export { instance as CustomRule } from './customRule';
+export { instance as ForesightRule } from './foresightRule';
+export { instance as MusicGridRule } from './musicGridRule';
+export { instance as MysteryRule } from './mysteryRule';
+export { instance as OffByXRule } from './offByXRule';
+export { instance as RegionAreaRule } from './regionAreaRule';
+export { instance as SameShapeRule } from './sameShapeRule';
+export { instance as SymbolsPerRegionRule } from './symbolsPerRegionRule';
+export { instance as UndercluedRule } from './undercluedRule';
+export { instance as UniqueShapeRule } from './uniqueShapeRule';

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

@@ -0,0 +1,27 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { Color, RuleState } from '../primitives';
+import RegionShapeRule from './regionShapeRule';
+import { SearchVariant } from './rule';
+export default class SameShapeRule extends RegionShapeRule {
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **All <color> areas have the same shape and size**
+     *
+     * @param color - The color of the regions to compare.
+     */
+    constructor(color: Color);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color }: {
+        color?: Color;
+    }): this;
+}
+export declare const instance: SameShapeRule;

package/dist/data/rules/sameShapeRule.js

@@ -0,0 +1,88 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { minBy } from '../dataHelper';
+import { Color, State } from '../primitives';
+import RegionShapeRule from './regionShapeRule';
+class SameShapeRule extends RegionShapeRule {
+    /**
+     * **All <color> areas have the same shape and size**
+     *
+     * @param color - The color of the regions to compare.
+     */
+    constructor(color) {
+        super(color);
+    }
+    get id() {
+        return `same_shape`;
+    }
+    get explanation() {
+        return `All ${this.color} areas have the same shape and size`;
+    }
+    get configs() {
+        return SameShapeRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return this.color === Color.Light
+            ? SameShapeRule.EXAMPLE_GRID_LIGHT
+            : SameShapeRule.EXAMPLE_GRID_DARK;
+    }
+    get searchVariants() {
+        return SameShapeRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        const { regions, complete } = this.getShapeRegions(grid);
+        if (regions.length > 1) {
+            return {
+                state: State.Error,
+                positions: minBy(regions, island => island.count).positions,
+            };
+        }
+        else if (regions.length <= 1) {
+            return { state: complete ? State.Satisfied : State.Incomplete };
+        }
+        else {
+            return { state: State.Incomplete }; // not reachable but the TS is not happy
+        }
+    }
+    copyWith({ color }) {
+        return new SameShapeRule(color ?? this.color);
+    }
+}
+Object.defineProperty(SameShapeRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(SameShapeRule, "EXAMPLE_GRID_LIGHT", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['wwbww', 'wbwbw', 'wbwbw', 'bwwbb']))
+});
+Object.defineProperty(SameShapeRule, "EXAMPLE_GRID_DARK", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['bbwbb', 'bwbwb', 'bwbwb', 'wbbww']))
+});
+Object.defineProperty(SameShapeRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new SameShapeRule(Color.Light).searchVariant(),
+        new SameShapeRule(Color.Dark).searchVariant(),
+    ]
+});
+export default SameShapeRule;
+export const instance = new SameShapeRule(Color.Dark);

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

@@ -0,0 +1,37 @@
+import Rule, { SearchVariant } from './rule';
+import GridData from '../grid';
+import { AnyConfig } from '../config';
+import { Color, Comparison, RuleState } from '../primitives';
+export default class SymbolsPerRegionRule extends Rule {
+    readonly color: Color;
+    readonly count: number;
+    readonly comparison: Comparison;
+    private static readonly SYMBOL_POSITIONS;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRIDS;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Exactly <count> symbols per <color> area**
+     *
+     * @param color - Color of the region affected by the rule
+     * @param count - Number of symbols to have in each region
+     * @param comparison - Comparison to use when checking the number of symbols
+     */
+    constructor(color: Color, count: number, comparison?: Comparison);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ count, color, comparison, }: {
+        count?: number;
+        color?: Color;
+        comparison?: Comparison;
+    }): this;
+    withColor(color: Color): this;
+    withCount(count: number): this;
+    withComparison(comparison: Comparison): this;
+    private static countAllSymbolsOfPosition;
+}
+export declare const instance: SymbolsPerRegionRule;