@xtia/grid 0.0.1 → 0.0.2

package/lib/grid.d.ts

@@ -1,5 +1,5 @@
 import { Pipe2D } from "@xtia/pipe2d";
-import { Angle, GetXYFunc, Source2D } from "./utils.js";
+import { GetXYFunc, Source2D } from "./utils.js";
 type ChangeEvent<T> = {
     changedCells: Set<Cell<T>>;
 };
@@ -54,41 +54,28 @@ export declare class Cell<T> {
 export declare class Grid<T> {
     readonly width: number;
     readonly height: number;
-    private batch;
     private parentGet;
     private parentSet;
+    private batch;
     readonly cells: Pipe2D<Cell<T>>;
-    protected constructor(width: number, height: number, get: GetXYFunc<T>, set: (x: number, y: number, value: T) => void, batch: (cb: () => void) => void);
-    private writeMasks;
+    protected constructor(width: number, height: number, parentGet: GetXYFunc<T>, parentSet: (x: number, y: number, value: T) => void, batch: (cb: () => void) => void);
     pipe: Pipe2D<T>;
-    private isWritable;
     batchUpdate(fn: () => void): void;
     get(x: number, y: number): T;
     set(x: number, y: number, value: T): void;
     trySet(x: number, y: number, value: T): boolean;
-    fill(value: T): void;
-    paste(x: number, y: number, source: Source2D<T>): void;
-    applyWriteMask(mask: Source2D<boolean>): () => void;
+    fill(value: T, mask?: Source2D<boolean>): void;
+    paste(x: number, y: number, source: Source2D<T>, mask?: Source2D<boolean>): void;
     [Symbol.iterator](): IterableIterator<{
         x: number;
         y: number;
         value: T;
     }>;
     forEach(callback: (value: T, x: number, y: number) => void): void;
-    getVisibilityMap(originX: number, originY: number, maxDistance: number, isWall: (value: T, x: number, y: number) => boolean, options?: {
-        startAngle?: Angle;
-        endAngle?: Angle;
-        includeWalls?: boolean;
-        angleStep?: Angle;
-    }): Pipe2D<boolean>;
-    getFloodMap(startX: number, startY: number, predicate: (value: T, x: number, y: number, initialValue: T) => boolean, options?: {
-        includeDiagonals?: boolean;
-        maxDistance?: number;
-    }): Pipe2D<boolean>;
     combine<U, R>(aux: Source2D<U>, cb: (source: T, aux: U) => R): GridBase<R>;
     map<U>(read: (initial: T, x: number, y: number) => U, write: (local: U, x: number, y: number) => T): Grid<U>;
     region(x: number, y: number, width: number, height: number): Grid<T>;
-    static init<T>(width: number, height: number, initCell: () => T): GridBase<T>;
+    static init<T>(width: number, height: number, initCell: (x: number, y: number) => T): GridBase<T>;
     static from<T>(source: Source2D<T>): GridBase<T>;
     static solid<T>(width: number, height: number, fillValue: T): GridBase<T>;
 }
@@ -99,7 +86,6 @@ export declare class GridBase<T> extends Grid<T> {
     private batchState;
     batchUpdate(fn: () => void): void;
     constructor(source: Source2D<T>);
-    constructor(width: number, height: number, cellInit: GetXYFunc<T>);
     on<K extends keyof EventMap<T>>(eventName: K, handler: (data: EventMap<T>[K]) => void): () => void;
     private xyToIndex;
     private _set;

package/lib/grid.js

@@ -1,5 +1,5 @@
 import { Pipe2D } from "@xtia/pipe2d";
-import { angleToRadians, OrderedQueue } from "./utils.js";
+import { OrderedQueue } from "./utils.js";
 export var TraversalType;
 (function (TraversalType) {
     TraversalType[TraversalType["cardinal"] = 0] = "cardinal";
@@ -177,6 +177,8 @@ export class Cell {
     }
     createVisibilityMap(isWall, maxDistance = Infinity) {
         return new Pipe2D(this.gridView.width, this.gridView.height, (x, y) => {
+            if (isWall(this))
+                return Visibility.hidden;
             const distance = getDistance(this, { x, y });
             if (distance > maxDistance) {
                 return Visibility.hidden;
@@ -200,20 +202,16 @@ function getDistance(c1, c2) {
     return Math.sqrt(Math.pow(c2.x - c1.x, 2) + Math.pow(c2.y - c1.y, 2));
 }
 export class Grid {
-    constructor(width, height, get, set, batch) {
+    constructor(width, height, parentGet, parentSet, batch) {
         this.width = width;
         this.height = height;
+        this.parentGet = parentGet;
+        this.parentSet = parentSet;
         this.batch = batch;
         this.cells = new Pipe2D(this.width, this.height, (x, y) => {
             return new Cell(x, y, this);
         }).strict().withCache();
-        this.writeMasks = [];
         this.pipe = new Pipe2D(this);
-        this.parentGet = get;
-        this.parentSet = set;
-    }
-    isWritable(x, y) {
-        return !this.writeMasks.some(mask => !mask.mask.get(x, y));
     }
     batchUpdate(fn) {
         this.batch(fn);
@@ -228,8 +226,7 @@ export class Grid {
         if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
             throw new RangeError("Coordinates out of bounds");
         }
-        if (this.isWritable(x, y))
-            this.parentSet(x, y, value);
+        this.parentSet(x, y, value);
     }
     trySet(x, y, value) {
         if (x < 0 || x >= this.width || y < 0 || y >= this.height)
@@ -237,39 +234,31 @@ export class Grid {
         this.set(x, y, value);
         return true;
     }
-    fill(value) {
+    fill(value, mask) {
         this.batchUpdate(() => {
             for (let y = 0; y < this.height; y++) {
                 for (let x = 0; x < this.width; x++) {
-                    const tx = x;
-                    const ty = y;
-                    this.trySet(tx, ty, value);
+                    if (mask && !mask.get(x, y))
+                        continue;
+                    this.trySet(x, y, value);
                 }
             }
         });
     }
-    paste(x, y, source) {
+    paste(x, y, source, mask) {
         const cachedSource = new GridBase(source);
         this.batchUpdate(() => {
             for (let oy = 0; oy < source.height; oy++) {
                 for (let ox = 0; ox < source.width; ox++) {
                     const tx = ox + x;
                     const ty = oy + y;
+                    if (mask && !mask.get(tx, ty))
+                        continue;
                     this.trySet(tx, ty, cachedSource.get(ox, oy));
                 }
             }
         });
     }
-    applyWriteMask(mask) {
-        const unique = { mask };
-        this.writeMasks.push(unique);
-        return () => {
-            const idx = this.writeMasks.indexOf(unique);
-            if (idx == -1)
-                throw new Error("Mask was not present");
-            this.writeMasks.splice(idx, 1);
-        };
-    }
     *[Symbol.iterator]() {
         for (let y = 0; y < this.height; y++) {
             for (let x = 0; x < this.width; x++) {
@@ -284,91 +273,15 @@ export class Grid {
             }
         }
     }
-    getVisibilityMap(originX, originY, maxDistance, isWall, options) {
-        const { startAngle = { asTurns: 0 }, endAngle = { asTurns: 1 }, includeWalls = false, angleStep = { asDegrees: 1 } } = options || {};
-        const visibilityGrid = new GridBase(this.width, this.height, () => false);
-        const startRad = angleToRadians(startAngle);
-        const endRad = angleToRadians(endAngle);
-        const stepRad = angleToRadians(angleStep);
-        const totalAngle = endRad > startRad
-            ? endRad - startRad
-            : endRad + (2 * Math.PI) - startRad;
-        const effectiveStepRad = Math.max(0.001, Math.min(stepRad, totalAngle));
-        const steps = Math.ceil(totalAngle / effectiveStepRad);
-        for (let i = 0; i <= steps; i++) {
-            const angle = startRad + i * effectiveStepRad;
-            if (angle > endRad && i > 0)
-                break;
-            const endX = Math.round(originX + maxDistance * Math.cos(angle));
-            const endY = Math.round(originY + maxDistance * Math.sin(angle));
-            let x0 = originX;
-            let y0 = originY;
-            let x1 = endX;
-            let y1 = endY;
-            const dx = Math.abs(x1 - x0);
-            const dy = Math.abs(y1 - y0);
-            const sx = x0 < x1 ? 1 : -1;
-            const sy = y0 < y1 ? 1 : -1;
-            let err = dx - dy;
-            while (true) {
-                if (x0 < 0 || x0 >= this.width || y0 < 0 || y0 >= this.height) {
-                    break;
-                }
-                const isWallCell = isWall(this.get(x0, y0), x0, y0);
-                if (isWallCell) {
-                    if (includeWalls) {
-                        visibilityGrid.set(x0, y0, true);
-                    }
-                    break;
-                }
-                else {
-                    visibilityGrid.set(x0, y0, true);
-                }
-                if (x0 === x1 && y0 === y1)
-                    break;
-                const e2 = 2 * err;
-                if (e2 > -dy) {
-                    err -= dy;
-                    x0 += sx;
-                }
-                if (e2 < dx) {
-                    err += dx;
-                    y0 += sy;
-                }
-            }
-        }
-        return visibilityGrid.pipe;
-    }
-    getFloodMap(startX, startY, predicate, options) {
-        const { includeDiagonals = false, maxDistance = Infinity } = options || {};
-        const result = new GridBase(this.width, this.height, () => false);
-        const startValue = this.get(startX, startY);
-        if (!predicate(startValue, startX, startY, startValue)) {
-            return result.pipe;
-        }
-        const queue = [[startX, startY, 0]];
-        result.set(startX, startY, true);
-        while (queue.length > 0) {
-            const [x, y, distance] = queue.shift();
-            if (distance >= maxDistance)
-                continue;
-            this.cells.get(x, y).getNeighbours(includeDiagonals)
-                .forEach(neighbour => {
-                if (result.get(neighbour.x, neighbour.y))
-                    return;
-                if (predicate(neighbour.value, neighbour.x, neighbour.y, startValue)) {
-                    result.set(neighbour.x, neighbour.y, true);
-                    queue.push([neighbour.x, neighbour.y, distance + 1]);
-                }
-            });
-        }
-        return result.pipe;
-    }
     combine(aux, cb) {
         const width = Math.min(this.width, aux.width);
         const height = Math.min(this.height, aux.height);
-        return new GridBase(width, height, (x, y) => {
-            return cb(this.get(x, y), aux.get(x, y));
+        return new GridBase({
+            width,
+            height,
+            get: (x, y) => {
+                return cb(this.get(x, y), aux.get(x, y));
+            }
         });
     }
     map(read, write) {
@@ -384,7 +297,11 @@ export class Grid {
         }, fn => this.batch(fn));
     }
     static init(width, height, initCell) {
-        return new GridBase(width, height, initCell);
+        return new GridBase({
+            width,
+            height,
+            get: initCell
+        });
     }
     static from(source) {
         return new GridBase(source);
@@ -416,22 +333,14 @@ export class GridBase extends Grid {
             this.triggerChange(changed);
         }
     }
-    constructor(widthOrSource, height, cellInit) {
-        const source = typeof widthOrSource == "object"
-            ? widthOrSource
-            : {
-                width: widthOrSource,
-                height: height,
-                get: cellInit
-            };
+    constructor(source) {
         super(source.width, source.height, (x, y) => this.data[this.xyToIndex(x, y)], (x, y, value) => this._set(x, y, value), fn => this.batchUpdate(fn));
         this.eventHandlers = {};
         this.batchState = null;
-        this.data = Array.from({ length: source.width * source.height }, (_, i) => {
-            const x = i % source.width;
-            const y = Math.floor(i / source.width);
-            return source.get(x, y);
-        });
+        const sourcePipe = source instanceof Pipe2D
+            ? source
+            : new Pipe2D(source);
+        this.data = sourcePipe.toFlatArrayXY();
     }
     on(eventName, handler) {
         const unique = { fn: handler };

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "2D store and utilities",
   "name": "@xtia/grid",
   "exports": {
@@ -11,16 +11,14 @@
   },
   "scripts": {
     "build": "npx tsc",
-    "test": "npx jest"
+    "test": "npx vitest run"
   },
   "files": [
     "lib/"
   ],
   "devDependencies": {
-    "@swc/jest": "^0.2.39",
-    "@types/jest": "^30.0.0",
-    "jest": "^30.4.2",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   },
   "dependencies": {
     "@xtia/pipe2d": "^2.1.0"