@logic-pad/core 0.1.0

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

@@ -0,0 +1,36 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { Direction, State } from '../primitives';
+import Symbol from './symbol';
+export type DirectionLinkerMap = {
+    [key in Direction]: Direction;
+};
+export default 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 getColor;
+    private deltaCoordinate;
+    validateSymbol(grid: GridData): State;
+    copyWith({ x, y }: {
+        x?: number;
+        y?: number;
+    }): this;
+    private getInitialCheckedCouples;
+}
+export declare const instance: undefined;

package/dist/data/symbols/directionLinkerSymbol.js

@@ -0,0 +1,259 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { Color, Direction, State } from '../primitives';
+import Symbol from './symbol';
+class DirectionLinkerSymbol extends Symbol {
+    /**
+     * **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);
+        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, "linkedDirections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                [Direction.Left]: Direction.Left,
+                [Direction.Up]: Direction.Up,
+                [Direction.Right]: Direction.Right,
+                [Direction.Down]: Direction.Down,
+            }
+        });
+    }
+    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;
+    }
+    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;
+    }
+    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
+        const baseColor = grid.getTile(Math.round(this.x), Math.round(this.y)).color;
+        if (baseColor === Color.Gray) {
+            return State.Incomplete;
+        }
+        const checkedCouples = this.getInitialCheckedCouples(this.x, this.y);
+        const queue = checkedCouples.map(([p1, p2]) => [
+            { ...p1 },
+            { ...p2 },
+        ]);
+        let grayFound = false;
+        while (queue.length > 0) {
+            const turtle = queue.shift();
+            const [c1, c2] = turtle;
+            const color1 = this.getColor(c1, grid);
+            const color2 = this.getColor(c2, grid);
+            const colorSet = new Set([color1, color2]);
+            if (colorSet.has(null) && !colorSet.has(baseColor)) {
+                colorSet.delete(null);
+            }
+            if (colorSet.size === 2 && !colorSet.has(Color.Gray)) {
+                return State.Error;
+            }
+            if (colorSet.has(Color.Gray)) {
+                grayFound = true;
+            }
+            if (color1 === baseColor) {
+                const directions = Object.keys(this.linkedDirections);
+                for (const direction of directions) {
+                    const newTurtle = [
+                        this.deltaCoordinate(c1, direction),
+                        this.deltaCoordinate(c2, this.linkedDirections[direction]),
+                    ];
+                    if (checkedCouples.some(([c1, c2]) => c1.x === newTurtle[0].x &&
+                        c1.y === newTurtle[0].y &&
+                        c2.x === newTurtle[1].x &&
+                        c2.y === newTurtle[1].y) ||
+                        (c1.x === newTurtle[1].x &&
+                            c1.y === newTurtle[1].y &&
+                            c2.x === newTurtle[0].x &&
+                            c2.y === newTurtle[0].y)) {
+                        continue;
+                    }
+                    checkedCouples.push([newTurtle[0], newTurtle[1]]);
+                    queue.push(newTurtle);
+                }
+            }
+        }
+        return grayFound ? State.Incomplete : State.Satisfied;
+    }
+    copyWith({ x, y }) {
+        return new DirectionLinkerSymbol(x ?? this.x, y ?? this.y);
+    }
+    getInitialCheckedCouples(x, y) {
+        // 1x1
+        if (x % 1 === 0 && y % 1 === 0) {
+            return [
+                [
+                    { x, y },
+                    { x, y },
+                ],
+            ];
+        }
+        // 1x2
+        if (x % 1 === 0) {
+            return [
+                [
+                    { x, y: y - 0.5 },
+                    {
+                        x,
+                        y: y +
+                            (this.linkedDirections[Direction.Up] === Direction.Up &&
+                                this.linkedDirections[Direction.Down] === Direction.Down
+                                ? -0.5
+                                : 0.5),
+                    },
+                ],
+            ];
+        }
+        // 2x1
+        if (y % 1 === 0) {
+            return [
+                [
+                    { x: x - 0.5, y },
+                    {
+                        x: x +
+                            (this.linkedDirections[Direction.Left] === Direction.Left &&
+                                this.linkedDirections[Direction.Right] === Direction.Right
+                                ? -0.5
+                                : 0.5),
+                        y,
+                    },
+                ],
+            ];
+        }
+        // 2x2
+        if (this.linkedDirections[Direction.Left] === Direction.Left &&
+            this.linkedDirections[Direction.Right] === Direction.Right) {
+            return [
+                [
+                    { x: x - 0.5, y: y - 0.5 },
+                    { x: x - 0.5, y: y + 0.5 },
+                ],
+                [
+                    { x: x + 0.5, y: y - 0.5 },
+                    { x: x + 0.5, y: y + 0.5 },
+                ],
+            ];
+        }
+        if (this.linkedDirections[Direction.Up] === Direction.Up &&
+            this.linkedDirections[Direction.Down] === Direction.Down) {
+            return [
+                [
+                    { x: x - 0.5, y: y - 0.5 },
+                    { x: x + 0.5, y: y - 0.5 },
+                ],
+                [
+                    { x: x - 0.5, y: y + 0.5 },
+                    { x: x + 0.5, y: y + 0.5 },
+                ],
+            ];
+        }
+        else if ((this.linkedDirections[Direction.Up] === Direction.Left &&
+            this.linkedDirections[Direction.Left] === Direction.Up) ||
+            (this.linkedDirections[Direction.Up] === Direction.Right &&
+                this.linkedDirections[Direction.Right] === Direction.Up)) {
+            return [
+                [
+                    { x: x - 0.5, y: y - 0.5 },
+                    { x: x - 0.5, y: y - 0.5 },
+                ],
+            ];
+        }
+        return [
+            [
+                { x: x - 0.5, y: y - 0.5 },
+                { x: x + 0.5, y: y + 0.5 },
+            ],
+            [
+                { x: x - 0.5, y: y + 0.5 },
+                { x: x + 0.5, y: y - 0.5 },
+            ],
+        ];
+    }
+}
+Object.defineProperty(DirectionLinkerSymbol, "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,
+        },
+    ])
+});
+Object.defineProperty(DirectionLinkerSymbol, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['wwbbw', 'wwwww', 'wwwww', 'wwwww']))
+});
+Object.defineProperty(DirectionLinkerSymbol, "directionDeltas", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        [Direction.Up]: { dx: 0, dy: -1 },
+        [Direction.Down]: { dx: 0, dy: 1 },
+        [Direction.Left]: { dx: -1, dy: 0 },
+        [Direction.Right]: { dx: 1, dy: 0 },
+    }
+});
+export default DirectionLinkerSymbol;
+export const instance = undefined;

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

@@ -0,0 +1,26 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { State } from '../primitives';
+import DirectionLinkerSymbol from './directionLinkerSymbol';
+export default class GalaxySymbol extends DirectionLinkerSymbol {
+    readonly x: number;
+    readonly y: number;
+    private static readonly linkedDirections;
+    /**
+     * **Galaxies are centers of rotational symmetry**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     */
+    constructor(x: number, y: number);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    validateSymbol(grid: GridData): State;
+    copyWith({ x, y }: {
+        x?: number;
+        y?: number;
+    }): this;
+}
+export declare const instance: GalaxySymbol;

package/dist/data/symbols/galaxySymbol.js

@@ -0,0 +1,74 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { Direction } from '../primitives';
+import DirectionLinkerSymbol from './directionLinkerSymbol';
+class GalaxySymbol extends DirectionLinkerSymbol {
+    /**
+     * **Galaxies are centers of rotational symmetry**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     */
+    constructor(x, y) {
+        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
+        });
+        super.changeDirections(GalaxySymbol.linkedDirections);
+    }
+    get id() {
+        return `galaxy`;
+    }
+    get explanation() {
+        return `*Galaxies* are centers of rotational symmetry`;
+    }
+    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,
+            },
+        ]);
+    }
+    createExampleGrid() {
+        return Object.freeze(GridData.create(['wbbbb', 'wbwww', 'bbwbb', 'wwwbb']).addSymbol(new GalaxySymbol(2, 2)));
+    }
+    validateSymbol(grid) {
+        return super.validateSymbol(grid);
+    }
+    copyWith({ x, y }) {
+        return new GalaxySymbol(x ?? this.x, y ?? this.y);
+    }
+}
+Object.defineProperty(GalaxySymbol, "linkedDirections", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        [Direction.Left]: Direction.Right,
+        [Direction.Up]: Direction.Down,
+        [Direction.Right]: Direction.Left,
+        [Direction.Down]: Direction.Up,
+    }
+});
+export default GalaxySymbol;
+export const instance = new GalaxySymbol(0, 0);

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

@@ -0,0 +1,3 @@
+import Symbol from './symbol';
+declare const allSymbols: Map<string, Symbol>;
+export { allSymbols };

package/dist/data/symbols/index.js

@@ -0,0 +1,10 @@
+import * as symbols from './symbols.gen';
+const allSymbols = new Map();
+function register(prototype) {
+    allSymbols.set(prototype.id, prototype);
+}
+Object.values(symbols).forEach(symbol => {
+    if (symbol)
+        register(symbol);
+});
+export { allSymbols };

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

@@ -0,0 +1,31 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { State } from '../primitives';
+import Symbol from './symbol';
+export default class LetterSymbol extends Symbol {
+    readonly x: number;
+    readonly y: number;
+    readonly letter: string;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Letters must be sorted into one type per area**
+     *
+     * @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: LetterSymbol;

package/dist/data/symbols/letterSymbol.js

@@ -0,0 +1,137 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { array } from '../dataHelper';
+import { Color, State } from '../primitives';
+import Symbol from './symbol';
+class LetterSymbol extends Symbol {
+    /**
+     * **Letters must be sorted into one type per area**
+     *
+     * @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);
+        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, "letter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: letter
+        });
+        this.letter = letter;
+    }
+    get id() {
+        return `letter`;
+    }
+    get explanation() {
+        return '*Letters* must be sorted into one type per area';
+    }
+    get configs() {
+        return LetterSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        return LetterSymbol.EXAMPLE_GRID;
+    }
+    validateSymbol(grid) {
+        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 {
+            complete = false;
+        }
+        for (const symbol of grid.symbols.get(this.id) ?? []) {
+            if (symbol !== this && symbol instanceof LetterSymbol) {
+                const symbolX = Math.floor(symbol.x);
+                const symbolY = Math.floor(symbol.y);
+                if (symbol.letter === this.letter) {
+                    const theirColor = grid.getTile(symbolX, symbolY).color;
+                    if ((color !== Color.Gray && !visited[symbolY][symbolX]) ||
+                        (color !== Color.Gray &&
+                            theirColor !== Color.Gray &&
+                            theirColor !== color)) {
+                        return State.Error;
+                    }
+                }
+                else if (color !== Color.Gray && connected[symbolY][symbolX]) {
+                    return State.Error;
+                }
+            }
+        }
+        return complete ? State.Satisfied : State.Incomplete;
+    }
+    copyWith({ x, y, letter, }) {
+        return new LetterSymbol(x ?? this.x, y ?? this.y, letter ?? this.letter);
+    }
+    withLetter(letter) {
+        return this.copyWith({ letter });
+    }
+}
+Object.defineProperty(LetterSymbol, "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.String,
+            default: 'A',
+            field: 'letter',
+            description: 'Letter',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(LetterSymbol, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['bbbww', 'wwbbw', 'wwbbb', 'bwwww'])
+        .addSymbol(new LetterSymbol(0, 0, 'B'))
+        .addSymbol(new LetterSymbol(3, 0, 'A'))
+        .addSymbol(new LetterSymbol(4, 1, 'A'))
+        .addSymbol(new LetterSymbol(3, 2, 'B'))
+        .addSymbol(new LetterSymbol(1, 1, 'C'))
+        .addSymbol(new LetterSymbol(0, 2, 'C'))
+        .addSymbol(new LetterSymbol(4, 3, 'C')))
+});
+export default LetterSymbol;
+export const instance = new LetterSymbol(0, 0, 'A');

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

@@ -0,0 +1,29 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { Orientation, State } from '../primitives';
+import DirectionLinkerSymbol from './directionLinkerSymbol';
+export default class LotusSymbol extends DirectionLinkerSymbol {
+    readonly x: number;
+    readonly y: number;
+    readonly orientation: Orientation;
+    private static readonly linkedDirectionsFromOrientation;
+    /**
+     * **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: number, y: number, orientation: Orientation);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    validateSymbol(grid: GridData): State;
+    copyWith({ x, y, orientation, }: {
+        x?: number;
+        y?: number;
+        orientation?: Orientation;
+    }): this;
+}
+export declare const instance: LotusSymbol;