@aethervtt/shard-nav 0.0.1

package/dist/geometry.js

@@ -0,0 +1,176 @@
+class TriangleSoup {
+  positions = new Float32Array(9 * 256);
+  areas = new Uint8Array(256);
+  count = 0;
+  min = new Float64Array([Infinity, Infinity, Infinity]);
+  max = new Float64Array([-Infinity, -Infinity, -Infinity]);
+  clear() {
+    this.count = 0;
+    this.min.fill(Infinity);
+    this.max.fill(-Infinity);
+  }
+  grow() {
+    const p = new Float32Array(this.positions.length * 2);
+    p.set(this.positions);
+    this.positions = p;
+    const a = new Uint8Array(this.areas.length * 2);
+    a.set(this.areas);
+    this.areas = a;
+  }
+  /** Adds a triangle given in world space. */
+  push(ax, ay, az, bx, by, bz, cx, cy, cz, area) {
+    if (this.count === this.areas.length) this.grow();
+    const o = this.count * 9;
+    const p = this.positions;
+    p[o] = ax;
+    p[o + 1] = ay;
+    p[o + 2] = az;
+    p[o + 3] = bx;
+    p[o + 4] = by;
+    p[o + 5] = bz;
+    p[o + 6] = cx;
+    p[o + 7] = cy;
+    p[o + 8] = cz;
+    this.areas[this.count++] = area;
+    for (let k = 0; k < 9; k += 3) {
+      const x = p[o + k];
+      const y = p[o + k + 1];
+      const z = p[o + k + 2];
+      if (x < this.min[0]) this.min[0] = x;
+      if (y < this.min[1]) this.min[1] = y;
+      if (z < this.min[2]) this.min[2] = z;
+      if (x > this.max[0]) this.max[0] = x;
+      if (y > this.max[1]) this.max[1] = y;
+      if (z > this.max[2]) this.max[2] = z;
+    }
+  }
+}
+function pushTransformed(soup, local, indices, triangles, m, area) {
+  const det = m[0] * (m[5] * m[10] - m[6] * m[9]) - m[1] * (m[4] * m[10] - m[6] * m[8]) + m[2] * (m[4] * m[9] - m[5] * m[8]);
+  const flip = det < 0;
+  const tx = (i) => m[0] * local[i] + m[1] * local[i + 1] + m[2] * local[i + 2] + m[3];
+  const ty = (i) => m[4] * local[i] + m[5] * local[i + 1] + m[6] * local[i + 2] + m[7];
+  const tz = (i) => m[8] * local[i] + m[9] * local[i + 1] + m[10] * local[i + 2] + m[11];
+  for (let t = 0; t < triangles; t++) {
+    const a = 3 * (indices ? indices[3 * t] : 3 * t);
+    let b = 3 * (indices ? indices[3 * t + 1] : 3 * t + 1);
+    let c = 3 * (indices ? indices[3 * t + 2] : 3 * t + 2);
+    if (flip) {
+      const s = b;
+      b = c;
+      c = s;
+    }
+    soup.push(tx(a), ty(a), tz(a), tx(b), ty(b), tz(b), tx(c), ty(c), tz(c), area);
+  }
+}
+function outward(tris) {
+  for (let o = 0; o < tris.length; o += 9) {
+    const e0x = tris[o + 3] - tris[o];
+    const e0y = tris[o + 4] - tris[o + 1];
+    const e0z = tris[o + 5] - tris[o + 2];
+    const e1x = tris[o + 6] - tris[o];
+    const e1y = tris[o + 7] - tris[o + 1];
+    const e1z = tris[o + 8] - tris[o + 2];
+    const nx = e0y * e1z - e0z * e1y;
+    const ny = e0z * e1x - e0x * e1z;
+    const nz = e0x * e1y - e0y * e1x;
+    const cx = tris[o] + tris[o + 3] + tris[o + 6];
+    const cy = tris[o + 1] + tris[o + 4] + tris[o + 7];
+    const cz = tris[o + 2] + tris[o + 5] + tris[o + 8];
+    if (nx * cx + ny * cy + nz * cz < 0) {
+      for (let k = 0; k < 3; k++) {
+        const s = tris[o + 3 + k];
+        tris[o + 3 + k] = tris[o + 6 + k];
+        tris[o + 6 + k] = s;
+      }
+    }
+  }
+  return tris;
+}
+function boxTriangles(hx, hy, hz) {
+  const tris = [];
+  const quad = (a, b, c, d) => {
+    tris.push(...a, ...b, ...c, ...a, ...c, ...d);
+  };
+  const p = (x, y, z) => [x * hx, y * hy, z * hz];
+  quad(p(-1, 1, -1), p(-1, 1, 1), p(1, 1, 1), p(1, 1, -1));
+  quad(p(-1, -1, -1), p(1, -1, -1), p(1, -1, 1), p(-1, -1, 1));
+  quad(p(-1, -1, 1), p(1, -1, 1), p(1, 1, 1), p(-1, 1, 1));
+  quad(p(-1, -1, -1), p(-1, 1, -1), p(1, 1, -1), p(1, -1, -1));
+  quad(p(1, -1, -1), p(1, 1, -1), p(1, 1, 1), p(1, -1, 1));
+  quad(p(-1, -1, -1), p(-1, -1, 1), p(-1, 1, 1), p(-1, 1, -1));
+  return outward(tris);
+}
+function latheTriangles(profile, segments = 12) {
+  const tris = [];
+  const at = (ring, k) => {
+    const [r, y] = profile[ring];
+    const a = 2 * Math.PI * k / segments;
+    return [r * Math.cos(a), y, r * Math.sin(a)];
+  };
+  for (let i = 0; i + 1 < profile.length; i++) {
+    for (let k = 0; k < segments; k++) {
+      const a = at(i, k);
+      const b = at(i, k + 1);
+      const c = at(i + 1, k + 1);
+      const d = at(i + 1, k);
+      if (profile[i][0] > 0) tris.push(...a, ...b, ...c);
+      if (profile[i + 1][0] > 0) tris.push(...a, ...c, ...d);
+    }
+  }
+  for (const ring of [0, profile.length - 1]) {
+    const [r, y] = profile[ring];
+    if (r <= 0) continue;
+    for (let k = 0; k < segments; k++) tris.push(0, y, 0, ...at(ring, k), ...at(ring, k + 1));
+  }
+  const mid = (profile[0][1] + profile[profile.length - 1][1]) / 2;
+  for (let o = 1; o < tris.length; o += 3) tris[o] = tris[o] - mid;
+  outward(tris);
+  for (let o = 1; o < tris.length; o += 3) tris[o] = tris[o] + mid;
+  return tris;
+}
+function sphereProfile(radius, center = 0, from = -1, to = 1, rings = 6) {
+  const out = [];
+  for (let i = 0; i <= rings; i++) {
+    const a = Math.PI / 2 * (from + (to - from) * i / rings);
+    out.push([radius * Math.cos(a), center + radius * Math.sin(a)]);
+  }
+  return out;
+}
+function capsuleProfile(radius, halfHeight) {
+  return [
+    ...sphereProfile(radius, -halfHeight, -1, 0, 3),
+    ...sphereProfile(radius, halfHeight, 0, 1, 3)
+  ];
+}
+function heightfieldTriangles(rows, cols, heights, hx, hy, hz) {
+  const tris = [];
+  if (rows < 2 || cols < 2 || heights.length < rows * cols) return tris;
+  const p = (r, c) => [
+    -hx + 2 * hx * c / (cols - 1),
+    heights[r * cols + c] * hy,
+    -hz + 2 * hz * r / (rows - 1)
+  ];
+  for (let r = 0; r + 1 < rows; r++) {
+    for (let c = 0; c + 1 < cols; c++) {
+      tris.push(...p(r, c), ...p(r + 1, c), ...p(r + 1, c + 1));
+      tris.push(...p(r, c), ...p(r + 1, c + 1), ...p(r, c + 1));
+    }
+  }
+  return tris;
+}
+function pushMesh(soup, mesh, m, area) {
+  const indices = mesh.indices;
+  const triangles = indices ? Math.floor(indices.length / 3) : Math.floor(mesh.vertexCount / 3);
+  pushTransformed(soup, mesh.positions, indices, triangles, m, area);
+}
+export {
+  TriangleSoup,
+  boxTriangles,
+  capsuleProfile,
+  heightfieldTriangles,
+  latheTriangles,
+  pushMesh,
+  pushTransformed,
+  sphereProfile
+};

package/dist/grid.d.ts

@@ -0,0 +1,96 @@
+export declare const DIAGONAL_MODES: readonly ['no-corners', 'never', 'always'];
+export type DiagonalMode = (typeof DIAGONAL_MODES)[number];
+/** Diagonal rule as a number, for hot code: 0 no-corners, 1 never, 2 always. */
+export declare const DIAGONAL_NO_CORNERS = 0;
+export declare const DIAGONAL_NEVER = 1;
+export declare const DIAGONAL_ALWAYS = 2;
+/**
+ * Walkable cells and their costs, row by row from y = 0 (the bottom row, lowest world y).
+ * 0 is blocked; 1 is normal ground; higher values cost that many times more to cross.
+ */
+export declare class NavGridData {
+    width: number;
+    height: number;
+    costs: Uint8Array;
+    /**
+     * Bumps on every edit, so grids and agents built from it know to refresh. `set` bumps it; code
+     * that writes `costs` directly must bump it too.
+     */
+    version: number;
+    private masks;
+    private maskVersions;
+    constructor(width: number, height: number, costs?: Uint8Array);
+    get(x: number, y: number): number;
+    /** Sets a cell's cost (0 blocks it). Out-of-range cells are `nav/out-of-bounds`. */
+    set(x: number, y: number, cost: number): void;
+    /**
+     * Per cell, a bit per direction (see `DX`, `DY`) that A* may step in under the diagonal rule:
+     * in bounds, walkable, and not cutting a blocked corner when that's not allowed. Cached until
+     * `version` changes, so searches skip walls without testing them.
+     */
+    neighbors(diagonal: number): Uint8Array;
+    copyFrom(other: NavGridData): void;
+}
+/**
+ * Reusable A* state for grids up to a size: a binary heap over TypedArrays and a generation
+ * counter per search, so a search neither allocates nor clears arrays once it has grown.
+ */
+export declare class GridSearch {
+    private capacity;
+    private g;
+    private parent;
+    /** `gen`: seen this search (open). `gen + 1`: closed. Anything else: untouched. */
+    private stamp;
+    private heap;
+    private heapF;
+    private heapG;
+    private heapPos;
+    private stack;
+    private gen;
+    /** The last path's cells (y · width + x), start first. */
+    cells: Int32Array<ArrayBuffer>;
+    /** How many cells `cells` holds. */
+    count: number;
+    /** Path cost of the last search (world distance × cell cost). */
+    cost: number;
+    /** Whether the last search reached the goal; false means `cells` ends at the closest cell. */
+    reached: boolean;
+    /** Cells expanded by the last search. */
+    expanded: number;
+    private ensure;
+    /**
+     * Finds the cheapest path from cell (sx, sy) to (gx, gy). Moving costs the world distance
+     * (cell size `csx` × `csy`) times the entered cell's cost. Returns true when the goal was
+     * reached; otherwise `cells` leads to the reachable cell closest to the goal. Both cells must
+     * be walkable (see `nearestWalkable`).
+     */
+    search(grid: NavGridData, sx: number, sy: number, gx: number, gy: number, diagonal: number, csx?: number, csy?: number): boolean;
+}
+/** Scratch for `gridRaycast`: where the ray stopped, in cell units. */
+export interface GridHit {
+    /** 0..1 along the segment; 1 means it reached the end. */
+    t: number;
+    x: number;
+    y: number;
+}
+/**
+ * Walks the segment (ax, ay) → (bx, by), in cell units, through the cells it touches
+ * (Amanatides–Woo). Stops at the first blocked cell, a cell costing more than `maxCost`, or a
+ * corner squeezed between two blocked cells (unless `always`). Returns true when the whole
+ * segment is clear; writes the stop point and fraction reached into `hit` when given.
+ */
+export declare function gridTrace(grid: NavGridData, ax: number, ay: number, bx: number, by: number, diagonal: number, maxCost: number, hit?: GridHit): boolean;
+/** `gridTrace` with the segment in `seg` (ax, ay, bx, by), for per-frame callers. */
+export declare function traceSegment(grid: NavGridData, seg: Float64Array, diagonal: number, maxCost: number, hit?: GridHit): boolean;
+/**
+ * String-pulls a cell path into corners: from the start point, the path runs straight to the
+ * farthest cell center it can see, and on from there. Points are in cell units (cell (x, y) spans
+ * [x, x + 1] × [y, y + 1]); `ends` holds the start and end points (sx, sy, ex, ey). Writes
+ * `stride`-spaced x, y pairs into `out` and returns the corner count (start and end included).
+ */
+export declare function smoothGridPath(grid: NavGridData, cells: Int32Array, count: number, ends: Float64Array, diagonal: number, out: Float32Array, stride: number, maxCorners: number): number;
+/**
+ * The walkable cell nearest to (x, y) within `radius` cells, as y · width + x, or -1. Searches
+ * rings outward and picks the closest center in the first ring that has one.
+ */
+export declare function nearestWalkable(grid: NavGridData, x: number, y: number, radius: number): number;