spoint 0.1.60 → 0.1.62

package/client/app.js

@@ -1033,20 +1033,10 @@ const client = new PhysicsNetworkClient({
   predictionEnabled: true,
   smoothInterpolation: true,
   onStateUpdate: (state) => {
-    const smoothState = client.getSmoothState()
-    for (const p of smoothState.players) {
+    for (const p of state.players) {
       if (!playerMeshes.has(p.id)) createPlayerVRM(p.id)
-      const mesh = playerMeshes.get(p.id)
-      const feetOff = mesh?.userData?.feetOffset ?? 1.3
-      const tx = p.position[0], ty = p.position[1] - feetOff, tz = p.position[2]
-      const existingTarget = playerTargets.get(p.id)
-      if (existingTarget) { existingTarget.x = tx; existingTarget.y = ty; existingTarget.z = tz }
-      else playerTargets.set(p.id, { x: tx, y: ty, z: tz })
-      playerStates.set(p.id, p)
-      const dx = tx - mesh.position.x, dy = ty - mesh.position.y, dz = tz - mesh.position.z
-      if (!mesh.userData.initialized || dx * dx + dy * dy + dz * dz > 100) { mesh.position.set(tx, ty, tz); mesh.userData.initialized = true }
     }
-    for (const e of smoothState.entities) {
+    for (const e of state.entities) {
       const mesh = entityMeshes.get(e.id)
       if (mesh && e.position) {
         const et = entityTargets.get(e.id)
@@ -1057,11 +1047,10 @@ const client = new PhysicsNetworkClient({
       }
       if (!entityMeshes.has(e.id)) loadEntityModel(e.id, e)
     }
-    rebuildEntityHierarchy(smoothState.entities)
     latestState = state
     if (!firstSnapshotReceived) {
       firstSnapshotReceived = true
-      for (const e of smoothState.entities) {
+      for (const e of state.entities) {
         if (e.model && !entityMeshes.has(e.id)) firstSnapshotEntityPending.add(e.id)
       }
       checkAllLoaded()
@@ -1467,7 +1456,27 @@ function animate(timestamp) {
   const frameDt = smoothDt
   fpsFrames++
   if (now - fpsLast >= 1000) { fpsDisplay = fpsFrames; fpsFrames = 0; fpsLast = now }
-  const lerpFactor = 1.0 - Math.exp(-16.0 * frameDt)
+  const rttMs = client.getRTT?.() || 0
+  const lerpConstant = rttMs > 100 ? 24.0 : 16.0
+  const lerpFactor = 1.0 - Math.exp(-lerpConstant * frameDt)
+  const smoothState = client.getSmoothState()
+  for (const p of smoothState.players) {
+    if (!playerMeshes.has(p.id)) continue
+    const mesh = playerMeshes.get(p.id)
+    const feetOff = mesh?.userData?.feetOffset ?? 1.3
+    const tx = p.position[0], ty = p.position[1] - feetOff, tz = p.position[2]
+    const existingTarget = playerTargets.get(p.id)
+    if (existingTarget) { existingTarget.x = tx; existingTarget.y = ty; existingTarget.z = tz }
+    else playerTargets.set(p.id, { x: tx, y: ty, z: tz })
+    playerStates.set(p.id, p)
+    if (!mesh.userData.initialized) { mesh.position.set(tx, ty, tz); mesh.userData.initialized = true }
+  }
+  for (const e of smoothState.entities) {
+    const mesh = entityMeshes.get(e.id)
+    if (mesh && e.position) mesh.position.set(e.position[0], e.position[1], e.position[2])
+    if (mesh && e.rotation) mesh.quaternion.set(e.rotation[0], e.rotation[1], e.rotation[2], e.rotation[3])
+  }
+  if (smoothState.entities.length > 0) rebuildEntityHierarchy(smoothState.entities)
   playerTargets.forEach((target, id) => {
     const mesh = playerMeshes.get(id)
     if (!mesh) return

package/package.json

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

package/src/client/JitterBuffer.js

@@ -34,7 +34,7 @@ export class JitterBuffer {
 
     while (this.buffer.length > this.maxSize) this.buffer.shift()
 
-    const maxAge = Math.max(300, this.rtt + this.jitter * 3)
+    const maxAge = Math.max(400, this.rtt + this.jitter * 3 + 150)
     const cutoff = now - maxAge
     while (this.buffer.length > 0 && this.buffer[0].clientTime < cutoff) this.buffer.shift()
   }
@@ -111,8 +111,9 @@ export class JitterBuffer {
   updateRTT(pingTime, pongTime) {
     const instant = pongTime - pingTime
     this.rttVariance = this.rttVariance * 0.75 + Math.abs(instant - this.rtt) * 0.25
-    this.rtt = this.rtt * 0.875 + instant * 0.125
-    this.targetDelay = this.baseDelay + this.rtt * 0.5 + this.jitter * 2
+    const alpha = instant > this.rtt ? 0.5 : 0.1
+    this.rtt = this.rtt * (1 - alpha) + instant * alpha
+    this.targetDelay = Math.min(250, this.baseDelay + this.rtt * 0.5 + this.jitter * 2)
   }
 
   getBufferHealth() { return this.buffer.length }

package/src/client/MessageHandler.js

@@ -56,15 +56,14 @@ export class MessageHandler {
     const oldPlayerId = this._playerId
     this._playerId = payload.playerId
     this._currentTick = payload.tick
-    if (oldPlayerId && oldPlayerId !== this._playerId) {
-      snapProc?.removePlayer(oldPlayerId)
-      if (this._smoothInterp) this._smoothInterp.removePlayer(oldPlayerId)
-      this._callbacks.onPlayerLeft?.(oldPlayerId)
-    }
-    if (!this._predEngine) {
-      this._predEngine = new PredictionEngine(this._config.tickRate || 128)
-      this._predEngine.init(this._playerId)
+    snapProc?.clear()
+    if (this._smoothInterp) {
+      this._smoothInterp.reset()
+      this._smoothInterp.setLocalPlayer(this._playerId)
     }
+    if (oldPlayerId) this._callbacks.onPlayerLeft?.(oldPlayerId)
+    this._predEngine = new PredictionEngine(this._config.tickRate || 128)
+    this._predEngine.init(this._playerId)
     if (this._config.smoothInterpolation !== false && !this._smoothInterp) {
       this._smoothInterp = new SmoothInterpolation({ predictionEnabled: this._config.predictionEnabled !== false })
       this._smoothInterp.setLocalPlayer(this._playerId)

package/src/client/ReconciliationEngine.js

@@ -2,35 +2,22 @@ export class ReconciliationEngine {
   constructor(config = {}) {
     this.correctionThreshold = config.correctionThreshold || 0.01
     this.correctionSpeed = config.correctionSpeed || 0.5
-    this.lastReconcileTime = 0
-    this.reconcileInterval = config.reconcileInterval || 100
   }
 
   reconcile(serverState, localState, tick) {
-    const now = Date.now()
-    if (now - this.lastReconcileTime < this.reconcileInterval) {
-      return { needsCorrection: false, correction: null }
-    }
-
-    this.lastReconcileTime = now
-
     const divergence = this.calculateDivergence(serverState, localState)
-
     if (divergence < this.correctionThreshold) {
       return { needsCorrection: false, divergence }
     }
-
     const correction = this.generateCorrection(serverState, localState)
     return { needsCorrection: true, correction, divergence }
   }
 
   calculateDivergence(serverState, localState) {
     if (!serverState || !localState) return 0
-
     const dx = serverState.position[0] - localState.position[0]
     const dy = serverState.position[1] - localState.position[1]
     const dz = serverState.position[2] - localState.position[2]
-
     return Math.sqrt(dx * dx + dy * dy + dz * dz)
   }
 

package/src/client/SmoothInterpolation.js

@@ -12,7 +12,6 @@ export class SmoothInterpolation {
     this.entityKalmanConfig = config.entityKalman || {
       positionQ: 2.0, velocityQ: 4.0, positionR: 0.01, velocityR: 0.5
     }
-
     this.localPlayerId = null
     this.predictionEnabled = config.predictionEnabled !== false
     this._lastDisplayTime = 0