@xtia/grid 0.0.9 → 0.0.10

package/README.md

@@ -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
@@ -190,7 +205,7 @@ const visibility = start.createVisibilityMap(
 
 // 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);
+screenGrid.paste(spriteMap, 0, 0, visibility);
 ```
 
 ### Reusing path data

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>;
@@ -65,7 +65,7 @@ export declare class Grid<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;
+    paste(source: Source2D<T>, x?: number, y?: number, mask?: Source2D<boolean> | GetXYFunc<boolean>): void;
     [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,7 +235,12 @@ 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;
@@ -260,7 +261,7 @@ export class Grid {
             }
         });
     }
-    paste(x, y, source, mask) {
+    paste(source, x = 0, y = 0, mask) {
         const maskSource = typeof mask == "function" ? {
             width: this.width,
             height: this.height,
@@ -311,8 +312,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 +380,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.10",
   "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"
   }
 }