murow 0.1.1 → 0.1.3

package/dist/netcode/cjs/index.js

@@ -34,7 +34,8 @@ __export(src_exports, {
   encodeDelta: () => encodeDelta,
   makeFieldsAccessor: () => makeFieldsAccessor,
   makeMarkDirty: () => makeMarkDirty,
-  networked: () => networked
+  networked: () => networked,
+  rateIncludes: () => rateIncludes
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -108,7 +109,7 @@ var import_protocol3 = require("murow/protocol");
 
 // src/codec/delta-codec.ts
 var HEADER_BYTES = 4 + 4 + 2 + 2;
-function encodeDelta(world, tick, entities, components, numMaskWords, despawned = [], clientAckTick = 0) {
+function encodeDelta(world, tick, entities, components, numMaskWords, despawned = [], clientAckTick = 0, includeComponent = () => true) {
   const perEntityMasks = new Array(entities.length);
   const perEntityBitmaskBytes = numMaskWords * 4;
   let bodyBytes = 0;
@@ -120,6 +121,8 @@ function encodeDelta(world, tick, entities, components, numMaskWords, despawned
       const c = components[ci];
       if (!world.has(eid, c))
         continue;
+      if (!includeComponent(eid, c))
+        continue;
       const wordIndex = ci >>> 5;
       const bitIndex = ci & 31;
       mask[wordIndex] |= 1 << bitIndex;
@@ -271,6 +274,18 @@ function decodeDelta(world, buf, components, numMaskWords, ensureEntity, shouldA
   };
 }
 
+// src/components/sync-spec.ts
+function networked(spec) {
+  return spec;
+}
+function rateIncludes(rate, dirty, tick) {
+  if (rate === "every-tick")
+    return true;
+  if (rate === "on-change")
+    return dirty;
+  return dirty || rate.every > 0 && tick % rate.every === 0;
+}
+
 // src/ctx.ts
 function makeFieldsAccessor(world, entity) {
   return function fields(component) {
@@ -501,6 +516,7 @@ var GameServer = class extends Network {
       }
       if (current.length === 0 && despawned.length === 0 && !peer.needsBaseline)
         continue;
+      const include = peer.needsBaseline ? void 0 : (eid, c) => rateIncludes(c.__sync.rate, this.world.isDirty(eid, c), this.tickCounter);
       const buf = encodeDelta(
         this.world,
         this.tickCounter,
@@ -508,7 +524,8 @@ var GameServer = class extends Network {
         this.syncedComponents,
         this.syncedNumMaskWords,
         despawned,
-        peer.lastAckedClientTick
+        peer.lastAckedClientTick,
+        include
       );
       const framed = new Uint8Array(buf.length + 1);
       framed[0] = MSG_SNAPSHOT;
@@ -850,67 +867,67 @@ var LagCompensation = class {
 // src/client/game-client.ts
 var import_binary_codec2 = require("murow/core/binary-codec");
 var import_simple_rng2 = require("murow/core/simple-rng");
+var import_prediction = require("murow/core/prediction");
 var import_protocol4 = require("murow/protocol");
 
-// src/client/interpolation-buffer.ts
+// src/client/strategies/snapshot-interpolation.ts
 var import_lerp = require("murow/core/lerp");
+var import_timeline = require("murow/core/timeline");
+var import_clock = require("murow/core/clock");
 function modeFor(c) {
   const sync = c.__sync;
   return sync?.interp ?? "lerp";
 }
-var InterpolationBuffer = class {
-  constructor(serverToLocal, capacity, delayMs, staleWindowMs) {
-    this.buffer = [];
-    this.renderTick = -Infinity;
-    this.latestReceivedAt = -Infinity;
-    this.smoothedTickRateMs = 0;
+var DEFAULT_MAX_DESYNC = 500;
+var DEFAULT_MAX_BRIDGE_GAP = 250;
+var SnapshotInterpolation = class {
+  constructor(serverToLocal, capacity, delayMs, staleWindowMs, maxDesyncMs = DEFAULT_MAX_DESYNC, nominalTickMs = 0, maxBridgeGapMs = DEFAULT_MAX_BRIDGE_GAP) {
+    this.clock = new import_clock.SlewClock();
     this.serverToLocal = serverToLocal;
-    this.capacity = capacity;
+    this.timeline = new import_timeline.Timeline(capacity, staleWindowMs);
     this.delay = delayMs;
-    this.staleWindow = staleWindowMs;
+    this.maxDesync = maxDesyncMs;
+    this.nominalTickMs = nominalTickMs;
+    this.smoothedTickRateMs = nominalTickMs;
+    this.maxBridgeGap = maxBridgeGapMs;
+  }
+  get staleWindow() {
+    return this.timeline.staleWindow;
   }
   setDelay(delayMs) {
     this.delay = delayMs;
   }
   setStaleWindow(staleWindowMs) {
-    this.staleWindow = staleWindowMs;
+    this.timeline.setStaleWindow(staleWindowMs);
+  }
+  setMaxDesync(maxDesyncMs) {
+    this.maxDesync = maxDesyncMs;
+  }
+  setMaxBridgeGap(maxBridgeGapMs) {
+    this.maxBridgeGap = maxBridgeGapMs;
   }
   record(snapshot) {
-    const gap = snapshot.receivedAt - this.latestReceivedAt;
-    if (this.buffer.length > 0 && gap > this.staleWindow) {
-      this.buffer.length = 0;
-      this.renderTick = -Infinity;
-      this.latestReceivedAt = -Infinity;
-      this.smoothedTickRateMs = 0;
-    }
-    if (snapshot.receivedAt > this.latestReceivedAt) {
-      this.latestReceivedAt = snapshot.receivedAt;
+    const reset = this.timeline.record(snapshot.serverTick, snapshot.receivedAt, snapshot);
+    if (reset) {
+      this.smoothedTickRateMs = this.nominalTickMs;
+      this.clock.reset();
     }
-    let insertAt = this.buffer.length;
-    while (insertAt > 0 && this.buffer[insertAt - 1].serverTick >= snapshot.serverTick) {
-      if (this.buffer[insertAt - 1].serverTick === snapshot.serverTick)
-        return;
-      insertAt--;
-    }
-    this.buffer.splice(insertAt, 0, snapshot);
-    while (this.buffer.length > this.capacity)
-      this.buffer.shift();
   }
   clear() {
-    this.buffer.length = 0;
-    this.renderTick = -Infinity;
-    this.latestReceivedAt = -Infinity;
-    this.smoothedTickRateMs = 0;
+    this.timeline.clear();
+    this.clock.reset();
+    this.smoothedTickRateMs = this.nominalTickMs;
   }
   apply(world, now, components, shouldSkip) {
-    if (this.buffer.length === 0)
+    const tl = this.timeline;
+    if (tl.length === 0)
       return;
-    const newest = this.buffer[this.buffer.length - 1];
-    const oldest = this.buffer[0];
+    const newest = tl.newest().sample;
+    const oldest = tl.oldest().sample;
     let tickRateMs = 0;
-    if (this.buffer.length >= 2) {
+    if (tl.length >= 2) {
       const tickSpan = newest.serverTick - oldest.serverTick;
-      const wallSpan = this.latestReceivedAt - oldest.receivedAt;
+      const wallSpan = tl.latestReceivedAt - oldest.receivedAt;
       const rawTickRateMs = tickSpan > 0 && wallSpan > 0 ? wallSpan / tickSpan : 0;
       if (rawTickRateMs > 0) {
         if (this.smoothedTickRateMs === 0)
@@ -928,42 +945,23 @@ var InterpolationBuffer = class {
     }
     const ageBeyondDelay = now - newest.receivedAt - this.delay;
     const targetTick = newest.serverTick + ageBeyondDelay / tickRateMs;
-    if (this.renderTick === -Infinity) {
-      this.renderTick = targetTick;
-    } else {
-      const drift = targetTick - this.renderTick;
-      if (drift > 2) {
-        this.renderTick = targetTick;
-      } else {
-        const warp = Math.max(0.9, Math.min(1.1, 1 + drift * 0.05));
-        this.renderTick += warp;
-      }
-    }
-    const renderTick = this.renderTick;
-    let a = null;
-    let b = null;
-    for (let i = 0; i < this.buffer.length - 1; i++) {
-      const s0 = this.buffer[i];
-      const s1 = this.buffer[i + 1];
-      if (s0.serverTick <= renderTick && renderTick <= s1.serverTick) {
-        a = s0;
-        b = s1;
-        break;
-      }
-    }
-    if (a === null || b === null) {
+    const renderTick = this.clock.advance(targetTick, this.maxDesync / tickRateMs);
+    const straddle = tl.straddle(renderTick);
+    if (straddle === null) {
       if (renderTick < oldest.serverTick)
         return;
       this.writeSnapshot(world, newest, components, shouldSkip);
       return;
     }
+    const [aIndex, bIndex] = straddle;
+    const a = tl.at(aIndex).sample;
+    const b = tl.at(bIndex).sample;
     const seen = /* @__PURE__ */ new Set();
     for (const eid of a.entityIds)
       seen.add(eid);
     for (const eid of b.entityIds)
       seen.add(eid);
-    const aIndex = this.buffer.indexOf(a);
-    const bIndex = this.buffer.indexOf(b);
+    const maxBridgeTicks = this.maxBridgeGap / tickRateMs;
     for (const serverEid of seen) {
       const localEid = this.serverToLocal.get(serverEid);
       if (localEid === void 0)
@@ -975,13 +973,13 @@ var InterpolationBuffer = class {
         let va = a.componentValuesByEntity.get(serverEid)?.get(c);
         while (va === void 0 && aIdx > 0) {
           aIdx--;
-          va = this.buffer[aIdx].componentValuesByEntity.get(serverEid)?.get(c);
+          va = tl.at(aIdx).sample.componentValuesByEntity.get(serverEid)?.get(c);
         }
         let bIdx = bIndex;
         let vb = b.componentValuesByEntity.get(serverEid)?.get(c);
-        while (vb === void 0 && bIdx < this.buffer.length - 1) {
+        while (vb === void 0 && bIdx < tl.length - 1) {
           bIdx++;
-          vb = this.buffer[bIdx].componentValuesByEntity.get(serverEid)?.get(c);
+          vb = tl.at(bIdx).sample.componentValuesByEntity.get(serverEid)?.get(c);
         }
         if (va === void 0 && vb === void 0)
           continue;
@@ -995,8 +993,10 @@ var InterpolationBuffer = class {
           if (mode === "none") {
             toWrite = vb;
           } else {
-            const aTick = this.buffer[aIdx].serverTick;
-            const bTick = this.buffer[bIdx].serverTick;
+            const bTick = tl.at(bIdx).sample.serverTick;
+            let aTick = tl.at(aIdx).sample.serverTick;
+            if (bTick - aTick > maxBridgeTicks)
+              aTick = bTick - 1;
             const wideSpan = bTick - aTick;
             const wideT = wideSpan > 0 ? Math.min(1, Math.max(0, (renderTick - aTick) / wideSpan)) : 0;
             if (mode === "step") {
@@ -1073,7 +1073,6 @@ var GameClient = class extends Network {
       "error"
     ]);
     this.predictionMap = null;
-    this.predictionHistory = [];
     this.localTick = 0;
     this.intentSequence = 0;
     this.lastServerTick = 0;
@@ -1084,6 +1083,8 @@ var GameClient = class extends Network {
     this.predictedEntities = /* @__PURE__ */ new Set();
     /** Set when MSG_ASSIGN_ENTITY lands before the matching spawn. */
     this.pendingAssignedServerEid = null;
+    /** Spawns discovered during a decode, emitted once values are written. */
+    this.deferredSpawns = [];
     /** Resolved local entity for the server's assignment. Default for sendIntent. */
     this._assignedEntity = null;
     this._rttMs = null;
@@ -1104,12 +1105,60 @@ var GameClient = class extends Network {
     this.rng = new import_simple_rng2.SimpleRNG(1);
     this.lastDt = opts.loop.ticker.intervalMs / 1e3;
     this.now = opts.now ?? (() => performance.now());
-    this.interpBuffer = new InterpolationBuffer(
+    this.interpBuffer = new SnapshotInterpolation(
       this.serverToLocal,
       16,
       interpolationDelay,
-      staleWindowMs
+      staleWindowMs,
+      strategy.maxDesync,
+      opts.loop.ticker.intervalMs,
+      strategy.maxBridgeGap
     );
+    this.reconciler = new import_prediction.Reconciler({
+      bufferSize: this.predictionBufferSize,
+      restore: ({ decoded, resetEntities }) => {
+        for (const serverEid of decoded.serverEntityIds) {
+          const localEid = this.serverToLocal.get(serverEid);
+          if (localEid === void 0)
+            continue;
+          if (!this.predictedEntities.has(localEid))
+            continue;
+          const comps = decoded.valuesByServerEntity.get(serverEid);
+          if (comps === void 0)
+            continue;
+          for (const [c, value] of comps) {
+            if (this.world.has(localEid, c)) {
+              this.world.update(localEid, c, value);
+            } else {
+              this.world.add(localEid, c, value);
+            }
+          }
+          resetEntities.add(localEid);
+        }
+      },
+      replay: (preds, { decoded, resetEntities }) => {
+        let replayedCount = 0;
+        for (const pred of preds) {
+          if (!resetEntities.has(pred.entity))
+            continue;
+          const predFn = this.predictionMap?.[pred.name];
+          if (predFn === void 0)
+            continue;
+          const ctx = {
+            world: this.world,
+            entity: pred.entity,
+            tick: pred.tick,
+            deltaTime: pred.deltaTime,
+            rng: this.rng,
+            fields: makeFieldsAccessor(this.world, pred.entity),
+            markDirty: makeMarkDirty(this.world, pred.entity)
+          };
+          predFn(pred.payload, ctx);
+          replayedCount++;
+        }
+        this.emit("reconciled", { rewindTick: decoded.clientAckTick, replayed: replayedCount });
+      }
+    });
     this.discoverSyncedComponents();
     this.wireTransport();
     this.wireLoop();
@@ -1196,6 +1245,7 @@ var GameClient = class extends Network {
   }
   handleSnapshot(payload) {
     try {
+      this.deferredSpawns.length = 0;
       const decoded = decodeDelta(
         this.world,
         payload,
@@ -1209,6 +1259,12 @@ var GameClient = class extends Network {
         () => false
       );
       this.lastServerTick = decoded.tick;
+      for (const spawn of this.deferredSpawns) {
+        this.emit("spawn", { entity: spawn.entity, components: spawn.components });
+        if (spawn.assigned)
+          this.emit("assigned", { entity: spawn.entity });
+      }
+      this.deferredSpawns.length = 0;
       this.emit("snapshot", { tick: decoded.tick, byteSize: payload.length + 1 });
       this.interpBuffer.record({
         receivedAt: this.now(),
@@ -1241,13 +1297,14 @@ var GameClient = class extends Network {
       const components = {};
       for (const c of present)
         components[c.name] = true;
-      this.emit("spawn", { entity: localEid, components });
+      let assigned = false;
       if (this.pendingAssignedServerEid === serverEid) {
         this.pendingAssignedServerEid = null;
         this.predictedEntities.add(localEid);
         this._assignedEntity = localEid;
-        this.emit("assigned", { entity: localEid });
+        assigned = true;
       }
+      this.deferredSpawns.push({ entity: localEid, components, assigned });
     }
     return localEid;
   }
@@ -1266,60 +1323,9 @@ var GameClient = class extends Network {
    * the server has acked, replay the rest on top.
    */
   reconcile(decoded) {
-    const resetEntities = /* @__PURE__ */ new Set();
-    for (const serverEid of decoded.serverEntityIds) {
-      const localEid = this.serverToLocal.get(serverEid);
-      if (localEid === void 0)
-        continue;
-      if (!this.predictedEntities.has(localEid))
-        continue;
-      const comps = decoded.valuesByServerEntity.get(serverEid);
-      if (comps === void 0)
-        continue;
-      for (const [c, value] of comps) {
-        if (this.world.has(localEid, c)) {
-          this.world.update(localEid, c, value);
-        } else {
-          this.world.add(localEid, c, value);
-        }
-      }
-      resetEntities.add(localEid);
-    }
-    const ackSequence = decoded.clientAckTick;
-    let cut = 0;
-    while (cut < this.predictionHistory.length && this.predictionHistory[cut].sequence <= ackSequence) {
-      cut++;
-    }
-    if (cut > 0)
-      this.predictionHistory.splice(0, cut);
-    const remaining = this.predictionHistory.length;
-    if (remaining === 0) {
-      this.emit("reconciled", { rewindTick: ackSequence, replayed: 0 });
-      return;
-    }
-    let replayedCount = 0;
-    for (let i = 0; i < remaining; i++) {
-      const pred = this.predictionHistory[i];
-      if (!resetEntities.has(pred.entity))
-        continue;
-      const predFn = this.predictionMap?.[pred.name];
-      if (predFn === void 0)
-        continue;
-      const ctx = {
-        world: this.world,
-        entity: pred.entity,
-        tick: pred.tick,
-        deltaTime: pred.deltaTime,
-        rng: this.rng,
-        fields: makeFieldsAccessor(this.world, pred.entity),
-        markDirty: makeMarkDirty(this.world, pred.entity)
-      };
-      predFn(pred.payload, ctx);
-      replayedCount++;
-    }
-    this.emit("reconciled", {
-      rewindTick: ackSequence,
-      replayed: replayedCount
+    this.reconciler.reconcile(decoded.clientAckTick, {
+      decoded,
+      resetEntities: /* @__PURE__ */ new Set()
     });
   }
   handleRpc(payload) {
@@ -1393,7 +1399,7 @@ var GameClient = class extends Network {
         markDirty: makeMarkDirty(this.world, entity)
       };
       predFn(payload, ctx);
-      this.predictionHistory.push({
+      this.reconciler.record(sequence, {
         tick: this.localTick,
         sequence,
         name,
@@ -1402,9 +1408,6 @@ var GameClient = class extends Network {
         deltaTime
       });
       this.predictedEntities.add(entity);
-      while (this.predictionHistory.length > this.predictionBufferSize) {
-        this.predictionHistory.shift();
-      }
     }
     return true;
   }
@@ -1435,7 +1438,7 @@ var GameClient = class extends Network {
     return this.localTick;
   }
   getPredictionDepth() {
-    return this.predictionHistory.length;
+    return this.reconciler.pending;
   }
   get interpolationDelay() {
     return this.interpBuffer.delay;
@@ -1443,6 +1446,12 @@ var GameClient = class extends Network {
   setInterpolationDelay(ms) {
     this.interpBuffer.setDelay(ms);
   }
+  setMaxDesync(ms) {
+    this.interpBuffer.setMaxDesync(ms);
+  }
+  setMaxBridgeGap(ms) {
+    this.interpBuffer.setMaxBridgeGap(ms);
+  }
 };
 
 // src/transports/memory-transport.ts
@@ -1545,8 +1554,3 @@ var MemoryPeerTransport = class {
     queueMicrotask(() => this.clientOpenHandler?.());
   }
 };
-
-// src/components/sync-spec.ts
-function networked(spec) {
-  return spec;
-}