@xtia/grid 0.0.11 → 0.0.13

package/README.md

@@ -179,6 +179,9 @@ const numOfAdjacentMines = clickedCell.getNeighbours(true)
 ```
 
 ### Path finding
+
+`findPath()` computes an optimal path from a cell to another location in the grid, accounting for cell/traversal costs according to a user-provided predicate or `Map<T, number>`.
+
 ```ts
 const costs = {
 	grass: 1,
@@ -189,6 +192,7 @@ const costs = {
 
 const start = world.cells.get(5, 5);
 const destination = world.cells.get(90, 90);
+
 const path = start.findPath(
 	destination, // or simply [90, 90]
 	(cell) => costs[cell.value]
@@ -197,13 +201,14 @@ const path = start.findPath(
 
 ### Visibility mapping
 
+`createVisibilityMap()` returns a `Pipe2D<boolean>` that maps which cells are 'visible' from the starting point, according to a user-provided predicate to determine which cells block vision.
+
 ```ts
 // createVisibilityMap(isClear);
 const visibility = start.createVisibilityMap(
 	cell => cell.value === "grass" // anything except grass blocks vision
 );
 
-// writeMask() creates a live view that only allows writes at positions allowed by the mask Source2D/function
 screenGrid.writeMask(visibility).paste(spriteMap, 0, 0);
 ```
 

package/lib/grid.d.ts

@@ -76,6 +76,7 @@ export declare class Grid<T> {
     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>;
+    scroll(xDelta: number, yDelta: number, fill: T): this;
     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>;

package/lib/grid.js

@@ -72,7 +72,7 @@ export class Cell {
             ? (cell) => { var _a; return (_a = getCost.get(cell.value)) !== null && _a !== void 0 ? _a : Infinity; }
             : getCost;
         costs.set(this, 0);
-        const queue = new OrderedQueue(cell => { var _a; return (_a = costs.get(cell)) !== null && _a !== void 0 ? _a : Infinity; }, this);
+        const queue = new OrderedQueue([this, 0]);
         const stopAtCell = options.stopAt && this.getSiblingCell(options.stopAt);
         while (queue.length > 0) {
             const current = queue.take();
@@ -115,7 +115,7 @@ export class Cell {
                 if (newCost < oldCost && newCost <= maxCost) {
                     costs.set(n.cell, newCost);
                     pathInfo === null || pathInfo === void 0 ? void 0 : pathInfo.set(n.cell, current);
-                    queue.add(n.cell);
+                    queue.add(n.cell, newCost);
                 }
             });
         }
@@ -218,17 +218,29 @@ export class Grid {
             return new Cell(x, y, this);
         }).strict().withCache();
         this.pipe = new Pipe2D(this);
+        if (!Number.isInteger(width) || !Number.isInteger(height)) {
+            throw new Error(`Grid width & height must be integer; got (${width} x ${height})`);
+        }
+        if (width < 0 || height < 0) {
+            throw new Error(`Grid width/height may not be less than 0; got (${width} x ${height})`);
+        }
     }
     batchUpdate(fn) {
         this.batch(fn);
     }
     get(x, y) {
+        if (!Number.isInteger(x) || !Number.isInteger(y)) {
+            throw new Error(`Coordinates must be integer; got (${x}, ${y})`);
+        }
         if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
             throw new RangeError("Coordinates out of bounds");
         }
         return this.parentGet(x, y);
     }
     set(x, y, value) {
+        if (!Number.isInteger(x) || !Number.isInteger(y)) {
+            throw new Error(`Coordinates must be integer; got (${x}, ${y})`);
+        }
         if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
             throw new RangeError("Coordinates out of bounds");
         }
@@ -255,7 +267,7 @@ export class Grid {
         });
     }
     paste(source, x = 0, y = 0) {
-        const cachedSource = new GridBase(source);
+        const cachedSource = new Pipe2D(source).stash();
         this.batchUpdate(() => {
             for (let oy = 0; oy < source.height; oy++) {
                 for (let ox = 0; ox < source.width; ox++) {
@@ -304,12 +316,37 @@ export class Grid {
         return new Grid(this.width, this.height, (x, y) => read(this.parentGet(x, y), x, y), (x, y, value) => this.parentSet(x, y, write(value, x, y)), fn => this.batch(fn));
     }
     region(x, y, width, height) {
+        if (!Number.isInteger(x) || !Number.isInteger(y) || !Number.isInteger(width) || !Number.isInteger(height)) {
+            throw new Error(`Region boundaries must be integer; got (${x}, ${y}), (${width} x ${height})`);
+        }
+        if (x < 0 || y < 0 || x + width > this.width || y + height > this.height) {
+            throw new Error("Requested region exceeds the parent's bounds");
+        }
         return new Grid(width, height, (tx, ty) => {
             return this.parentGet(tx + x, ty + y);
         }, (tx, ty, value) => {
             this.parentSet(tx + x, ty + y, value);
         }, fn => this.batch(fn));
     }
+    scroll(xDelta, yDelta, fill) {
+        if (!Number.isInteger(xDelta) || !Number.isInteger(yDelta)) {
+            throw new Error(`Scroll offsets must be integer; got (${xDelta}, ${yDelta})`);
+        }
+        this.paste(this, xDelta, yDelta);
+        if (xDelta > 0) {
+            this.region(0, 0, xDelta, this.height).fill(fill);
+        }
+        else if (xDelta < 0) {
+            this.region(this.width + xDelta, 0, -xDelta, this.height).fill(fill);
+        }
+        if (yDelta > 0) {
+            this.region(0, 0, this.width, yDelta).fill(fill);
+        }
+        else if (yDelta < 0) {
+            this.region(0, this.height + yDelta, this.width, -yDelta).fill(fill);
+        }
+        return this;
+    }
     static init(width, height, initCell) {
         return new GridBase({
             width,

package/lib/utils.d.ts

@@ -5,10 +5,9 @@ export type Source2D<T> = {
     get: GetXYFunc<T>;
 };
 export declare class OrderedQueue<T> {
-    private getCost;
     private queue;
-    constructor(getCost: (value: T) => number, ...values: T[]);
-    add(value: T): void;
+    constructor(...items: [T, number][]);
+    add(value: T, priority: number): void;
     get length(): number;
     take(): T;
 }

package/lib/utils.js

@@ -1,11 +1,9 @@
 export class OrderedQueue {
-    constructor(getCost, ...values) {
-        this.getCost = getCost;
+    constructor(...items) {
         this.queue = [];
-        values.forEach(v => this.add(v));
+        items.forEach(v => this.add(...v));
     }
-    add(value) {
-        const priority = this.getCost(value);
+    add(value, priority) {
         const item = { value, priority };
         let low = 0, high = this.queue.length;
         while (low < high) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "2D store and utilities, with zero-copy regions and transform layers, pathfinding, Pipe2D interop",
   "name": "@xtia/grid",
   "exports": {