spoint 0.1.81 → 0.1.83

package/apps/world/index.js

@@ -2,6 +2,7 @@ export default {
   port: 3001,
   tickRate: 128,
   gravity: [0, -9.81, 0],
+  relevanceRadius: 150,
   movement: {
     maxSpeed: 4.0,
     groundAccel: 10.0,
@@ -58,8 +59,19 @@ export default {
     fadeTime: 0.15
   },
   entities: [
-    { id: 'environment', model: './apps/tps-game/schwust.glb', position: [0, 0, 0], app: 'environment' }
+    { id: 'env-schwust',   model: './apps/tps-game/schwust.glb',          position: [0,   0, 0], app: 'environment' },
+    { id: 'env-kosova',    model: './apps/maps/aim_kosova_ak47.glb',       position: [200, 0, 0], app: 'environment' },
+    { id: 'env-sillos',    model: './apps/maps/aim_sillos.glb',            position: [400, 0, 0], app: 'environment' },
+    { id: 'env-dust2',     model: './apps/maps/de_dust2_kosovo.glb',       position: [600, 0, 0], app: 'environment' },
+    { id: 'env-gash',      model: './apps/maps/de_gash.glb',               position: [800, 0, 0], app: 'environment' }
   ],
-  playerModel: './apps/tps-game/cleetus.vrm',
-  spawnPoint: [-30, 7.6, -30]
+  spawnPoints: [
+    [-30,  20, -30],
+    [212,  20,  12],
+    [412,  20,  12],
+    [612,  20,  12],
+    [812,  20,  12]
+  ],
+  spawnPoint: [-30, 20, -30],
+  playerModel: './apps/tps-game/cleetus.vrm'
 }

package/package.json

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

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/sdk/BotHarness.js

@@ -0,0 +1,87 @@
+import { WebSocket } from 'ws'
+import { pack, unpack } from '../protocol/msgpack.js'
+
+const CONFIG = {
+  botCount: parseInt(process.env.BOT_COUNT || '100'),
+  durationMs: parseInt(process.env.BOT_DURATION || '60000'),
+  inputHz: parseInt(process.env.BOT_HZ || '60'),
+  serverUrl: process.env.BOT_URL || 'ws://localhost:3001/ws',
+  batchSize: parseInt(process.env.BOT_BATCH || '20'),
+  batchDelayMs: parseInt(process.env.BOT_DELAY || '100')
+}
+
+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/ServerAPI.js

@@ -33,7 +33,9 @@ export function createServerAPI(ctx) {
 
     async loadWorld(worldDef) {
       ctx.currentWorldDef = worldDef
-      if (worldDef.spawnPoint) ctx.worldSpawnPoint = [...worldDef.spawnPoint]
+      if (worldDef.spawnPoints?.length) ctx.worldSpawnPoints = worldDef.spawnPoints
+      else if (worldDef.spawnPoint) ctx.worldSpawnPoints = [worldDef.spawnPoint]
+      ctx.worldSpawnPoint = ctx.worldSpawnPoints?.[0] || worldDef.spawnPoint || [0, 5, 0]
       await appLoader.loadAll()
       const stage = stageLoader.loadFromDefinition('main', worldDef)
       return { entities: new Map(), apps: new Map(), count: stage.entityCount }

package/src/sdk/ServerHandlers.js

@@ -5,7 +5,8 @@ export function createConnectionHandlers(ctx) {
   const { tickSystem, playerManager, networkState, lagCompensator, physicsIntegration, connections, sessions, appLoader, appRuntime, emitter, inspector } = ctx
 
   function onClientConnect(transport) {
-    const sp = [...ctx.worldSpawnPoint]
+    const spawnPoints = ctx.worldSpawnPoints || [ctx.worldSpawnPoint]
+    const sp = [...spawnPoints[Math.floor(Math.random() * spawnPoints.length)]]
     const playerConfig = ctx.currentWorldDef?.player || {}
     const playerId = playerManager.addPlayer(transport, { position: sp, health: playerConfig.health })
     networkState.addPlayer(playerId, { position: sp })

package/src/sdk/TickHandler.js

@@ -1,35 +1,35 @@
 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 MAX_SENDS_PER_TICK = 25
 
 export function createTickHandler(deps) {
   const {
     networkState, playerManager, physicsIntegration,
     lagCompensator, physics, appRuntime, connections,
-    movement: m = {}, stageLoader, eventLog, _movement
+    movement: m = {}, stageLoader, eventLog, _movement, getRelevanceRadius
   } = 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,82 +62,98 @@ 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
-      if (stageLoader && stageLoader.getActiveStage()) {
+      const snapGroups = Math.max(1, Math.ceil(players.length / MAX_SENDS_PER_TICK))
+      const curGroup = tick % snapGroups
+
+      const relevanceRadius = (stageLoader && stageLoader.getActiveStage())
+        ? stageLoader.getActiveStage().spatial.relevanceRadius
+        : (getRelevanceRadius ? getRelevanceRadius() : 0)
+      if (relevanceRadius > 0) {
         for (const player of players) {
-          const pos = player.state.position
-          const entitySnap = appRuntime.getSnapshotForPlayer(pos, stageLoader.getActiveStage().spatial.relevanceRadius)
+          if (!isKeyframe && player.id % snapGroups !== 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, 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 % snapGroups !== 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
@@ -144,7 +162,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 (_) {}
     }
   }
 }

package/src/sdk/server.js

@@ -171,7 +171,8 @@ export async function createServer(config = {}) {
     connections,
     movement,
     stageLoader,
-    eventLog
+    eventLog,
+    getRelevanceRadius: () => ctx.currentWorldDef?.relevanceRadius || 0
   }))
 
   const { onClientConnect } = createConnectionHandlers(ctx)