@logic-pad/core 0.26.2 → 0.27.0

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

@@ -0,0 +1,159 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { Color } from '../primitives.js';
+import AreaNumberSymbol from './areaNumberSymbol.js';
+import LetterSymbol from './letterSymbol.js';
+import NumberSymbol from './numberSymbol.js';
+const OFFSETS = [
+    [0, -1],
+    [1, 0],
+    [0, 1],
+    [-1, 0],
+];
+export default class FocusSymbol extends NumberSymbol {
+    deadEnd;
+    get title() {
+        if (this.deadEnd) {
+            return 'Dead End';
+        }
+        else {
+            return 'Focus Number';
+        }
+    }
+    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.Boolean,
+            default: false,
+            field: 'deadEnd',
+            description: 'Dead End',
+            explanation: 'A Dead End is a Focus Number of 1 that can be stacked with other symbols.',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Number,
+            default: 1,
+            field: 'number',
+            description: 'Number',
+            explanation: 'Must be 1 for Dead Ends. Between 0 and 4 for Focus Numbers.',
+            configurable: true,
+        },
+    ]);
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['wwwww', 'bbbbw', 'wwbbw', 'wwwww']).withSymbols([
+        new FocusSymbol(0, 0, false, 1),
+        new FocusSymbol(4, 1, false, 2),
+        new FocusSymbol(1, 3, false, 3),
+    ]));
+    static EXAMPLE_GRID_DEAD_END = Object.freeze(GridData.create(['wwwww', 'bbbbw', 'wwwbw', 'bbbbw']).withSymbols([
+        new FocusSymbol(0, 0, true, 1),
+        new FocusSymbol(4, 3, true, 1),
+        new FocusSymbol(0, 2, true, 1),
+        new FocusSymbol(2, 2, true, 1),
+        new AreaNumberSymbol(0, 2, 3),
+        new LetterSymbol(0, 0, 'A'),
+        new LetterSymbol(4, 3, 'A'),
+    ]));
+    /**
+     * **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, y, deadEnd, number) {
+        if (deadEnd) {
+            number = 1;
+        }
+        super(x, y, number);
+        this.deadEnd = deadEnd;
+        this.deadEnd = deadEnd;
+    }
+    get id() {
+        return `focus`;
+    }
+    get placementStep() {
+        return 1;
+    }
+    get explanation() {
+        if (this.deadEnd) {
+            return `*Dead Ends* connect to one adjacent cell of the same color`;
+        }
+        else {
+            return '*Focus Numbers* count directly adjacent cells of the same color';
+        }
+    }
+    get configs() {
+        return FocusSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        if (this.deadEnd) {
+            return FocusSymbol.EXAMPLE_GRID_DEAD_END;
+        }
+        else {
+            return FocusSymbol.EXAMPLE_GRID;
+        }
+    }
+    countForColor(grid, color) {
+        let gray = 0;
+        let same = 0;
+        const visited = [];
+        for (const [dx, dy] of OFFSETS) {
+            const x = this.x + dx;
+            const y = this.y + dy;
+            if (grid.wrapAround.value) {
+                const pos = grid.toArrayCoordinates(x, y);
+                if (visited.some(v => v.x === pos.x && v.y === pos.y))
+                    continue;
+                visited.push(pos);
+            }
+            const tile = grid.getTile(x, y);
+            if (!tile.exists)
+                continue;
+            if (tile.color === Color.Gray)
+                gray++;
+            else if (tile.color === color)
+                same++;
+        }
+        return { completed: same, possible: same + gray };
+    }
+    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) {
+            const dark = this.countForColor(grid, Color.Dark);
+            const light = this.countForColor(grid, Color.Light);
+            return {
+                completed: Math.min(dark.completed, light.completed),
+                possible: Math.max(dark.possible, light.possible),
+            };
+        }
+        return this.countForColor(grid, color);
+    }
+    descriptionEquals(other) {
+        return this.id === other.id && this.explanation === other.explanation;
+    }
+    copyWith({ x, y, deadEnd, number, }) {
+        return new FocusSymbol(x ?? this.x, y ?? this.y, deadEnd ?? this.deadEnd, number ?? this.number);
+    }
+    withNumber(number) {
+        return this.copyWith({ number });
+    }
+    withDeadEnd(deadEnd) {
+        return this.copyWith({ deadEnd });
+    }
+}
+export const instance = new FocusSymbol(0, 0, false, 1);

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

@@ -0,0 +1,27 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { State } from '../primitives.js';
+import DirectionLinkerSymbol from './directionLinkerSymbol.js';
+export default class GalaxySymbol extends DirectionLinkerSymbol {
+    readonly x: number;
+    readonly y: number;
+    readonly title = "Galaxy";
+    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/src/data/symbols/galaxySymbol.js

@@ -0,0 +1,61 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { Direction } from '../primitives.js';
+import DirectionLinkerSymbol from './directionLinkerSymbol.js';
+export default class GalaxySymbol extends DirectionLinkerSymbol {
+    x;
+    y;
+    title = 'Galaxy';
+    static linkedDirections = {
+        [Direction.Left]: Direction.Right,
+        [Direction.Up]: Direction.Down,
+        [Direction.Right]: Direction.Left,
+        [Direction.Down]: Direction.Up,
+    };
+    /**
+     * **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);
+        this.x = x;
+        this.y = 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);
+    }
+}
+export const instance = new GalaxySymbol(0, 0);

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

@@ -0,0 +1,38 @@
+import { AnyConfig } from '../config.js';
+import { SymbolDisplayHandler } from '../events/onSymbolDisplay.js';
+import GridData from '../grid.js';
+import { State } from '../primitives.js';
+import Symbol from './symbol.js';
+export default class HiddenSymbol extends Symbol implements SymbolDisplayHandler {
+    readonly x: number;
+    readonly y: number;
+    readonly revealLocation: boolean;
+    readonly title = "Hidden Symbol Marker";
+    get configExplanation(): string;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Hidden Symbols: color cells correctly to reveal more clues**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param revealLocation - Whether to reveal the location of the symbol.
+     */
+    constructor(x: number, y: number, revealLocation?: boolean);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get necessaryForCompletion(): boolean;
+    get visibleWhenSolving(): boolean;
+    get sortOrder(): number;
+    validateSymbol(grid: GridData, solution: GridData | null): State;
+    onSymbolDisplay(grid: GridData, solution: GridData | null, symbol: Symbol, editing: boolean): boolean;
+    copyWith({ x, y, revealLocation, }: {
+        x?: number;
+        y?: number;
+        revealLocation?: boolean;
+    }): this;
+    withRevealLocation(revealLocation: boolean): this;
+}
+export declare const instance: HiddenSymbol;

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

@@ -0,0 +1,113 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { Color, State } from '../primitives.js';
+import CustomIconSymbol from './customIconSymbol.js';
+import Symbol from './symbol.js';
+export default class HiddenSymbol extends Symbol {
+    x;
+    y;
+    revealLocation;
+    title = 'Hidden Symbol Marker';
+    get configExplanation() {
+        return 'Other symbols in the same location will be hidden until this tile is colored correctly.';
+    }
+    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.Boolean,
+            default: false,
+            field: 'revealLocation',
+            description: 'Reveal symbol location',
+            explanation: 'Whether to show this symbol when the tile is not yet colored correctly.',
+            configurable: true,
+        },
+    ]);
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['w']).addSymbol(new CustomIconSymbol('', GridData.create(['.']), 0, 0, 'MdHideSource') // Not using HiddenSymbol here because it is meant to be hidden in non-edit mode
+    ));
+    /**
+     * **Hidden Symbols: color cells correctly to reveal more clues**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param revealLocation - Whether to reveal the location of the symbol.
+     */
+    constructor(x, y, revealLocation = false) {
+        super(x, y);
+        this.x = x;
+        this.y = y;
+        this.revealLocation = revealLocation;
+        this.revealLocation = revealLocation;
+    }
+    get id() {
+        return `hidden`;
+    }
+    get explanation() {
+        return '*Hidden Symbols*: color cells correctly to reveal more clues';
+    }
+    get configs() {
+        return HiddenSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        return HiddenSymbol.EXAMPLE_GRID;
+    }
+    get necessaryForCompletion() {
+        return false;
+    }
+    get visibleWhenSolving() {
+        return this.revealLocation;
+    }
+    get sortOrder() {
+        return 0;
+    }
+    validateSymbol(grid, solution) {
+        const thisX = Math.floor(this.x);
+        const thisY = Math.floor(this.y);
+        const thisColor = grid.getTile(thisX, thisY).color;
+        if (solution) {
+            return thisColor === solution.getTile(thisX, thisY).color
+                ? State.Satisfied
+                : State.Incomplete;
+        }
+        else {
+            return thisColor !== Color.Gray ? State.Satisfied : State.Incomplete;
+        }
+    }
+    onSymbolDisplay(grid, solution, symbol, editing) {
+        if (editing)
+            return true;
+        const thisX = Math.floor(this.x);
+        const thisY = Math.floor(this.y);
+        const symX = Math.floor(symbol.x);
+        const symY = Math.floor(symbol.y);
+        if (thisX !== symX || thisY !== symY)
+            return true;
+        const thisColor = grid.getTile(thisX, thisY).color;
+        const colorMatch = solution
+            ? thisColor === solution.getTile(thisX, thisY).color
+            : thisColor !== Color.Gray;
+        if (symbol.id === this.id) {
+            return !colorMatch;
+        }
+        return colorMatch;
+    }
+    copyWith({ x, y, revealLocation, }) {
+        return new HiddenSymbol(x ?? this.x, y ?? this.y, revealLocation ?? this.revealLocation);
+    }
+    withRevealLocation(revealLocation) {
+        return this.copyWith({ revealLocation });
+    }
+}
+export const instance = new HiddenSymbol(0, 0);

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

@@ -0,0 +1,33 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import NumberSymbol from './numberSymbol.js';
+export default class HouseSymbol extends NumberSymbol {
+    readonly x: number;
+    readonly y: number;
+    readonly number: number;
+    readonly title = "House";
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Houses must connect to exactly one other house**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param number - The number of houses in this region.
+     */
+    constructor(x: number, y: number, number: number);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    countTiles(grid: GridData): {
+        completed: number;
+        possible: number;
+    } | null;
+    copyWith({ x, y, number, }: {
+        x?: number;
+        y?: number;
+        number?: number;
+    }): this;
+}
+export declare const instance: HouseSymbol;

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

@@ -0,0 +1,104 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { array } from '../dataHelper.js';
+import { Color } from '../primitives.js';
+import NumberSymbol from './numberSymbol.js';
+export default class HouseSymbol extends NumberSymbol {
+    x;
+    y;
+    number;
+    title = 'House';
+    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: 2,
+            field: 'number',
+            description: 'Number',
+            explanation: 'Number of houses in this region',
+            configurable: true,
+        },
+    ]);
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['bbbww', 'wwwbw', 'wbbbw', 'wwwww'])
+        .addSymbol(new HouseSymbol(0, 0, 2))
+        .addSymbol(new HouseSymbol(2, 0, 2))
+        .addSymbol(new HouseSymbol(3, 0, 2))
+        .addSymbol(new HouseSymbol(2, 1, 2))
+        .addSymbol(new HouseSymbol(3, 1, 2))
+        .addSymbol(new HouseSymbol(1, 2, 2)));
+    /**
+     * **Houses must connect to exactly one other house**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param number - The number of houses in this region.
+     */
+    constructor(x, y, number) {
+        super(x, y, number);
+        this.x = x;
+        this.y = y;
+        this.number = number;
+    }
+    get id() {
+        return `house`;
+    }
+    get explanation() {
+        return '*House numbers* count the number of houses in the region';
+    }
+    get configs() {
+        return HouseSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        return HouseSymbol.EXAMPLE_GRID;
+    }
+    countTiles(grid) {
+        if (!this.validateSubtilePlacement(grid))
+            return null;
+        const thisX = Math.floor(this.x);
+        const thisY = Math.floor(this.y);
+        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)
+            return { completed: 0, possible: Number.MAX_SAFE_INTEGER };
+        grid.iterateArea({ x: thisX, y: thisY }, tile => tile.color === Color.Gray || tile.color === color, (_, x, y) => {
+            visited[y][x] = true;
+        });
+        grid.iterateArea({ x: thisX, y: thisY }, tile => tile.color === color, (_, x, y) => {
+            connected[y][x] = true;
+        });
+        let completedHouses = 0;
+        let possibleHouses = 0;
+        for (const symbol of grid.symbols.get(this.id) ?? []) {
+            if (symbol instanceof HouseSymbol) {
+                const symbolX = Math.floor(symbol.x);
+                const symbolY = Math.floor(symbol.y);
+                if (connected[symbolY][symbolX])
+                    completedHouses++;
+                else if (visited[symbolY][symbolX])
+                    possibleHouses++;
+            }
+        }
+        return {
+            completed: completedHouses,
+            possible: completedHouses + possibleHouses,
+        };
+    }
+    copyWith({ x, y, number, }) {
+        return new HouseSymbol(x ?? this.x, y ?? this.y, number ?? this.number);
+    }
+}
+export const instance = new HouseSymbol(0, 0, 2);

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

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

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

@@ -0,0 +1,10 @@
+import * as symbols from './symbols.gen.js';
+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/src/data/symbols/letterSymbol.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 LetterSymbol extends Symbol {
+    readonly x: number;
+    readonly y: number;
+    readonly letter: string;
+    readonly title = "Letter";
+    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;