spoint 0.1.601 → 0.1.603

package/apps/_lib/steering.js

@@ -37,19 +37,19 @@ import { createComponentPool } from './ComponentPool.js'
 // step()/followPath() themselves stay pure functions of their arguments (from/target/dt/peers) --
 // there is no PER-TICK mutable numeric state to pool here (unlike health.js's hp/alive/lastHitAt);
 // followPath's cursor is already caller-owned (`state`), not instance-owned.
-const _pool = createComponentPool({ fields: { speed: 'f64', arriveRadius: 'f64', separation: 'f64', clampToTerrain: 'f64', yOffset: 'f64' } })
+const _pool = createComponentPool({ fields: { speed: 'f64', arriveRadius: 'f64', separation: 'f64', clampToTerrain: 'f64', yOffset: 'f64', useNavCost: 'f64' } })
 // Cached column references + the epoch they were captured at -- see health.js/ComponentPool.js's
 // header comment for why (plain fixed-length typed arrays are ~2.5x faster per-access than the
 // identity-stable resizable-ArrayBuffer alternative this module tried first and reverted; every hot-path
 // entry point calls `_sync()` first -- a single integer compare in the common case, only re-fetching the
 // five column references on the rare epoch mismatch that means a grow() just happened).
 let _speed = _pool.column('speed'), _arriveRadius = _pool.column('arriveRadius'), _separation = _pool.column('separation')
-let _clampToTerrain = _pool.column('clampToTerrain'), _yOffset = _pool.column('yOffset')
+let _clampToTerrain = _pool.column('clampToTerrain'), _yOffset = _pool.column('yOffset'), _useNavCost = _pool.column('useNavCost')
 let _epoch = _pool.epoch
 function _sync() {
   if (_epoch === _pool.epoch) return
   _speed = _pool.column('speed'); _arriveRadius = _pool.column('arriveRadius'); _separation = _pool.column('separation')
-  _clampToTerrain = _pool.column('clampToTerrain'); _yOffset = _pool.column('yOffset')
+  _clampToTerrain = _pool.column('clampToTerrain'); _yOffset = _pool.column('yOffset'); _useNavCost = _pool.column('useNavCost')
   _epoch = _pool.epoch
 }
 
@@ -79,6 +79,10 @@ function _stepImpl(slot, appCtx, from, target, dt, peers) {
   const dist = Math.hypot(vx, vz)
   let sp = speed
   if (dist <= arriveRadius) sp = dist > 1e-4 ? speed * (dist / arriveRadius) : 0   // arrive: ease to a stop
+  if (_useNavCost[slot] === 1 && typeof appCtx.navCostAt === 'function' && dist > 1e-4) {
+    const cost = appCtx.navCostAt(fx, fz)
+    if (typeof cost === 'number' && Number.isFinite(cost) && cost > 0) sp = sp / cost
+  }
   if (dist > 1e-4) { vx = (vx / dist) * sp; vz = (vz / dist) * sp } else { vx = 0; vz = 0 }
   // separation: sum push-away from nearby peers
   if (separation > 0 && peers && peers.length) {
@@ -106,6 +110,7 @@ export function defineSteering(spec = {}, appCtx) {
   _separation[slot] = spec.separation ?? 0
   _clampToTerrain[slot] = spec.clampToTerrain ? 1 : 0
   _yOffset[slot] = spec.yOffset ?? 0
+  _useNavCost[slot] = spec.useNavCost ? 1 : 0
   let _disposed = false
 
   const steering = {

package/apps/combat-bot/index.js

@@ -36,7 +36,7 @@ export default {
       const home = [...ctx.entity.position]
       ctx.entity.custom = { ...(ctx.entity.custom || {}), mesh: 'capsule', color: c.color ?? '#dd3344', sx: 0.5, sy: 1.7, sz: 0.5, _isBot: true }
       ctx.state.health = ctx.defineHealth({ max: c.health ?? 100, invulnMs: 300, onDeath: () => _onDeath(ctx) })
-      ctx.state.steering = ctx.defineSteering({ speed: c.speed ?? 3.5, arriveRadius: 1, clampToTerrain: true, yOffset: 0.9 })
+      ctx.state.steering = ctx.defineSteering({ speed: c.speed ?? 3.5, arriveRadius: 1, clampToTerrain: true, yOffset: 0.9, useNavCost: true })
       ctx.state.weapon = ctx.defineWeapon({ damage: c.damage ?? 20, range: c.range ?? 80, fireRateMs: c.fireRateMs ?? 250, magazine: 0 })
       ctx.state.weaponRange = c.range ?? 80
       ctx.state.home = home

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spoint",
-  "version": "0.1.601",
+  "version": "0.1.603",
   "description": "Physics and netcode SDK for multiplayer game servers",
   "type": "module",
   "workspaces": [

package/src/apps/AppContext.js

@@ -398,6 +398,17 @@ export class AppContext {
     return this._runtime._physics?.terrainHeightAt(x, z) ?? null
   }
 
+  terrainKindAt(x, z) {
+    return this._runtime._physics?._terrainStreamer?.splineCarve?.kindAt(x, z) ?? null
+  }
+
+  navCostAt(x, z) {
+    const kind = this.terrainKindAt(x, z)
+    if (kind === 'road') return 0.5
+    if (kind === 'river') return 3
+    return 1
+  }
+
   // Real per-world sea-level Y, in the SAME local scene-space entity.position[1]/terrainHeightAt already
   // use. Reuses the identical formula the client's underwater fog-tint shader splices in at terrain-ready
   // (client/core/UnderwaterTint.js setSeaLevelY, fed by client/app.js: `(f.offsetY||0) - (f.anchorHeight||0)`)

package/src/terrain/SplineCarve.js

@@ -6,6 +6,15 @@ function cellKey(cx, cz) {
   return (cx + OFF) * BIG + (cz + OFF)
 }
 
+function carveHash(seed, i) {
+  let h = seed | 0
+  h = Math.imul(h ^ (i | 0), 0x27d4eb2d) >>> 0
+  h ^= h >>> 15; h = Math.imul(h, 0x2c1b3c6d) >>> 0
+  h ^= h >>> 12; h = Math.imul(h, 0x297a2d39) >>> 0
+  h ^= h >>> 15
+  return (h >>> 0) / 4294967296
+}
+
 function catmullRom(p0, p1, p2, p3, t) {
   const getX = (p) => Array.isArray(p) ? p[0] : p.x
   const getZ = (p) => Array.isArray(p) ? p[1] : p.z
@@ -134,26 +143,47 @@ export function createSplineCarveLayer() {
   const cells = new Map()
   const appliedSplines = []
 
-  function carve(controlPoints, width, depth, kind, baseHeightFn) {
+  function carve(controlPoints, width, depth, kind, baseHeightFn, opts = {}) {
     if (!Array.isArray(controlPoints) || controlPoints.length < 2) return { touched: 0 }
     if (!Number.isFinite(width) || width <= 0 || !Number.isFinite(depth)) return { touched: 0 }
     if (kind !== 'river' && kind !== 'road') return { touched: 0 }
+    const { seed = 0, widthVariance = 0, bankErosion = 0 } = opts
+    const isRiver = kind === 'river'
     const stepSize = Math.max(1, width * 0.5)
     const spinePoints = sampleSpline(controlPoints, stepSize)
     if (spinePoints.length === 0) return { touched: 0 }
-    const halfWidth = width * 0.5
+    const maxHalfWidth = (width * 0.5) * (1 + (isRiver ? widthVariance : 0)) + (isRiver ? bankErosion : 0)
     let touched = 0
-    for (const sp of spinePoints) {
+    let arcLen = 0
+    for (let si = 0; si < spinePoints.length; si++) {
+      const sp = spinePoints[si]
       const sx = sp.x, sz = sp.z
-      const cx0 = Math.floor((sx - halfWidth) / CELL_M), cx1 = Math.ceil((sx + halfWidth) / CELL_M)
-      const cz0 = Math.floor((sz - halfWidth) / CELL_M), cz1 = Math.ceil((sz + halfWidth) / CELL_M)
+      if (si > 0) { const px = spinePoints[si - 1].x, pz = spinePoints[si - 1].z; arcLen += Math.hypot(sx - px, sz - pz) }
+      let halfWidth = width * 0.5
+      if (isRiver && widthVariance > 0) {
+        const t = carveHash(seed, Math.round(arcLen * 0.1))
+        halfWidth *= 1 + (t * 2 - 1) * widthVariance
+      }
+      const cx0 = Math.floor((sx - maxHalfWidth) / CELL_M), cx1 = Math.ceil((sx + maxHalfWidth) / CELL_M)
+      const cz0 = Math.floor((sz - maxHalfWidth) / CELL_M), cz1 = Math.ceil((sz + maxHalfWidth) / CELL_M)
       for (let cz = cz0; cz <= cz1; cz++) {
         for (let cx = cx0; cx <= cx1; cx++) {
-          const ccx = cx * CELL_M + CELL_M * 0.5, ccz = cz * CELL_M + CELL_M * 0.5
-          const dx = ccx - sx, dz = ccz - sz
-          const d = Math.hypot(dx, dz)
-          if (d > halfWidth) continue
-          const falloff = 0.5 * (1 + Math.cos((d / halfWidth) * Math.PI))
+          const cMinX = cx * CELL_M, cMinZ = cz * CELL_M
+          const ccx = cMinX + CELL_M * 0.5, ccz = cMinZ + CELL_M * 0.5
+          let bankOffset = 0
+          if (isRiver && bankErosion > 0) {
+            const angle = carveHash(seed ^ 0x5bd1e995, cx * 92821 + cz) * Math.PI * 2
+            bankOffset = (carveHash(seed ^ 0x1b873593, cx * 15485863 + cz) * 2 - 1) * bankErosion * (0.5 + 0.5 * Math.cos(angle))
+          }
+          const cellHalfWidth = halfWidth + bankOffset
+          if (cellHalfWidth <= 0) continue
+          const nearestX = Math.max(cMinX, Math.min(sx, cMinX + CELL_M))
+          const nearestZ = Math.max(cMinZ, Math.min(sz, cMinZ + CELL_M))
+          const d = Math.hypot(nearestX - sx, nearestZ - sz)
+          if (d > cellHalfWidth) continue
+          const dCenter = Math.hypot(ccx - sx, ccz - sz)
+          const falloffDist = Math.min(dCenter, cellHalfWidth)
+          const falloff = 0.5 * (1 + Math.cos((falloffDist / cellHalfWidth) * Math.PI))
           const key = cellKey(cx, cz)
           const base = typeof baseHeightFn === 'function' ? baseHeightFn(ccx, ccz) : null
           const targetDelta = Number.isFinite(base) ? -depth * falloff : 0
@@ -165,7 +195,7 @@ export function createSplineCarveLayer() {
         }
       }
     }
-    if (touched > 0) appliedSplines.push({ controlPoints: controlPoints.map(p => Array.isArray(p) ? [p[0], p[1]] : [p.x, p.z]), width, depth, kind })
+    if (touched > 0) appliedSplines.push({ controlPoints: controlPoints.map(p => Array.isArray(p) ? [p[0], p[1]] : [p.x, p.z]), width, depth, kind, seed, widthVariance, bankErosion })
     return { touched }
   }
 
@@ -220,7 +250,7 @@ export function loadSplineCarveLayer(json, baseHeightFn) {
   if (json && Array.isArray(json.splines)) {
     for (const s of json.splines) {
       if (!s || !Array.isArray(s.controlPoints) || !Number.isFinite(s.width) || !Number.isFinite(s.depth)) continue
-      layer.carve(s.controlPoints, s.width, s.depth, s.kind, baseHeightFn)
+      layer.carve(s.controlPoints, s.width, s.depth, s.kind, baseHeightFn, { seed: s.seed ?? 0, widthVariance: s.widthVariance ?? 0, bankErosion: s.bankErosion ?? 0 })
     }
   }
   return layer

package/src/terrain/TerrainPhysics.js

@@ -386,5 +386,6 @@ export async function setupTerrainStreaming({ physics, playerManager, worldDef,
     const c = streamer.center || (getCenter ? getCenter() : null) || tcfg.center || [0, 0]
     await streamer._rebuild(c[0], c[1])
   }
+  physics._terrainStreamer = streamer
   return streamer
 }