@logic-pad/core 0.1.0

package/dist/data/solver/underclued/undercluedWorker.js

@@ -0,0 +1,131 @@
+import { Color, State } from '../../primitives';
+import { Serializer } from '../../serializer/allSerializers';
+import validateGrid from '../../validate';
+function posToCoords(pos, width) {
+    if (pos === undefined) {
+        throw new Error('pos is undefined');
+    }
+    return [pos % width, Math.floor(pos / width)];
+}
+function coordsToPos(a, width) {
+    return a[0] + a[1] * width;
+}
+function getValidGrid(grid, assumptions, canAssump) {
+    while (true) {
+        // Get assumption
+        const newAssump = canAssump.findIndex((a, i) => a && !assumptions.includes(i));
+        if (newAssump === -1) {
+            return [grid, assumptions, true];
+        }
+        // Set assumption's color to dark
+        const coords = posToCoords(newAssump, grid.width);
+        grid = grid.setTile(coords[0], coords[1], tile => tile.withColor(Color.Dark));
+        assumptions.push(newAssump);
+        for (const a of grid.connections.getConnectedTiles({
+            x: coords[0],
+            y: coords[1],
+        })) {
+            canAssump[coordsToPos([a.x, a.y], grid.width)] =
+                a.x === coords[0] && a.y === coords[1];
+        }
+        const state = validateGrid(grid, null);
+        // If the grid is invalid, try to backtrack to a right assumption
+        if (state.final === State.Error) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            [grid, assumptions] = tryToBacktrack(grid, assumptions);
+            if (assumptions.length === 0) {
+                return [grid, assumptions, false];
+            }
+        }
+    }
+}
+function tryToBacktrack(grid, assumptions) {
+    while (assumptions.length > 0) {
+        const coords = posToCoords(assumptions[assumptions.length - 1], grid.width);
+        if (grid.getTile(coords[0], coords[1]).color === Color.Light) {
+            grid = grid.setTile(coords[0], coords[1], tile => tile.withColor(Color.Gray));
+            assumptions.pop();
+        }
+        else {
+            grid = grid.setTile(coords[0], coords[1], tile => tile.withColor(Color.Light));
+            const state = validateGrid(grid, null);
+            if (state.final === State.Error) {
+                grid = grid.setTile(coords[0], coords[1], tile => tile.withColor(Color.Gray));
+                assumptions.pop();
+            }
+            else {
+                return [grid, assumptions];
+            }
+        }
+    }
+    return [grid, assumptions];
+}
+function computeSolution(initialGrid) {
+    const canAssump = initialGrid.tiles
+        .map(row => row.map(t => t.exists && !t.fixed))
+        .flat();
+    let lastValidGrid = [];
+    let assumptions = [];
+    let currentGrid = initialGrid.copyWith({});
+    let anyNewGrid;
+    while (assumptions.length > 0 || lastValidGrid.length === 0) {
+        [currentGrid, assumptions, anyNewGrid] = getValidGrid(currentGrid, assumptions, canAssump);
+        console.log(currentGrid.tiles
+            .map(row => row
+            .map(t => {
+            const color = t.color === Color.Light ? 'w' : 'b';
+            if (t.color === Color.Gray)
+                return 'n';
+            if (!t.exists)
+                return '.';
+            return t.fixed ? color.toUpperCase() : color;
+        })
+            .join(''))
+            .join('\n'));
+        if (!anyNewGrid) {
+            break;
+        }
+        const newLastValidGrid = currentGrid.tiles
+            .map(row => row.map(t => t.color))
+            .flat();
+        if (lastValidGrid.length !== 0) {
+            const diff = newLastValidGrid.map((color, i) => color === lastValidGrid[i]);
+            diff.forEach((same, i) => {
+                if (!same) {
+                    newLastValidGrid[i] = Color.Gray;
+                }
+            });
+        }
+        [currentGrid, assumptions] = tryToBacktrack(currentGrid, assumptions);
+        lastValidGrid = newLastValidGrid;
+    }
+    // Create a new grid with lastValidGrid
+    let solutionGrid = initialGrid.copyWith({});
+    lastValidGrid.forEach((color, i) => {
+        const coords = posToCoords(i, solutionGrid.width);
+        solutionGrid = solutionGrid.setTile(coords[0], coords[1], tile => tile.withColor(color));
+    });
+    console.log(solutionGrid.tiles
+        .map(row => row
+        .map(t => {
+        const color = t.color === Color.Light ? 'w' : 'b';
+        if (t.color === Color.Gray)
+            return 'n';
+        if (!t.exists)
+            return '.';
+        return t.fixed ? color.toUpperCase() : color;
+    })
+        .join(''))
+        .join('\n'));
+    return solutionGrid;
+}
+onmessage = e => {
+    if (!e.data || typeof e.data !== 'string')
+        return;
+    const grid = Serializer.parseGrid(e.data);
+    const solved = computeSolution(grid);
+    postMessage(Serializer.stringifyGrid(solved));
+};
+// make typescript happy
+// eslint-disable-next-line import/no-anonymous-default-export
+export default null;

package/dist/data/solver/z3/modules/areaNumberModule.d.ts

@@ -0,0 +1,9 @@
+import { Solver, Optimize } from 'z3-solver';
+import GridData from '../../../grid';
+import Z3SolverContext from '../z3SolverContext';
+import Z3Module from './z3Module';
+export default class AreaNumberModule extends Z3Module {
+    readonly id: string;
+    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
+}
+export declare const instance: AreaNumberModule;

package/dist/data/solver/z3/modules/areaNumberModule.js

@@ -0,0 +1,35 @@
+import Z3Module from './z3Module';
+import { instance as areaNumberInstance, } from '../../../symbols/areaNumberSymbol';
+import { Point } from 'grilops';
+export default class AreaNumberModule extends Z3Module {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: areaNumberInstance.id
+        });
+    }
+    encode(grid, ctx) {
+        const symbols = grid.symbols.get(this.id);
+        // optimizations
+        if (!symbols || symbols.length === 0) {
+            return;
+        }
+        for (const symbol of symbols) {
+            if (symbol.number < 1) {
+                ctx.solver.add(ctx.ctx.Bool.val(false));
+                return;
+            }
+        }
+        // encode for real
+        const rc = ctx.regionConstrainer;
+        for (const symbol of symbols) {
+            const x = Math.floor(symbol.x);
+            const y = Math.floor(symbol.y);
+            ctx.solver.add(rc.regionSizeGrid.get(new Point(y, x)).eq(Math.round(symbol.number)));
+        }
+    }
+}
+export const instance = new AreaNumberModule();

package/dist/data/solver/z3/modules/cellCountModule.d.ts

@@ -0,0 +1,9 @@
+import { Solver, Optimize } from 'z3-solver';
+import GridData from '../../../grid';
+import Z3SolverContext from '../z3SolverContext';
+import Z3Module from './z3Module';
+export default class CellCountModule extends Z3Module {
+    readonly id: string;
+    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
+}
+export declare const instance: CellCountModule;

package/dist/data/solver/z3/modules/cellCountModule.js

@@ -0,0 +1,59 @@
+import Z3Module from './z3Module';
+import { Point } from 'grilops';
+import { instance as cellCountInstance, } from '../../../rules/cellCountRule';
+import { Color } from '../../../primitives';
+export default class CellCountModule extends Z3Module {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cellCountInstance.id
+        });
+    }
+    encode(grid, ctx) {
+        const rules = grid.rules.filter(rule => rule.id === this.id);
+        // optimizations
+        if (rules.length === 0) {
+            return;
+        }
+        const colorMap = new Map();
+        for (const rule of rules) {
+            if (colorMap.has(rule.color)) {
+                if (colorMap.get(rule.color) !== rule.count) {
+                    ctx.solver.add(ctx.ctx.Bool.val(false));
+                    return;
+                }
+            }
+            else {
+                colorMap.set(rule.color, rule.count);
+            }
+        }
+        for (const [color, count] of colorMap.entries()) {
+            const { min, max } = grid.getColorCount(color);
+            if (min > count || max < count) {
+                ctx.solver.add(ctx.ctx.Bool.val(false));
+                return;
+            }
+        }
+        if (colorMap.has(Color.Light) && colorMap.has(Color.Dark)) {
+            if (colorMap.get(Color.Light) + colorMap.get(Color.Dark) !==
+                grid.getTileCount(true)) {
+                ctx.solver.add(ctx.ctx.Bool.val(false));
+                return;
+            }
+        }
+        // encode for real
+        for (const [color, count] of colorMap.entries()) {
+            const sumTerms = [];
+            grid.forEach((tile, x, y) => {
+                if (tile.exists) {
+                    sumTerms.push(ctx.ctx.If(ctx.grid.cellAt(new Point(y, x)).eq(ctx.symbolSet.indices[color]), 1, 0));
+                }
+            });
+            ctx.solver.add(ctx.ctx.Sum(sumTerms[0], ...sumTerms.slice(1)).eq(count));
+        }
+    }
+}
+export const instance = new CellCountModule();

package/dist/data/solver/z3/modules/connectAllModule.d.ts

@@ -0,0 +1,9 @@
+import { Solver, Optimize } from 'z3-solver';
+import GridData from '../../../grid';
+import Z3SolverContext from '../z3SolverContext';
+import Z3Module from './z3Module';
+export default class ConnectAllModule extends Z3Module {
+    readonly id: string;
+    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
+}
+export declare const instance: ConnectAllModule;

package/dist/data/solver/z3/modules/connectAllModule.js

@@ -0,0 +1,32 @@
+import Z3Module from './z3Module';
+import { instance as connectAllInstance, } from '../../../rules/connectAllRule';
+export default class ConnectAllModule extends Z3Module {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: connectAllInstance.id
+        });
+    }
+    encode(grid, ctx) {
+        const rules = grid.rules.filter(rule => rule.id === this.id);
+        // optimizations to try to simplify the encoding
+        if (rules.length === 0) {
+            return;
+        }
+        // encode for real
+        const rc = ctx.regionConstrainer;
+        for (const color of new Set(rules.map(rule => rule.color))) {
+            const sumTerms = [];
+            for (const [p, cell] of ctx.grid.grid.entries()) {
+                sumTerms.push(ctx.ctx.If(cell
+                    .eq(ctx.symbolSet.indices[color])
+                    .and(rc.parentGrid.get(p).eq(1)), 1, 0));
+            }
+            ctx.solver.add(ctx.ctx.Sum(sumTerms[0], ...sumTerms.slice(1)).eq(1));
+        }
+    }
+}
+export const instance = new ConnectAllModule();

package/dist/data/solver/z3/modules/dartModule.d.ts

@@ -0,0 +1,9 @@
+import { Solver, Optimize } from 'z3-solver';
+import GridData from '../../../grid';
+import Z3SolverContext from '../z3SolverContext';
+import Z3Module from './z3Module';
+export default class DartModule extends Z3Module {
+    readonly id: string;
+    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
+}
+export declare const instance: DartModule;

package/dist/data/solver/z3/modules/dartModule.js

@@ -0,0 +1,69 @@
+import Z3Module from './z3Module';
+import { instance as dartInstance, } from '../../../symbols/dartSymbol';
+import { Point, reduceCells } from 'grilops';
+import { Color } from '../../../primitives';
+import { move } from '../../../dataHelper';
+import { convertDirection } from '../utils';
+export default class DartModule extends Z3Module {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: dartInstance.id
+        });
+    }
+    encode(grid, ctx) {
+        const symbols = grid.symbols.get(this.id);
+        // optimizations
+        if (!symbols || symbols.length === 0) {
+            return;
+        }
+        for (const symbol of symbols) {
+            const x = Math.floor(symbol.x);
+            const y = Math.floor(symbol.y);
+            const startPos = move({ x, y }, symbol.orientation);
+            const tile = grid.getTile(x, y);
+            if (tile.fixed) {
+                let min = 0;
+                let unknown = 0;
+                grid.iterateDirectionAll(startPos, symbol.orientation, () => true, cell => {
+                    if (!cell.exists)
+                        return;
+                    if (cell.fixed &&
+                        cell.color !== tile.color &&
+                        cell.color !== Color.Gray)
+                        min++;
+                    if (!cell.fixed)
+                        unknown++;
+                });
+                if (min > symbol.number || min + unknown < symbol.number) {
+                    ctx.solver.add(ctx.ctx.Bool.val(false));
+                    return;
+                }
+            }
+            else {
+                let count = 0;
+                grid.iterateDirectionAll(startPos, symbol.orientation, () => true, cell => {
+                    if (!cell.exists)
+                        return;
+                    count++;
+                });
+                if (count < symbol.number) {
+                    ctx.solver.add(ctx.ctx.Bool.val(false));
+                    return;
+                }
+            }
+        }
+        // encode for real
+        for (const symbol of symbols) {
+            const x = Math.floor(symbol.x);
+            const y = Math.floor(symbol.y);
+            const startPos = move({ x, y }, symbol.orientation);
+            const origin = ctx.grid.cellAt(new Point(y, x));
+            ctx.solver.add(reduceCells(ctx.grid.ctx, ctx.grid, new Point(startPos.y, startPos.x), convertDirection(symbol.orientation), ctx.ctx.Int.val(0), (acc, cell) => ctx.ctx.If(ctx.ctx.Or(cell.eq(origin), cell.eq(ctx.symbolSet.indices.empty)), acc, acc.add(1))).eq(symbol.number));
+        }
+    }
+}
+export const instance = new DartModule();

package/dist/data/solver/z3/modules/index.d.ts

@@ -0,0 +1,3 @@
+import Z3Module from './z3Module';
+declare const allZ3Modules: Map<string, Z3Module>;
+export { allZ3Modules };

package/dist/data/solver/z3/modules/index.js

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

package/dist/data/solver/z3/modules/letterModule.d.ts

@@ -0,0 +1,9 @@
+import { Solver, Optimize } from 'z3-solver';
+import GridData from '../../../grid';
+import Z3SolverContext from '../z3SolverContext';
+import Z3Module from './z3Module';
+export default class LetterModule extends Z3Module {
+    readonly id: string;
+    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
+}
+export declare const instance: LetterModule;

package/dist/data/solver/z3/modules/letterModule.js

@@ -0,0 +1,41 @@
+import Z3Module from './z3Module';
+import { instance as letterInstance, } from '../../../symbols/letterSymbol';
+import { Point } from 'grilops';
+export default class LetterModule extends Z3Module {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: letterInstance.id
+        });
+    }
+    encode(grid, ctx) {
+        const symbols = grid.symbols.get(this.id);
+        if (!symbols || symbols.length === 0) {
+            return;
+        }
+        const rc = ctx.regionConstrainer;
+        const letterMap = new Map();
+        for (const symbol of symbols) {
+            const x = Math.floor(symbol.x);
+            const y = Math.floor(symbol.y);
+            if (letterMap.has(symbol.letter)) {
+                ctx.solver.add(letterMap
+                    .get(symbol.letter)
+                    .eq(rc.regionIdGrid.get(new Point(y, x))));
+            }
+            else {
+                letterMap.set(symbol.letter, rc.regionIdGrid.get(new Point(y, x)));
+            }
+        }
+        const letters = Array.from(letterMap.values());
+        for (let i = 0; i < letters.length - 1; i++) {
+            for (let j = i + 1; j < letters.length; j++) {
+                ctx.solver.add(letters[i].neq(letters[j]));
+            }
+        }
+    }
+}
+export const instance = new LetterModule();

package/dist/data/solver/z3/modules/modules.gen.d.ts

@@ -0,0 +1,8 @@
+export { instance as AreaNumberModule } from './areaNumberModule';
+export { instance as CellCountModule } from './cellCountModule';
+export { instance as ConnectAllModule } from './connectAllModule';
+export { instance as DartModule } from './dartModule';
+export { instance as LetterModule } from './letterModule';
+export { instance as MyopiaModule } from './myopiaModule';
+export { instance as RegionAreaModule } from './regionAreaModule';
+export { instance as ViewpointModule } from './viewpointModule';

package/dist/data/solver/z3/modules/modules.gen.js

@@ -0,0 +1,12 @@
+/* prettier-ignore-start */
+/* eslint-disable */
+// @ts-nocheck
+// noinspection JSUnusedGlobalSymbols
+export { instance as AreaNumberModule } from './areaNumberModule';
+export { instance as CellCountModule } from './cellCountModule';
+export { instance as ConnectAllModule } from './connectAllModule';
+export { instance as DartModule } from './dartModule';
+export { instance as LetterModule } from './letterModule';
+export { instance as MyopiaModule } from './myopiaModule';
+export { instance as RegionAreaModule } from './regionAreaModule';
+export { instance as ViewpointModule } from './viewpointModule';

package/dist/data/solver/z3/modules/myopiaModule.d.ts

@@ -0,0 +1,9 @@
+import { Solver, Optimize } from 'z3-solver';
+import GridData from '../../../grid';
+import Z3SolverContext from '../z3SolverContext';
+import Z3Module from './z3Module';
+export default class MyopiaModule extends Z3Module {
+    readonly id: string;
+    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
+}
+export declare const instance: MyopiaModule;

package/dist/data/solver/z3/modules/myopiaModule.js

@@ -0,0 +1,64 @@
+import Z3Module from './z3Module';
+import { instance as myopiaInstance, } from '../../../symbols/myopiaSymbol';
+import { Point, reduceCells } from 'grilops';
+import { DIRECTIONS, ORIENTATIONS } from '../../../primitives';
+import { convertDirection } from '../utils';
+import { move } from '../../../dataHelper';
+export default class MyopiaModule extends Z3Module {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: myopiaInstance.id
+        });
+    }
+    encode(grid, ctx) {
+        const symbols = grid.symbols.get(this.id);
+        // optimizations
+        if (!symbols || symbols.length === 0) {
+            return;
+        }
+        // encode for real
+        for (const symbol of symbols) {
+            const x = Math.floor(symbol.x);
+            const y = Math.floor(symbol.y);
+            const startPos = new Point(y, x);
+            const origin = ctx.grid.cellAt(new Point(y, x));
+            const pointedTerms = [];
+            const otherTerms = [];
+            ORIENTATIONS.filter(d => symbol.directions[d]).forEach(direction => {
+                pointedTerms.push(reduceCells(ctx.grid.ctx, ctx.grid, startPos, convertDirection(direction), ctx.ctx.Int.val(0), (acc, cell, p) => {
+                    const nextPos = move({ x: p.x, y: p.y }, direction);
+                    if (grid.isPositionValid(nextPos.x, nextPos.y)) {
+                        return ctx.ctx.If(cell.eq(origin), acc.add(1), acc);
+                    }
+                    else {
+                        return ctx.ctx.If(cell.eq(origin), acc.add(Number.MAX_SAFE_INTEGER), acc);
+                    }
+                }, (_, cell) => cell.neq(origin)));
+            });
+            (symbol.diagonals ? ORIENTATIONS : DIRECTIONS)
+                .filter(d => !symbol.directions[d])
+                .forEach(direction => {
+                otherTerms.push(reduceCells(ctx.grid.ctx, ctx.grid, startPos, convertDirection(direction), ctx.ctx.Int.val(0), (acc, cell, p) => {
+                    const nextPos = move({ x: p.x, y: p.y }, direction);
+                    if (grid.isPositionValid(nextPos.x, nextPos.y)) {
+                        return ctx.ctx.If(cell.eq(origin), acc.add(1), acc);
+                    }
+                    else {
+                        return ctx.ctx.If(cell.eq(origin), acc.add(Number.MAX_SAFE_INTEGER), acc);
+                    }
+                }, (_, cell) => cell.neq(origin)));
+            });
+            for (let i = 1; i < pointedTerms.length; i++) {
+                ctx.solver.add(pointedTerms[i].eq(pointedTerms[0]));
+            }
+            for (const otherTerm of otherTerms) {
+                ctx.solver.add(otherTerm.gt(pointedTerms[0]));
+            }
+        }
+    }
+}
+export const instance = new MyopiaModule();

package/dist/data/solver/z3/modules/regionAreaModule.d.ts

@@ -0,0 +1,9 @@
+import { Solver, Optimize } from 'z3-solver';
+import GridData from '../../../grid';
+import Z3SolverContext from '../z3SolverContext';
+import Z3Module from './z3Module';
+export default class RegionAreaModule extends Z3Module {
+    readonly id: string;
+    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
+}
+export declare const instance: RegionAreaModule;

package/dist/data/solver/z3/modules/regionAreaModule.js

@@ -0,0 +1,48 @@
+import Z3Module from './z3Module';
+import { instance as regionAreaInstance, } from '../../../rules/regionAreaRule';
+export default class RegionAreaModule extends Z3Module {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: regionAreaInstance.id
+        });
+    }
+    encode(grid, ctx) {
+        const rules = grid.rules.filter(rule => rule.id === this.id);
+        // optimizations
+        if (rules.length === 0) {
+            return;
+        }
+        const colorMap = new Map();
+        for (const rule of rules) {
+            if (colorMap.has(rule.color)) {
+                if (colorMap.get(rule.color) !== rule.size) {
+                    ctx.solver.add(ctx.ctx.Bool.val(false));
+                    return;
+                }
+            }
+            else {
+                colorMap.set(rule.color, rule.size);
+            }
+        }
+        for (const [color, count] of colorMap.entries()) {
+            if (count < 0 || count > grid.getColorCount(color).max) {
+                ctx.solver.add(ctx.ctx.Bool.val(false));
+                return;
+            }
+        }
+        // encode for real
+        const rc = ctx.regionConstrainer;
+        for (const [color, count] of colorMap.entries()) {
+            for (const [p, cell] of ctx.grid.grid.entries()) {
+                ctx.solver.add(cell
+                    .eq(ctx.symbolSet.indices[color])
+                    .implies(rc.regionSizeGrid.get(p).eq(count)));
+            }
+        }
+    }
+}
+export const instance = new RegionAreaModule();

package/dist/data/solver/z3/modules/viewpointModule.d.ts

@@ -0,0 +1,9 @@
+import { Solver, Optimize } from 'z3-solver';
+import GridData from '../../../grid';
+import Z3SolverContext from '../z3SolverContext';
+import Z3Module from './z3Module';
+export default class ViewpointModule extends Z3Module {
+    readonly id: string;
+    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
+}
+export declare const instance: ViewpointModule;

package/dist/data/solver/z3/modules/viewpointModule.js

@@ -0,0 +1,37 @@
+import Z3Module from './z3Module';
+import { instance as viewpointInstance, } from '../../../symbols/viewpointSymbol';
+import { Point, reduceCells } from 'grilops';
+import { DIRECTIONS } from '../../../primitives';
+import { move } from '../../../dataHelper';
+import { convertDirection } from '../utils';
+export default class ViewpointModule extends Z3Module {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: viewpointInstance.id
+        });
+    }
+    encode(grid, ctx) {
+        const symbols = grid.symbols.get(this.id);
+        // optimizations
+        if (!symbols || symbols.length === 0) {
+            return;
+        }
+        // encode for real
+        for (const symbol of symbols) {
+            const x = Math.floor(symbol.x);
+            const y = Math.floor(symbol.y);
+            const origin = ctx.grid.cellAt(new Point(y, x));
+            const sumTerms = [];
+            DIRECTIONS.forEach(direction => {
+                const startPos = move({ x, y }, direction);
+                sumTerms.push(reduceCells(ctx.grid.ctx, ctx.grid, new Point(startPos.y, startPos.x), convertDirection(direction), ctx.ctx.Int.val(0), (acc, cell) => ctx.ctx.If(cell.eq(origin), acc.add(1), acc), (_, cell) => cell.neq(origin)));
+            });
+            ctx.solver.add(ctx.ctx.Sum(ctx.ctx.Int.val(1), ...sumTerms).eq(symbol.number));
+        }
+    }
+}
+export const instance = new ViewpointModule();

package/dist/data/solver/z3/modules/z3Module.d.ts

@@ -0,0 +1,7 @@
+import GridData from '../../../grid';
+import Z3SolverContext from '../z3SolverContext';
+export default abstract class Z3Module {
+    abstract get id(): string;
+    abstract encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name>): void;
+}
+export declare const instance: undefined;

package/dist/data/solver/z3/modules/z3Module.js

@@ -0,0 +1,3 @@
+export default class Z3Module {
+}
+export const instance = undefined;

package/dist/data/solver/z3/utils.d.ts

@@ -0,0 +1,2 @@
+import { Direction, Orientation } from '../../primitives';
+export declare function convertDirection(direction: Orientation | Direction): import("grilops").Direction;