quake2ts 0.0.286 → 0.0.289

package/packages/client/dist/esm/index.js

@@ -2297,6 +2297,333 @@ var BinaryStream = class {
     out.z = norm[2];
   }
 };
+var BinaryWriter = class {
+  constructor(sizeOrBuffer = 1400) {
+    if (typeof sizeOrBuffer === "number") {
+      this.buffer = new Uint8Array(sizeOrBuffer);
+      this.fixed = false;
+    } else {
+      this.buffer = sizeOrBuffer;
+      this.fixed = true;
+    }
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    this.offset = 0;
+  }
+  ensureSpace(bytes) {
+    if (this.offset + bytes > this.buffer.byteLength) {
+      if (this.fixed) {
+        throw new Error(`Buffer overflow: capacity ${this.buffer.byteLength}, needed ${this.offset + bytes}`);
+      }
+      const newSize = Math.max(this.buffer.byteLength * 2, this.offset + bytes);
+      const newBuffer = new Uint8Array(newSize);
+      newBuffer.set(this.buffer);
+      this.buffer = newBuffer;
+      this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    }
+  }
+  writeByte(value) {
+    this.ensureSpace(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+  writeChar(value) {
+    this.ensureSpace(1);
+    this.view.setInt8(this.offset, value);
+    this.offset += 1;
+  }
+  writeShort(value) {
+    this.ensureSpace(2);
+    this.view.setInt16(this.offset, value, true);
+    this.offset += 2;
+  }
+  writeLong(value) {
+    this.ensureSpace(4);
+    this.view.setInt32(this.offset, value, true);
+    this.offset += 4;
+  }
+  writeFloat(value) {
+    this.ensureSpace(4);
+    this.view.setFloat32(this.offset, value, true);
+    this.offset += 4;
+  }
+  writeString(value) {
+    const len2 = value.length;
+    this.ensureSpace(len2 + 1);
+    for (let i = 0; i < len2; i++) {
+      this.view.setUint8(this.offset + i, value.charCodeAt(i));
+    }
+    this.view.setUint8(this.offset + len2, 0);
+    this.offset += len2 + 1;
+  }
+  writeCoord(value) {
+    this.writeShort(Math.trunc(value * 8));
+  }
+  writeAngle(value) {
+    this.writeByte(Math.trunc(value * 256 / 360) & 255);
+  }
+  writeAngle16(value) {
+    this.writeShort(Math.trunc(value * 65536 / 360) & 65535);
+  }
+  writePos(pos) {
+    this.writeCoord(pos.x);
+    this.writeCoord(pos.y);
+    this.writeCoord(pos.z);
+  }
+  writeDir(dir) {
+    let maxDot = -1;
+    let bestIndex = 0;
+    if (dir.x === 0 && dir.y === 0 && dir.z === 0) {
+      this.writeByte(0);
+      return;
+    }
+    for (let i = 0; i < ANORMS.length; i++) {
+      const norm = ANORMS[i];
+      const dot2 = dir.x * norm[0] + dir.y * norm[1] + dir.z * norm[2];
+      if (dot2 > maxDot) {
+        maxDot = dot2;
+        bestIndex = i;
+      }
+    }
+    this.writeByte(bestIndex);
+  }
+  getData() {
+    return this.buffer.slice(0, this.offset);
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  getOffset() {
+    return this.offset;
+  }
+  reset() {
+    this.offset = 0;
+  }
+};
+var _NetChan = class _NetChan2 {
+  constructor() {
+    this.qport = 0;
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    this.incomingReliableAcknowledged = false;
+    this.incomingReliableSequence = 0;
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    this.lastReceived = 0;
+    this.lastSent = 0;
+    this.remoteAddress = null;
+    this.reliableMessage = new BinaryWriter(_NetChan2.MAX_MSGLEN);
+    const now = Date.now();
+    this.lastReceived = now;
+    this.lastSent = now;
+    this.qport = Math.floor(Math.random() * 65536);
+  }
+  /**
+   * Setup the netchan with specific settings
+   */
+  setup(qport, address = null) {
+    this.qport = qport;
+    this.remoteAddress = address;
+    this.reset();
+  }
+  /**
+   * Reset the netchan state
+   */
+  reset() {
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    this.incomingReliableAcknowledged = false;
+    this.incomingReliableSequence = 0;
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    this.reliableMessage.reset();
+    this.lastReceived = Date.now();
+    this.lastSent = Date.now();
+  }
+  /**
+   * Transmits a packet containing reliable and unreliable data
+   */
+  transmit(unreliableData) {
+    this.outgoingSequence++;
+    this.lastSent = Date.now();
+    const headerSize = _NetChan2.PACKET_HEADER;
+    const reliableSize = this.reliableLength > 0 ? this.reliableLength + 2 : 0;
+    let unreliableSize = unreliableData ? unreliableData.length : 0;
+    if (headerSize + reliableSize + unreliableSize > _NetChan2.MAX_MSGLEN) {
+      unreliableSize = _NetChan2.MAX_MSGLEN - headerSize - reliableSize;
+      if (unreliableSize < 0) unreliableSize = 0;
+    }
+    const buffer = new ArrayBuffer(headerSize + reliableSize + unreliableSize);
+    const view = new DataView(buffer);
+    const result = new Uint8Array(buffer);
+    let sequence = this.outgoingSequence;
+    if (this.reliableLength > 0) {
+      sequence |= 2147483648;
+      if ((this.outgoingReliableSequence & 1) !== 0) {
+        sequence |= 1073741824;
+      }
+    }
+    view.setUint32(0, sequence, true);
+    let ack = this.incomingSequence;
+    if ((this.incomingReliableSequence & 1) !== 0) {
+      ack |= 2147483648;
+    }
+    view.setUint32(4, ack, true);
+    view.setUint16(8, this.qport, true);
+    let offset = headerSize;
+    if (this.reliableLength > 0) {
+      view.setUint16(offset, this.reliableLength, true);
+      offset += 2;
+      const reliableBuffer = this.reliableMessage.getBuffer();
+      const reliableBytes = reliableBuffer.subarray(0, this.reliableLength);
+      result.set(reliableBytes, offset);
+      offset += this.reliableLength;
+    }
+    if (unreliableData && unreliableSize > 0) {
+      const chunk = unreliableData.slice(0, unreliableSize);
+      result.set(chunk, offset);
+    }
+    return result;
+  }
+  /**
+   * Processes a received packet
+   * Returns the payload data (reliable + unreliable) to be processed, or null if discarded
+   */
+  process(packet) {
+    if (packet.length < _NetChan2.PACKET_HEADER) {
+      return null;
+    }
+    this.lastReceived = Date.now();
+    const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const sequence = view.getUint32(0, true);
+    const ack = view.getUint32(4, true);
+    const qport = view.getUint16(8, true);
+    if (this.qport !== qport) {
+      return null;
+    }
+    const seqNumberClean = sequence & ~(2147483648 | 1073741824);
+    if ((seqNumberClean - this.incomingSequence | 0) <= 0) {
+      return null;
+    }
+    this.incomingSequence = seqNumberClean;
+    const ackNumber = ack & ~2147483648;
+    const ackReliable = (ack & 2147483648) !== 0;
+    if (ackNumber > this.incomingAcknowledged) {
+      this.incomingAcknowledged = ackNumber;
+    }
+    if (this.reliableLength > 0) {
+      const receivedAckBit = ackReliable ? 1 : 0;
+      const currentReliableBit = this.outgoingReliableSequence & 1;
+      if (receivedAckBit !== currentReliableBit) {
+        this.reliableLength = 0;
+        this.reliableMessage.reset();
+        this.outgoingReliableSequence ^= 1;
+      }
+    }
+    const hasReliableData = (sequence & 2147483648) !== 0;
+    const reliableSeqBit = (sequence & 1073741824) !== 0 ? 1 : 0;
+    let payloadOffset = _NetChan2.PACKET_HEADER;
+    let reliableData = null;
+    if (hasReliableData) {
+      if (payloadOffset + 2 > packet.byteLength) return null;
+      const reliableLen = view.getUint16(payloadOffset, true);
+      payloadOffset += 2;
+      const expectedBit = this.incomingReliableSequence & 1;
+      if (reliableSeqBit === expectedBit) {
+        this.incomingReliableSequence++;
+        if (payloadOffset + reliableLen > packet.byteLength) return null;
+        reliableData = packet.slice(payloadOffset, payloadOffset + reliableLen);
+      }
+      payloadOffset += reliableLen;
+    }
+    const unreliableData = packet.slice(payloadOffset);
+    if (reliableData && reliableData.length > 0) {
+      const totalLen = reliableData.length + unreliableData.length;
+      const result = new Uint8Array(totalLen);
+      result.set(reliableData, 0);
+      result.set(unreliableData, reliableData.length);
+      return result;
+    }
+    if (unreliableData) {
+      return unreliableData;
+    }
+    return new Uint8Array(0);
+  }
+  /**
+   * Checks if reliable message buffer is empty and ready for new data
+   */
+  canSendReliable() {
+    return this.reliableLength === 0;
+  }
+  /**
+   * Writes a byte to the reliable message buffer
+   */
+  writeReliableByte(value) {
+    if (this.reliableLength + 1 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeByte(value);
+    this.reliableLength++;
+  }
+  /**
+   * Writes a short to the reliable message buffer
+   */
+  writeReliableShort(value) {
+    if (this.reliableLength + 2 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeShort(value);
+    this.reliableLength += 2;
+  }
+  /**
+   * Writes a long to the reliable message buffer
+   */
+  writeReliableLong(value) {
+    if (this.reliableLength + 4 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeLong(value);
+    this.reliableLength += 4;
+  }
+  /**
+   * Writes a string to the reliable message buffer
+   */
+  writeReliableString(value) {
+    const len2 = value.length + 1;
+    if (this.reliableLength + len2 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeString(value);
+    this.reliableLength += len2;
+  }
+  /**
+   * Returns the current reliable data buffer
+   */
+  getReliableData() {
+    if (this.reliableLength === 0) {
+      return new Uint8Array(0);
+    }
+    const buffer = this.reliableMessage.getBuffer();
+    return buffer.subarray(0, this.reliableLength);
+  }
+  /**
+   * Checks if we need to send a keepalive packet
+   */
+  needsKeepalive(currentTime) {
+    return currentTime - this.lastSent > 1e3;
+  }
+  /**
+   * Checks if the connection has timed out
+   */
+  isTimedOut(currentTime, timeoutMs = 3e4) {
+    return currentTime - this.lastReceived > timeoutMs;
+  }
+};
+_NetChan.MAX_MSGLEN = 1400;
+_NetChan.FRAGMENT_SIZE = 1024;
+_NetChan.PACKET_HEADER = 10;
+_NetChan.HEADER_OVERHEAD = _NetChan.PACKET_HEADER + 2;
 var AmmoType = /* @__PURE__ */ ((AmmoType22) => {
   AmmoType22[AmmoType22["Bullets"] = 0] = "Bullets";
   AmmoType22[AmmoType22["Shells"] = 1] = "Shells";
@@ -8827,7 +9154,7 @@ var BinaryStream2 = class {
     out.z = norm[2];
   }
 };
-var BinaryWriter = class {
+var BinaryWriter2 = class {
   constructor(sizeOrBuffer = 1400) {
     if (typeof sizeOrBuffer === "number") {
       this.buffer = new Uint8Array(sizeOrBuffer);
@@ -9019,6 +9346,231 @@ var NetworkMessageBuilder = class {
     this.writeByte(best);
   }
 };
+var _NetChan3 = class _NetChan4 {
+  constructor() {
+    this.qport = 0;
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    this.incomingReliableAcknowledged = false;
+    this.incomingReliableSequence = 0;
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    this.lastReceived = 0;
+    this.lastSent = 0;
+    this.remoteAddress = null;
+    this.reliableMessage = new BinaryWriter2(_NetChan4.MAX_MSGLEN);
+    const now = Date.now();
+    this.lastReceived = now;
+    this.lastSent = now;
+    this.qport = Math.floor(Math.random() * 65536);
+  }
+  /**
+   * Setup the netchan with specific settings
+   */
+  setup(qport, address = null) {
+    this.qport = qport;
+    this.remoteAddress = address;
+    this.reset();
+  }
+  /**
+   * Reset the netchan state
+   */
+  reset() {
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    this.incomingReliableAcknowledged = false;
+    this.incomingReliableSequence = 0;
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    this.reliableMessage.reset();
+    this.lastReceived = Date.now();
+    this.lastSent = Date.now();
+  }
+  /**
+   * Transmits a packet containing reliable and unreliable data
+   */
+  transmit(unreliableData) {
+    this.outgoingSequence++;
+    this.lastSent = Date.now();
+    const headerSize = _NetChan4.PACKET_HEADER;
+    const reliableSize = this.reliableLength > 0 ? this.reliableLength + 2 : 0;
+    let unreliableSize = unreliableData ? unreliableData.length : 0;
+    if (headerSize + reliableSize + unreliableSize > _NetChan4.MAX_MSGLEN) {
+      unreliableSize = _NetChan4.MAX_MSGLEN - headerSize - reliableSize;
+      if (unreliableSize < 0) unreliableSize = 0;
+    }
+    const buffer = new ArrayBuffer(headerSize + reliableSize + unreliableSize);
+    const view = new DataView(buffer);
+    const result = new Uint8Array(buffer);
+    let sequence = this.outgoingSequence;
+    if (this.reliableLength > 0) {
+      sequence |= 2147483648;
+      if ((this.outgoingReliableSequence & 1) !== 0) {
+        sequence |= 1073741824;
+      }
+    }
+    view.setUint32(0, sequence, true);
+    let ack = this.incomingSequence;
+    if ((this.incomingReliableSequence & 1) !== 0) {
+      ack |= 2147483648;
+    }
+    view.setUint32(4, ack, true);
+    view.setUint16(8, this.qport, true);
+    let offset = headerSize;
+    if (this.reliableLength > 0) {
+      view.setUint16(offset, this.reliableLength, true);
+      offset += 2;
+      const reliableBuffer = this.reliableMessage.getBuffer();
+      const reliableBytes = reliableBuffer.subarray(0, this.reliableLength);
+      result.set(reliableBytes, offset);
+      offset += this.reliableLength;
+    }
+    if (unreliableData && unreliableSize > 0) {
+      const chunk = unreliableData.slice(0, unreliableSize);
+      result.set(chunk, offset);
+    }
+    return result;
+  }
+  /**
+   * Processes a received packet
+   * Returns the payload data (reliable + unreliable) to be processed, or null if discarded
+   */
+  process(packet) {
+    if (packet.length < _NetChan4.PACKET_HEADER) {
+      return null;
+    }
+    this.lastReceived = Date.now();
+    const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const sequence = view.getUint32(0, true);
+    const ack = view.getUint32(4, true);
+    const qport = view.getUint16(8, true);
+    if (this.qport !== qport) {
+      return null;
+    }
+    const seqNumberClean = sequence & ~(2147483648 | 1073741824);
+    if ((seqNumberClean - this.incomingSequence | 0) <= 0) {
+      return null;
+    }
+    this.incomingSequence = seqNumberClean;
+    const ackNumber = ack & ~2147483648;
+    const ackReliable = (ack & 2147483648) !== 0;
+    if (ackNumber > this.incomingAcknowledged) {
+      this.incomingAcknowledged = ackNumber;
+    }
+    if (this.reliableLength > 0) {
+      const receivedAckBit = ackReliable ? 1 : 0;
+      const currentReliableBit = this.outgoingReliableSequence & 1;
+      if (receivedAckBit !== currentReliableBit) {
+        this.reliableLength = 0;
+        this.reliableMessage.reset();
+        this.outgoingReliableSequence ^= 1;
+      }
+    }
+    const hasReliableData = (sequence & 2147483648) !== 0;
+    const reliableSeqBit = (sequence & 1073741824) !== 0 ? 1 : 0;
+    let payloadOffset = _NetChan4.PACKET_HEADER;
+    let reliableData = null;
+    if (hasReliableData) {
+      if (payloadOffset + 2 > packet.byteLength) return null;
+      const reliableLen = view.getUint16(payloadOffset, true);
+      payloadOffset += 2;
+      const expectedBit = this.incomingReliableSequence & 1;
+      if (reliableSeqBit === expectedBit) {
+        this.incomingReliableSequence++;
+        if (payloadOffset + reliableLen > packet.byteLength) return null;
+        reliableData = packet.slice(payloadOffset, payloadOffset + reliableLen);
+      }
+      payloadOffset += reliableLen;
+    }
+    const unreliableData = packet.slice(payloadOffset);
+    if (reliableData && reliableData.length > 0) {
+      const totalLen = reliableData.length + unreliableData.length;
+      const result = new Uint8Array(totalLen);
+      result.set(reliableData, 0);
+      result.set(unreliableData, reliableData.length);
+      return result;
+    }
+    if (unreliableData) {
+      return unreliableData;
+    }
+    return new Uint8Array(0);
+  }
+  /**
+   * Checks if reliable message buffer is empty and ready for new data
+   */
+  canSendReliable() {
+    return this.reliableLength === 0;
+  }
+  /**
+   * Writes a byte to the reliable message buffer
+   */
+  writeReliableByte(value) {
+    if (this.reliableLength + 1 > _NetChan4.MAX_MSGLEN - _NetChan4.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeByte(value);
+    this.reliableLength++;
+  }
+  /**
+   * Writes a short to the reliable message buffer
+   */
+  writeReliableShort(value) {
+    if (this.reliableLength + 2 > _NetChan4.MAX_MSGLEN - _NetChan4.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeShort(value);
+    this.reliableLength += 2;
+  }
+  /**
+   * Writes a long to the reliable message buffer
+   */
+  writeReliableLong(value) {
+    if (this.reliableLength + 4 > _NetChan4.MAX_MSGLEN - _NetChan4.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeLong(value);
+    this.reliableLength += 4;
+  }
+  /**
+   * Writes a string to the reliable message buffer
+   */
+  writeReliableString(value) {
+    const len2 = value.length + 1;
+    if (this.reliableLength + len2 > _NetChan4.MAX_MSGLEN - _NetChan4.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeString(value);
+    this.reliableLength += len2;
+  }
+  /**
+   * Returns the current reliable data buffer
+   */
+  getReliableData() {
+    if (this.reliableLength === 0) {
+      return new Uint8Array(0);
+    }
+    const buffer = this.reliableMessage.getBuffer();
+    return buffer.subarray(0, this.reliableLength);
+  }
+  /**
+   * Checks if we need to send a keepalive packet
+   */
+  needsKeepalive(currentTime) {
+    return currentTime - this.lastSent > 1e3;
+  }
+  /**
+   * Checks if the connection has timed out
+   */
+  isTimedOut(currentTime, timeoutMs = 3e4) {
+    return currentTime - this.lastReceived > timeoutMs;
+  }
+};
+_NetChan3.MAX_MSGLEN = 1400;
+_NetChan3.FRAGMENT_SIZE = 1024;
+_NetChan3.PACKET_HEADER = 10;
+_NetChan3.HEADER_OVERHEAD = _NetChan3.PACKET_HEADER + 2;
 var AmmoType2 = /* @__PURE__ */ ((AmmoType22) => {
   AmmoType22[AmmoType22["Bullets"] = 0] = "Bullets";
   AmmoType22[AmmoType22["Shells"] = 1] = "Shells";
@@ -9557,6 +10109,91 @@ var DEMO_ITEM_MAPPING = [
   // IT_ITEM_COMPASS
 ];
 
+// src/entities.ts
+function lerp2(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpAngle(a, b, t) {
+  return lerp2(a, b, t);
+}
+function buildRenderableEntities(latestEntities, previousEntities, alpha, configStrings, imports) {
+  const renderables = [];
+  const assets = imports.engine.assets;
+  if (!assets) return renderables;
+  let prevMap;
+  if (previousEntities instanceof Map) {
+    prevMap = previousEntities;
+  } else {
+    prevMap = new Map(previousEntities.map((e) => [e.number, e]));
+  }
+  for (const ent of latestEntities) {
+    const prev = prevMap.get(ent.number) ?? ent;
+    const modelIndex = ent.modelIndex ?? ent.modelindex;
+    const skinNum = ent.skinNum ?? ent.skinnum;
+    if (modelIndex === void 0) continue;
+    const modelName = configStrings.getModelName(modelIndex);
+    if (!modelName) continue;
+    const model = assets.getMd2Model(modelName) || assets.getMd3Model(modelName);
+    if (!model) continue;
+    const origin = {
+      x: lerp2(prev.origin.x, ent.origin.x, alpha),
+      y: lerp2(prev.origin.y, ent.origin.y, alpha),
+      z: lerp2(prev.origin.z, ent.origin.z, alpha)
+    };
+    const angles = {
+      x: lerpAngle(prev.angles.x, ent.angles.x, alpha),
+      y: lerpAngle(prev.angles.y, ent.angles.y, alpha),
+      z: lerpAngle(prev.angles.z, ent.angles.z, alpha)
+    };
+    const frame = ent.frame;
+    const prevFrame = prev.frame;
+    const scaleA = prev.scale !== void 0 ? prev.scale : 1;
+    const scaleB = ent.scale !== void 0 ? ent.scale : 1;
+    const scale3 = lerp2(scaleA, scaleB, alpha);
+    const getAlpha = (val) => val === void 0 || val === 0 ? 255 : val;
+    const alphaA = getAlpha(prev.alpha);
+    const alphaB = getAlpha(ent.alpha);
+    const alphaVal = lerp2(alphaA, alphaB, alpha);
+    const normalizedAlpha = alphaVal / 255;
+    const mat = mat4_exports.create();
+    mat4_exports.translate(mat, mat, [origin.x, origin.y, origin.z]);
+    mat4_exports.rotateZ(mat, mat, angles.z * Math.PI / 180);
+    mat4_exports.rotateY(mat, mat, angles.y * Math.PI / 180);
+    mat4_exports.rotateX(mat, mat, angles.x * Math.PI / 180);
+    mat4_exports.scale(mat, mat, [scale3, scale3, scale3]);
+    const skinName = skinNum !== void 0 && skinNum > 0 ? configStrings.getImageName(skinNum) : void 0;
+    if (model.header.magic === 844121161) {
+      renderables.push({
+        type: "md2",
+        model,
+        // Cast to Md2Model
+        blend: {
+          frame0: prevFrame,
+          frame1: frame,
+          lerp: alpha
+        },
+        transform: mat,
+        skin: skinName,
+        alpha: normalizedAlpha
+      });
+    } else if (model.header.magic === 860898377) {
+      renderables.push({
+        type: "md3",
+        model,
+        blend: {
+          frame0: prevFrame,
+          frame1: frame,
+          lerp: alpha
+        },
+        transform: mat,
+        alpha: normalizedAlpha
+        // Lighting? Skins?
+      });
+    }
+  }
+  return renderables;
+}
+
 // src/demo/handler.ts
 var MAX_CONFIGSTRINGS3 = 32768;
 var ClientNetworkHandler = class {
@@ -9564,6 +10201,8 @@ var ClientNetworkHandler = class {
     this.configstrings = new Array(MAX_CONFIGSTRINGS3).fill("");
     this.entities = /* @__PURE__ */ new Map();
     // Current frame entities
+    this.previousEntities = /* @__PURE__ */ new Map();
+    // Previous frame entities
     this.baselines = /* @__PURE__ */ new Map();
     this.previousFrame = null;
     this.latestFrame = null;
@@ -9587,8 +10226,10 @@ var ClientNetworkHandler = class {
     console.log(`Demo: Server Data - Protocol: ${protocol}, Level: ${levelName}, Tick: ${tickRate ?? 10}`);
     this.configstrings.fill("");
     this.entities.clear();
+    this.previousEntities.clear();
     this.baselines.clear();
     this.latestFrame = null;
+    this.previousFrame = null;
     this.playerNum = playerNum;
     if (this.callbacks?.onServerData) {
       this.callbacks.onServerData(protocol, tickRate);
@@ -9606,6 +10247,7 @@ var ClientNetworkHandler = class {
   onFrame(frame) {
     if (this.latestFrame) {
       this.previousFrame = this.latestFrame;
+      this.previousEntities = this.entities;
     }
     this.latestFrame = frame;
     this.stats = [...frame.playerState.stats];
@@ -9916,7 +10558,10 @@ var ClientNetworkHandler = class {
     if (this.previousFrame && timeMs !== void 0) {
       const latestServerTime = this.latestFrame.serverFrame * 100;
       const previousServerTime = this.previousFrame.serverFrame * 100;
-      if (timeMs >= previousServerTime && timeMs <= latestServerTime) {
+      if (timeMs <= 1) {
+        const previousState = this.convertFrameToPredictionState(this.previousFrame);
+        return interpolatePredictionState(previousState, latestState, Math.max(0, Math.min(1, timeMs)));
+      } else if (timeMs >= previousServerTime && timeMs <= latestServerTime) {
         const alpha = (timeMs - previousServerTime) / (latestServerTime - previousServerTime);
         const previousState = this.convertFrameToPredictionState(this.previousFrame);
         return interpolatePredictionState(previousState, latestState, Math.max(0, Math.min(1, alpha)));
@@ -9924,6 +10569,27 @@ var ClientNetworkHandler = class {
     }
     return latestState;
   }
+  getRenderableEntities(alpha, configStrings) {
+    if (!this.latestFrame) return [];
+    if (!this.imports) return [];
+    const latest = Array.from(this.entities.values());
+    const previous = this.previousEntities.size > 0 ? this.previousEntities : latest;
+    return buildRenderableEntities(
+      latest,
+      previous,
+      alpha,
+      configStrings,
+      this.imports
+    );
+  }
+  getDemoCamera(alpha) {
+    const ps = this.getPredictionState(alpha);
+    return {
+      origin: ps.origin,
+      angles: ps.viewAngles,
+      fov: ps.fov ?? 90
+    };
+  }
   get latestServerFrame() {
     return this.latestFrame?.serverFrame ?? 0;
   }
@@ -10842,82 +11508,6 @@ var WheelMenuSystem = class {
   }
 };
 
-// src/entities.ts
-function lerp2(a, b, t) {
-  return a + (b - a) * t;
-}
-function lerpAngle(a, b, t) {
-  return lerp2(a, b, t);
-}
-function buildRenderableEntities(latestEntities, previousEntities, alpha, configStrings, imports) {
-  const renderables = [];
-  const assets = imports.engine.assets;
-  if (!assets) return renderables;
-  const prevMap = new Map(previousEntities.map((e) => [e.number, e]));
-  for (const ent of latestEntities) {
-    const prev = prevMap.get(ent.number) ?? ent;
-    const modelName = configStrings.getModelName(ent.modelIndex);
-    if (!modelName) continue;
-    const model = assets.getMd2Model(modelName) || assets.getMd3Model(modelName);
-    if (!model) continue;
-    const origin = {
-      x: lerp2(prev.origin.x, ent.origin.x, alpha),
-      y: lerp2(prev.origin.y, ent.origin.y, alpha),
-      z: lerp2(prev.origin.z, ent.origin.z, alpha)
-    };
-    const angles = {
-      x: lerpAngle(prev.angles.x, ent.angles.x, alpha),
-      y: lerpAngle(prev.angles.y, ent.angles.y, alpha),
-      z: lerpAngle(prev.angles.z, ent.angles.z, alpha)
-    };
-    const frame = ent.frame;
-    const prevFrame = prev.frame;
-    const scaleA = prev.scale !== void 0 ? prev.scale : 1;
-    const scaleB = ent.scale !== void 0 ? ent.scale : 1;
-    const scale3 = lerp2(scaleA, scaleB, alpha);
-    const getAlpha = (val) => val === void 0 || val === 0 ? 255 : val;
-    const alphaA = getAlpha(prev.alpha);
-    const alphaB = getAlpha(ent.alpha);
-    const alphaVal = lerp2(alphaA, alphaB, alpha);
-    const normalizedAlpha = alphaVal / 255;
-    const mat = mat4_exports.create();
-    mat4_exports.translate(mat, mat, [origin.x, origin.y, origin.z]);
-    mat4_exports.rotateZ(mat, mat, angles.z * Math.PI / 180);
-    mat4_exports.rotateY(mat, mat, angles.y * Math.PI / 180);
-    mat4_exports.rotateX(mat, mat, angles.x * Math.PI / 180);
-    mat4_exports.scale(mat, mat, [scale3, scale3, scale3]);
-    if (model.header.magic === 844121161) {
-      renderables.push({
-        type: "md2",
-        model,
-        // Cast to Md2Model
-        blend: {
-          frame0: prevFrame,
-          frame1: frame,
-          lerp: alpha
-        },
-        transform: mat,
-        skin: ent.skinNum > 0 ? configStrings.getImageName(ent.skinNum) : void 0,
-        alpha: normalizedAlpha
-      });
-    } else if (model.header.magic === 860898377) {
-      renderables.push({
-        type: "md3",
-        model,
-        blend: {
-          frame0: prevFrame,
-          frame1: frame,
-          lerp: alpha
-        },
-        transform: mat,
-        alpha: normalizedAlpha
-        // Lighting? Skins?
-      });
-    }
-  }
-  return renderables;
-}
-
 // src/net/browserWsDriver.ts
 var BrowserWebSocketNetDriver = class {
   constructor() {
@@ -11048,7 +11638,7 @@ var MultiplayerConnection = class {
     if (this.commandHistory.length > CMD_BACKUP) {
       this.commandHistory.shift();
     }
-    const writer = new BinaryWriter();
+    const writer = new BinaryWriter2();
     writer.writeLong(0);
     writer.writeLong(0);
     writer.writeByte(ClientCommand.move);