@logic-pad/core 0.1.0

package/dist/data/symbols/lotusSymbol.js

@@ -0,0 +1,132 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { Direction, Orientation } from '../primitives';
+import DirectionLinkerSymbol from './directionLinkerSymbol';
+class LotusSymbol extends DirectionLinkerSymbol {
+    /**
+     * **Areas containing this symbol must be symmetrical**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param orientation - The orientation of the symbol.
+     */
+    constructor(x, y, orientation) {
+        super(x, y);
+        Object.defineProperty(this, "x", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: x
+        });
+        Object.defineProperty(this, "y", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: y
+        });
+        Object.defineProperty(this, "orientation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: orientation
+        });
+        super.changeDirections(LotusSymbol.linkedDirectionsFromOrientation[orientation]);
+    }
+    get id() {
+        return `lotus`;
+    }
+    get explanation() {
+        return `Areas containing this symbol must be *symmetrical*`;
+    }
+    get configs() {
+        return Object.freeze([
+            {
+                type: ConfigType.Number,
+                default: 0,
+                field: 'x',
+                description: 'X',
+                configurable: false,
+            },
+            {
+                type: ConfigType.Number,
+                default: 0,
+                field: 'y',
+                description: 'Y',
+                configurable: false,
+            },
+            {
+                type: ConfigType.Orientation,
+                default: Orientation.Up,
+                field: 'orientation',
+                description: 'Orientation',
+                configurable: true,
+            },
+        ]);
+    }
+    createExampleGrid() {
+        return Object.freeze(GridData.create(['wwbww', 'bwbwb', 'bwwwb', 'bwwwb']).addSymbol(new LotusSymbol(2, 2, Orientation.Up)));
+    }
+    validateSymbol(grid) {
+        return super.validateSymbol(grid);
+    }
+    copyWith({ x, y, orientation, }) {
+        return new LotusSymbol(x ?? this.x, y ?? this.y, orientation ?? this.orientation);
+    }
+}
+Object.defineProperty(LotusSymbol, "linkedDirectionsFromOrientation", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        [Orientation.Up]: {
+            [Direction.Left]: Direction.Right,
+            [Direction.Up]: Direction.Up,
+            [Direction.Right]: Direction.Left,
+            [Direction.Down]: Direction.Down,
+        },
+        [Orientation.UpRight]: {
+            [Direction.Left]: Direction.Down,
+            [Direction.Up]: Direction.Right,
+            [Direction.Right]: Direction.Up,
+            [Direction.Down]: Direction.Left,
+        },
+        [Orientation.Right]: {
+            [Direction.Left]: Direction.Left,
+            [Direction.Up]: Direction.Down,
+            [Direction.Right]: Direction.Right,
+            [Direction.Down]: Direction.Up,
+        },
+        [Orientation.DownRight]: {
+            [Direction.Left]: Direction.Up,
+            [Direction.Up]: Direction.Left,
+            [Direction.Right]: Direction.Down,
+            [Direction.Down]: Direction.Right,
+        },
+        [Orientation.Down]: {
+            [Direction.Left]: Direction.Right,
+            [Direction.Up]: Direction.Up,
+            [Direction.Right]: Direction.Left,
+            [Direction.Down]: Direction.Down,
+        },
+        [Orientation.DownLeft]: {
+            [Direction.Left]: Direction.Down,
+            [Direction.Up]: Direction.Right,
+            [Direction.Right]: Direction.Up,
+            [Direction.Down]: Direction.Left,
+        },
+        [Orientation.Left]: {
+            [Direction.Left]: Direction.Left,
+            [Direction.Up]: Direction.Down,
+            [Direction.Right]: Direction.Right,
+            [Direction.Down]: Direction.Up,
+        },
+        [Orientation.UpLeft]: {
+            [Direction.Left]: Direction.Up,
+            [Direction.Up]: Direction.Left,
+            [Direction.Right]: Direction.Down,
+            [Direction.Down]: Direction.Right,
+        },
+    }
+});
+export default LotusSymbol;
+export const instance = new LotusSymbol(0, 0, Orientation.Up);

package/dist/data/symbols/minesweeperSymbol.d.ts

@@ -0,0 +1,31 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import NumberSymbol from './numberSymbol';
+export default class MinesweeperSymbol extends NumberSymbol {
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Minesweeper numbers count opposite cells in 8 adjacent spaces**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param number - The number of cells seen by the symbol.
+     */
+    constructor(x: number, y: number, number: number);
+    get id(): string;
+    get placementStep(): number;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    countTiles(grid: GridData): {
+        completed: number;
+        possible: number;
+    };
+    copyWith({ x, y, number, }: {
+        x?: number;
+        y?: number;
+        number?: number;
+    }): this;
+    withNumber(number: number): this;
+}
+export declare const instance: MinesweeperSymbol;

package/dist/data/symbols/minesweeperSymbol.js

@@ -0,0 +1,100 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { Color } from '../primitives';
+import NumberSymbol from './numberSymbol';
+class MinesweeperSymbol extends NumberSymbol {
+    /**
+     * **Minesweeper numbers count opposite cells in 8 adjacent spaces**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param number - The number of cells seen by the symbol.
+     */
+    constructor(x, y, number) {
+        super(x, y, number);
+    }
+    get id() {
+        return `minesweeper`;
+    }
+    get placementStep() {
+        return 1;
+    }
+    get explanation() {
+        return `*Minesweeper numbers* count opposite cells in 8 adjacent spaces`;
+    }
+    get configs() {
+        return MinesweeperSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        return MinesweeperSymbol.EXAMPLE_GRID;
+    }
+    countTiles(grid) {
+        if (Math.floor(this.x) !== this.x || Math.floor(this.y) !== this.y)
+            return { completed: 0, possible: Number.MAX_SAFE_INTEGER };
+        const color = grid.getTile(this.x, this.y).color;
+        if (color === Color.Gray)
+            return { completed: 0, possible: Number.MAX_SAFE_INTEGER };
+        let gray = 0;
+        let opposite = 0;
+        for (let y = this.y - 1; y <= this.y + 1; y++) {
+            for (let x = this.x - 1; x <= this.x + 1; x++) {
+                if (x === this.x && y === this.y)
+                    continue;
+                const tile = grid.getTile(x, y);
+                if (!tile.exists)
+                    continue;
+                if (tile.color === Color.Gray)
+                    gray++;
+                else if (tile.color !== color)
+                    opposite++;
+            }
+        }
+        return { completed: opposite, possible: opposite + gray };
+    }
+    copyWith({ x, y, number, }) {
+        return new MinesweeperSymbol(x ?? this.x, y ?? this.y, number ?? this.number);
+    }
+    withNumber(number) {
+        return this.copyWith({ number });
+    }
+}
+Object.defineProperty(MinesweeperSymbol, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Number,
+            default: 0,
+            field: 'x',
+            description: 'X',
+            configurable: false,
+        },
+        {
+            type: ConfigType.Number,
+            default: 0,
+            field: 'y',
+            description: 'Y',
+            configurable: false,
+        },
+        {
+            type: ConfigType.Number,
+            default: 1,
+            field: 'number',
+            description: 'Number',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(MinesweeperSymbol, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['wwbww', 'wwbwb', 'wwbwb', 'bwwww'])
+        .addSymbol(new MinesweeperSymbol(1, 1, 3))
+        .addSymbol(new MinesweeperSymbol(3, 1, 5))
+        .addSymbol(new MinesweeperSymbol(4, 1, 4))
+        .addSymbol(new MinesweeperSymbol(2, 3, 1)))
+});
+export default MinesweeperSymbol;
+export const instance = new MinesweeperSymbol(0, 0, 1);

package/dist/data/symbols/multiEntrySymbol.d.ts

@@ -0,0 +1,11 @@
+import Instruction from '../instruction';
+import Symbol from './symbol';
+export default abstract class MultiEntrySymbol extends Symbol {
+    /**
+     * Determines if the description of two MultiEntrySymbols can be merged when displayed in the UI.
+     * @param other - The other MultiEntrySymbol to compare to.
+     * @returns Whether the two MultiEntrySymbols have the same description.
+     */
+    descriptionEquals(other: Instruction): boolean;
+}
+export declare const instance: undefined;

package/dist/data/symbols/multiEntrySymbol.js

@@ -0,0 +1,14 @@
+import Symbol from './symbol';
+export default class MultiEntrySymbol extends Symbol {
+    /**
+     * Determines if the description of two MultiEntrySymbols can be merged when displayed in the UI.
+     * @param other - The other MultiEntrySymbol to compare to.
+     * @returns Whether the two MultiEntrySymbols have the same description.
+     */
+    descriptionEquals(other) {
+        return (this.id === other.id &&
+            this.explanation === other.explanation &&
+            this.createExampleGrid().equals(other.createExampleGrid()));
+    }
+}
+export const instance = undefined;

package/dist/data/symbols/myopiaSymbol.d.ts

@@ -0,0 +1,34 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { OrientationToggle, State } from '../primitives';
+import MultiEntrySymbol from './multiEntrySymbol';
+export default class MyopiaSymbol extends MultiEntrySymbol {
+    readonly diagonals: boolean;
+    readonly directions: OrientationToggle;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    private static readonly EXAMPLE_DIAGONAL_GRID;
+    /**
+     * **Viewpoint Numbers count visible cells in the four directions**
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param diagonals - Whether the symbol should consider diagonal directions.
+     * @param directions - The directions in which an arrow is pointing.
+     */
+    constructor(x: number, y: number, diagonals: boolean, directions: OrientationToggle);
+    get id(): string;
+    get placementStep(): number;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    validateSymbol(grid: GridData): State;
+    copyWith({ x, y, diagonals, directions, }: {
+        x?: number;
+        y?: number;
+        diagonals?: boolean;
+        directions?: OrientationToggle;
+    }): this;
+    withDirections(directions: OrientationToggle): this;
+    withDiagonals(diagonals: boolean): this;
+}
+export declare const instance: MyopiaSymbol;

package/dist/data/symbols/myopiaSymbol.js

@@ -0,0 +1,187 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { Color, ORIENTATIONS, Orientation, State, orientationToggle, } from '../primitives';
+import MultiEntrySymbol from './multiEntrySymbol';
+class MyopiaSymbol extends MultiEntrySymbol {
+    /**
+     * **Viewpoint Numbers count visible cells in the four directions**
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param diagonals - Whether the symbol should consider diagonal directions.
+     * @param directions - The directions in which an arrow is pointing.
+     */
+    constructor(x, y, diagonals, directions) {
+        super(x, y);
+        Object.defineProperty(this, "diagonals", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: diagonals
+        });
+        Object.defineProperty(this, "directions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: directions
+        });
+        this.directions = directions;
+        this.diagonals =
+            directions[Orientation.DownLeft] ||
+                directions[Orientation.DownRight] ||
+                directions[Orientation.UpLeft] ||
+                directions[Orientation.UpRight]
+                ? true
+                : diagonals;
+    }
+    get id() {
+        return `myopia`;
+    }
+    get placementStep() {
+        return 1;
+    }
+    get explanation() {
+        return this.diagonals
+            ? '*Framed myopia arrows* point to *all* the closest opposite cells in 8 directions'
+            : '*Myopia arrows* point to *all* the closest cells of the opposite color';
+    }
+    get configs() {
+        return MyopiaSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        return this.diagonals
+            ? MyopiaSymbol.EXAMPLE_DIAGONAL_GRID
+            : MyopiaSymbol.EXAMPLE_GRID;
+    }
+    validateSymbol(grid) {
+        const tile = grid.getTile(this.x, this.y);
+        if (!tile.exists || tile.color === Color.Gray)
+            return State.Incomplete;
+        const allDirections = this.diagonals
+            ? ORIENTATIONS
+            : [Orientation.Up, Orientation.Down, Orientation.Left, Orientation.Right];
+        const map = {
+            up: { min: 0, max: 0, complete: true },
+            down: { min: 0, max: 0, complete: true },
+            left: { min: 0, max: 0, complete: true },
+            right: { min: 0, max: 0, complete: true },
+            'up-left': { min: 0, max: 0, complete: true },
+            'up-right': { min: 0, max: 0, complete: true },
+            'down-left': { min: 0, max: 0, complete: true },
+            'down-right': { min: 0, max: 0, complete: true },
+        };
+        const pos = { x: this.x, y: this.y };
+        allDirections.forEach(direction => {
+            grid.iterateDirectionAll(pos, direction, t => !t.exists || t.color === tile.color, () => {
+                map[direction].min++;
+            });
+            let stopped = false;
+            grid.iterateDirectionAll(pos, direction, t => {
+                if (!t.exists)
+                    return true;
+                if (t.color === tile.color || t.color === Color.Gray)
+                    return true;
+                stopped = true;
+                return false;
+            }, t => {
+                map[direction].max++;
+                if (t.exists && t.color === Color.Gray)
+                    map[direction].complete = false;
+            });
+            if (!stopped)
+                map[direction].max = Number.MAX_SAFE_INTEGER;
+        });
+        const pointedDirections = allDirections.filter(d => this.directions[d]);
+        const otherDirections = allDirections.filter(d => !this.directions[d]);
+        for (let i = 0; i < pointedDirections.length; i++) {
+            const direction1 = pointedDirections[i];
+            for (let j = i + 1; j < pointedDirections.length; j++) {
+                const direction2 = pointedDirections[j];
+                if (map[direction1].min > map[direction2].max)
+                    return State.Error;
+                if (map[direction2].min > map[direction1].max)
+                    return State.Error;
+            }
+        }
+        if (Math.min(...otherDirections.map(d => map[d].max)) <=
+            Math.max(...pointedDirections.map(d => map[d].min)))
+            return State.Error;
+        if (pointedDirections.length === 0 &&
+            otherDirections.some(d => map[d].max !== Number.MAX_SAFE_INTEGER))
+            return State.Error;
+        if (pointedDirections.some(d => map[d].complete && map[d].max === Number.MAX_SAFE_INTEGER))
+            return State.Error;
+        if (pointedDirections.length > 0 &&
+            otherDirections.length > 0 &&
+            pointedDirections.every(d => map[d].complete) &&
+            Math.max(...pointedDirections.map(d => map[d].max)) <
+                Math.min(...otherDirections.map(d => map[d].min)))
+            return State.Satisfied;
+        if (allDirections.every(d => map[d].complete))
+            return State.Satisfied;
+        return State.Incomplete;
+    }
+    copyWith({ x, y, diagonals, directions, }) {
+        return new MyopiaSymbol(x ?? this.x, y ?? this.y, diagonals ?? this.diagonals, directions ?? this.directions);
+    }
+    withDirections(directions) {
+        return this.copyWith({ directions });
+    }
+    withDiagonals(diagonals) {
+        return this.copyWith({ diagonals });
+    }
+}
+Object.defineProperty(MyopiaSymbol, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Number,
+            default: 0,
+            field: 'x',
+            description: 'X',
+            configurable: false,
+        },
+        {
+            type: ConfigType.Number,
+            default: 0,
+            field: 'y',
+            description: 'Y',
+            configurable: false,
+        },
+        {
+            type: ConfigType.Boolean,
+            default: false,
+            field: 'diagonals',
+            description: 'Include diagonal directions',
+            configurable: true,
+        },
+        {
+            type: ConfigType.OrientationToggle,
+            default: orientationToggle(Orientation.Up, Orientation.Right),
+            field: 'directions',
+            description: 'Directions',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(MyopiaSymbol, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['wbwww', 'bwwwb', 'wwwww', 'wbwww']).withSymbols([
+        new MyopiaSymbol(1, 1, false, orientationToggle(Orientation.Up, Orientation.Left)),
+        new MyopiaSymbol(4, 3, false, orientationToggle(Orientation.Up)),
+    ]))
+});
+Object.defineProperty(MyopiaSymbol, "EXAMPLE_DIAGONAL_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['wbwww', 'bwwwb', 'wwwww', 'wbwww']).withSymbols([
+        new MyopiaSymbol(1, 2, true, orientationToggle(Orientation.UpLeft, Orientation.Down)),
+        new MyopiaSymbol(3, 2, true, orientationToggle(Orientation.UpRight)),
+    ]))
+});
+export default MyopiaSymbol;
+export const instance = new MyopiaSymbol(0, 0, false, orientationToggle(Orientation.Up, Orientation.Right));

package/dist/data/symbols/numberSymbol.d.ts

@@ -0,0 +1,19 @@
+import GridData from '../grid';
+import { State } from '../primitives';
+import Symbol from './symbol';
+/**
+ * All symbols which contain a number should extend this class to be compatible with off by X rules.
+ */
+export default abstract class NumberSymbol extends Symbol {
+    readonly x: number;
+    readonly y: number;
+    readonly number: number;
+    constructor(x: number, y: number, number: number);
+    abstract countTiles(grid: GridData): {
+        completed: number;
+        possible: number;
+    };
+    validateSymbol(grid: GridData): State;
+    withNumber(number: number): this;
+}
+export declare const instance: undefined;

package/dist/data/symbols/numberSymbol.js

@@ -0,0 +1,41 @@
+import { State } from '../primitives';
+import Symbol from './symbol';
+/**
+ * All symbols which contain a number should extend this class to be compatible with off by X rules.
+ */
+export default class NumberSymbol extends Symbol {
+    constructor(x, y, number) {
+        super(x, y);
+        Object.defineProperty(this, "x", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: x
+        });
+        Object.defineProperty(this, "y", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: y
+        });
+        Object.defineProperty(this, "number", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: number
+        });
+        this.number = number;
+    }
+    validateSymbol(grid) {
+        const { completed, possible } = this.countTiles(grid);
+        if (completed > this.number || possible < this.number)
+            return State.Error;
+        if (completed === this.number && possible === this.number)
+            return State.Satisfied;
+        return State.Incomplete;
+    }
+    withNumber(number) {
+        return this.copyWith({ number });
+    }
+}
+export const instance = undefined;

package/dist/data/symbols/symbol.d.ts

@@ -0,0 +1,16 @@
+import { GridResizeHandler } from '../events/onGridResize';
+import GridData from '../grid';
+import Instruction from '../instruction';
+import { State } from '../primitives';
+export default abstract class Symbol extends Instruction implements GridResizeHandler {
+    readonly x: number;
+    readonly y: number;
+    constructor(x: number, y: number);
+    abstract validateSymbol(grid: GridData): State;
+    onGridResize(_grid: GridData, mode: 'insert' | 'remove', direction: 'row' | 'column', index: number): this | null;
+    get placementStep(): number;
+    withX(x: number): this;
+    withY(y: number): this;
+    withPosition(x: number, y: number): this;
+}
+export declare const instance: undefined;

package/dist/data/symbols/symbol.js

@@ -0,0 +1,51 @@
+import Instruction from '../instruction';
+export default class Symbol extends Instruction {
+    constructor(x, y) {
+        super();
+        Object.defineProperty(this, "x", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: x
+        });
+        Object.defineProperty(this, "y", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: y
+        });
+        this.x = x;
+        this.y = y;
+    }
+    onGridResize(_grid, mode, direction, index) {
+        if (mode === 'insert') {
+            return this.copyWith({
+                x: direction === 'column' && this.x >= index ? this.x + 1 : this.x,
+                y: direction === 'row' && this.y >= index ? this.y + 1 : this.y,
+            });
+        }
+        else {
+            if (direction === 'column' && this.x === index)
+                return null;
+            if (direction === 'row' && this.y === index)
+                return null;
+            return this.copyWith({
+                x: direction === 'column' && this.x > index ? this.x - 1 : this.x,
+                y: direction === 'row' && this.y > index ? this.y - 1 : this.y,
+            });
+        }
+    }
+    get placementStep() {
+        return 0.5;
+    }
+    withX(x) {
+        return this.copyWith({ x });
+    }
+    withY(y) {
+        return this.copyWith({ y });
+    }
+    withPosition(x, y) {
+        return this.copyWith({ x, y });
+    }
+}
+export const instance = undefined;

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

@@ -0,0 +1,10 @@
+export { instance as AreaNumberSymbol } from './areaNumberSymbol';
+export { instance as CustomIconSymbol } from './customIconSymbol';
+export { instance as CustomTextSymbol } from './customTextSymbol';
+export { instance as DartSymbol } from './dartSymbol';
+export { instance as GalaxySymbol } from './galaxySymbol';
+export { instance as LetterSymbol } from './letterSymbol';
+export { instance as LotusSymbol } from './lotusSymbol';
+export { instance as MinesweeperSymbol } from './minesweeperSymbol';
+export { instance as MyopiaSymbol } from './myopiaSymbol';
+export { instance as ViewpointSymbol } from './viewpointSymbol';

package/dist/data/symbols/symbols.gen.js

@@ -0,0 +1,14 @@
+/* prettier-ignore-start */
+/* eslint-disable */
+// @ts-nocheck
+// noinspection JSUnusedGlobalSymbols
+export { instance as AreaNumberSymbol } from './areaNumberSymbol';
+export { instance as CustomIconSymbol } from './customIconSymbol';
+export { instance as CustomTextSymbol } from './customTextSymbol';
+export { instance as DartSymbol } from './dartSymbol';
+export { instance as GalaxySymbol } from './galaxySymbol';
+export { instance as LetterSymbol } from './letterSymbol';
+export { instance as LotusSymbol } from './lotusSymbol';
+export { instance as MinesweeperSymbol } from './minesweeperSymbol';
+export { instance as MyopiaSymbol } from './myopiaSymbol';
+export { instance as ViewpointSymbol } from './viewpointSymbol';