@xtia/grid 0.0.9 → 0.0.11

package/README.md

@@ -91,7 +91,7 @@ const mask = (x: number, y: number) => {
   const dist = Math.hypot(x - centre.x, y - centre.y);
   return dist > 12 && dist < 18; // mountain ring
 };
-world.fill("mountain", mask);
+world.writeMask(mask).fill("mountain");
 
 // get a view of just the interesting area
 const lakeRegion = world.region(25, 25, 30, 30);
@@ -130,6 +130,21 @@ const mountainCells = world.cells.toFlatArrayXY()
 	.filter(cell => cell.value === "mountain")
 	.map(cell => [cell.x, cell.y]);
 
+// or get a live, renderable minimap
+import { C } from "@xtia/rgba";
+
+const colourMap = new Map(Object.entries({
+	grass: C.x0f0,
+	water: C.x00f,
+	forest: C.x080,
+	mountain: C.xa70
+}));
+const minimap = world.pipe
+	.map(colourMap)
+	.floorCoordinates()
+	.crop(viewX, viewY, vw, vh)
+	.stretch(canvas.width, canvas.height);
+
 ```
 
 ## Cell interface
@@ -188,9 +203,8 @@ const visibility = start.createVisibilityMap(
 	cell => cell.value === "grass" // anything except grass blocks vision
 );
 
-// any 2d source, including visibility maps, can be used as a mask for paste/fill operations
-// paste(source: Source2D<T>, mask?: Source2D<boolean>)
-screenGrid.paste(spriteMap, visibility);
+// writeMask() creates a live view that only allows writes at positions allowed by the mask Source2D/function
+screenGrid.writeMask(visibility).paste(spriteMap, 0, 0);
 ```
 
 ### Reusing path data
@@ -219,8 +233,17 @@ We can perform batched updates, suppressing the 'change' event until a process c
 Pipe2D makes it easy to save and restore grid data:
 
 ```ts
-const saved = world.pipe.toFlatArrayXY(); // ["mountain", "forest", "grass", ...]
+const snapshot = world.pipe.stash();
+
+const restored = Grid.from(snapshot);
+// or paste it to an existing grid
+world.paste(snapshot);
+```
+
+For persistent storage or transmission, Pipe2D can export as array:
 
-const restoredPipe = Pipe2D.fromFlatArrayXY(saved);
-const restored = Grid.from(restoredPipe);
-```
+```ts
+const saved = snapshot.toFlatArrayXY(); // ["mountain", "forest", "grass", ...]
+
+const restoredSnapshot = Pipe2D.fromFlatArrayXY(saved);
+```

package/lib/grid.d.ts

@@ -13,7 +13,7 @@ type PathFindOptions<T> = {
         cell: Cell<T>;
         cost: number;
     }) => void;
-    shortcutMap?: Source2D<Cell<T>[] | undefined> | GetXYFunc<Cell<T>[]>;
+    shortcutMap?: Source2D<LocationSpec<T>[] | undefined> | GetXYFunc<LocationSpec<T>[] | undefined>;
 };
 type CostMapOptions<T> = PathFindOptions<T> & {
     stopAt?: LocationSpec<T>;
@@ -64,8 +64,9 @@ export declare class Grid<T> {
     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, mask?: Source2D<boolean> | GetXYFunc<boolean>): void;
-    paste(x: number, y: number, source: Source2D<T>, mask?: Source2D<boolean> | GetXYFunc<boolean>): void;
+    fill(value: T): void;
+    paste(source: Source2D<T>, x?: number, y?: number): void;
+    writeMask(mask: Source2D<boolean> | GetXYFunc<boolean>): Grid<T>;
     [Symbol.iterator](): IterableIterator<{
         x: number;
         y: number;

package/lib/grid.js

@@ -50,11 +50,7 @@ export class Cell {
         return this.gridView.cells.get(xDelta + this.x, yDelta + this.y);
     }
     findPath(target, getCost, options = {}) {
-        const pathMap = this.calculateCosts(getCost, {
-            stopAt: target,
-            allowDiagonal: options.allowDiagonal,
-            maxCost: options.maxCost,
-        }, true);
+        const pathMap = this.calculateCosts(getCost, Object.assign(Object.assign({}, options), { stopAt: target }), true);
         return pathMap === null || pathMap === void 0 ? void 0 : pathMap.get(...this.getSiblingXY(target));
     }
     getPathMap(getCost, options = {}) {
@@ -98,7 +94,7 @@ export class Cell {
                 ? options.shortcutMap(current.x, current.y)
                 : (_b = options.shortcutMap) === null || _b === void 0 ? void 0 : _b.get(current.x, current.y);
             if (shortcutCells) {
-                const shortcuts = shortcutCells.map(cell => ({
+                const shortcuts = shortcutCells.map(loc => this.getSiblingCell(loc)).map(cell => ({
                     traversalType: TraversalType.shortcut,
                     cell
                 }));
@@ -185,14 +181,14 @@ export class Cell {
         }
     }
     createVisibilityMap(isClear, options = {}) {
-        var _a, _b;
-        const maxDistance = (_a = options.maxDistance) !== null && _a !== void 0 ? _a : Infinity;
-        const boundariesVisible = (_b = options.boundariesVisible) !== null && _b !== void 0 ? _b : true;
+        var _a;
+        const maxDistance = options.maxDistance;
+        const boundariesVisible = (_a = options.boundariesVisible) !== null && _a !== void 0 ? _a : true;
         return new Pipe2D(this.gridView.width, this.gridView.height, (x, y) => {
             if (!isClear(this)) {
                 return x === this.x && y === this.y ? boundariesVisible : false;
             }
-            if (maxDistance < Infinity) {
+            if (maxDistance !== undefined) {
                 if (getDistance(this, { x, y }) > maxDistance) {
                     return false;
                 }
@@ -239,46 +235,46 @@ export class Grid {
         this.parentSet(x, y, value);
     }
     trySet(x, y, value) {
-        if (x < 0 || x >= this.width || y < 0 || y >= this.height)
+        if (x < 0
+            || x >= this.width
+            || y < 0
+            || y >= this.height
+            || !Number.isInteger(x)
+            || !Number.isInteger(y))
             return false;
         this.set(x, y, value);
         return true;
     }
-    fill(value, mask) {
-        const maskSource = typeof mask == "function" ? {
-            width: this.width,
-            height: this.height,
-            get: mask
-        } : mask;
+    fill(value) {
         this.batchUpdate(() => {
             for (let y = 0; y < this.height; y++) {
                 for (let x = 0; x < this.width; x++) {
-                    if (maskSource && !maskSource.get(x, y))
-                        continue;
                     this.trySet(x, y, value);
                 }
             }
         });
     }
-    paste(x, y, source, mask) {
-        const maskSource = typeof mask == "function" ? {
-            width: this.width,
-            height: this.height,
-            get: mask
-        } : mask;
+    paste(source, x = 0, y = 0) {
         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 (maskSource && !maskSource.get(tx, ty))
-                        continue;
-                    this.trySet(tx, ty, cachedSource.get(ox, oy));
+                    this.trySet(ox + x, oy + y, cachedSource.get(ox, oy));
                 }
             }
         });
     }
+    writeMask(mask) {
+        const getMask = typeof mask == "function"
+            ? mask
+            : (x, y) => mask.get(x, y);
+        return new Grid(this.width, this.height, this.parentGet, (x, y, v) => {
+            const writable = getMask(x, y);
+            if (writable) {
+                this.set(x, y, v);
+            }
+        }, cb => this.batch(cb));
+    }
     *[Symbol.iterator]() {
         for (let y = 0; y < this.height; y++) {
             for (let x = 0; x < this.width; x++) {
@@ -311,8 +307,6 @@ export class Grid {
         return new Grid(width, height, (tx, ty) => {
             return this.parentGet(tx + x, ty + y);
         }, (tx, ty, value) => {
-            if (tx < 0 || ty < 0 || tx >= width || ty >= height)
-                throw new Error("Out of bounds");
             this.parentSet(tx + x, ty + y, value);
         }, fn => this.batch(fn));
     }
@@ -381,17 +375,20 @@ export class GridBase extends Grid {
         if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
             throw new Error(`Coordinates out of bounds: (${x}, ${y})`);
         }
+        if (!Number.isInteger(x) || !Number.isInteger(y)) {
+            throw new Error(`Coordinates must be integer; got (${x}, ${y})`);
+        }
         return y * this.width + x;
     }
     _set(x, y, value) {
         const idx = this.xyToIndex(x, y);
         if (this.data[idx] === value)
             return;
+        this.data[this.xyToIndex(x, y)] = value;
         if (this.batchState) {
             this.batchState.changedCells.add(this.cells.get(x, y));
             return;
         }
-        this.data[this.xyToIndex(x, y)] = value;
         if (this.eventHandlers.change) {
             this.triggerChange(new Set([this.cells.get(x, y)]));
         }

package/lib/utils.d.ts

@@ -4,14 +4,6 @@ export type Source2D<T> = {
     height: number;
     get: GetXYFunc<T>;
 };
-export type Angle = {
-    asDegrees: number;
-} | {
-    asRadians: number;
-} | {
-    asTurns: number;
-};
-export declare function angleToRadians(angle: Angle): number;
 export declare class OrderedQueue<T> {
     private getCost;
     private queue;

package/lib/utils.js

@@ -1,12 +1,3 @@
-export function angleToRadians(angle) {
-    if ("asRadians" in angle)
-        return angle.asRadians;
-    if ("asDegrees" in angle)
-        return angle.asDegrees * (180 / Math.PI);
-    if ("asTurns" in angle)
-        return angle.asTurns * Math.PI * 2;
-    throw new Error("Invalid angle");
-}
 export class OrderedQueue {
     constructor(getCost, ...values) {
         this.getCost = getCost;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "2D store and utilities, with zero-copy regions and transform layers, pathfinding, Pipe2D interop",
   "name": "@xtia/grid",
   "exports": {
@@ -9,7 +9,12 @@
     },
     "./lib/*": null
   },
-  "keywords": ["grid", "game-dev", "pathfinding", "cellular-automata"],
+  "keywords": [
+    "grid",
+    "game-dev",
+    "pathfinding",
+    "cellular-automata"
+  ],
   "scripts": {
     "build": "npx tsc",
     "test": "npx vitest run"
@@ -18,10 +23,11 @@
     "lib/"
   ],
   "devDependencies": {
+    "@vitest/coverage-v8": "^4.1.10",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },
   "dependencies": {
-    "@xtia/pipe2d": "^2.1.0"
+    "@xtia/pipe2d": "^2.2.1"
   }
 }