@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/cjs/performance/NetworkPrediction.js

@@ -1,511 +1,453 @@
-'use strict';
-
-/**
- * @file NetworkPrediction.ts
- * @description Client-side prediction and rollback netcode
- * PRO-1.5: Runtime & Performance
- *
- * Features:
- * - Client-side prediction
- * - Server reconciliation
- * - Rollback netcode
- * - Input buffering
- * - State interpolation
- * - Lag compensation
- */
-// ============================================================
-// Default Configuration
-// ============================================================
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const DEFAULT_PREDICTION_CONFIG = {
-    maxPredictionFrames: 8,
-    snapshotBufferSize: 128,
-    inputBufferSize: 64,
-    reconciliationThreshold: 0.001,
-    interpolationDelay: 100,
-    maxRollbackFrames: 10,
-    tickRate: 60,
-    sendRate: 20,
+  maxPredictionFrames: 8,
+  snapshotBufferSize: 128,
+  inputBufferSize: 64,
+  reconciliationThreshold: 1e-3,
+  interpolationDelay: 100,
+  maxRollbackFrames: 10,
+  tickRate: 60,
+  sendRate: 20
 };
-// ============================================================
-// Input Buffer
-// ============================================================
 class InputBuffer {
-    constructor(maxSize = 64) {
-        this.buffer = new Map();
-        this.oldestFrame = 0;
-        this.newestFrame = -1;
-        this.maxSize = maxSize;
-    }
-    add(frame) {
-        this.buffer.set(frame.frame, frame);
-        if (frame.frame > this.newestFrame) {
-            this.newestFrame = frame.frame;
-        }
-        // Trim old frames
-        while (this.buffer.size > this.maxSize) {
-            this.buffer.delete(this.oldestFrame);
-            this.oldestFrame++;
-        }
-    }
-    get(frame) {
-        return this.buffer.get(frame);
-    }
-    getRange(startFrame, endFrame) {
-        const frames = [];
-        for (let f = startFrame; f <= endFrame; f++) {
-            const frame = this.buffer.get(f);
-            if (frame) {
-                frames.push(frame);
-            }
-        }
-        return frames;
-    }
-    getNewestFrame() {
-        return this.newestFrame;
-    }
-    getOldestFrame() {
-        return this.oldestFrame;
-    }
-    clear() {
-        this.buffer.clear();
-        this.oldestFrame = 0;
-        this.newestFrame = -1;
-    }
-    size() {
-        return this.buffer.size;
-    }
+  constructor(maxSize = 64) {
+    this.buffer = /* @__PURE__ */ new Map();
+    this.oldestFrame = 0;
+    this.newestFrame = -1;
+    this.maxSize = maxSize;
+  }
+  add(frame) {
+    this.buffer.set(frame.frame, frame);
+    if (frame.frame > this.newestFrame) {
+      this.newestFrame = frame.frame;
+    }
+    while (this.buffer.size > this.maxSize) {
+      this.buffer.delete(this.oldestFrame);
+      this.oldestFrame++;
+    }
+  }
+  get(frame) {
+    return this.buffer.get(frame);
+  }
+  getRange(startFrame, endFrame) {
+    const frames = [];
+    for (let f = startFrame; f <= endFrame; f++) {
+      const frame = this.buffer.get(f);
+      if (frame) {
+        frames.push(frame);
+      }
+    }
+    return frames;
+  }
+  getNewestFrame() {
+    return this.newestFrame;
+  }
+  getOldestFrame() {
+    return this.oldestFrame;
+  }
+  clear() {
+    this.buffer.clear();
+    this.oldestFrame = 0;
+    this.newestFrame = -1;
+  }
+  size() {
+    return this.buffer.size;
+  }
 }
-// ============================================================
-// Snapshot Buffer
-// ============================================================
 class SnapshotBuffer {
-    constructor(maxSize = 128) {
-        this.buffer = new Map();
-        this.oldestFrame = 0;
-        this.newestFrame = -1;
-        this.maxSize = maxSize;
-    }
-    add(snapshot) {
-        this.buffer.set(snapshot.frame, snapshot);
-        if (snapshot.frame > this.newestFrame) {
-            this.newestFrame = snapshot.frame;
-        }
-        // Trim old snapshots
-        while (this.buffer.size > this.maxSize) {
-            this.buffer.delete(this.oldestFrame);
-            this.oldestFrame++;
-        }
-    }
-    get(frame) {
-        return this.buffer.get(frame);
-    }
-    getClosest(frame) {
-        if (this.buffer.has(frame)) {
-            return this.buffer.get(frame);
-        }
-        // Find closest frame
-        let closest;
-        let minDiff = Infinity;
-        for (const [f, snapshot] of this.buffer) {
-            const diff = Math.abs(f - frame);
-            if (diff < minDiff) {
-                minDiff = diff;
-                closest = snapshot;
-            }
-        }
-        return closest;
-    }
-    getNewestFrame() {
-        return this.newestFrame;
-    }
-    getOldestFrame() {
-        return this.oldestFrame;
-    }
-    clear() {
-        this.buffer.clear();
-        this.oldestFrame = 0;
-        this.newestFrame = -1;
-    }
-    size() {
-        return this.buffer.size;
-    }
+  constructor(maxSize = 128) {
+    this.buffer = /* @__PURE__ */ new Map();
+    this.oldestFrame = 0;
+    this.newestFrame = -1;
+    this.maxSize = maxSize;
+  }
+  add(snapshot) {
+    this.buffer.set(snapshot.frame, snapshot);
+    if (snapshot.frame > this.newestFrame) {
+      this.newestFrame = snapshot.frame;
+    }
+    while (this.buffer.size > this.maxSize) {
+      this.buffer.delete(this.oldestFrame);
+      this.oldestFrame++;
+    }
+  }
+  get(frame) {
+    return this.buffer.get(frame);
+  }
+  getClosest(frame) {
+    if (this.buffer.has(frame)) {
+      return this.buffer.get(frame);
+    }
+    let closest;
+    let minDiff = Infinity;
+    for (const [f, snapshot] of this.buffer) {
+      const diff = Math.abs(f - frame);
+      if (diff < minDiff) {
+        minDiff = diff;
+        closest = snapshot;
+      }
+    }
+    return closest;
+  }
+  getNewestFrame() {
+    return this.newestFrame;
+  }
+  getOldestFrame() {
+    return this.oldestFrame;
+  }
+  clear() {
+    this.buffer.clear();
+    this.oldestFrame = 0;
+    this.newestFrame = -1;
+  }
+  size() {
+    return this.buffer.size;
+  }
 }
-// ============================================================
-// State Interpolator
-// ============================================================
 class StateInterpolator {
-    constructor(buffer, delay = 100) {
-        this.buffer = buffer;
-        this.delay = delay;
-    }
-    interpolate(currentTime) {
-        const targetTime = currentTime - this.delay;
-        // Find surrounding snapshots
-        let before;
-        let after;
-        const oldest = this.buffer.getOldestFrame();
-        const newest = this.buffer.getNewestFrame();
-        for (let f = newest; f >= oldest; f--) {
-            const snapshot = this.buffer.get(f);
-            if (!snapshot) {
-                continue;
-            }
-            if (snapshot.timestamp <= targetTime) {
-                before = snapshot;
-                after = this.buffer.get(f + 1);
-                break;
-            }
-        }
-        if (!before) {
-            return this.buffer.get(newest);
-        }
-        if (!after) {
-            return before;
-        }
-        // Interpolate between snapshots
-        const t = (targetTime - before.timestamp) / (after.timestamp - before.timestamp);
-        return this.interpolateSnapshots(before, after, Math.max(0, Math.min(1, t)));
-    }
-    interpolateSnapshots(a, b, t) {
-        const entities = [];
-        for (const entityA of a.entities) {
-            const entityB = b.entities.find((e) => e.id === entityA.id);
-            if (entityB) {
-                entities.push(this.interpolateEntity(entityA, entityB, t));
-            }
-            else {
-                entities.push({ ...entityA });
-            }
-        }
-        // Add new entities from B
-        for (const entityB of b.entities) {
-            if (!a.entities.find((e) => e.id === entityB.id)) {
-                entities.push({ ...entityB });
-            }
-        }
-        return {
-            frame: Math.round(a.frame + (b.frame - a.frame) * t),
-            tick: Math.round(a.tick + (b.tick - a.tick) * t),
-            timestamp: a.timestamp + (b.timestamp - a.timestamp) * t,
-            entities,
-            checksum: 0,
-        };
-    }
-    interpolateEntity(a, b, t) {
-        return {
-            id: a.id,
-            ownerId: a.ownerId,
-            position: {
-                x: a.position.x + (b.position.x - a.position.x) * t,
-                y: a.position.y + (b.position.y - a.position.y) * t,
-                z: a.position.z !== undefined && b.position.z !== undefined
-                    ? a.position.z + (b.position.z - a.position.z) * t
-                    : undefined,
-            },
-            velocity: {
-                x: a.velocity.x + (b.velocity.x - a.velocity.x) * t,
-                y: a.velocity.y + (b.velocity.y - a.velocity.y) * t,
-                z: a.velocity.z !== undefined && b.velocity.z !== undefined
-                    ? a.velocity.z + (b.velocity.z - a.velocity.z) * t
-                    : undefined,
-            },
-            rotation: this.lerpAngle(a.rotation, b.rotation, t),
-            state: { ...a.state, ...b.state },
-        };
-    }
-    lerpAngle(a, b, t) {
-        let diff = b - a;
-        while (diff > Math.PI) {
-            diff -= Math.PI * 2;
-        }
-        while (diff < -Math.PI) {
-            diff += Math.PI * 2;
-        }
-        return a + diff * t;
-    }
-    setDelay(delay) {
-        this.delay = delay;
-    }
-    getDelay() {
-        return this.delay;
-    }
+  constructor(buffer, delay = 100) {
+    this.buffer = buffer;
+    this.delay = delay;
+  }
+  interpolate(currentTime) {
+    const targetTime = currentTime - this.delay;
+    let before;
+    let after;
+    const oldest = this.buffer.getOldestFrame();
+    const newest = this.buffer.getNewestFrame();
+    for (let f = newest; f >= oldest; f--) {
+      const snapshot = this.buffer.get(f);
+      if (!snapshot) {
+        continue;
+      }
+      if (snapshot.timestamp <= targetTime) {
+        before = snapshot;
+        after = this.buffer.get(f + 1);
+        break;
+      }
+    }
+    if (!before) {
+      return this.buffer.get(newest);
+    }
+    if (!after) {
+      return before;
+    }
+    const t = (targetTime - before.timestamp) / (after.timestamp - before.timestamp);
+    return this.interpolateSnapshots(before, after, Math.max(0, Math.min(1, t)));
+  }
+  interpolateSnapshots(a, b, t) {
+    const entities = [];
+    for (const entityA of a.entities) {
+      const entityB = b.entities.find((e) => e.id === entityA.id);
+      if (entityB) {
+        entities.push(this.interpolateEntity(entityA, entityB, t));
+      } else {
+        entities.push({ ...entityA });
+      }
+    }
+    for (const entityB of b.entities) {
+      if (!a.entities.find((e) => e.id === entityB.id)) {
+        entities.push({ ...entityB });
+      }
+    }
+    return {
+      frame: Math.round(a.frame + (b.frame - a.frame) * t),
+      tick: Math.round(a.tick + (b.tick - a.tick) * t),
+      timestamp: a.timestamp + (b.timestamp - a.timestamp) * t,
+      entities,
+      checksum: 0
+    };
+  }
+  interpolateEntity(a, b, t) {
+    return {
+      id: a.id,
+      ownerId: a.ownerId,
+      position: {
+        x: a.position.x + (b.position.x - a.position.x) * t,
+        y: a.position.y + (b.position.y - a.position.y) * t,
+        z: a.position.z !== void 0 && b.position.z !== void 0 ? a.position.z + (b.position.z - a.position.z) * t : void 0
+      },
+      velocity: {
+        x: a.velocity.x + (b.velocity.x - a.velocity.x) * t,
+        y: a.velocity.y + (b.velocity.y - a.velocity.y) * t,
+        z: a.velocity.z !== void 0 && b.velocity.z !== void 0 ? a.velocity.z + (b.velocity.z - a.velocity.z) * t : void 0
+      },
+      rotation: this.lerpAngle(a.rotation, b.rotation, t),
+      state: { ...a.state, ...b.state }
+    };
+  }
+  lerpAngle(a, b, t) {
+    let diff = b - a;
+    while (diff > Math.PI) {
+      diff -= Math.PI * 2;
+    }
+    while (diff < -Math.PI) {
+      diff += Math.PI * 2;
+    }
+    return a + diff * t;
+  }
+  setDelay(delay) {
+    this.delay = delay;
+  }
+  getDelay() {
+    return this.delay;
+  }
 }
-// ============================================================
-// Client Prediction
-// ============================================================
 class ClientPrediction {
-    constructor(config) {
-        this.localPlayerId = '';
-        this.currentFrame = 0;
-        this.lastConfirmedFrame = -1;
-        this.pendingInputs = [];
-        this.stats = {
-            predictedFrames: 0,
-            rollbacks: 0,
-            mispredictions: 0,
-            averageRTT: 0,
-            jitter: 0,
-            packetsLost: 0,
-            inputDelay: 0,
-        };
-        this.config = { ...DEFAULT_PREDICTION_CONFIG, ...config };
-        this.localInputBuffer = new InputBuffer(this.config.inputBufferSize);
-        this.predictedSnapshots = new SnapshotBuffer(this.config.snapshotBufferSize);
-        this.serverSnapshots = new SnapshotBuffer(this.config.snapshotBufferSize);
-        this.interpolator = new StateInterpolator(this.serverSnapshots, this.config.interpolationDelay);
-        this.simulate = (snapshot) => snapshot; // Default no-op
-    }
-    // ─── Setup ─────────────────────────────────────────────
-    setSimulation(fn) {
-        this.simulate = fn;
-    }
-    setLocalPlayer(playerId) {
-        this.localPlayerId = playerId;
-    }
-    // ─── Input Handling ────────────────────────────────────
-    addLocalInput(input) {
-        const frame = {
-            frame: this.currentFrame,
-            tick: this.currentFrame,
-            timestamp: Date.now(),
-            inputs: [
-                {
-                    ...input,
-                    playerId: this.localPlayerId,
-                    sequence: this.currentFrame,
-                },
-            ],
-        };
-        this.localInputBuffer.add(frame);
-        this.pendingInputs.push(frame);
-        return frame;
-    }
-    getPendingInputs() {
-        return [...this.pendingInputs];
-    }
-    acknowledgeInput(sequence) {
-        this.pendingInputs = this.pendingInputs.filter((f) => f.frame > sequence);
-    }
-    // ─── Prediction ────────────────────────────────────────
-    predict(baseSnapshot) {
-        let predicted = { ...baseSnapshot };
-        const startFrame = baseSnapshot.frame + 1;
-        // Apply all pending inputs
-        for (let frame = startFrame; frame <= this.currentFrame; frame++) {
-            const inputFrame = this.localInputBuffer.get(frame);
-            if (inputFrame) {
-                predicted = this.simulate(predicted, inputFrame.inputs);
-                predicted.frame = frame;
-            }
-        }
-        this.predictedSnapshots.add(predicted);
-        this.stats.predictedFrames++;
-        return predicted;
-    }
-    // ─── Server Reconciliation ─────────────────────────────
-    receiveServerSnapshot(snapshot) {
-        this.serverSnapshots.add(snapshot);
-        // Check for misprediction
-        const predicted = this.predictedSnapshots.get(snapshot.frame);
-        if (predicted) {
-            const error = this.calculatePredictionError(predicted, snapshot);
-            if (error > this.config.reconciliationThreshold) {
-                this.stats.mispredictions++;
-                this.onMisprediction?.(snapshot.frame, predicted, snapshot);
-                // Rollback and resimulate
-                this.rollback(snapshot);
-            }
-        }
-        // Update last confirmed frame
-        if (snapshot.frame > this.lastConfirmedFrame) {
-            this.lastConfirmedFrame = snapshot.frame;
-            this.acknowledgeInput(snapshot.frame);
-        }
-    }
-    calculatePredictionError(predicted, actual) {
-        let maxError = 0;
-        // Find local player entity
-        const predictedLocal = predicted.entities.find((e) => e.ownerId === this.localPlayerId);
-        const actualLocal = actual.entities.find((e) => e.ownerId === this.localPlayerId);
-        if (predictedLocal && actualLocal) {
-            const dx = predictedLocal.position.x - actualLocal.position.x;
-            const dy = predictedLocal.position.y - actualLocal.position.y;
-            maxError = Math.sqrt(dx * dx + dy * dy);
+  constructor(config) {
+    this.localPlayerId = "";
+    this.currentFrame = 0;
+    this.lastConfirmedFrame = -1;
+    this.pendingInputs = [];
+    this.stats = {
+      predictedFrames: 0,
+      rollbacks: 0,
+      mispredictions: 0,
+      averageRTT: 0,
+      jitter: 0,
+      packetsLost: 0,
+      inputDelay: 0
+    };
+    this.config = { ...DEFAULT_PREDICTION_CONFIG, ...config };
+    this.localInputBuffer = new InputBuffer(this.config.inputBufferSize);
+    this.predictedSnapshots = new SnapshotBuffer(this.config.snapshotBufferSize);
+    this.serverSnapshots = new SnapshotBuffer(this.config.snapshotBufferSize);
+    this.interpolator = new StateInterpolator(this.serverSnapshots, this.config.interpolationDelay);
+    this.simulate = (snapshot) => snapshot;
+  }
+  // ─── Setup ─────────────────────────────────────────────
+  setSimulation(fn) {
+    this.simulate = fn;
+  }
+  setLocalPlayer(playerId) {
+    this.localPlayerId = playerId;
+  }
+  // ─── Input Handling ────────────────────────────────────
+  addLocalInput(input) {
+    const frame = {
+      frame: this.currentFrame,
+      tick: this.currentFrame,
+      timestamp: Date.now(),
+      inputs: [
+        {
+          ...input,
+          playerId: this.localPlayerId,
+          sequence: this.currentFrame
         }
-        return maxError;
-    }
-    rollback(serverSnapshot) {
-        const rollbackFrames = this.currentFrame - serverSnapshot.frame;
-        if (rollbackFrames > this.config.maxRollbackFrames) {
-            console.warn(`Rollback too large: ${rollbackFrames} frames`);
-            return;
-        }
-        this.stats.rollbacks++;
-        this.onRollback?.(this.currentFrame, serverSnapshot.frame);
-        // Resimulate from server snapshot
-        let state = serverSnapshot;
-        for (let frame = serverSnapshot.frame + 1; frame <= this.currentFrame; frame++) {
-            const inputFrame = this.localInputBuffer.get(frame);
-            if (inputFrame) {
-                state = this.simulate(state, inputFrame.inputs);
-                state.frame = frame;
-                this.predictedSnapshots.add(state);
-            }
-        }
-    }
-    // ─── Frame Management ──────────────────────────────────
-    tick() {
-        this.currentFrame++;
-    }
-    getCurrentFrame() {
-        return this.currentFrame;
-    }
-    setCurrentFrame(frame) {
-        this.currentFrame = frame;
-    }
-    getLastConfirmedFrame() {
-        return this.lastConfirmedFrame;
-    }
-    // ─── Interpolation ─────────────────────────────────────
-    getInterpolatedState(currentTime) {
-        return this.interpolator.interpolate(currentTime);
-    }
-    setInterpolationDelay(delay) {
-        this.interpolator.setDelay(delay);
-    }
-    // ─── Stats ─────────────────────────────────────────────
-    getStats() {
-        return { ...this.stats };
-    }
-    updateRTT(rtt) {
-        // Exponential moving average
-        this.stats.averageRTT = this.stats.averageRTT * 0.9 + rtt * 0.1;
-        // Calculate jitter
-        const diff = Math.abs(rtt - this.stats.averageRTT);
-        this.stats.jitter = this.stats.jitter * 0.9 + diff * 0.1;
-    }
-    recordPacketLoss() {
-        this.stats.packetsLost++;
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setOnRollback(callback) {
-        this.onRollback = callback;
-    }
-    setOnMisprediction(callback) {
-        this.onMisprediction = callback;
-    }
-    // ─── Reset ─────────────────────────────────────────────
-    reset() {
-        this.localInputBuffer.clear();
-        this.predictedSnapshots.clear();
-        this.serverSnapshots.clear();
-        this.pendingInputs = [];
-        this.currentFrame = 0;
-        this.lastConfirmedFrame = -1;
-        this.stats = {
-            predictedFrames: 0,
-            rollbacks: 0,
-            mispredictions: 0,
-            averageRTT: 0,
-            jitter: 0,
-            packetsLost: 0,
-            inputDelay: 0,
-        };
-    }
+      ]
+    };
+    this.localInputBuffer.add(frame);
+    this.pendingInputs.push(frame);
+    return frame;
+  }
+  getPendingInputs() {
+    return [...this.pendingInputs];
+  }
+  acknowledgeInput(sequence) {
+    this.pendingInputs = this.pendingInputs.filter((f) => f.frame > sequence);
+  }
+  // ─── Prediction ────────────────────────────────────────
+  predict(baseSnapshot) {
+    let predicted = { ...baseSnapshot };
+    const startFrame = baseSnapshot.frame + 1;
+    for (let frame = startFrame; frame <= this.currentFrame; frame++) {
+      const inputFrame = this.localInputBuffer.get(frame);
+      if (inputFrame) {
+        predicted = this.simulate(predicted, inputFrame.inputs);
+        predicted.frame = frame;
+      }
+    }
+    this.predictedSnapshots.add(predicted);
+    this.stats.predictedFrames++;
+    return predicted;
+  }
+  // ─── Server Reconciliation ─────────────────────────────
+  receiveServerSnapshot(snapshot) {
+    this.serverSnapshots.add(snapshot);
+    const predicted = this.predictedSnapshots.get(snapshot.frame);
+    if (predicted) {
+      const error = this.calculatePredictionError(predicted, snapshot);
+      if (error > this.config.reconciliationThreshold) {
+        this.stats.mispredictions++;
+        this.onMisprediction?.(snapshot.frame, predicted, snapshot);
+        this.rollback(snapshot);
+      }
+    }
+    if (snapshot.frame > this.lastConfirmedFrame) {
+      this.lastConfirmedFrame = snapshot.frame;
+      this.acknowledgeInput(snapshot.frame);
+    }
+  }
+  calculatePredictionError(predicted, actual) {
+    let maxError = 0;
+    const predictedLocal = predicted.entities.find((e) => e.ownerId === this.localPlayerId);
+    const actualLocal = actual.entities.find((e) => e.ownerId === this.localPlayerId);
+    if (predictedLocal && actualLocal) {
+      const dx = predictedLocal.position.x - actualLocal.position.x;
+      const dy = predictedLocal.position.y - actualLocal.position.y;
+      maxError = Math.sqrt(dx * dx + dy * dy);
+    }
+    return maxError;
+  }
+  rollback(serverSnapshot) {
+    const rollbackFrames = this.currentFrame - serverSnapshot.frame;
+    if (rollbackFrames > this.config.maxRollbackFrames) {
+      console.warn(`Rollback too large: ${rollbackFrames} frames`);
+      return;
+    }
+    this.stats.rollbacks++;
+    this.onRollback?.(this.currentFrame, serverSnapshot.frame);
+    let state = serverSnapshot;
+    for (let frame = serverSnapshot.frame + 1; frame <= this.currentFrame; frame++) {
+      const inputFrame = this.localInputBuffer.get(frame);
+      if (inputFrame) {
+        state = this.simulate(state, inputFrame.inputs);
+        state.frame = frame;
+        this.predictedSnapshots.add(state);
+      }
+    }
+  }
+  // ─── Frame Management ──────────────────────────────────
+  tick() {
+    this.currentFrame++;
+  }
+  getCurrentFrame() {
+    return this.currentFrame;
+  }
+  setCurrentFrame(frame) {
+    this.currentFrame = frame;
+  }
+  getLastConfirmedFrame() {
+    return this.lastConfirmedFrame;
+  }
+  // ─── Interpolation ─────────────────────────────────────
+  getInterpolatedState(currentTime) {
+    return this.interpolator.interpolate(currentTime);
+  }
+  setInterpolationDelay(delay) {
+    this.interpolator.setDelay(delay);
+  }
+  // ─── Stats ─────────────────────────────────────────────
+  getStats() {
+    return { ...this.stats };
+  }
+  updateRTT(rtt) {
+    this.stats.averageRTT = this.stats.averageRTT * 0.9 + rtt * 0.1;
+    const diff = Math.abs(rtt - this.stats.averageRTT);
+    this.stats.jitter = this.stats.jitter * 0.9 + diff * 0.1;
+  }
+  recordPacketLoss() {
+    this.stats.packetsLost++;
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setOnRollback(callback) {
+    this.onRollback = callback;
+  }
+  setOnMisprediction(callback) {
+    this.onMisprediction = callback;
+  }
+  // ─── Reset ─────────────────────────────────────────────
+  reset() {
+    this.localInputBuffer.clear();
+    this.predictedSnapshots.clear();
+    this.serverSnapshots.clear();
+    this.pendingInputs = [];
+    this.currentFrame = 0;
+    this.lastConfirmedFrame = -1;
+    this.stats = {
+      predictedFrames: 0,
+      rollbacks: 0,
+      mispredictions: 0,
+      averageRTT: 0,
+      jitter: 0,
+      packetsLost: 0,
+      inputDelay: 0
+    };
+  }
 }
-// ============================================================
-// Lag Compensation
-// ============================================================
 class LagCompensation {
-    constructor(maxRewindMs = 200) {
-        this.snapshots = new SnapshotBuffer(128);
-        this.maxRewindMs = maxRewindMs;
-    }
-    recordSnapshot(snapshot) {
-        this.snapshots.add(snapshot);
-    }
-    rewind(targetTime, currentTime) {
-        const rewindMs = currentTime - targetTime;
-        if (rewindMs > this.maxRewindMs) {
-            console.warn(`Rewind request too large: ${rewindMs}ms`);
-            return undefined;
-        }
-        // Find snapshot at target time
-        const oldest = this.snapshots.getOldestFrame();
-        const newest = this.snapshots.getNewestFrame();
-        for (let f = newest; f >= oldest; f--) {
-            const snapshot = this.snapshots.get(f);
-            if (snapshot && snapshot.timestamp <= targetTime) {
-                return snapshot;
-            }
-        }
-        return this.snapshots.get(oldest);
-    }
-    hitTest(shooterPos, direction, maxDistance, targetTime, currentTime) {
-        const snapshot = this.rewind(targetTime, currentTime);
-        if (!snapshot) {
-            return { hit: false };
-        }
-        // Simple ray-circle intersection
-        for (const entity of snapshot.entities) {
-            const dx = entity.position.x - shooterPos.x;
-            const dy = entity.position.y - shooterPos.y;
-            // Project onto ray
-            const t = dx * direction.x + dy * direction.y;
-            if (t < 0 || t > maxDistance) {
-                continue;
-            }
-            // Distance from ray
-            const closestX = shooterPos.x + direction.x * t;
-            const closestY = shooterPos.y + direction.y * t;
-            const dist = Math.sqrt(Math.pow(entity.position.x - closestX, 2) + Math.pow(entity.position.y - closestY, 2));
-            // Assume entity radius of 0.5
-            if (dist < 0.5) {
-                return {
-                    hit: true,
-                    entityId: entity.id,
-                    hitPos: { x: closestX, y: closestY },
-                };
-            }
-        }
-        return { hit: false };
-    }
-    setMaxRewind(ms) {
-        this.maxRewindMs = ms;
-    }
-    clear() {
-        this.snapshots.clear();
+  constructor(maxRewindMs = 200) {
+    this.snapshots = new SnapshotBuffer(128);
+    this.maxRewindMs = maxRewindMs;
+  }
+  recordSnapshot(snapshot) {
+    this.snapshots.add(snapshot);
+  }
+  rewind(targetTime, currentTime) {
+    const rewindMs = currentTime - targetTime;
+    if (rewindMs > this.maxRewindMs) {
+      console.warn(`Rewind request too large: ${rewindMs}ms`);
+      return void 0;
+    }
+    const oldest = this.snapshots.getOldestFrame();
+    const newest = this.snapshots.getNewestFrame();
+    for (let f = newest; f >= oldest; f--) {
+      const snapshot = this.snapshots.get(f);
+      if (snapshot && snapshot.timestamp <= targetTime) {
+        return snapshot;
+      }
+    }
+    return this.snapshots.get(oldest);
+  }
+  hitTest(shooterPos, direction, maxDistance, targetTime, currentTime) {
+    const snapshot = this.rewind(targetTime, currentTime);
+    if (!snapshot) {
+      return { hit: false };
     }
+    for (const entity of snapshot.entities) {
+      const dx = entity.position.x - shooterPos.x;
+      const dy = entity.position.y - shooterPos.y;
+      const t = dx * direction.x + dy * direction.y;
+      if (t < 0 || t > maxDistance) {
+        continue;
+      }
+      const closestX = shooterPos.x + direction.x * t;
+      const closestY = shooterPos.y + direction.y * t;
+      const dist = Math.sqrt(
+        Math.pow(entity.position.x - closestX, 2) + Math.pow(entity.position.y - closestY, 2)
+      );
+      if (dist < 0.5) {
+        return {
+          hit: true,
+          entityId: entity.id,
+          hitPos: { x: closestX, y: closestY }
+        };
+      }
+    }
+    return { hit: false };
+  }
+  setMaxRewind(ms) {
+    this.maxRewindMs = ms;
+  }
+  clear() {
+    this.snapshots.clear();
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createClientPrediction(config) {
-    return new ClientPrediction(config);
+  return new ClientPrediction(config);
 }
 function createLagCompensation(maxRewindMs) {
-    return new LagCompensation(maxRewindMs);
+  return new LagCompensation(maxRewindMs);
 }
 function createInputBuffer(maxSize) {
-    return new InputBuffer(maxSize);
+  return new InputBuffer(maxSize);
 }
 function createSnapshotBuffer(maxSize) {
-    return new SnapshotBuffer(maxSize);
+  return new SnapshotBuffer(maxSize);
 }
 function createStateInterpolator(buffer, delay) {
-    return new StateInterpolator(buffer, delay);
+  return new StateInterpolator(buffer, delay);
 }
 function calculateChecksum(snapshot) {
-    // Simple checksum for validation
-    let hash = 0;
-    for (const entity of snapshot.entities) {
-        hash ^= Math.round(entity.position.x * 1000);
-        hash ^= Math.round(entity.position.y * 1000) << 10;
-        hash ^= Math.round(entity.rotation * 1000) << 20;
-    }
-    return hash >>> 0;
+  let hash = 0;
+  for (const entity of snapshot.entities) {
+    hash ^= Math.round(entity.position.x * 1e3);
+    hash ^= Math.round(entity.position.y * 1e3) << 10;
+    hash ^= Math.round(entity.rotation * 1e3) << 20;
+  }
+  return hash >>> 0;
 }
-
 exports.ClientPrediction = ClientPrediction;
 exports.DEFAULT_PREDICTION_CONFIG = DEFAULT_PREDICTION_CONFIG;
 exports.InputBuffer = InputBuffer;