spoint 0.1.80 → 0.1.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spoint",
-  "version": "0.1.80",
+  "version": "0.1.82",
   "description": "Physics and netcode SDK for multiplayer game servers",
   "type": "module",
   "main": "src/index.js",

package/src/apps/AppRuntime.js

@@ -64,7 +64,7 @@ export class AppRuntime {
     }
     if (config.autoTrimesh && entity.model && this._physics) {
       entity.collider = { type: 'trimesh', model: entity.model }
-      this._physics.addStaticTrimeshAsync(this.resolveAssetPath(entity.model), 0)
+      this._physics.addStaticTrimeshAsync(this.resolveAssetPath(entity.model), 0, entity.position || [0,0,0])
         .then(id => { entity._physicsBodyId = id })
         .catch(e => console.error(`[AppRuntime] Failed to create trimesh for ${entity.model}:`, e.message))
     }

package/src/connection/ConnectionManager.js

@@ -127,6 +127,18 @@ export class ConnectionManager extends EventEmitter {
     return count
   }
 
+  sendPacked(clientId, data, unreliable) {
+    const client = this.clients.get(clientId)
+    if (!client || !client.transport.isOpen) return false
+    try {
+      if (unreliable) return client.transport.sendUnreliable(data)
+      return client.transport.send(data)
+    } catch (err) {
+      console.error(`[connection] sendPacked error to ${clientId}:`, err.message)
+      return false
+    }
+  }
+
   getAllStats() {
     return {
       activeConnections: this.clients.size,

package/src/netcode/SnapshotEncoder.js

@@ -28,21 +28,7 @@ function encodeEntity(e) {
   ]
 }
 
-function entityKey(encoded) {
-  let k = encoded[1]
-  for (let i = 2; i < 10; i++) k += '|' + encoded[i]
-  k += '|' + encoded[9]
-  if (encoded[10] !== null && encoded[10] !== undefined) k += '|' + JSON.stringify(encoded[10])
-  return k
-}
-
 export class SnapshotEncoder {
-  static encode(snapshot) {
-    const players = (snapshot.players || []).map(encodePlayer)
-    const entities = (snapshot.entities || []).map(encodeEntity)
-    return { tick: snapshot.tick || 0, timestamp: snapshot.timestamp || 0, players, entities }
-  }
-
   static encodeDelta(snapshot, prevEntityMap) {
     const players = (snapshot.players || []).map(encodePlayer)
     const currentIds = new Set()
@@ -50,11 +36,16 @@ export class SnapshotEncoder {
     const nextMap = new Map()
     for (const e of snapshot.entities || []) {
       const encoded = encodeEntity(e)
-      const key = entityKey(encoded)
       currentIds.add(e.id)
-      nextMap.set(e.id, key)
       const prev = prevEntityMap.get(e.id)
-      if (prev !== key) entities.push(encoded)
+      let k = encoded[1]
+      for (let i = 2; i < 10; i++) k += '|' + encoded[i]
+      k += '|' + encoded[9]
+      const cust = encoded[10]
+      const custStr = (prev && prev[1] === cust) ? prev[2] : (cust != null ? JSON.stringify(cust) : '')
+      k += '|' + custStr
+      nextMap.set(e.id, [k, cust, custStr])
+      if (!prev || prev[0] !== k) entities.push(encoded)
     }
     const removed = []
     for (const id of prevEntityMap.keys()) {
@@ -66,6 +57,12 @@ export class SnapshotEncoder {
     }
   }
 
+  static encode(snapshot) {
+    const players = (snapshot.players || []).map(encodePlayer)
+    const entities = (snapshot.entities || []).map(encodeEntity)
+    return { tick: snapshot.tick || 0, timestamp: snapshot.timestamp || 0, players, entities }
+  }
+
   static decode(data) {
     if (data.players && Array.isArray(data.players)) {
       const players = data.players.map(p => {

package/src/physics/GLBLoader.js

@@ -364,6 +364,164 @@ async function extractMeshWithMeshopt(buf, json, prim, binOffset, meshName) {
   }
 }
 
+/**
+ * Extract ALL meshes and ALL primitives from a GLB file and combine them into
+ * a single flat vertex/index buffer suitable for a trimesh collider.
+ * Handles Draco-compressed primitives. Used for map collision where the GLB
+ * may have dozens of meshes each with many primitives.
+ *
+ * @param {string} filepath - Path to GLB file
+ * @returns {Promise<Object>} {vertices: Float32Array, indices: Uint32Array, vertexCount, triangleCount}
+ */
+export async function extractAllMeshesFromGLBAsync(filepath) {
+  console.log(`[GLBLoader] Extracting ALL meshes from: ${filepath}`)
+  const buf = readFileSync(filepath)
+  if (buf.toString('ascii', 0, 4) !== 'glTF') throw new Error('Not a GLB file')
+
+  const jsonLen = buf.readUInt32LE(12)
+  const json = JSON.parse(buf.toString('utf-8', 20, 20 + jsonLen))
+  const binOffset = 20 + jsonLen + 8
+
+  const allVertices = []
+  const allIndices = []
+  let vertexOffset = 0
+  let totalTriangles = 0
+
+  // Build a node->transform map for node hierarchy
+  const nodeTransforms = buildNodeTransforms(json)
+
+  for (let meshIdx = 0; meshIdx < (json.meshes || []).length; meshIdx++) {
+    const mesh = json.meshes[meshIdx]
+    // Find node referencing this mesh to get its world transform
+    const nodeIdx = (json.nodes || []).findIndex(n => n.mesh === meshIdx)
+    const worldTransform = nodeIdx >= 0 ? nodeTransforms[nodeIdx] : null
+
+    for (let primIdx = 0; primIdx < mesh.primitives.length; primIdx++) {
+      const prim = mesh.primitives[primIdx]
+      let result
+      try {
+        if (prim.extensions?.KHR_draco_mesh_compression) {
+          result = await decompressDracoMesh(buf, json, prim, binOffset, mesh.name)
+        } else {
+          result = extractStandardMesh(buf, json, prim, binOffset, mesh.name)
+        }
+      } catch (e) {
+        console.warn(`[GLBLoader] Skipping mesh[${meshIdx}] prim[${primIdx}]: ${e.message}`)
+        continue
+      }
+
+      if (!result.indices || result.triangleCount === 0) continue
+
+      // Apply world transform to vertices if present
+      let verts = result.vertices
+      if (worldTransform) {
+        verts = applyTransformMatrix(result.vertices, worldTransform)
+      }
+
+      allVertices.push(verts)
+      // Remap indices by current vertex offset
+      const remapped = new Uint32Array(result.indices.length)
+      for (let i = 0; i < result.indices.length; i++) {
+        remapped[i] = result.indices[i] + vertexOffset
+      }
+      allIndices.push(remapped)
+      vertexOffset += result.vertexCount
+      totalTriangles += result.triangleCount
+    }
+  }
+
+  if (allVertices.length === 0) throw new Error('No valid mesh primitives found in GLB')
+
+  // Concatenate all vertex and index arrays
+  const totalVerts = vertexOffset
+  const combinedVertices = new Float32Array(totalVerts * 3)
+  let vOff = 0
+  for (const v of allVertices) { combinedVertices.set(v, vOff); vOff += v.length }
+
+  const combinedIndices = new Uint32Array(totalTriangles * 3)
+  let iOff = 0
+  for (const idx of allIndices) { combinedIndices.set(idx, iOff); iOff += idx.length }
+
+  console.log(`[GLBLoader] Combined: ${totalVerts} vertices, ${totalTriangles} triangles from ${allIndices.length} primitives`)
+  return { vertices: combinedVertices, indices: combinedIndices, vertexCount: totalVerts, triangleCount: totalTriangles }
+}
+
+/**
+ * Build world-space 4x4 transform matrices for every node in the scene graph.
+ * Returns an array indexed by node index.
+ */
+function buildNodeTransforms(json) {
+  const nodes = json.nodes || []
+  const matrices = new Array(nodes.length).fill(null)
+
+  function getMatrix(nodeIdx) {
+    if (matrices[nodeIdx] !== null) return matrices[nodeIdx]
+    const node = nodes[nodeIdx]
+    let local = mat4Identity()
+    if (node.matrix) {
+      local = node.matrix.slice()
+    } else {
+      const t = node.translation || [0, 0, 0]
+      const r = node.rotation || [0, 0, 0, 1]
+      const s = node.scale || [1, 1, 1]
+      local = mat4TRS(t, r, s)
+    }
+    // Find parent
+    const parentIdx = nodes.findIndex((n, i) => i !== nodeIdx && (n.children || []).includes(nodeIdx))
+    if (parentIdx >= 0) {
+      local = mat4Mul(getMatrix(parentIdx), local)
+    }
+    matrices[nodeIdx] = local
+    return local
+  }
+
+  for (let i = 0; i < nodes.length; i++) getMatrix(i)
+  return matrices
+}
+
+function mat4Identity() {
+  return [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]
+}
+
+function mat4TRS(t, r, s) {
+  const [qx, qy, qz, qw] = r
+  const [sx, sy, sz] = s
+  const x2=qx+qx, y2=qy+qy, z2=qz+qz
+  const xx=qx*x2, xy=qx*y2, xz=qx*z2
+  const yy=qy*y2, yz=qy*z2, zz=qz*z2
+  const wx=qw*x2, wy=qw*y2, wz=qw*z2
+  return [
+    (1-(yy+zz))*sx, (xy+wz)*sx,    (xz-wy)*sx,    0,
+    (xy-wz)*sy,     (1-(xx+zz))*sy,(yz+wx)*sy,    0,
+    (xz+wy)*sz,     (yz-wx)*sz,    (1-(xx+yy))*sz,0,
+    t[0], t[1], t[2], 1
+  ]
+}
+
+function mat4Mul(a, b) {
+  const out = new Array(16)
+  for (let row = 0; row < 4; row++) {
+    for (let col = 0; col < 4; col++) {
+      let sum = 0
+      for (let k = 0; k < 4; k++) sum += a[row + k*4] * b[k + col*4]
+      out[row + col*4] = sum
+    }
+  }
+  return out
+}
+
+function applyTransformMatrix(vertices, m) {
+  const count = vertices.length / 3
+  const out = new Float32Array(vertices.length)
+  for (let i = 0; i < count; i++) {
+    const x = vertices[i*3], y = vertices[i*3+1], z = vertices[i*3+2]
+    out[i*3]   = m[0]*x + m[4]*y + m[8]*z  + m[12]
+    out[i*3+1] = m[1]*x + m[5]*y + m[9]*z  + m[13]
+    out[i*3+2] = m[2]*x + m[6]*y + m[10]*z + m[14]
+  }
+  return out
+}
+
 /**
  * Check if a GLB file has Draco-compressed meshes without attempting extraction.
  * Useful for validation and error reporting.

package/src/physics/World.js

@@ -1,5 +1,5 @@
-import initJolt from 'jolt-physics/wasm-compat'
-import { extractMeshFromGLB, extractMeshFromGLBAsync } from './GLBLoader.js'
+import initJolt from 'jolt-physics/wasm-compat'
+import { extractMeshFromGLB, extractMeshFromGLBAsync, extractAllMeshesFromGLBAsync } from './GLBLoader.js'
 const LAYER_STATIC = 0, LAYER_DYNAMIC = 1, NUM_LAYERS = 2
 let joltInstance = null
 async function getJolt() { if (!joltInstance) joltInstance = await initJolt(); return joltInstance }
@@ -71,110 +71,92 @@ export class PhysicsWorld {
     layer = motionType === 'static' ? LAYER_STATIC : LAYER_DYNAMIC
     return this._addBody(shape, position, mt, layer, { ...opts, meta: { type: motionType, shape: shapeType } })
   }
-  addStaticTrimesh(glbPath, meshIndex = 0) {
-    const J = this.Jolt
-    const mesh = extractMeshFromGLB(glbPath, meshIndex)
-    
-    // Apply node transform if present (scale, rotation, translation)
-    let vertices = mesh.vertices
-    const nodeT = mesh.nodeTransform
-    if (nodeT) {
-      const numVerts = mesh.vertexCount
-      vertices = new Float32Array(numVerts * 3)
-      
-      const scale = nodeT.scale || [1, 1, 1]
-      const translation = nodeT.translation || [0, 0, 0]
-      const rotation = nodeT.rotation
-      
-      for (let i = 0; i < numVerts; i++) {
-        let x = mesh.vertices[i * 3] * scale[0]
-        let y = mesh.vertices[i * 3 + 1] * scale[1]
-        let z = mesh.vertices[i * 3 + 2] * scale[2]
-        
-        if (rotation) {
-          const [qx, qy, qz, qw] = rotation
-          const ix = qw * x + qy * z - qz * y
-          const iy = qw * y + qz * x - qx * z
-          const iz = qw * z + qx * y - qy * x
-          const iw = -qx * x - qy * y - qz * z
-          x = ix * qw - iw * qx - iy * qz + iz * qy
-          y = iy * qw - iw * qy - iz * qx + ix * qz
-          z = iz * qw - iw * qz - ix * qy + iy * qx
-        }
-        
-        vertices[i * 3] = x + translation[0]
-        vertices[i * 3 + 1] = y + translation[1]
-        vertices[i * 3 + 2] = z + translation[2]
-      }
-    }
-    
-    const triangles = new J.TriangleList(); triangles.resize(mesh.triangleCount)
-    for (let t = 0; t < mesh.triangleCount; t++) {
-      const tri = triangles.at(t)
-      for (let v = 0; v < 3; v++) {
-        const idx = mesh.indices[t * 3 + v]
-        tri.set_mV(v, new J.Float3(vertices[idx * 3], vertices[idx * 3 + 1], vertices[idx * 3 + 2]))
-      }
-    }
-    const shape = new J.MeshShapeSettings(triangles).Create().Get()
-    return this._addBody(shape, [0, 0, 0], J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', mesh: mesh.name, triangles: mesh.triangleCount } })
-  }
+  addStaticTrimesh(glbPath, meshIndex = 0) {
+    const J = this.Jolt
+    const mesh = extractMeshFromGLB(glbPath, meshIndex)
+    
+    // Apply node transform if present (scale, rotation, translation)
+    let vertices = mesh.vertices
+    const nodeT = mesh.nodeTransform
+    if (nodeT) {
+      const numVerts = mesh.vertexCount
+      vertices = new Float32Array(numVerts * 3)
+      
+      const scale = nodeT.scale || [1, 1, 1]
+      const translation = nodeT.translation || [0, 0, 0]
+      const rotation = nodeT.rotation
+      
+      for (let i = 0; i < numVerts; i++) {
+        let x = mesh.vertices[i * 3] * scale[0]
+        let y = mesh.vertices[i * 3 + 1] * scale[1]
+        let z = mesh.vertices[i * 3 + 2] * scale[2]
+        
+        if (rotation) {
+          const [qx, qy, qz, qw] = rotation
+          const ix = qw * x + qy * z - qz * y
+          const iy = qw * y + qz * x - qx * z
+          const iz = qw * z + qx * y - qy * x
+          const iw = -qx * x - qy * y - qz * z
+          x = ix * qw - iw * qx - iy * qz + iz * qy
+          y = iy * qw - iw * qy - iz * qx + ix * qz
+          z = iz * qw - iw * qz - ix * qy + iy * qx
+        }
+        
+        vertices[i * 3] = x + translation[0]
+        vertices[i * 3 + 1] = y + translation[1]
+        vertices[i * 3 + 2] = z + translation[2]
+      }
+    }
+    
+    const triangles = new J.TriangleList(); triangles.resize(mesh.triangleCount)
+    const f3 = new J.Float3(0, 0, 0)
+    for (let t = 0; t < mesh.triangleCount; t++) {
+      const tri = triangles.at(t)
+      for (let v = 0; v < 3; v++) {
+        const idx = mesh.indices[t * 3 + v]
+        f3.x = vertices[idx * 3]; f3.y = vertices[idx * 3 + 1]; f3.z = vertices[idx * 3 + 2]
+        tri.set_mV(v, f3)
+      }
+    }
+    const settings = new J.MeshShapeSettings(triangles)
+    const shape = settings.Create().Get()
+    J.destroy(f3)
+    J.destroy(triangles)
+    J.destroy(settings)
+    return this._addBody(shape, [0, 0, 0], J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', mesh: mesh.name, triangles: mesh.triangleCount } })
+  }
 
-  addStaticTrimeshAsync(glbPath, meshIndex = 0, position = [0, 0, 0]) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const J = this.Jolt
-        const mesh = await extractMeshFromGLBAsync(glbPath, meshIndex)
-        
-        // Apply node transform if present (scale, rotation, translation)
-        let vertices = mesh.vertices
-        const nodeT = mesh.nodeTransform
-        if (nodeT) {
-          const numVerts = mesh.vertexCount
-          vertices = new Float32Array(numVerts * 3)
-          
-          const scale = nodeT.scale || [1, 1, 1]
-          const translation = nodeT.translation || [0, 0, 0]
-          const rotation = nodeT.rotation
-          
-          for (let i = 0; i < numVerts; i++) {
-            let x = mesh.vertices[i * 3] * scale[0]
-            let y = mesh.vertices[i * 3 + 1] * scale[1]
-            let z = mesh.vertices[i * 3 + 2] * scale[2]
-            
-            if (rotation) {
-              const [qx, qy, qz, qw] = rotation
-              const ix = qw * x + qy * z - qz * y
-              const iy = qw * y + qz * x - qx * z
-              const iz = qw * z + qx * y - qy * x
-              const iw = -qx * x - qy * y - qz * z
-              x = ix * qw - iw * qx - iy * qz + iz * qy
-              y = iy * qw - iw * qy - iz * qx + ix * qz
-              z = iz * qw - iw * qz - ix * qy + iy * qx
-            }
-            
-            vertices[i * 3] = x + translation[0]
-            vertices[i * 3 + 1] = y + translation[1]
-            vertices[i * 3 + 2] = z + translation[2]
-          }
-        }
-        
-        const triangles = new J.TriangleList(); triangles.resize(mesh.triangleCount)
-        for (let t = 0; t < mesh.triangleCount; t++) {
-          const tri = triangles.at(t)
-          for (let v = 0; v < 3; v++) {
-            const idx = mesh.indices[t * 3 + v]
-            tri.set_mV(v, new J.Float3(vertices[idx * 3], vertices[idx * 3 + 1], vertices[idx * 3 + 2]))
-          }
-        }
-        const shape = new J.MeshShapeSettings(triangles).Create().Get()
-        const id = this._addBody(shape, position, J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', mesh: mesh.name, triangles: mesh.triangleCount } })
-        resolve(id)
-      } catch (e) {
-        reject(e)
-      }
-    })
-  }
+  addStaticTrimeshAsync(glbPath, meshIndex = 0, position = [0, 0, 0]) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const J = this.Jolt
+        // Use combined extraction: all meshes + all primitives (handles Draco, multi-mesh maps)
+        const mesh = await extractAllMeshesFromGLBAsync(glbPath)
+        const { vertices, indices, triangleCount } = mesh
+
+        const triangles = new J.TriangleList(); triangles.resize(triangleCount)
+        // Reuse a single Float3 to avoid WASM heap growth from per-vertex allocations
+        const f3 = new J.Float3(0, 0, 0)
+        for (let t = 0; t < triangleCount; t++) {
+          const tri = triangles.at(t)
+          for (let v = 0; v < 3; v++) {
+            const idx = indices[t * 3 + v]
+            f3.x = vertices[idx * 3]; f3.y = vertices[idx * 3 + 1]; f3.z = vertices[idx * 3 + 2]
+            tri.set_mV(v, f3)
+          }
+        }
+        const settings = new J.MeshShapeSettings(triangles)
+        const shape = settings.Create().Get()
+        J.destroy(f3)
+        J.destroy(triangles)
+        J.destroy(settings)
+        const id = this._addBody(shape, position, J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', triangles: triangleCount } })
+        resolve(id)
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
   addPlayerCharacter(radius, halfHeight, position, mass) {
     const J = this.Jolt
     const cvs = new J.CharacterVirtualSettings()
@@ -232,9 +214,7 @@ export class PhysicsWorld {
   getCharacterPosition(charId) {
     const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
     const p = ch.GetPosition()
-    const r = [p.GetX(), p.GetY(), p.GetZ()]
-    this.Jolt.destroy(p)
-    return r
+    return [p.GetX(), p.GetY(), p.GetZ()]
   }
   getCharacterVelocity(charId) {
     const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
@@ -320,8 +300,8 @@ export class PhysicsWorld {
     const dir = len > 0 ? [direction[0] / len, direction[1] / len, direction[2] / len] : direction
     const ray = new J.RRayCast(new J.RVec3(origin[0], origin[1], origin[2]), new J.Vec3(dir[0] * maxDistance, dir[1] * maxDistance, dir[2] * maxDistance))
     const rs = new J.RayCastSettings(), col = new J.CastRayClosestHitCollisionCollector()
-    const bp = new J.DefaultBroadPhaseLayerFilter(this._ovbp)
-    const ol = new J.DefaultObjectLayerFilter(this._objFilter)
+    const bp = new J.DefaultBroadPhaseLayerFilter(this.jolt.GetObjectVsBroadPhaseLayerFilter(), LAYER_DYNAMIC)
+    const ol = new J.DefaultObjectLayerFilter(this.jolt.GetObjectLayerPairFilter(), LAYER_DYNAMIC)
     const eb = excludeBodyId != null ? this._getBody(excludeBodyId) : null
     const bf = eb ? new J.IgnoreSingleBodyFilter(eb.GetID()) : new J.BodyFilter()
     const sf = new J.ShapeFilter()
@@ -335,13 +315,25 @@ export class PhysicsWorld {
     return result
   }
   destroy() {
+    if (!this.Jolt) return
+    const J = this.Jolt
     if (this.characters) {
-      for (const [id, ch] of this.characters) {
-        this.Jolt.destroy(ch)
-      }
+      for (const ch of this.characters.values()) J.destroy(ch)
       this.characters.clear()
     }
+    if (this._charFilters) {
+      J.destroy(this._charFilters.bp)
+      J.destroy(this._charFilters.ol)
+      J.destroy(this._charFilters.body)
+      J.destroy(this._charFilters.shape)
+      this._charFilters = null
+    }
+    if (this._charUpdateSettings) { J.destroy(this._charUpdateSettings); this._charUpdateSettings = null }
+    if (this._charGravity) { J.destroy(this._charGravity); this._charGravity = null }
     for (const [id] of this.bodies) this.removeBody(id)
-    if (this.jolt) { this.Jolt.destroy(this.jolt); this.jolt = null }
+    if (this._tmpVec3) { J.destroy(this._tmpVec3); this._tmpVec3 = null }
+    if (this._tmpRVec3) { J.destroy(this._tmpRVec3); this._tmpRVec3 = null }
+    if (this.jolt) { J.destroy(this.jolt); this.jolt = null }
+    this.physicsSystem = null; this.bodyInterface = null
   }
 }

package/src/sdk/BotHarness.js

@@ -0,0 +1,87 @@
+import { WebSocket } from 'ws'
+import { pack, unpack } from '../protocol/msgpack.js'
+
+const CONFIG = {
+  botCount: 100,
+  durationMs: 60000,
+  inputHz: 60,
+  serverUrl: process.env.BOT_URL || 'ws://localhost:3001/ws',
+  batchSize: 10,
+  batchDelayMs: 200
+}
+
+const MSG_INPUT = 0x11
+const MSG_SNAPSHOT = 0x10
+
+function makeInput(botId, tick) {
+  const phase = (tick / 80 + botId * 0.37) % 1
+  return {
+    forward: phase < 0.7,
+    backward: phase > 0.85,
+    left: phase > 0.72 && phase < 0.82,
+    right: phase > 0.82 && phase < 0.85,
+    jump: tick % 200 === botId % 200,
+    sprint: tick % 400 < 300,
+    yaw: (botId / CONFIG.botCount) * Math.PI * 2 + Math.sin(tick / 180) * 0.8,
+    pitch: 0,
+    crouch: false,
+    interact: false
+  }
+}
+
+const stats = { connected: 0, snapshots: 0, errors: 0 }
+
+function createBot(botId) {
+  let tick = 0
+  let interval = null
+  const ws = new WebSocket(CONFIG.serverUrl)
+  ws.binaryType = 'arraybuffer'
+  ws.on('open', () => {
+    stats.connected++
+    interval = setInterval(() => {
+      if (ws.readyState !== WebSocket.OPEN) return
+      ws.send(pack({ type: MSG_INPUT, payload: makeInput(botId, ++tick) }))
+    }, 1000 / CONFIG.inputHz)
+  })
+  ws.on('message', data => {
+    try {
+      const msg = unpack(data instanceof ArrayBuffer ? new Uint8Array(data) : data)
+      if (msg?.type === MSG_SNAPSHOT) stats.snapshots++
+    } catch {}
+  })
+  ws.on('error', () => { stats.errors++ })
+  ws.on('close', () => { stats.connected--; if (interval) clearInterval(interval) })
+  return ws
+}
+
+async function sleep(ms) { return new Promise(r => setTimeout(r, ms)) }
+
+async function main() {
+  const start = Date.now()
+  console.log(`[BotHarness] Connecting ${CONFIG.botCount} bots → ${CONFIG.serverUrl}`)
+  const bots = []
+  for (let i = 0; i < CONFIG.botCount; i += CONFIG.batchSize) {
+    const end = Math.min(i + CONFIG.batchSize, CONFIG.botCount)
+    for (let j = i; j < end; j++) bots.push(createBot(j))
+    await sleep(CONFIG.batchDelayMs)
+  }
+  await sleep(2000)
+  console.log(`[BotHarness] ${stats.connected}/${CONFIG.botCount} connected, running ${CONFIG.durationMs / 1000}s`)
+  const reportInterval = setInterval(() => {
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1)
+    const rate = (stats.snapshots / parseFloat(elapsed)).toFixed(0)
+    console.log(`[BotHarness] t=${elapsed}s conn=${stats.connected} snaps=${stats.snapshots} (${rate}/s) err=${stats.errors}`)
+  }, 5000)
+  await sleep(CONFIG.durationMs)
+  clearInterval(reportInterval)
+  const elapsed = (Date.now() - start) / 1000
+  const perBotPerSec = (stats.snapshots / CONFIG.botCount / elapsed).toFixed(2)
+  console.log(`\n[BotHarness] ── FINAL ──`)
+  console.log(`[BotHarness] Duration: ${elapsed.toFixed(1)}s | Connected: ${stats.connected}/${CONFIG.botCount}`)
+  console.log(`[BotHarness] Snapshots: ${stats.snapshots} total | ${perBotPerSec}/bot/sec | Errors: ${stats.errors}`)
+  for (const ws of bots) if (ws.readyState === WebSocket.OPEN) ws.close()
+  await sleep(500)
+  process.exit(0)
+}
+
+main().catch(e => { console.error('[BotHarness] fatal:', e); process.exit(1) })

package/src/sdk/TickHandler.js

@@ -1,8 +1,11 @@
 import { MSG } from '../protocol/MessageTypes.js'
 import { SnapshotEncoder } from '../netcode/SnapshotEncoder.js'
+import { pack } from '../protocol/msgpack.js'
+import { isUnreliable } from '../protocol/MessageTypes.js'
 import { applyMovement as _applyMovement, DEFAULT_MOVEMENT as _DEFAULT_MOVEMENT } from '../shared/movement.js'
 
 const KEYFRAME_INTERVAL = 128
+const SNAP_GROUPS = 4
 
 export function createTickHandler(deps) {
   const {
@@ -13,23 +16,20 @@ export function createTickHandler(deps) {
   const applyMovement = _movement?.applyMovement || _applyMovement
   const DEFAULT_MOVEMENT = _movement?.DEFAULT_MOVEMENT || _DEFAULT_MOVEMENT
   const movement = { ...DEFAULT_MOVEMENT, ...m }
-  const collisionRestitution = movement.collisionRestitution || 0.2
-  const collisionDamping = movement.collisionDamping || 0.25
   let snapshotSeq = 0
-
   const playerEntityMaps = new Map()
   let broadcastEntityMap = new Map()
-
   let profileLog = 0
-  const separated = new Set()
+  const snapUnreliable = isUnreliable(MSG.SNAPSHOT)
+
   return function onTick(tick, dt) {
     const t0 = performance.now()
     networkState.setTick(tick, Date.now())
     const players = playerManager.getConnectedPlayers()
+
     for (const player of players) {
       const inputs = playerManager.getInputs(player.id)
       const st = player.state
-
       if (inputs.length > 0) {
         player.lastInput = inputs[inputs.length - 1].data
         playerManager.clearInputs(player.id)
@@ -37,12 +37,14 @@ export function createTickHandler(deps) {
       const inp = player.lastInput || null
       if (inp) {
         const yaw = inp.yaw || 0
-        st.rotation = [0, Math.sin(yaw / 2), 0, Math.cos(yaw / 2)]
+        st.rotation[0] = 0
+        st.rotation[1] = Math.sin(yaw / 2)
+        st.rotation[2] = 0
+        st.rotation[3] = Math.cos(yaw / 2)
         st.crouch = inp.crouch ? 1 : 0
         st.lookPitch = inp.pitch || 0
         st.lookYaw = yaw
       }
-
       applyMovement(st, inp, movement, dt)
       if (inp) physicsIntegration.setCrouch(player.id, !!inp.crouch)
       const wishedVx = st.velocity[0], wishedVz = st.velocity[2]
@@ -60,83 +62,95 @@ export function createTickHandler(deps) {
         crouch: st.crouch || 0, lookPitch: st.lookPitch || 0, lookYaw: st.lookYaw || 0
       })
     }
+
     const t1 = performance.now()
-    separated.clear()
+    const cellSz = physicsIntegration.config.capsuleRadius * 8
+    const minDist = physicsIntegration.config.capsuleRadius * 2
+    const minDist2 = minDist * minDist
+    const grid = new Map()
+    for (const p of players) {
+      const cx = Math.floor(p.state.position[0] / cellSz)
+      const cz = Math.floor(p.state.position[2] / cellSz)
+      const ck = cx * 65536 + cz
+      let cell = grid.get(ck)
+      if (!cell) { cell = []; grid.set(ck, cell) }
+      cell.push(p)
+    }
     for (const player of players) {
-      const collisions = physicsIntegration.checkCollisionWithOthers(player.id, players)
-      for (const collision of collisions) {
-        const pairKey = player.id < collision.playerId ? `${player.id}-${collision.playerId}` : `${collision.playerId}-${player.id}`
-        if (separated.has(pairKey)) continue
-        separated.add(pairKey)
-        const other = playerManager.getPlayer(collision.playerId)
-        if (!other) continue
-        const nx = collision.normal[0], nz = collision.normal[2]
-        const minDist = physicsIntegration.config.capsuleRadius * 2
-        const overlap = minDist - collision.distance
-        const halfPush = overlap * 0.5
-        const pushVel = Math.min(halfPush / dt, 3.0)
-        player.state.position[0] -= nx * halfPush
-        player.state.position[2] -= nz * halfPush
-        player.state.velocity[0] -= nx * pushVel
-        player.state.velocity[2] -= nz * pushVel
-        other.state.position[0] += nx * halfPush
-        other.state.position[2] += nz * halfPush
-        other.state.velocity[0] += nx * pushVel
-        other.state.velocity[2] += nz * pushVel
-        physicsIntegration.setPlayerPosition(player.id, player.state.position)
-        physicsIntegration.setPlayerPosition(other.id, other.state.position)
+      const px = player.state.position[0], py = player.state.position[1], pz = player.state.position[2]
+      const cx = Math.floor(px / cellSz), cz = Math.floor(pz / cellSz)
+      for (let ddx = -1; ddx <= 1; ddx++) {
+        for (let ddz = -1; ddz <= 1; ddz++) {
+          const neighbors = grid.get((cx + ddx) * 65536 + (cz + ddz))
+          if (!neighbors) continue
+          for (const other of neighbors) {
+            if (other.id <= player.id) continue
+            const ox = other.state.position[0], oy = other.state.position[1], oz = other.state.position[2]
+            const dx = ox - px, dy = oy - py, dz = oz - pz
+            const dist2 = dx * dx + dy * dy + dz * dz
+            if (dist2 >= minDist2 || dist2 === 0) continue
+            const distance = Math.sqrt(dist2)
+            const nx = dx / distance, nz = dz / distance
+            const overlap = minDist - distance
+            const halfPush = overlap * 0.5
+            const pushVel = Math.min(halfPush / dt, 3.0)
+            player.state.position[0] -= nx * halfPush
+            player.state.position[2] -= nz * halfPush
+            player.state.velocity[0] -= nx * pushVel
+            player.state.velocity[2] -= nz * pushVel
+            other.state.position[0] += nx * halfPush
+            other.state.position[2] += nz * halfPush
+            other.state.velocity[0] += nx * pushVel
+            other.state.velocity[2] += nz * pushVel
+            physicsIntegration.setPlayerPosition(player.id, player.state.position)
+            physicsIntegration.setPlayerPosition(other.id, other.state.position)
+          }
+        }
       }
     }
+
     const t2 = performance.now()
     physics.step(dt)
     const t3 = performance.now()
     appRuntime.tick(tick, dt)
     const t4 = performance.now()
+
     if (players.length > 0) {
       const playerSnap = networkState.getSnapshot()
       snapshotSeq++
       const isKeyframe = snapshotSeq % KEYFRAME_INTERVAL === 0
+      const curGroup = tick % SNAP_GROUPS
+
       if (stageLoader && stageLoader.getActiveStage()) {
+        const relevanceRadius = stageLoader.getActiveStage().spatial.relevanceRadius
         for (const player of players) {
-          const pos = player.state.position
-          const entitySnap = appRuntime.getSnapshotForPlayer(pos, stageLoader.getActiveStage().spatial.relevanceRadius)
+          if (!isKeyframe && player.id % SNAP_GROUPS !== curGroup) continue
+          const entitySnap = appRuntime.getSnapshotForPlayer(player.state.position, relevanceRadius)
           const combined = { tick: playerSnap.tick, timestamp: playerSnap.timestamp, players: playerSnap.players, entities: entitySnap.entities }
-          if (isKeyframe || !playerEntityMaps.has(player.id)) {
-            const encoded = SnapshotEncoder.encode(combined)
-            const { entityMap } = SnapshotEncoder.encodeDelta(combined, new Map())
-            playerEntityMaps.set(player.id, entityMap)
-            connections.send(player.id, MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
-          } else {
-            const prevMap = playerEntityMaps.get(player.id)
-            const { encoded, entityMap } = SnapshotEncoder.encodeDelta(combined, prevMap)
-            playerEntityMaps.set(player.id, entityMap)
-            connections.send(player.id, MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
-          }
+          const prevMap = (isKeyframe || !playerEntityMaps.has(player.id)) ? new Map() : playerEntityMaps.get(player.id)
+          const { encoded, entityMap } = SnapshotEncoder.encodeDelta(combined, prevMap)
+          playerEntityMaps.set(player.id, entityMap)
+          connections.send(player.id, MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
         }
       } else {
         const entitySnap = appRuntime.getSnapshot()
         const combined = { tick: playerSnap.tick, timestamp: playerSnap.timestamp, players: playerSnap.players, entities: entitySnap.entities }
-        if (isKeyframe || broadcastEntityMap.size === 0) {
-          const encoded = SnapshotEncoder.encode(combined)
-          const { entityMap } = SnapshotEncoder.encodeDelta(combined, new Map())
-          broadcastEntityMap = entityMap
-          connections.broadcast(MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
-        } else {
-          const { encoded, entityMap } = SnapshotEncoder.encodeDelta(combined, broadcastEntityMap)
-          broadcastEntityMap = entityMap
-          connections.broadcast(MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
+        const prevMap = (isKeyframe || broadcastEntityMap.size === 0) ? new Map() : broadcastEntityMap
+        const { encoded, entityMap } = SnapshotEncoder.encodeDelta(combined, prevMap)
+        broadcastEntityMap = entityMap
+        const data = pack({ type: MSG.SNAPSHOT, payload: { seq: snapshotSeq, ...encoded } })
+        for (const player of players) {
+          if (!isKeyframe && player.id % SNAP_GROUPS !== curGroup) continue
+          connections.sendPacked(player.id, data, snapUnreliable)
         }
       }
     }
+
     for (const id of playerEntityMaps.keys()) {
       if (!playerManager.getPlayer(id)) playerEntityMaps.delete(id)
     }
     const t5 = performance.now()
-    try {
-      appRuntime._drainReloadQueue()
-    } catch (e) {
-      console.error('[TickHandler] reload queue error:', e.message)
-    }
+    try { appRuntime._drainReloadQueue() } catch (e) { console.error('[TickHandler] reload queue error:', e.message) }
     profileLog++
     if (profileLog % 1280 === 0) {
       const total = t5 - t0
@@ -145,7 +159,7 @@ export function createTickHandler(deps) {
       const rss = (mem.rss / 1048576).toFixed(1)
       const ext = (mem.external / 1048576).toFixed(1)
       const ab = (mem.arrayBuffers / 1048576).toFixed(1)
-      try { console.log(`[tick-profile] tick:${tick} players:${players.length} total:${total.toFixed(2)}ms | mv:${(t1-t0).toFixed(2)} col:${(t2-t1).toFixed(2)} phys:${(t3-t2).toFixed(2)} app:${(t4-t3).toFixed(2)} snap:${(t5-t4).toFixed(2)} | heap:${heap}MB rss:${rss}MB ext:${ext}MB ab:${ab}MB`) } catch (_) {}
+      try { console.log(`[tick-profile] tick:${tick} players:${players.length} total:${total.toFixed(2)}ms | mv:${(t1 - t0).toFixed(2)} col:${(t2 - t1).toFixed(2)} phys:${(t3 - t2).toFixed(2)} app:${(t4 - t3).toFixed(2)} snap:${(t5 - t4).toFixed(2)} | heap:${heap}MB rss:${rss}MB ext:${ext}MB ab:${ab}MB`) } catch (_) {}
     }
   }
 }