@logic-pad/core 0.1.0

package/dist/data/serializer/serializerBase.d.ts

@@ -0,0 +1,27 @@
+import GridData from '../grid';
+import GridConnections from '../gridConnections';
+import Rule from '../rules/rule';
+import TileData from '../tile';
+import Symbol from '../symbols/symbol';
+import { Puzzle } from '../puzzle';
+export default abstract class SerializerBase {
+    abstract get version(): number;
+    abstract stringifyTile(tile: TileData): string;
+    abstract parseTile(str: string): TileData;
+    abstract stringifyRule(rule: Rule): string;
+    abstract stringifySymbol(symbol: Symbol): string;
+    abstract parseRule(str: string): Rule;
+    abstract parseSymbol(str: string): Symbol;
+    abstract stringifyConnections(connections: GridConnections): string;
+    abstract parseConnections(input: string): GridConnections;
+    abstract stringifyTiles(tiles: readonly (readonly TileData[])[]): string;
+    abstract parseTiles(input: string): TileData[][];
+    abstract stringifyRules(rules: readonly Rule[]): string;
+    abstract parseRules(input: string): Rule[];
+    abstract stringifySymbols(symbols: ReadonlyMap<string, readonly Symbol[]>): string;
+    abstract parseSymbols(input: string): Map<string, Symbol[]>;
+    abstract stringifyGrid(grid: GridData): string;
+    abstract parseGrid(input: string): GridData;
+    abstract stringifyPuzzle(puzzle: Puzzle): string;
+    abstract parsePuzzle(input: string): Puzzle;
+}

package/dist/data/serializer/serializerBase.js

@@ -0,0 +1,2 @@
+export default class SerializerBase {
+}

package/dist/data/serializer/serializer_v0.d.ts

@@ -0,0 +1,36 @@
+import GridData from '../grid';
+import GridConnections from '../gridConnections';
+import Rule from '../rules/rule';
+import TileData from '../tile';
+import Symbol from '../symbols/symbol';
+import Instruction from '../instruction';
+import { AnyConfig } from '../config';
+import SerializerBase from './serializerBase';
+import { Puzzle } from '../puzzle';
+import { ControlLine } from '../rules/musicControlLine';
+export default class SerializerV0 extends SerializerBase {
+    readonly version = 0;
+    stringifyTile(tile: TileData): string;
+    parseTile(str: string): TileData;
+    stringifyControlLine(line: ControlLine): string;
+    parseControlLine(str: string): ControlLine;
+    stringifyConfig(instruction: Instruction, config: AnyConfig): string;
+    parseConfig(configs: readonly AnyConfig[], entry: string): [string, unknown];
+    stringifyInstruction(instruction: Instruction): string;
+    stringifyRule(rule: Rule): string;
+    stringifySymbol(symbol: Symbol): string;
+    parseRule(str: string): Rule;
+    parseSymbol(str: string): Symbol;
+    stringifyConnections(connections: GridConnections): string;
+    parseConnections(input: string): GridConnections;
+    stringifyTiles(tiles: readonly (readonly TileData[])[]): string;
+    parseTiles(input: string): TileData[][];
+    stringifyRules(rules: readonly Rule[]): string;
+    parseRules(input: string): Rule[];
+    stringifySymbols(symbols: ReadonlyMap<string, readonly Symbol[]>): string;
+    parseSymbols(input: string): Map<string, Symbol[]>;
+    stringifyGrid(grid: GridData): string;
+    parseGrid(input: string): GridData;
+    stringifyPuzzle(puzzle: Puzzle): string;
+    parsePuzzle(input: string): Puzzle;
+}

package/dist/data/serializer/serializer_v0.js

@@ -0,0 +1,426 @@
+import GridData from '../grid';
+import GridConnections from '../gridConnections';
+import TileData from '../tile';
+import { ConfigType } from '../config';
+import { Color, DIRECTIONS, ORIENTATIONS, Orientation, directionToggle, orientationToggle, } from '../primitives';
+import { array, escape, unescape } from '../dataHelper';
+import { allRules } from '../rules';
+import { allSymbols } from '../symbols';
+import SerializerBase from './serializerBase';
+import { ControlLine, Row } from '../rules/musicControlLine';
+const OFFSETS = [
+    { x: 0, y: -1 },
+    { x: -1, y: 0 },
+    { x: 1, y: 0 },
+    { x: 0, y: 1 },
+];
+const orientationChars = {
+    [Orientation.Up]: 'u',
+    [Orientation.UpRight]: 'x',
+    [Orientation.Right]: 'r',
+    [Orientation.DownRight]: 'z',
+    [Orientation.Down]: 'd',
+    [Orientation.DownLeft]: 'y',
+    [Orientation.Left]: 'l',
+    [Orientation.UpLeft]: 'w',
+};
+export default class SerializerV0 extends SerializerBase {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    stringifyTile(tile) {
+        if (!tile.exists)
+            return '.';
+        const char = tile.color === Color.Gray ? 'n' : tile.color === Color.Dark ? 'b' : 'w';
+        return tile.fixed ? char.toUpperCase() : char;
+    }
+    parseTile(str) {
+        return TileData.create(str);
+    }
+    stringifyControlLine(line) {
+        const result = [];
+        result.push(`c${line.column}`);
+        if (line.bpm !== null)
+            result.push(`b${line.bpm}`);
+        if (line.pedal !== null)
+            result.push(`p${line.pedal ? '1' : '0'}`);
+        if (line.checkpoint)
+            result.push('s');
+        result.push(`r${line.rows
+            .map(row => `v${row.velocity ?? ''}n${row.note ?? ''}`)
+            .join(',')}`);
+        return result.join('|');
+    }
+    parseControlLine(str) {
+        let column = null;
+        let bpm = null;
+        let pedal = null;
+        let checkpoint = false;
+        const rows = [];
+        const data = str.split('|');
+        for (const entry of data) {
+            const key = entry.charAt(0);
+            const value = entry.slice(1);
+            switch (key) {
+                case 'c':
+                    column = value === '' ? null : Number(value);
+                    break;
+                case 'b':
+                    bpm = value === '' ? null : Number(value);
+                    break;
+                case 'p':
+                    pedal = value === '1' ? true : value === '0' ? false : null;
+                    break;
+                case 's':
+                    checkpoint = true;
+                    break;
+                case 'r':
+                    rows.push(...value.split(',').map(row => {
+                        const match = row.match(/^v([\d.]*?)n(.*)$/);
+                        if (!match)
+                            return new Row(null, null);
+                        const [, velocity, note] = match;
+                        return new Row(note === '' ? null : note, velocity === '' ? null : Number(velocity));
+                    }));
+                    break;
+            }
+        }
+        return new ControlLine(column ?? 0, bpm, pedal, checkpoint, rows);
+    }
+    stringifyConfig(instruction, config) {
+        switch (config.type) {
+            case ConfigType.Boolean:
+                return (config.field +
+                    '=' +
+                    (instruction[config.field] ? '1' : '0'));
+            case ConfigType.Number:
+            case ConfigType.Color:
+            case ConfigType.Comparison:
+            case ConfigType.Direction:
+            case ConfigType.Orientation:
+                return (config.field +
+                    '=' +
+                    String(instruction[config.field]));
+            case ConfigType.NullableBoolean:
+                return (config.field +
+                    '=' +
+                    (instruction[config.field] === null
+                        ? ''
+                        : instruction[config.field]
+                            ? '1'
+                            : '0'));
+            case ConfigType.NullableNumber:
+                return (config.field +
+                    '=' +
+                    (instruction[config.field] === null
+                        ? ''
+                        : String(instruction[config.field])));
+            case ConfigType.DirectionToggle:
+                return (config.field +
+                    '=' +
+                    DIRECTIONS.filter(dir => instruction[config.field][dir])
+                        .map(x => orientationChars[x])
+                        .join(''));
+            case ConfigType.OrientationToggle:
+                return (config.field +
+                    '=' +
+                    ORIENTATIONS.filter(dir => instruction[config.field][dir])
+                        .map(x => orientationChars[x])
+                        .join(''));
+            case ConfigType.String:
+            case ConfigType.Icon:
+                return (config.field +
+                    '=' +
+                    escape(String(instruction[config.field])));
+            case ConfigType.NullableNote:
+                return (config.field +
+                    '=' +
+                    escape(instruction[config.field] === null
+                        ? ''
+                        : escape(String(instruction[config.field]))));
+            case ConfigType.Tile:
+            case ConfigType.Grid:
+                return (config.field +
+                    '=' +
+                    escape(this.stringifyGrid(instruction[config.field])));
+            case ConfigType.NullableGrid:
+                return (config.field +
+                    '=' +
+                    escape(instruction[config.field] === null
+                        ? ''
+                        : this.stringifyGrid(instruction[config.field])));
+            case ConfigType.ControlLines:
+                return (config.field +
+                    '=' +
+                    escape(instruction[config.field]
+                        .map(line => this.stringifyControlLine(line))
+                        .join(':')));
+        }
+    }
+    parseConfig(configs, entry) {
+        const [key, value] = entry.split('=');
+        const config = configs.find(x => x.field === key);
+        if (!config)
+            throw new Error(`Unknown config: ${key}`);
+        switch (config.type) {
+            case ConfigType.Boolean:
+                return [config.field, value === '1'];
+            case ConfigType.NullableBoolean:
+                return [config.field, value === '' ? null : value === '1'];
+            case ConfigType.Number:
+                return [config.field, Number(value)];
+            case ConfigType.NullableNumber:
+                return [config.field, value === '' ? null : Number(value)];
+            case ConfigType.Color:
+                return [config.field, value];
+            case ConfigType.Comparison:
+                return [config.field, value];
+            case ConfigType.Direction:
+                return [config.field, value];
+            case ConfigType.DirectionToggle: {
+                const toggle = directionToggle();
+                for (const dir of DIRECTIONS) {
+                    toggle[dir] = value.includes(orientationChars[dir]);
+                }
+                return [config.field, toggle];
+            }
+            case ConfigType.Orientation:
+                return [config.field, value];
+            case ConfigType.OrientationToggle: {
+                const toggle = orientationToggle();
+                for (const dir of ORIENTATIONS) {
+                    toggle[dir] = value.includes(orientationChars[dir]);
+                }
+                return [config.field, toggle];
+            }
+            case ConfigType.String:
+            case ConfigType.Icon:
+                return [config.field, unescape(value)];
+            case ConfigType.Tile:
+            case ConfigType.Grid:
+                return [config.field, this.parseGrid(unescape(value))];
+            case ConfigType.NullableGrid:
+                return [
+                    config.field,
+                    value === '' ? null : this.parseGrid(unescape(value)),
+                ];
+            case ConfigType.ControlLines:
+                return [
+                    config.field,
+                    unescape(value)
+                        .split(':')
+                        .map(line => this.parseControlLine(line)),
+                ];
+            case ConfigType.NullableNote:
+                return [config.field, value === '' ? null : unescape(value)];
+        }
+    }
+    stringifyInstruction(instruction) {
+        return `${instruction.id},${instruction.configs?.map(config => this.stringifyConfig(instruction, config)).join(',') ?? ''}`;
+    }
+    stringifyRule(rule) {
+        return this.stringifyInstruction(rule);
+    }
+    stringifySymbol(symbol) {
+        return this.stringifyInstruction(symbol);
+    }
+    parseRule(str) {
+        const [id, ...entries] = str.split(',');
+        const instruction = allRules.get(id);
+        if (!instruction)
+            throw new Error(`Unknown rule: ${id}`);
+        const configs = instruction.configs;
+        if (configs == null)
+            return instruction.copyWith({});
+        return instruction.copyWith(Object.fromEntries(entries
+            .filter(entry => entry !== '')
+            .map(entry => this.parseConfig(configs, entry))));
+    }
+    parseSymbol(str) {
+        const [id, ...entries] = str.split(',');
+        const instruction = allSymbols.get(id);
+        if (!instruction)
+            throw new Error(`Unknown symbol: ${id}`);
+        const configs = instruction.configs;
+        if (configs == null)
+            return instruction.copyWith({});
+        return instruction.copyWith(Object.fromEntries(entries.map(entry => this.parseConfig(configs, entry))));
+    }
+    stringifyConnections(connections) {
+        const maxX = connections.edges.reduce((max, edge) => Math.max(max, edge.x1, edge.x2), 0);
+        const maxY = connections.edges.reduce((max, edge) => Math.max(max, edge.y1, edge.y2), 0);
+        const result = array(maxX + 1, maxY + 1, () => '.');
+        for (let y = 0; y <= maxY; y++) {
+            for (let x = 0; x <= maxX; x++) {
+                if (result[y][x] !== '.') {
+                    continue;
+                }
+                const tiles = connections.getConnectedTiles({ x, y });
+                if (tiles.length < 2) {
+                    continue;
+                }
+                const existingChars = [];
+                for (const { x: tx, y: ty } of tiles) {
+                    for (const { x: dx, y: dy } of OFFSETS) {
+                        if (tx + dx > maxX ||
+                            ty + dy > maxY ||
+                            tx + dx < 0 ||
+                            ty + dy < 0) {
+                            continue;
+                        }
+                        if (result[ty + dy][tx + dx] !== '.')
+                            existingChars.push(result[ty + dy][tx + dx]);
+                    }
+                }
+                let char = 'A';
+                while (existingChars.includes(char)) {
+                    char = String.fromCharCode(char.charCodeAt(0) + 1);
+                }
+                for (const connection of tiles) {
+                    result[connection.y][connection.x] = char;
+                }
+            }
+        }
+        return `C${maxX + 1}:${result.map(row => row.join('')).join('')}`.replace(/\.+$/, '');
+    }
+    parseConnections(input) {
+        if (!input.startsWith('C')) {
+            throw new Error('Invalid grid connections\n' + input);
+        }
+        const [size, data] = input.slice(1).split(':');
+        const width = Number(size);
+        const tiles = array(width, Math.ceil(data.length / width), (x, y) => data[y * width + x]);
+        return GridConnections.create(tiles.map(row => row.join('')));
+    }
+    stringifyTiles(tiles) {
+        return `T${tiles[0]?.length ?? 0}:${tiles.map(row => row.map(tile => this.stringifyTile(tile)).join('')).join('')}`;
+    }
+    parseTiles(input) {
+        if (!input.startsWith('T')) {
+            throw new Error('Invalid grid data\n' + input);
+        }
+        const [size, data] = input.slice(1).split(':');
+        const width = Number(size);
+        return array(width, Math.ceil(data.length / width), (x, y) => this.parseTile(data.charAt(y * width + x)));
+    }
+    stringifyRules(rules) {
+        return `R${rules.map(rule => this.stringifyRule(rule)).join(':')}`;
+    }
+    parseRules(input) {
+        if (!input.startsWith('R')) {
+            throw new Error('Invalid rules\n' + input);
+        }
+        return input
+            .slice(1)
+            .split(':')
+            .filter(rule => rule !== '')
+            .map(rule => this.parseRule(rule));
+    }
+    stringifySymbols(symbols) {
+        return `S${Array.from(symbols.values())
+            .flat()
+            .map(symbol => this.stringifySymbol(symbol))
+            .join(':')}`;
+    }
+    parseSymbols(input) {
+        if (!input.startsWith('S')) {
+            throw new Error('Invalid symbols\n' + input);
+        }
+        const symbols = new Map();
+        input
+            .slice(1)
+            .split(':')
+            .filter(symbol => symbol !== '')
+            .forEach(symbol => {
+            const parsed = this.parseSymbol(symbol);
+            if (symbols.has(parsed.id)) {
+                symbols.set(parsed.id, [...symbols.get(parsed.id), parsed]);
+            }
+            else {
+                symbols.set(parsed.id, [parsed]);
+            }
+        });
+        return symbols;
+    }
+    stringifyGrid(grid) {
+        const data = [
+            this.stringifyTiles(grid.tiles),
+            this.stringifyConnections(grid.connections),
+            this.stringifySymbols(grid.symbols),
+            this.stringifyRules(grid.rules),
+        ];
+        return `${grid.width}x${grid.height}|${data.join('|')}`;
+    }
+    parseGrid(input) {
+        const data = input.split('|');
+        let width;
+        let height;
+        let tiles;
+        let connections;
+        let symbols;
+        let rules;
+        for (const d of data) {
+            if (/^\d+x\d+$/.test(d)) {
+                [width, height] = d.split('x').map(Number);
+            }
+            else if (d.startsWith('T')) {
+                tiles = this.parseTiles(d);
+            }
+            else if (d.startsWith('C')) {
+                connections = this.parseConnections(d);
+            }
+            else if (d.startsWith('S')) {
+                symbols = this.parseSymbols(d);
+            }
+            else if (d.startsWith('R')) {
+                rules = this.parseRules(d);
+            }
+            else {
+                throw new Error(`Invalid data: ${d}`);
+            }
+        }
+        return new GridData(width ?? tiles?.[0].length ?? 0, height ?? tiles?.length ?? 0, tiles, connections, symbols, rules);
+    }
+    stringifyPuzzle(puzzle) {
+        let grid = puzzle.grid;
+        if (puzzle.solution !== null) {
+            const tiles = array(puzzle.grid.width, puzzle.grid.height, (x, y) => {
+                const tile = puzzle.grid.getTile(x, y);
+                const solutionTile = puzzle.solution.getTile(x, y);
+                return tile.exists &&
+                    !tile.fixed &&
+                    solutionTile.exists &&
+                    solutionTile.color !== Color.Gray
+                    ? tile.copyWith({
+                        color: puzzle.solution.tiles[y][x].color,
+                    })
+                    : tile;
+            });
+            grid = puzzle.grid.copyWith({ tiles });
+        }
+        return JSON.stringify({
+            title: puzzle.title,
+            grid: this.stringifyGrid(grid),
+            difficulty: puzzle.difficulty,
+            link: puzzle.link,
+            author: puzzle.author,
+            description: puzzle.description,
+        });
+    }
+    parsePuzzle(input) {
+        const { grid: gridString, ...metadata } = JSON.parse(input);
+        const grid = this.parseGrid(gridString);
+        const reset = grid.resetTiles();
+        return {
+            ...metadata,
+            grid: reset,
+            solution: grid.colorEquals(reset) ? null : grid,
+        };
+    }
+}

package/dist/data/shapes.d.ts

@@ -0,0 +1,17 @@
+import { Color, Position } from './primitives';
+import TileData from './tile';
+export interface ShapeElement {
+    x: number;
+    y: number;
+    color: Color;
+}
+export interface Shape {
+    width: number;
+    height: number;
+    elements: ShapeElement[];
+}
+export declare function shapeEquals(a: Shape, b: Shape): boolean;
+export declare function tilesToShape(tiles: readonly (readonly TileData[])[]): Shape;
+export declare function positionsToShape(positions: Position[], color: Color): Shape;
+export declare function getShapeVariants(shape: Shape): Shape[];
+export declare function normalizeShape(shape: Shape): Shape;

package/dist/data/shapes.js

@@ -0,0 +1,117 @@
+import { Color } from './primitives';
+const colorIndex = {
+    [Color.Dark]: 2,
+    [Color.Light]: 1,
+    [Color.Gray]: 0,
+};
+function compareColor(a, b) {
+    return colorIndex[a] - colorIndex[b];
+}
+function compareElement(a, b) {
+    if (!a && !b)
+        return 0;
+    if (!a)
+        return -1;
+    if (!b)
+        return 1;
+    return a.y - b.y || a.x - b.x || compareColor(a.color, b.color);
+}
+function compareShape(a, b) {
+    for (let i = 0; i < Math.max(a.elements.length, b.elements.length); i++) {
+        const cmp = compareElement(a.elements[i], b.elements[i]);
+        if (cmp !== 0)
+            return cmp;
+    }
+    return 0;
+}
+export function shapeEquals(a, b) {
+    return compareShape(a, b) === 0;
+}
+function recenterShape(shape) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const element of shape.elements) {
+        minX = Math.min(minX, element.x);
+        minY = Math.min(minY, element.y);
+        maxX = Math.max(maxX, element.x);
+        maxY = Math.max(maxY, element.y);
+    }
+    for (const element of shape.elements) {
+        element.x -= minX;
+        element.y -= minY;
+    }
+    shape.width = maxX - minX + 1;
+    shape.height = maxY - minY + 1;
+    return shape;
+}
+export function tilesToShape(tiles) {
+    const shape = {
+        width: Math.max(...tiles.map(row => row.length)),
+        height: tiles.length,
+        elements: [],
+    };
+    for (let y = 0; y < tiles.length; y++) {
+        for (let x = 0; x < tiles[y].length; x++) {
+            const tile = tiles[y][x];
+            if (tile.exists && tile.color !== Color.Gray) {
+                shape.elements.push({ x, y, color: tile.color });
+            }
+        }
+    }
+    return recenterShape(shape);
+}
+export function positionsToShape(positions, color) {
+    return recenterShape({
+        width: 0,
+        height: 0,
+        elements: positions.map(p => ({ x: p.x, y: p.y, color })),
+    });
+}
+const shapeVariants = [
+    { x: 'x', y: 'y' },
+    { x: '-y', y: 'x' },
+    { x: '-x', y: '-y' },
+    { x: 'y', y: '-x' },
+    { x: '-x', y: 'y' },
+    { x: 'x', y: '-y' },
+    { x: 'y', y: 'x' },
+    { x: '-y', y: '-x' },
+];
+function mapCoord(map, x, y, width, height) {
+    switch (map) {
+        case 'x':
+            return x;
+        case 'y':
+            return y;
+        case '-x':
+            return width - 1 - x;
+        case '-y':
+            return height - 1 - y;
+    }
+}
+export function getShapeVariants(shape) {
+    const variants = shapeVariants.map(({ x, y }) => ({
+        width: x.endsWith('x') ? shape.width : shape.height,
+        height: y.endsWith('y') ? shape.height : shape.width,
+        elements: shape.elements
+            .map(element => ({
+            x: mapCoord(x, element.x, element.y, shape.width, shape.height),
+            y: mapCoord(y, element.x, element.y, shape.width, shape.height),
+            color: element.color,
+        }))
+            .sort(compareElement),
+    }));
+    const uniqueVariants = [];
+    for (const variant of variants) {
+        if (!uniqueVariants.some(shape => shapeEquals(shape, variant))) {
+            uniqueVariants.push(variant);
+        }
+    }
+    return uniqueVariants;
+}
+export function normalizeShape(shape) {
+    const variants = getShapeVariants(shape);
+    return variants.reduce((min, variant) => (compareShape(variant, min) < 0 ? variant : min), variants[0]);
+}

package/dist/data/solver/allSolvers.d.ts

@@ -0,0 +1,3 @@
+import Solver from './solver';
+declare const allSolvers: Map<string, Solver>;
+export { allSolvers };

package/dist/data/solver/allSolvers.js

@@ -0,0 +1,11 @@
+import UndercluedSolver from './underclued/undercluedSolver';
+import BacktrackSolver from './backtrack/backtrackSolver';
+import Z3Solver from './z3/z3Solver';
+const allSolvers = new Map();
+function register(prototype) {
+    allSolvers.set(prototype.id, prototype);
+}
+register(new BacktrackSolver());
+register(new UndercluedSolver());
+register(new Z3Solver());
+export { allSolvers };

package/dist/data/solver/backtrack/backtrackSolver.d.ts

@@ -0,0 +1,9 @@
+import GridData from '../../grid';
+import Solver from '../solver';
+export default class BacktrackSolver extends Solver {
+    private static readonly supportedInstrs;
+    readonly id = "backtrack";
+    readonly description = "Solves puzzles using backtracking with optimizations (blazingly fast). Support most rules and symbols (including underclued).";
+    solve(grid: GridData): AsyncGenerator<GridData | null>;
+    isInstructionSupported(instructionId: string): boolean;
+}