spoint 0.1.0 → 0.1.10

package/src/connection/SessionStore.js

@@ -13,7 +13,8 @@ export class SessionStore {
       token,
       playerId,
       state: state ? { ...state } : {},
-      createdAt: Date.now()
+      createdAt: Date.now(),
+      lastTouched: Date.now()
     }
     this.sessions.set(token, session)
     this._setupExpire(token)
@@ -24,17 +25,20 @@ export class SessionStore {
     const session = this.sessions.get(token)
     if (!session) return false
     if (data.state) Object.assign(session.state, data.state)
-    session.lastUpdated = Date.now()
+    session.lastTouched = Date.now()
+    this._refreshExpire(token)
     return true
   }
 
   get(token) {
     const session = this.sessions.get(token)
     if (!session) return null
-    if (Date.now() - session.createdAt > this.ttl) {
+    if (Date.now() - session.lastTouched > this.ttl) {
       this.destroy(token)
       return null
     }
+    session.lastTouched = Date.now()
+    this._refreshExpire(token)
     return session
   }
 
@@ -46,6 +50,12 @@ export class SessionStore {
     this.timers.set(token, timer)
   }
 
+  _refreshExpire(token) {
+    const old = this.timers.get(token)
+    if (old) clearTimeout(old)
+    this._setupExpire(token)
+  }
+
   destroy(token) {
     const timer = this.timers.get(token)
     if (timer) clearTimeout(timer)

package/src/index.client.js

@@ -1,8 +1,6 @@
 export { InputHandler } from './client/InputHandler.js'
 export { PhysicsNetworkClient } from './client/PhysicsNetworkClient.js'
-export { PredictionEngine } from './client/PredictionEngine.js'
-export { ReconciliationEngine } from './client/ReconciliationEngine.js'
-
-export { MSG, msgName, DISCONNECT_REASONS, CONNECTION_QUALITY, UNRELIABLE_MSGS, isUnreliable } from './protocol/MessageTypes.js'
-export { Codec } from './protocol/Codec.js'
-export { SequenceTracker } from './protocol/SequenceTracker.js'
+export { MSG } from './protocol/MessageTypes.js'
+export { KalmanFilter3D, SmoothStateTracker } from './client/KalmanFilter.js'
+export { JitterBuffer } from './client/JitterBuffer.js'
+export { SmoothInterpolation } from './client/SmoothInterpolation.js'

package/src/netcode/EventLog.js

@@ -1,7 +1,9 @@
 export class EventLog {
   constructor(config = {}) {
-    this._log = []
-    this._maxSize = config.maxSize || 100000
+    this._maxSize = config.maxSize || 1000
+    this._buf = new Array(this._maxSize)
+    this._head = 0
+    this._count = 0
     this._nextId = 1
     this._recording = true
   }
@@ -16,13 +18,19 @@ export class EventLog {
       data,
       meta: { actor: meta.actor || null, reason: meta.reason || null, context: meta.context || null, sourceApp: meta.sourceApp || null, sourceEntity: meta.sourceEntity || null, causalEventId: meta.causalEventId || null, ...meta }
     }
-    this._log.push(event)
-    if (this._log.length > this._maxSize) this._log.shift()
+    this._buf[this._head] = event
+    this._head = (this._head + 1) % this._maxSize
+    if (this._count < this._maxSize) this._count++
     return event
   }
 
+  _toArray() {
+    if (this._count < this._maxSize) return this._buf.slice(0, this._count)
+    return [...this._buf.slice(this._head), ...this._buf.slice(0, this._head)]
+  }
+
   query(filter = {}) {
-    return this._log.filter(e => {
+    return this._toArray().filter(e => {
       if (filter.type && e.type !== filter.type) return false
       if (filter.tick !== undefined && e.tick !== filter.tick) return false
       if (filter.tickRange && (e.tick < filter.tickRange[0] || e.tick > filter.tickRange[1])) return false
@@ -34,30 +42,36 @@ export class EventLog {
   }
 
   getRange(startTick, endTick) {
-    return this._log.filter(e => e.tick >= startTick && e.tick <= endTick)
+    return this._toArray().filter(e => e.tick >= startTick && e.tick <= endTick)
   }
 
-  get size() { return this._log.length }
-  get lastTick() { return this._log.length > 0 ? this._log[this._log.length - 1].tick : 0 }
+  get size() { return this._count }
+  get lastTick() {
+    if (this._count === 0) return 0
+    const idx = (this._head - 1 + this._maxSize) % this._maxSize
+    return this._buf[idx].tick
+  }
 
   pause() { this._recording = false }
   resume() { this._recording = true }
-  clear() { this._log = []; this._nextId = 1 }
+  clear() { this._buf = new Array(this._maxSize); this._head = 0; this._count = 0; this._nextId = 1 }
 
-  serialize() { return JSON.stringify(this._log) }
+  serialize() { return JSON.stringify(this._toArray()) }
 
   static deserialize(json) {
-    const log = new EventLog()
-    log._log = JSON.parse(json)
-    log._nextId = log._log.length > 0 ? log._log[log._log.length - 1].id + 1 : 1
+    const arr = JSON.parse(json)
+    const log = new EventLog({ maxSize: Math.max(arr.length, 1000) })
+    for (const e of arr) log._buf[log._head++] = e
+    log._count = arr.length
+    log._head = log._head % log._maxSize
+    log._nextId = arr.length > 0 ? arr[arr.length - 1].id + 1 : 1
     return log
   }
 
   replay(runtime, options = {}) {
-    const speed = options.speed || 1
     const startTick = options.startTick || 0
     const endTick = options.endTick || Infinity
-    const events = this._log.filter(e => e.tick >= startTick && e.tick <= endTick)
+    const events = this._toArray().filter(e => e.tick >= startTick && e.tick <= endTick)
     const result = { eventsReplayed: 0, errors: [] }
     for (const event of events) {
       try {

package/src/netcode/LagCompensator.js

@@ -6,37 +6,37 @@ export class LagCompensator {
 
   recordPlayerPosition(playerId, position, rotation, velocity, tick) {
     if (!this.playerHistory.has(playerId)) {
-      this.playerHistory.set(playerId, [])
+      this.playerHistory.set(playerId, { buf: new Array(128), head: 0, len: 0 })
     }
 
-    const history = this.playerHistory.get(playerId)
-    history.push({
-      tick,
-      timestamp: Date.now(),
-      position: [...position],
-      rotation: [...rotation],
-      velocity: [...velocity]
-    })
+    const ring = this.playerHistory.get(playerId)
+    const idx = (ring.head + ring.len) % 128
+    if (!ring.buf[idx]) ring.buf[idx] = { tick: 0, timestamp: 0, position: [0,0,0], rotation: [0,0,0,1], velocity: [0,0,0] }
+    const entry = ring.buf[idx]
+    entry.tick = tick; entry.timestamp = Date.now()
+    entry.position[0] = position[0]; entry.position[1] = position[1]; entry.position[2] = position[2]
+    entry.rotation[0] = rotation[0]; entry.rotation[1] = rotation[1]; entry.rotation[2] = rotation[2]; entry.rotation[3] = rotation[3]
+    entry.velocity[0] = velocity[0]; entry.velocity[1] = velocity[1]; entry.velocity[2] = velocity[2]
+    if (ring.len < 128) ring.len++
+    else ring.head = (ring.head + 1) % 128
 
     const cutoff = Date.now() - this.historyWindow
-    while (history.length > 0 && history[0].timestamp < cutoff) {
-      history.shift()
+    while (ring.len > 0 && ring.buf[ring.head].timestamp < cutoff) {
+      ring.head = (ring.head + 1) % 128; ring.len--
     }
   }
 
   getPlayerStateAtTime(playerId, millisAgo) {
-    const history = this.playerHistory.get(playerId)
-    if (!history || history.length === 0) return null
+    const ring = this.playerHistory.get(playerId)
+    if (!ring || ring.len === 0) return null
 
     const targetTime = Date.now() - millisAgo
     let best = null
 
-    for (const state of history) {
-      if (state.timestamp <= targetTime) {
-        best = state
-      } else {
-        break
-      }
+    for (let i = 0; i < ring.len; i++) {
+      const entry = ring.buf[(ring.head + i) % 128]
+      if (entry.timestamp <= targetTime) best = entry
+      else break
     }
 
     return best
@@ -56,10 +56,10 @@ export class LagCompensator {
   }
 
   detectTeleport(playerId, newPosition, threshold = 50) {
-    const history = this.playerHistory.get(playerId)
-    if (!history || history.length < 2) return false
+    const ring = this.playerHistory.get(playerId)
+    if (!ring || ring.len < 2) return false
 
-    const lastPos = history[history.length - 1].position
+    const lastPos = ring.buf[(ring.head + ring.len - 1) % 128].position
     const dist = Math.sqrt((newPosition[0] - lastPos[0])**2 + (newPosition[1] - lastPos[1])**2 + (newPosition[2] - lastPos[2])**2)
 
     return dist > threshold
@@ -70,9 +70,8 @@ export class LagCompensator {
   }
 
   getStats() {
-    return {
-      trackedPlayers: this.playerHistory.size,
-      totalSamples: Array.from(this.playerHistory.values()).reduce((sum, h) => sum + h.length, 0)
-    }
+    let total = 0
+    for (const ring of this.playerHistory.values()) total += ring.len
+    return { trackedPlayers: this.playerHistory.size, totalSamples: total }
   }
 }

package/src/netcode/NetworkState.js

@@ -50,7 +50,10 @@ export class NetworkState {
         velocity: p.velocity,
         onGround: p.onGround,
         health: p.health,
-        inputSequence: p.inputSequence
+        inputSequence: p.inputSequence,
+        crouch: p.crouch || 0,
+        lookPitch: p.lookPitch || 0,
+        lookYaw: p.lookYaw || 0
       }))
     }
   }

package/src/netcode/PhysicsIntegration.js

@@ -5,21 +5,26 @@ export class PhysicsIntegration {
       gravity: config.gravity || [0, -9.81, 0],
       capsuleRadius: config.capsuleRadius || 0.4,
       capsuleHalfHeight: config.capsuleHalfHeight || 0.9,
-      playerMass: config.playerMass || 160,
+      crouchHalfHeight: config.crouchHalfHeight || 0.45,
+      playerMass: config.playerMass || 120,
       ...config
     }
     this.playerBodies = new Map()
+    this._crouchStates = new Map()
   }
 
   setPhysicsWorld(world) {
     this.physicsWorld = world
   }
 
-  addPlayerCollider(playerId, radius = 0.4) {
-    if (!this.physicsWorld) {
-      this.playerBodies.set(playerId, { id: playerId, charId: null, onGround: true })
-      return
-    }
+  addPlayerCollider(playerId, radius = 0.4) {
+    if (this.playerBodies.has(playerId)) {
+      this.removePlayerCollider(playerId)
+    }
+    if (!this.physicsWorld) {
+      this.playerBodies.set(playerId, { id: playerId, charId: null, onGround: true })
+      return
+    }
     const charId = this.physicsWorld.addPlayerCharacter(
       radius,
       this.config.capsuleHalfHeight,
@@ -129,4 +134,13 @@ export class PhysicsIntegration {
     if (distance > 2.0) return { valid: false, reason: 'move_too_far', distance }
     return { valid: true }
   }
+
+  setCrouch(playerId, isCrouching) {
+    const data = this.playerBodies.get(playerId)
+    if (!data?.charId || !this.physicsWorld) return
+    const currentState = this._crouchStates.get(playerId)
+    if (currentState === isCrouching) return
+    this.physicsWorld.setCharacterCrouch(data.charId, isCrouching)
+    this._crouchStates.set(playerId, isCrouching)
+  }
 }

package/src/netcode/PlayerManager.js

@@ -3,6 +3,9 @@ export class PlayerManager {
     this.players = new Map()
     this.nextPlayerId = 1
     this.inputBuffers = new Map()
+    this._connectedCache = null
+    this._connectedGen = 0
+    this._cachedGen = -1
   }
 
   addPlayer(socket, initialState = {}) {
@@ -17,7 +20,7 @@ export class PlayerManager {
         velocity: initialState.velocity || [0, 0, 0],
         angularVelocity: initialState.angularVelocity || [0, 0, 0],
         onGround: true,
-        health: 100
+        health: initialState.health ?? 100
       },
       inputSequence: 0,
       lastInputTime: 0,
@@ -26,12 +29,14 @@ export class PlayerManager {
     }
     this.players.set(playerId, player)
     this.inputBuffers.set(playerId, [])
+    this._connectedGen++
     return playerId
   }
 
   removePlayer(playerId) {
     this.players.delete(playerId)
     this.inputBuffers.delete(playerId)
+    this._connectedGen++
   }
 
   getPlayer(playerId) {
@@ -43,7 +48,10 @@ export class PlayerManager {
   }
 
   getConnectedPlayers() {
-    return this.getAllPlayers().filter(p => p.connected)
+    if (this._cachedGen === this._connectedGen) return this._connectedCache
+    this._connectedCache = this.getAllPlayers().filter(p => p.connected)
+    this._cachedGen = this._connectedGen
+    return this._connectedCache
   }
 
   getPlayerCount() {

package/src/netcode/SnapshotEncoder.js

@@ -2,28 +2,72 @@ function quantize(v, precision) {
   return Math.round(v * precision) / precision
 }
 
+function encodePlayer(p) {
+  return [
+    p.id,
+    quantize(p.position[0], 100), quantize(p.position[1], 100), quantize(p.position[2], 100),
+    quantize(p.rotation[0], 10000), quantize(p.rotation[1], 10000), quantize(p.rotation[2], 10000), quantize(p.rotation[3], 10000),
+    quantize(p.velocity[0], 100), quantize(p.velocity[1], 100), quantize(p.velocity[2], 100),
+    p.onGround ? 1 : 0,
+    Math.round(p.health || 0),
+    p.inputSequence || 0,
+    p.crouch || 0,
+    Math.round(((p.lookPitch || 0) + Math.PI) / (2 * Math.PI) * 255),
+    Math.round(((p.lookYaw || 0) % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI) / (2 * Math.PI) * 255)
+  ]
+}
+
+function encodeEntity(e) {
+  return [
+    e.id,
+    e.model || '',
+    quantize(e.position[0], 100), quantize(e.position[1], 100), quantize(e.position[2], 100),
+    quantize(e.rotation[0], 10000), quantize(e.rotation[1], 10000), quantize(e.rotation[2], 10000), quantize(e.rotation[3], 10000),
+    e.bodyType || 'static',
+    e.custom || null
+  ]
+}
+
+function entityKey(encoded) {
+  let k = ''
+  for (let i = 1; i < encoded.length; i++) {
+    const v = encoded[i]
+    k += v === null ? 'N' : typeof v === 'object' ? JSON.stringify(v) : v
+    k += '|'
+  }
+  return k
+}
+
 export class SnapshotEncoder {
   static encode(snapshot) {
-    const players = (snapshot.players || []).map(p => [
-      p.id,
-      quantize(p.position[0], 100), quantize(p.position[1], 100), quantize(p.position[2], 100),
-      quantize(p.rotation[0], 10000), quantize(p.rotation[1], 10000), quantize(p.rotation[2], 10000), quantize(p.rotation[3], 10000),
-      quantize(p.velocity[0], 100), quantize(p.velocity[1], 100), quantize(p.velocity[2], 100),
-      p.onGround ? 1 : 0,
-      Math.round(p.health || 0),
-      p.inputSequence || 0
-    ])
-    const entities = (snapshot.entities || []).map(e => [
-      e.id,
-      e.model || '',
-      quantize(e.position[0], 100), quantize(e.position[1], 100), quantize(e.position[2], 100),
-      quantize(e.rotation[0], 10000), quantize(e.rotation[1], 10000), quantize(e.rotation[2], 10000), quantize(e.rotation[3], 10000),
-      e.bodyType || 'static',
-      e.custom || null
-    ])
+    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()
+    const entities = []
+    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)
+    }
+    const removed = []
+    for (const id of prevEntityMap.keys()) {
+      if (!currentIds.has(id)) removed.push(id)
+    }
+    return {
+      encoded: { tick: snapshot.tick || 0, timestamp: snapshot.timestamp || 0, players, entities, removed: removed.length ? removed : undefined, delta: 1 },
+      entityMap: nextMap
+    }
+  }
+
   static decode(data) {
     if (data.players && Array.isArray(data.players)) {
       const players = data.players.map(p => {
@@ -31,7 +75,10 @@ export class SnapshotEncoder {
           id: p[0], position: [p[1], p[2], p[3]],
           rotation: [p[4], p[5], p[6], p[7]],
           velocity: [p[8], p[9], p[10]],
-          onGround: p[11] === 1, health: p[12], inputSequence: p[13]
+          onGround: p[11] === 1, health: p[12], inputSequence: p[13],
+          crouch: p[14] || 0,
+          lookPitch: (p[15] || 0) / 255 * 2 * Math.PI - Math.PI,
+          lookYaw: (p[16] || 0) / 255 * 2 * Math.PI
         }
         return p
       })
@@ -42,7 +89,7 @@ export class SnapshotEncoder {
         }
         return e
       })
-      return { tick: data.tick, timestamp: data.timestamp, players, entities }
+      return { tick: data.tick, timestamp: data.timestamp, players, entities, delta: data.delta, removed: data.removed }
     }
     return data
   }

package/src/netcode/TickSystem.js

@@ -25,11 +25,13 @@ export class TickSystem {
   loop() {
     if (!this.running) return
     const now = Date.now()
-    const elapsed = now - this.lastTickTime
-    if (elapsed >= this.tickDuration && !this._reloadLocked) {
+    let elapsed = now - this.lastTickTime
+    let steps = 0
+    const maxSteps = 4
+    while (elapsed >= this.tickDuration && !this._reloadLocked && steps < maxSteps) {
       this._tickInProgress = true
       this.currentTick++
-      this.lastTickTime = now
+      this.lastTickTime += this.tickDuration
       for (const callback of this.callbacks) {
         callback(this.currentTick, this.tickDuration / 1000)
       }
@@ -38,8 +40,15 @@ export class TickSystem {
         this._reloadResolve()
         this._reloadResolve = null
       }
+      elapsed = now - this.lastTickTime
+      steps++
+    }
+    if (now - this.lastTickTime > this.tickDuration * maxSteps) {
+      this.lastTickTime = now
     }
-    setImmediate(() => this.loop())
+    const gap = this.tickDuration - (Date.now() - this.lastTickTime)
+    if (gap > 2) setTimeout(() => this.loop(), 1)
+    else setImmediate(() => this.loop())
   }
 
   pauseForReload() {

package/src/physics/World.js

@@ -6,9 +6,11 @@ async function getJolt() { if (!joltInstance) joltInstance = await initJolt(); r
 export class PhysicsWorld {
   constructor(config = {}) {
     this.gravity = config.gravity || [0, -9.81, 0]
+    this.crouchHalfHeight = config.crouchHalfHeight || 0.45
     this.Jolt = null; this.jolt = null; this.physicsSystem = null; this.bodyInterface = null
     this.bodies = new Map(); this.bodyMeta = new Map()
     this._objFilter = null; this._ovbp = null
+    this._charShapes = new Map()
   }
   async init() {
     const J = await getJolt()
@@ -99,12 +101,29 @@ export class PhysicsWorld {
       this._charUpdateSettings.mStickToFloorStepDown = new J.Vec3(0, -0.5, 0)
       this._charUpdateSettings.mWalkStairsStepUp = new J.Vec3(0, 0.4, 0)
       this._charGravity = new J.Vec3(this.gravity[0], this.gravity[1], this.gravity[2])
+      this._tmpVec3 = new J.Vec3(0, 0, 0)
+      this._tmpRVec3 = new J.RVec3(0, 0, 0)
     }
     const id = this._nextCharId = (this._nextCharId || 0) + 1
     if (!this.characters) this.characters = new Map()
     this.characters.set(id, ch)
+    this._charShapes.set(id, { radius, standHeight: halfHeight, crouchHeight: this.crouchHalfHeight })
     return id
   }
+  setCharacterCrouch(charId, isCrouching) {
+    const data = this._charShapes.get(charId)
+    if (!data) return
+    const heightDiff = (data.standHeight - data.crouchHeight) * 0.5
+    const ch = this.characters?.get(charId)
+    if (!ch) return
+    const pos = this.getCharacterPosition(charId)
+    if (isCrouching) {
+      pos[1] -= heightDiff
+    } else {
+      pos[1] += heightDiff
+    }
+    this.setCharacterPosition(charId, pos)
+  }
   updateCharacter(charId, dt) {
     const ch = this.characters?.get(charId)
     if (!ch) return
@@ -113,19 +132,27 @@ export class PhysicsWorld {
   }
   getCharacterPosition(charId) {
     const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
-    const p = ch.GetPosition(); return [p.GetX(), p.GetY(), p.GetZ()]
+    const p = ch.GetPosition()
+    const r = [p.GetX(), p.GetY(), p.GetZ()]
+    this.Jolt.destroy(p)
+    return r
   }
   getCharacterVelocity(charId) {
     const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
-    const v = ch.GetLinearVelocity(); return [v.GetX(), v.GetY(), v.GetZ()]
+    const v = ch.GetLinearVelocity()
+    const r = [v.GetX(), v.GetY(), v.GetZ()]
+    this.Jolt.destroy(v)
+    return r
   }
   setCharacterVelocity(charId, velocity) {
     const ch = this.characters?.get(charId); if (!ch) return
-    ch.SetLinearVelocity(new this.Jolt.Vec3(velocity[0], velocity[1], velocity[2]))
+    const v = this._tmpVec3; v.Set(velocity[0], velocity[1], velocity[2])
+    ch.SetLinearVelocity(v)
   }
   setCharacterPosition(charId, position) {
     const ch = this.characters?.get(charId); if (!ch) return
-    ch.SetPosition(new this.Jolt.RVec3(position[0], position[1], position[2]))
+    const p = this._tmpRVec3; p.Set(position[0], position[1], position[2])
+    ch.SetPosition(p)
   }
   getCharacterGroundState(charId) {
     const ch = this.characters?.get(charId); if (!ch) return false
@@ -133,36 +160,53 @@ export class PhysicsWorld {
   }
   removeCharacter(charId) {
     if (!this.characters) return
-    this.characters.delete(charId)
+    const ch = this.characters.get(charId)
+    if (ch) {
+      this.Jolt.destroy(ch)
+      this.characters.delete(charId)
+    }
   }
   _getBody(bodyId) { return this.bodies.get(bodyId) }
   getBodyPosition(bodyId) {
     const b = this._getBody(bodyId); if (!b) return [0, 0, 0]
-    const p = this.bodyInterface.GetPosition(b.GetID()); return [p.GetX(), p.GetY(), p.GetZ()]
+    const p = this.bodyInterface.GetPosition(b.GetID())
+    const r = [p.GetX(), p.GetY(), p.GetZ()]
+    this.Jolt.destroy(p)
+    return r
   }
   getBodyRotation(bodyId) {
     const b = this._getBody(bodyId); if (!b) return [0, 0, 0, 1]
-    const r = this.bodyInterface.GetRotation(b.GetID()); return [r.GetX(), r.GetY(), r.GetZ(), r.GetW()]
+    const q = this.bodyInterface.GetRotation(b.GetID())
+    const r = [q.GetX(), q.GetY(), q.GetZ(), q.GetW()]
+    this.Jolt.destroy(q)
+    return r
   }
   getBodyVelocity(bodyId) {
     const b = this._getBody(bodyId); if (!b) return [0, 0, 0]
-    const v = this.bodyInterface.GetLinearVelocity(b.GetID()); return [v.GetX(), v.GetY(), v.GetZ()]
+    const v = this.bodyInterface.GetLinearVelocity(b.GetID())
+    const r = [v.GetX(), v.GetY(), v.GetZ()]
+    this.Jolt.destroy(v)
+    return r
   }
   setBodyPosition(bodyId, position) {
     const b = this._getBody(bodyId); if (!b) return
-    this.bodyInterface.SetPosition(b.GetID(), new this.Jolt.RVec3(position[0], position[1], position[2]), this.Jolt.EActivation_Activate)
+    const p = this._tmpRVec3 || new this.Jolt.RVec3(0, 0, 0); p.Set(position[0], position[1], position[2])
+    this.bodyInterface.SetPosition(b.GetID(), p, this.Jolt.EActivation_Activate)
   }
   setBodyVelocity(bodyId, velocity) {
     const b = this._getBody(bodyId); if (!b) return
-    this.bodyInterface.SetLinearVelocity(b.GetID(), new this.Jolt.Vec3(velocity[0], velocity[1], velocity[2]))
+    const v = this._tmpVec3 || new this.Jolt.Vec3(0, 0, 0); v.Set(velocity[0], velocity[1], velocity[2])
+    this.bodyInterface.SetLinearVelocity(b.GetID(), v)
   }
   addForce(bodyId, force) {
     const b = this._getBody(bodyId); if (!b) return
-    this.bodyInterface.AddForce(b.GetID(), new this.Jolt.Vec3(force[0], force[1], force[2]))
+    const v = this._tmpVec3 || new this.Jolt.Vec3(0, 0, 0); v.Set(force[0], force[1], force[2])
+    this.bodyInterface.AddForce(b.GetID(), v)
   }
   addImpulse(bodyId, impulse) {
     const b = this._getBody(bodyId); if (!b) return
-    this.bodyInterface.AddImpulse(b.GetID(), new this.Jolt.Vec3(impulse[0], impulse[1], impulse[2]))
+    const v = this._tmpVec3 || new this.Jolt.Vec3(0, 0, 0); v.Set(impulse[0], impulse[1], impulse[2])
+    this.bodyInterface.AddImpulse(b.GetID(), v)
   }
   step(deltaTime) { if (!this.jolt) return; this.jolt.Step(deltaTime, deltaTime > 1 / 55 ? 2 : 1) }
   removeBody(bodyId) {
@@ -191,5 +235,14 @@ export class PhysicsWorld {
     J.destroy(ray); J.destroy(rs); J.destroy(col); J.destroy(bp); J.destroy(ol); J.destroy(bf); J.destroy(sf)
     return result
   }
-  destroy() { for (const [id] of this.bodies) this.removeBody(id); if (this.jolt) { this.Jolt.destroy(this.jolt); this.jolt = null } }
+  destroy() {
+    if (this.characters) {
+      for (const [id, ch] of this.characters) {
+        this.Jolt.destroy(ch)
+      }
+      this.characters.clear()
+    }
+    for (const [id] of this.bodies) this.removeBody(id)
+    if (this.jolt) { this.Jolt.destroy(this.jolt); this.jolt = null }
+  }
 }