@logic-pad/core 0.26.2 → 0.26.3

package/dist/src/data/symbols/dartSymbol.d.ts

@@ -0,0 +1,36 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { Orientation } from '../primitives.js';
+import NumberSymbol from './numberSymbol.js';
+export default class DartSymbol extends NumberSymbol {
+    readonly orientation: Orientation;
+    readonly title = "Dart";
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Darts count opposite color cells in that direction**
+     *
+     * @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.
+     * @param orientation - The orientation of the symbol.
+     */
+    constructor(x: number, y: number, number: number, orientation: Orientation);
+    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, orientation, }: {
+        x?: number;
+        y?: number;
+        number?: number;
+        orientation?: Orientation;
+    }): this;
+    withNumber(number: number): this;
+}
+export declare const instance: DartSymbol;

package/dist/src/data/symbols/dartSymbol.js

@@ -0,0 +1,96 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { Color, Orientation } from '../primitives.js';
+import NumberSymbol from './numberSymbol.js';
+export default class DartSymbol extends NumberSymbol {
+    orientation;
+    title = 'Dart';
+    static CONFIGS = 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,
+        },
+        {
+            type: ConfigType.Orientation,
+            default: Orientation.Right,
+            field: 'orientation',
+            description: 'Orientation',
+            configurable: true,
+        },
+    ]);
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['wwbbw', 'wwwww', 'wbwbb', 'wwwww'])
+        .addSymbol(new DartSymbol(1, 0, 1, Orientation.Down))
+        .addSymbol(new DartSymbol(4, 0, 2, Orientation.Left))
+        .addSymbol(new DartSymbol(3, 1, 1, Orientation.Down))
+        .addSymbol(new DartSymbol(0, 2, 3, Orientation.Right)));
+    /**
+     * **Darts count opposite color cells in that direction**
+     *
+     * @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.
+     * @param orientation - The orientation of the symbol.
+     */
+    constructor(x, y, number, orientation) {
+        super(x, y, number);
+        this.orientation = orientation;
+        this.orientation = orientation;
+    }
+    get id() {
+        return `dart`;
+    }
+    get placementStep() {
+        return 1;
+    }
+    get explanation() {
+        return `*Darts* count opposite color cells in that direction`;
+    }
+    get configs() {
+        return DartSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        return DartSymbol.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;
+        grid.iterateDirectionAll({ x: this.x, y: this.y }, this.orientation, () => true, tile => {
+            if (!tile.exists)
+                return;
+            if (tile.color === Color.Gray)
+                gray++;
+            else if (tile.color !== color)
+                opposite++;
+        });
+        return { completed: opposite, possible: opposite + gray };
+    }
+    copyWith({ x, y, number, orientation, }) {
+        return new DartSymbol(x ?? this.x, y ?? this.y, number ?? this.number, orientation ?? this.orientation);
+    }
+    withNumber(number) {
+        return this.copyWith({ number });
+    }
+}
+export const instance = new DartSymbol(0, 0, 1, Orientation.Right);

package/dist/src/data/symbols/directionLinkerSymbol.d.ts

@@ -0,0 +1,29 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { Direction, State } from '../primitives.js';
+import Symbol from './symbol.js';
+export type DirectionLinkerMap = Record<Direction, Direction>;
+export default abstract class DirectionLinkerSymbol extends Symbol {
+    readonly x: number;
+    readonly y: number;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    private static readonly directionDeltas;
+    private linkedDirections;
+    /**
+     * **Darts count opposite color cells in that direction**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     */
+    constructor(x: number, y: number);
+    changeDirections(linkedDirections: DirectionLinkerMap): this;
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    private deltaCoordinate;
+    validateSymbol(grid: GridData): State;
+    private getInitialCheckedCouples;
+}
+export declare const instance: undefined;

package/dist/src/data/symbols/directionLinkerSymbol.js

@@ -0,0 +1,232 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { Color, Direction, State } from '../primitives.js';
+import Symbol from './symbol.js';
+function getColor(c, grid) {
+    if (!grid.isPositionValid(c.x, c.y) || !grid.getTile(c.x, c.y).exists) {
+        return null;
+    }
+    return grid.getTile(c.x, c.y).color;
+}
+function makeTurtle(pos1, pos2, grid) {
+    return {
+        pos1,
+        color1: getColor(pos1, grid),
+        pos2,
+        color2: getColor(pos2, grid),
+    };
+}
+export default class DirectionLinkerSymbol extends Symbol {
+    x;
+    y;
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.Number,
+            default: 0,
+            field: 'x',
+            description: 'X',
+            configurable: false,
+        },
+        {
+            type: ConfigType.Number,
+            default: 0,
+            field: 'y',
+            description: 'Y',
+            configurable: false,
+        },
+    ]);
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['wwbbw', 'wwwww', 'wwwww', 'wwwww']));
+    static directionDeltas = {
+        [Direction.Up]: { dx: 0, dy: -1 },
+        [Direction.Down]: { dx: 0, dy: 1 },
+        [Direction.Left]: { dx: -1, dy: 0 },
+        [Direction.Right]: { dx: 1, dy: 0 },
+    };
+    linkedDirections = {
+        [Direction.Left]: Direction.Left,
+        [Direction.Up]: Direction.Up,
+        [Direction.Right]: Direction.Right,
+        [Direction.Down]: Direction.Down,
+    };
+    /**
+     * **Darts count opposite color cells in that direction**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     */
+    constructor(x, y) {
+        super(x, y);
+        this.x = x;
+        this.y = y;
+    }
+    changeDirections(linkedDirections) {
+        this.linkedDirections = linkedDirections;
+        return this;
+    }
+    get id() {
+        return `linkedDirection`;
+    }
+    get explanation() {
+        return `Direction pointed by this symbol should *behave* the same.`;
+    }
+    get configs() {
+        return DirectionLinkerSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        return DirectionLinkerSymbol.EXAMPLE_GRID;
+    }
+    deltaCoordinate(c, direction) {
+        return {
+            x: c.x + DirectionLinkerSymbol.directionDeltas[direction].dx,
+            y: c.y + DirectionLinkerSymbol.directionDeltas[direction].dy,
+        };
+    }
+    validateSymbol(grid) {
+        // A turtle is an object which have 2 coordinates
+        // This turtle when activated will check the color of both the cells it is pointing to
+        // If the color of one of the cell is gray, the turtle doesn't fire any other turtle
+        // If one of the turtle's coordinate is out of the grid, consider it's color as opposite of the base color
+        // If the color of both cells are different, return a State.Error
+        // If the color of both are the same as the color of the turtle, the turtle fires another turtle in all the directions according to the linked directions except the one it came from and the directions where a turtle has already been fired
+        // If the color of both are the opposite of the turtle, the turtle doesn't fire any other turtle
+        // If no turtle remains, go to final state
+        // Final state is State.Satisfied if no gray cell is found, State.Incomplete otherwise
+        let checkedCouples = this.getInitialCheckedCouples(this.x, this.y, grid);
+        if (checkedCouples.some(({ color1, color2 }) => (color1 === null && color2 !== null) ||
+            (color1 !== null && color2 === null))) {
+            return State.Error;
+        }
+        if (checkedCouples.some(({ color1, color2 }) => color1 === Color.Gray || color2 === Color.Gray)) {
+            return State.Incomplete;
+        }
+        checkedCouples = checkedCouples.filter(({ color1, color2 }) => color1 !== null && color2 !== null);
+        const queue = checkedCouples.slice();
+        let grayFound = false;
+        while (queue.length > 0) {
+            const turtle = queue.shift();
+            const { pos1, pos2, color1: baseColor1, color2: baseColor2 } = turtle;
+            const color1 = getColor(pos1, grid);
+            const color2 = getColor(pos2, grid);
+            if (color1 === Color.Gray || color2 === Color.Gray) {
+                grayFound = true;
+            }
+            else if (color1 === null || color2 === null) {
+                if ((color1 === null && color2 === baseColor2) ||
+                    (color2 === null && color1 === baseColor1)) {
+                    return State.Error;
+                }
+            }
+            else if (color1 !== baseColor1 || color2 !== baseColor2) {
+                if (color1 === baseColor1 || color2 === baseColor2) {
+                    return State.Error;
+                }
+            }
+            if (color1 === baseColor1) {
+                const directions = Object.keys(this.linkedDirections);
+                for (const direction of directions) {
+                    const newTurtle = {
+                        pos1: this.deltaCoordinate(pos1, direction),
+                        pos2: this.deltaCoordinate(pos2, this.linkedDirections[direction]),
+                        color1: baseColor1,
+                        color2: baseColor2,
+                    };
+                    const newArrTurtle = {
+                        pos1: grid.toArrayCoordinates(newTurtle.pos1.x, newTurtle.pos1.y),
+                        pos2: grid.toArrayCoordinates(newTurtle.pos2.x, newTurtle.pos2.y),
+                        color1: baseColor1,
+                        color2: baseColor2,
+                    };
+                    const newColor1 = getColor(newArrTurtle.pos1, grid);
+                    const newColor2 = getColor(newArrTurtle.pos2, grid);
+                    if (newColor1 !== baseColor1 &&
+                        newColor2 !== baseColor2 &&
+                        newColor1 !== Color.Gray &&
+                        newColor2 !== Color.Gray) {
+                        continue;
+                    }
+                    if (checkedCouples.some(({ pos1, pos2 }) => pos1.x === newArrTurtle.pos1.x &&
+                        pos1.y === newArrTurtle.pos1.y &&
+                        pos2.x === newArrTurtle.pos2.x &&
+                        pos2.y === newArrTurtle.pos2.y) ||
+                        (pos1.x === newArrTurtle.pos2.x &&
+                            pos1.y === newArrTurtle.pos2.y &&
+                            pos2.x === newArrTurtle.pos1.x &&
+                            pos2.y === newArrTurtle.pos1.y)) {
+                        continue;
+                    }
+                    checkedCouples.push(newArrTurtle);
+                    queue.push(newTurtle);
+                }
+            }
+        }
+        return grayFound ? State.Incomplete : State.Satisfied;
+    }
+    getInitialCheckedCouples(x, y, grid) {
+        // 1x1
+        if (x % 1 === 0 && y % 1 === 0) {
+            return [makeTurtle({ x, y }, { x, y }, grid)];
+        }
+        // 1x2
+        if (x % 1 === 0) {
+            if (this.linkedDirections[Direction.Up] === Direction.Up &&
+                this.linkedDirections[Direction.Down] === Direction.Down) {
+                return [
+                    makeTurtle({ x, y: y - 0.5 }, { x, y: y - 0.5 }, grid),
+                    makeTurtle({ x, y: y + 0.5 }, { x, y: y + 0.5 }, grid),
+                ];
+            }
+            else {
+                return [makeTurtle({ x, y: y - 0.5 }, { x, y: y + 0.5 }, grid)];
+            }
+        }
+        // 2x1
+        if (y % 1 === 0) {
+            if (this.linkedDirections[Direction.Left] === Direction.Left &&
+                this.linkedDirections[Direction.Right] === Direction.Right) {
+                return [
+                    makeTurtle({ x: x - 0.5, y }, { x: x - 0.5, y }, grid),
+                    makeTurtle({ x: x + 0.5, y }, { x: x + 0.5, y }, grid),
+                ];
+            }
+            else {
+                return [makeTurtle({ x: x - 0.5, y }, { x: x + 0.5, y }, grid)];
+            }
+        }
+        // 2x2
+        if (this.linkedDirections[Direction.Left] === Direction.Left &&
+            this.linkedDirections[Direction.Right] === Direction.Right) {
+            return [
+                makeTurtle({ x: x - 0.5, y: y - 0.5 }, { x: x - 0.5, y: y + 0.5 }, grid),
+                makeTurtle({ x: x + 0.5, y: y - 0.5 }, { x: x + 0.5, y: y + 0.5 }, grid),
+            ];
+        }
+        if (this.linkedDirections[Direction.Up] === Direction.Up &&
+            this.linkedDirections[Direction.Down] === Direction.Down) {
+            return [
+                makeTurtle({ x: x - 0.5, y: y - 0.5 }, { x: x + 0.5, y: y - 0.5 }, grid),
+                makeTurtle({ x: x - 0.5, y: y + 0.5 }, { x: x + 0.5, y: y + 0.5 }, grid),
+            ];
+        }
+        else if (this.linkedDirections[Direction.Up] === Direction.Left &&
+            this.linkedDirections[Direction.Left] === Direction.Up) {
+            return [
+                makeTurtle({ x: x - 0.5, y: y - 0.5 }, { x: x - 0.5, y: y - 0.5 }, grid),
+                makeTurtle({ x: x - 0.5, y: y + 0.5 }, { x: x + 0.5, y: y - 0.5 }, grid),
+                makeTurtle({ x: x + 0.5, y: y + 0.5 }, { x: x + 0.5, y: y + 0.5 }, grid),
+            ];
+        }
+        else if (this.linkedDirections[Direction.Up] === Direction.Right &&
+            this.linkedDirections[Direction.Right] === Direction.Up) {
+            return [
+                makeTurtle({ x: x + 0.5, y: y - 0.5 }, { x: x + 0.5, y: y - 0.5 }, grid),
+                makeTurtle({ x: x - 0.5, y: y - 0.5 }, { x: x + 0.5, y: y + 0.5 }, grid),
+                makeTurtle({ x: x - 0.5, y: y + 0.5 }, { x: x - 0.5, y: y + 0.5 }, grid),
+            ];
+        }
+        return [
+            makeTurtle({ x: x - 0.5, y: y - 0.5 }, { x: x + 0.5, y: y + 0.5 }, grid),
+            makeTurtle({ x: x - 0.5, y: y + 0.5 }, { x: x + 0.5, y: y - 0.5 }, grid),
+        ];
+    }
+}
+export const instance = undefined;

package/dist/src/data/symbols/everyLetterSymbol.d.ts

@@ -0,0 +1,32 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { State } from '../primitives.js';
+import Symbol from './symbol.js';
+export default class EveryLetterSymbol extends Symbol {
+    readonly x: number;
+    readonly y: number;
+    readonly letter: string;
+    readonly title = "Hollow Letter";
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Include each Hollow Letter once per region**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param letter - The letter of the symbol.
+     */
+    constructor(x: number, y: number, letter: string);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    validateSymbol(grid: GridData): State;
+    copyWith({ x, y, letter, }: {
+        x?: number;
+        y?: number;
+        letter?: string;
+    }): this;
+    withLetter(letter: string): this;
+}
+export declare const instance: EveryLetterSymbol;

package/dist/src/data/symbols/everyLetterSymbol.js

@@ -0,0 +1,119 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { array } from '../dataHelper.js';
+import { Color, State } from '../primitives.js';
+import Symbol from './symbol.js';
+export default class EveryLetterSymbol extends Symbol {
+    x;
+    y;
+    letter;
+    title = 'Hollow Letter';
+    static CONFIGS = 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.String,
+            default: 'a',
+            field: 'letter',
+            description: 'Letter',
+            explanation: 'Use single lowercase letters by convention.',
+            configurable: true,
+        },
+    ]);
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['bwwbw', 'bwbbw', 'wwbww', 'bbbwb'])
+        .addSymbol(new EveryLetterSymbol(2, 0, 'b'))
+        .addSymbol(new EveryLetterSymbol(4, 1, 'a'))
+        .addSymbol(new EveryLetterSymbol(0, 2, 'a'))
+        .addSymbol(new EveryLetterSymbol(3, 2, 'b')));
+    /**
+     * **Include each Hollow Letter once per region**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param letter - The letter of the symbol.
+     */
+    constructor(x, y, letter) {
+        super(x, y);
+        this.x = x;
+        this.y = y;
+        this.letter = letter;
+        this.letter = letter;
+    }
+    get id() {
+        return `every_letter`;
+    }
+    get explanation() {
+        return 'Include each *Hollow Letter* once per region';
+    }
+    get configs() {
+        return EveryLetterSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        return EveryLetterSymbol.EXAMPLE_GRID;
+    }
+    validateSymbol(grid) {
+        if (!this.validateSubtilePlacement(grid))
+            return State.Error;
+        const uniqueLetters = new Set(grid.symbols.get(this.id)?.map(s => s.letter));
+        if (uniqueLetters.size === 0) {
+            return State.Satisfied;
+        }
+        const possibleLetters = new Set(uniqueLetters);
+        const thisX = Math.floor(this.x);
+        const thisY = Math.floor(this.y);
+        let complete = true;
+        const visited = array(grid.width, grid.height, () => false);
+        const connected = array(grid.width, grid.height, () => false);
+        const color = grid.getTile(thisX, thisY).color;
+        if (color !== Color.Gray) {
+            grid.iterateArea({ x: thisX, y: thisY }, tile => tile.color === Color.Gray || tile.color === color, (tile, x, y) => {
+                visited[y][x] = true;
+                if (tile.color === Color.Gray)
+                    complete = false;
+            });
+            grid.iterateArea({ x: thisX, y: thisY }, tile => tile.color === color, (_, x, y) => {
+                connected[y][x] = true;
+            });
+        }
+        else {
+            return State.Incomplete;
+        }
+        for (const symbol of grid.symbols.get(this.id) ?? []) {
+            if (symbol instanceof EveryLetterSymbol) {
+                const symbolX = Math.floor(symbol.x);
+                const symbolY = Math.floor(symbol.y);
+                if (visited[symbolY][symbolX]) {
+                    possibleLetters.delete(symbol.letter);
+                }
+                if (connected[symbolY][symbolX]) {
+                    if (!uniqueLetters.delete(symbol.letter)) {
+                        return State.Error;
+                    }
+                }
+            }
+        }
+        if (possibleLetters.size > 0) {
+            return State.Error;
+        }
+        return complete ? State.Satisfied : State.Incomplete;
+    }
+    copyWith({ x, y, letter, }) {
+        return new EveryLetterSymbol(x ?? this.x, y ?? this.y, letter ?? this.letter);
+    }
+    withLetter(letter) {
+        return this.copyWith({ letter });
+    }
+}
+export const instance = new EveryLetterSymbol(0, 0, 'a');

package/dist/src/data/symbols/focusSymbol.d.ts

@@ -0,0 +1,40 @@
+import { AnyConfig } from '../config.js';
+import { SymbolMergeHandler } from '../events/onSymbolMerge.js';
+import GridData from '../grid.js';
+import NumberSymbol from './numberSymbol.js';
+import Symbol from './symbol.js';
+export default class FocusSymbol extends NumberSymbol implements SymbolMergeHandler {
+    readonly deadEnd: boolean;
+    get title(): string;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    private static readonly EXAMPLE_GRID_DEAD_END;
+    /**
+     * **Focus Numbers count directly adjacent cells of the same color**
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param deadEnd - Whether this Focus Number is a Dead End.
+     * @param number - The focus number.
+     */
+    constructor(x: number, y: number, deadEnd: boolean, number: number);
+    get id(): string;
+    get placementStep(): number;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    private countForColor;
+    countTiles(grid: GridData): {
+        completed: number;
+        possible: number;
+    };
+    descriptionEquals(other: Symbol): boolean;
+    copyWith({ x, y, deadEnd, number, }: {
+        x?: number;
+        y?: number;
+        deadEnd?: boolean;
+        number?: number;
+    }): this;
+    withNumber(number: number): this;
+    withDeadEnd(deadEnd: boolean): this;
+}
+export declare const instance: FocusSymbol;