sindicate 0.1.0 → 0.4.0

package/src/systems/nav.js

@@ -0,0 +1,343 @@
+// Grid A* pathfinding for settlement walkers — Nick's spec (A* Pathfinding Project style):
+// STATIC obstacles are solved by PATHING (a baked walkability grid per settlement; routes go
+// AROUND barrels/stalls/wells/walls from the start), and the whisker/side-step layer is only
+// for DYNAMIC avoidance (other people, horses, the player).
+//
+// One NavGrid per settlement, baked LAZILY off the first path request (async, ~57k cells,
+// yielded so it never blocks a frame; walkers fall back to direct-walk until it's ready).
+// Cells are 0.5m over ±90m; a cell is blocked if the 2D collider set corrects a point away
+// (world.collide returns the CORRECTED position — blocked means it MOVED) or the building/prop
+// BVH cuts a knee-height cross or a standing post through it. Blocked cells are dilated one
+// cell (~walker radius) so paths keep shoulder clearance.
+import * as THREE from 'three/webgpu';
+
+const CELL = 0.5;
+const HALF = 90;                   // grid half-extent (m) around the settlement centre
+const MAX_EXPAND = 24000;          // A* node budget — bail (null) rather than stall a frame
+// The WIDE grid is the horse-clearance layer: a second dilation (radius 2 ≈ 1.0 m vs the walker's
+// 0.5 m) so a ~0.7 m horse doesn't route through a gap only a man fits, PLUS a water/cliff gate a man
+// on foot doesn't get. WATER_BLOCK: deeper than this and a horse won't ford it. SLOPE_BLOCK: a rise
+// this big over one cell (0.6 m over 0.5 m ≈ 50°) is a cliff face, not a bank. Both gate the WIDE grid
+// ONLY — the proven walker grid is untouched.
+const WATER_BLOCK = 0.6;
+const SLOPE_BLOCK = 0.6;
+let _bakeChain = Promise.resolve(); // grids bake ONE AT A TIME (see bake())
+
+const _a = new THREE.Vector3(), _b = new THREE.Vector3();
+
+class NavGrid {
+  constructor(world, cx, cz) {
+    this.world = world; this.cx = cx; this.cz = cz;
+    this.n = Math.ceil((HALF * 2) / CELL);
+    this.blocked = null;           // Uint8Array once baked
+    this.ready = false; this._baking = false;
+  }
+
+  cell(wx, wz) {
+    const ix = Math.floor((wx - (this.cx - HALF)) / CELL);
+    const iz = Math.floor((wz - (this.cz - HALF)) / CELL);
+    return (ix < 0 || iz < 0 || ix >= this.n || iz >= this.n) ? -1 : iz * this.n + ix;
+  }
+  worldOf(i, out) { out.x = this.cx - HALF + ((i % this.n) + 0.5) * CELL; out.z = this.cz - HALF + (Math.floor(i / this.n) + 0.5) * CELL; return out; }
+
+  bake() {
+    if (this._baking || this.ready) return;
+    this._baking = true;
+    // GLOBAL bake queue: grids bake ONE AT A TIME. All the world's camps requesting grids at
+    // once (39 of them at boot) ran concurrent bakes over the castle load — the "dead on
+    // raising Kingsreach at shitty fps" hang.
+    _bakeChain = _bakeChain.then(() => this._bakeNow()).catch((e) => { this._baking = false; console.warn('[nav] grid bake failed — navigation stays un-ready', e?.message ?? e); });
+  }
+
+  async _bakeNow() {
+    const t0 = performance.now();
+    const { world, n } = this;
+    // PRE-BAKED NAV FILES (same scheme as the VAT bins): the grid is a pure function of the
+    // settlement's static geometry, so read /assets/nav/<name>.bin when it exists and skip
+    // the 6-8s raycast bake entirely. Bins write themselves via /__save-navbin on a miss —
+    // but ONLY when no deferred region is still pending inside the grid (caching a wall-less
+    // grid before its village streams in would freeze the mistake into a file). Nuke
+    // public/assets/nav/ (or bump NAV_BIN_VER) after changing any settlement layout.
+    // VER 2: the bin now stores the UNDILATED masks (bit0 = static, bit1 = wide-only water/cliff gate)
+    // and both dilations run on load — so tweaking a clearance radius needs no rebake, only a code
+    // change. (VER 1 stored the pre-dilated walker grid; its name differs, so old bins are simply not
+    // found and rebake once.)
+    const NAV_BIN_VER = 4;   // VER 4: sample navFloorAt (interior floors walkable, furniture on them blocked) — VER 3 sampled tabletops and speckled interiors, so re-bake once
+    const binName = `nav${NAV_BIN_VER}_${this.cx}_${this.cz}_${n}.bin`;
+    try {
+      const r = await fetch(`/assets/nav/${binName}`);
+      if (r.ok) {
+        const buf = new Uint8Array(await r.arrayBuffer());
+        if (buf.length === n * n) {
+          const raw = new Uint8Array(n * n), wideSrc = new Uint8Array(n * n);
+          for (let i = 0; i < buf.length; i++) { const v = buf[i]; raw[i] = v & 1; wideSrc[i] = (v & 1) | ((v >> 1) & 1); }
+          this.rawMask = raw;                            // UNDILATED static mask — tight indoor routing (see path/walkable `tight`)
+          this.blocked = this._dilate(raw, 1);
+          this.blockedWide = this._dilate(wideSrc, 2);
+          this.ready = true; this._baking = false;
+          console.log(`[nav] grid @(${this.cx},${this.cz}) read from bin (${Math.round(performance.now() - t0)}ms)`);
+          return;
+        }
+      }
+    } catch (e) { /* no bin — bake below */ }
+    const raw = new Uint8Array(n * n);   // static geometry (both grids)
+    const gate = new Uint8Array(n * n);  // deep water + cliffs (WIDE grid only)
+    let k = 0;
+    let sliceT0 = performance.now();
+    for (let iz = 0; iz < n; iz++) {
+      for (let ix = 0; ix < n; ix++, k++) {
+        const wx = this.cx - HALF + (ix + 0.5) * CELL;
+        const wz = this.cz - HALF + (iz + 0.5) * CELL;
+        const gterrain = world.groundAt(wx, wz);
+        const y = world.navFloorAt(wx, wz);   // the FLOOR a walker stands on — terrain outdoors, the raised floor indoors — so a building INTERIOR is navigable instead of being blocked by its own floorboards. (navFloorAt, not walkSurfaceAt: the latter returns the highest surface = a TABLETOP, which made tables read walkable and speckled the interior; the floor lets the furniture ray below catch the tabletops instead.)
+        // ── STATIC geometry (BOTH grids) ──────────────────────────────────────────────────────────
+        // 2D circles/rects (trees/fences/wells/stall posts): blocked = the point gets corrected away.
+        // Then BVH (buildings/props): knee-height cross + counter-height cross + a DOWNWARD post. The
+        // post must cast top→bottom: stall counters/tabletops face UP, and BVH raycasts cull back-faces
+        // — an upward ray from under the counter sailed through it (stalls read walkable, walkers routed
+        // straight through the stands). A `blk` flag replaces the old per-test `continue` so the gate
+        // below still runs on cells the static tests clear.
+        let blk = 0;
+        const cor = world.collide(wx, wz, 0.1, 0, y);
+        if (cor && (Math.abs(cor.x - wx) > 1e-6 || Math.abs(cor.z - wz) > 1e-6)) blk = 1;
+        if (!blk) { _a.set(wx - 0.3, y + 0.55, wz); _b.set(wx + 0.3, y + 0.55, wz); if (world.segmentBlocked(_a, _b)) blk = 1; }
+        if (!blk) { _a.set(wx, y + 0.55, wz - 0.3); _b.set(wx, y + 0.55, wz + 0.3); if (world.segmentBlocked(_a, _b)) blk = 1; }
+        if (!blk) { _a.set(wx - 0.3, y + 0.95, wz); _b.set(wx + 0.3, y + 0.95, wz); if (world.segmentBlocked(_a, _b)) blk = 1; }
+        if (!blk) { _a.set(wx, y + 1.6, wz); _b.set(wx, y + 0.15, wz); if (world.segmentBlocked(_a, _b)) blk = 1; }
+        raw[k] = blk;
+        // ── WIDE-grid-only gate (HORSES): deep water and cliff faces. Kept OUT of raw so the walker
+        //    grid never changes; only blockedWide routes a horse around a river or a drop-off. ────────
+        if (!blk) {
+          if ((world.waterDepthAt?.(wx, wz) ?? 0) > WATER_BLOCK) gate[k] = 1;
+          else if (Math.abs(world.groundAt(wx + CELL, wz) - gterrain) > SLOPE_BLOCK || Math.abs(world.groundAt(wx, wz + CELL) - gterrain) > SLOPE_BLOCK) gate[k] = 1;   // cliffs are a TERRAIN feature → compare terrain, not the walk surface (a raised floor is not a cliff)
+        }
+      }
+      // yield by TIME BUDGET, not row count: 4 rows = ~1,440 cells × several BVH raycasts
+      // ≈ 15-25ms per slice — walkers requesting paths right after the reveal held the whole
+      // game at ~40fps for the 6-8s each grid took ("fps jumps from 40 to 75+ after 20s").
+      // 4ms/slice keeps frames whole; the bake just takes longer wall-clock, which is free —
+      // walkers direct-walk until ready.
+      if (performance.now() - sliceT0 > 4) {
+        await new Promise((r) => setTimeout(r, 0));
+        sliceT0 = performance.now();
+      }
+    }
+    // Two dilations from the same raw: the WALKER grid (radius 1 ≈ 0.5 m) and the HORSE-clearance grid
+    // (radius 2 ≈ 1.0 m, plus the water/cliff gate OR-ed in). Both are cheap array passes.
+    const wideSrc = new Uint8Array(n * n);
+    for (let i = 0; i < n * n; i++) wideSrc[i] = raw[i] | gate[i];
+    this.rawMask = raw;                                  // UNDILATED static mask — tight indoor routing (see path/walkable `tight`)
+    this.blocked = this._dilate(raw, 1);
+    this.blockedWide = this._dilate(wideSrc, 2);
+    this.ready = true; this._baking = false;
+    let nb = 0, nw = 0; for (let i = 0; i < n * n; i++) { nb += this.blocked[i]; nw += this.blockedWide[i]; }
+    console.log(`[nav] grid @(${this.cx},${this.cz}) ${n}x${n} baked in ${Math.round(performance.now() - t0)}ms — walker ${(100 * nb / (n * n)).toFixed(1)}% · horse ${(100 * nw / (n * n)).toFixed(1)}% blocked`);
+    // self-write the bin (UNDILATED masks: bit0 static + bit1 gate) — unless a deferred region still
+    // pends inside this grid (its walls aren't in the world yet; caching now bakes their absence in)
+    if (import.meta.env?.DEV) {
+      const pending = (world.deferredRegions ?? []).some((rg) => Math.hypot(rg.x - this.cx, rg.z - this.cz) < HALF + 60);
+      if (!pending) {
+        const packed = new Uint8Array(n * n);
+        for (let i = 0; i < n * n; i++) packed[i] = raw[i] | (gate[i] << 1);
+        fetch(`/__save-navbin?name=${binName}`, { method: 'POST', body: packed }).catch(() => { /* sink offline */ });
+      } else console.log(`[nav] grid @(${this.cx},${this.cz}) NOT cached — a deferred region is still pending inside it`);
+    }
+  }
+
+  // Chebyshev dilation: mark any free cell within `radius` cells of a blocked one, for clearance so
+  // paths keep their shoulders (and a horse its wider body) off the walls.
+  _dilate(src, radius) {
+    const n = this.n, out = new Uint8Array(n * n);
+    for (let iz = 0; iz < n; iz++) for (let ix = 0; ix < n; ix++) {
+      const i = iz * n + ix;
+      if (src[i]) { out[i] = 1; continue; }
+      let any = 0;
+      for (let dz = -radius; dz <= radius && !any; dz++) for (let dx = -radius; dx <= radius; dx++) {
+        const jx = ix + dx, jz = iz + dz;
+        if (jx >= 0 && jz >= 0 && jx < n && jz < n && src[jz * n + jx]) { any = 1; break; }
+      }
+      out[i] = any;
+    }
+    return out;
+  }
+
+  // open-neighbour count — used to reject 1-cell slots enclosed inside a blocked mass
+  openness(j, B = this.blocked) {
+    const n = this.n, ix = j % n, iz = Math.floor(j / n);
+    let open = 0;
+    for (let dz = -1; dz <= 1; dz++) for (let dx = -1; dx <= 1; dx++) {
+      if (!dx && !dz) continue;
+      const jx = ix + dx, jz = iz + dz;
+      if (jx >= 0 && jz >= 0 && jx < n && jz < n && !B[jz * n + jx]) open++;
+    }
+    return open;
+  }
+
+  // nearest open cell to i, spiralling out (a goal beside a stall lands in dilation).
+  // PREFERS well-connected cells: a crate warehouse leaves sealed 1-cell pockets inside its
+  // blocked mass, and snapping a goal into one made A* (correctly) fail → walkers fell back
+  // to walking blind INTO the crates. Poorly-connected candidates are only a last resort.
+  nearestOpen(i, maxR = 10, B = this.blocked) {
+    if (i < 0) return -1;
+    if (!B[i] && this.openness(i, B) >= 5) return i;
+    const n = this.n, ix0 = i % n, iz0 = Math.floor(i / n);
+    let fallback = !B[i] ? i : -1;
+    for (let r = 1; r <= maxR; r++) {
+      for (let dz = -r; dz <= r; dz++) for (let dx = -r; dx <= r; dx++) {
+        if (Math.max(Math.abs(dx), Math.abs(dz)) !== r) continue;   // ring only
+        const ix = ix0 + dx, iz = iz0 + dz;
+        if (ix < 0 || iz < 0 || ix >= n || iz >= n) continue;
+        const j = iz * n + ix;
+        if (B[j]) continue;
+        if (this.openness(j, B) >= 5) return j;
+        if (fallback < 0) fallback = j;
+      }
+    }
+    return fallback;
+  }
+
+  // is this world position walkable? (goal validation — covers BVH props the circle test misses).
+  // wide = the horse-clearance grid (fatter body + water/cliff), else the walker grid.
+  walkable(wx, wz, wide = false, tight = false) {
+    if (!this.ready) return null;                 // unknown yet
+    const i = this.cell(wx, wz);
+    const B = tight ? this.rawMask : (wide ? this.blockedWide : this.blocked);
+    return i >= 0 ? !B[i] : false;
+  }
+
+  // Straight line-of-sight between two WORLD points over the blocked grid. true = the line is clear of
+  // static geometry (aim straight there), false = something is in the way (an A* detour is needed),
+  // null = an endpoint falls outside this grid (unknown). The cheap gate the road followers ask every
+  // frame so they only pay for A* when a fence/wall actually blocks the road ahead.
+  losWorld(ax, az, bx, bz, wide = false) {
+    if (!this.ready) return null;
+    const i0 = this.cell(ax, az), i1 = this.cell(bx, bz);
+    if (i0 < 0 || i1 < 0) return null;
+    return this.los(i0, i1, wide ? this.blockedWide : this.blocked);
+  }
+
+  // grid line-of-sight (supercover walk) — used to smooth A* output to few waypoints
+  los(i0, i1, B = this.blocked) {
+    const n = this.n;
+    let x0 = i0 % n, z0 = Math.floor(i0 / n);
+    const x1 = i1 % n, z1 = Math.floor(i1 / n);
+    const dx = Math.abs(x1 - x0), dz = Math.abs(z1 - z0);
+    const sx = x0 < x1 ? 1 : -1, sz = z0 < z1 ? 1 : -1;
+    let err = dx - dz;
+    for (;;) {
+      if (B[z0 * n + x0]) return false;
+      if (x0 === x1 && z0 === z1) return true;
+      const e2 = 2 * err;
+      if (e2 > -dz) { err -= dz; x0 += sx; }
+      if (e2 < dx) { err += dx; z0 += sz; }
+    }
+  }
+
+  // A* (8-connected, octile heuristic) → smoothed world waypoints [{x,z}...] or null.
+  // wide = route on the horse-clearance grid; maxExpand caps the node budget (lower for on-demand
+  // road/chase calls so a bad request can't stall a frame).
+  path(x0, z0, x1, z1, wide = false, maxExpand = MAX_EXPAND, tight = false) {
+    if (!this.ready) { this.bake(); return null; }
+    const B = tight ? this.rawMask : (wide ? this.blockedWide : this.blocked);   // tight = route on the UNDILATED mask (a thin person threading a cramped interior the 0.5 m clearance grid would seal shut)
+    let s = this.nearestOpen(this.cell(x0, z0), 6, B);
+    let t = this.nearestOpen(this.cell(x1, z1), 10, B);
+    if (s < 0 || t < 0) return null;
+    if (s === t) return [{ x: x1, z: z1 }];
+    const n = this.n, N = n * n;
+    const g = (this._g ??= new Float32Array(N)); g.fill(Infinity);
+    const came = (this._came ??= new Int32Array(N));
+    const inClosed = (this._closed ??= new Uint8Array(N)); inClosed.fill(0);
+    // small binary heap over [f, idx] pairs
+    const heap = []; const push = (f, i) => { heap.push([f, i]); let c = heap.length - 1; while (c > 0) { const p = (c - 1) >> 1; if (heap[p][0] <= heap[c][0]) break; [heap[p], heap[c]] = [heap[c], heap[p]]; c = p; } };
+    const pop = () => { const top = heap[0], last = heap.pop(); if (heap.length) { heap[0] = last; let c = 0; for (;;) { const l = c * 2 + 1, r = l + 1; let m = c; if (l < heap.length && heap[l][0] < heap[m][0]) m = l; if (r < heap.length && heap[r][0] < heap[m][0]) m = r; if (m === c) break; [heap[m], heap[c]] = [heap[c], heap[m]]; c = m; } } return top; };
+    const tx = t % n, tz = Math.floor(t / n);
+    const H = (i) => { const dx = Math.abs((i % n) - tx), dz = Math.abs(Math.floor(i / n) - tz); return (dx + dz) + (Math.SQRT2 - 2) * Math.min(dx, dz); };
+    g[s] = 0; came[s] = -1; push(H(s), s);
+    let expanded = 0, found = false;
+    while (heap.length) {
+      const [, cur] = pop();
+      if (inClosed[cur]) continue;
+      inClosed[cur] = 1;
+      if (cur === t) { found = true; break; }
+      if (++expanded > maxExpand) break;
+      const cx = cur % n, cz = Math.floor(cur / n);
+      for (let dz = -1; dz <= 1; dz++) for (let dx = -1; dx <= 1; dx++) {
+        if (!dx && !dz) continue;
+        const jx = cx + dx, jz = cz + dz;
+        if (jx < 0 || jz < 0 || jx >= n || jz >= n) continue;
+        const j = jz * n + jx;
+        if (B[j] || inClosed[j]) continue;
+        if (dx && dz && (B[cz * n + jx] || B[jz * n + cx])) continue; // no corner-cutting
+        const cost = g[cur] + (dx && dz ? Math.SQRT2 : 1);
+        if (cost < g[j]) { g[j] = cost; came[j] = cur; push(cost + H(j), j); }
+      }
+    }
+    if (!found) return null;
+    // reconstruct then greedy line-of-sight smoothing → few waypoints
+    const cells = []; for (let i = t; i !== -1; i = came[i]) cells.push(i); cells.reverse();
+    const out = []; let anchor = 0;
+    for (let i = 2; i < cells.length; i++) {
+      if (!this.los(cells[anchor], cells[i], B)) { anchor = i - 1; out.push(cells[anchor]); }
+    }
+    const P = out.map((i) => this.worldOf(i, { x: 0, z: 0 }));
+    P.push({ x: x1, z: z1 });     // exact final goal
+    return P;
+  }
+}
+
+// Region manager: one grid per settlement, keyed by region name, centred on the walkers' own
+// wander points. Grids bake lazily off the first request; path() returns null until ready
+// (callers fall back to direct walking, so nothing pops or stalls while a grid bakes).
+export class Nav {
+  constructor(world) { this.world = world; this.grids = new Map(); }
+
+  gridFor(key, cx, cz) {
+    let grd = this.grids.get(key);
+    if (!grd) { grd = new NavGrid(this.world, Math.round(cx), Math.round(cz)); this.grids.set(key, grd); grd.bake(); }
+    return grd;
+  }
+
+  // path within a named region (wanderers) — null until the grid is baked / if unreachable
+  path(key, cx, cz, from, to) {
+    const grd = this.gridFor(key, cx, cz);
+    if (Math.abs(from.x - grd.cx) > HALF - 2 || Math.abs(from.z - grd.cz) > HALF - 2) return null;   // outside this grid
+    if (Math.abs(to.x - grd.cx) > HALF - 2 || Math.abs(to.z - grd.cz) > HALF - 2) return null;
+    return grd.path(from.x, from.z, to.x, to.z);
+  }
+
+  // ── road-follower access: REUSE a settlement's grid instead of owning a region ─────────────────
+  // The wanderers key a grid to their route centroid; a passing traveller doesn't know that centroid,
+  // so these let him reuse whatever grid already COVERS where he stands (the town's own, ready or still
+  // baking) and only bake a fresh one — centred on his nearest route end — where none does (a lonely
+  // ranch with no wanderers). No duplicate bake at a town that already has a grid.
+  _covers(grd, p) { return Math.abs(p.x - grd.cx) < HALF - 2 && Math.abs(p.z - grd.cz) < HALF - 2; }
+
+  coveringGrid(x, z) {   // any grid whose ±90 m window covers the point (ready OR baking)
+    for (const grd of this.grids.values()) if (Math.abs(x - grd.cx) < HALF - 2 && Math.abs(z - grd.cz) < HALF - 2) return grd;
+    return null;
+  }
+
+  _gridHere(from, centre) {
+    let grd = this.coveringGrid(from.x, from.z);         // reuse a covering grid if one exists…
+    if (!grd && centre) grd = this.gridFor(`r${Math.round(centre.x / 80)}_${Math.round(centre.z / 80)}`, centre.x, centre.z);   // …else bake this end's
+    return grd;
+  }
+
+  // Is the straight line from→to clear of static geometry near a settlement? true/false, or null when
+  // no baked grid covers the span (open ground — assume clear, there is nothing out there to route round).
+  // wide = test the horse-clearance grid (fatter body + water/cliff), else the walker grid.
+  losHere(from, to, centre, wide = false) {
+    const grd = this._gridHere(from, centre);
+    if (!grd || !grd.ready || !this._covers(grd, from) || !this._covers(grd, to)) return null;
+    return grd.losWorld(from.x, from.z, to.x, to.z, wide);
+  }
+
+  // A* around the statics between from→to using a covering (or this-end's) grid — smoothed waypoints,
+  // or null until a grid is baked / if unreachable (caller direct-walks + its own stuck backstop). The
+  // node budget is capped low (8k) since these fire on demand from the movement loop.
+  pathHere(from, to, centre, wide = false, tight = false) {
+    const grd = this._gridHere(from, centre);
+    if (!grd || !grd.ready || !this._covers(grd, from) || !this._covers(grd, to)) return null;
+    return grd.path(from.x, from.z, to.x, to.z, wide, 8000, tight);
+  }
+}