quake2ts 0.0.78 → 0.0.79

package/packages/engine/dist/cjs/index.cjs

@@ -43,6 +43,8 @@ __export(index_exports, {
   ConfigStringRegistry: () => ConfigStringRegistry,
   Cvar: () => Cvar,
   CvarRegistry: () => CvarRegistry,
+  DemoPlaybackController: () => DemoPlaybackController,
+  DemoReader: () => DemoReader,
   EngineHost: () => EngineHost,
   EngineRuntime: () => EngineRuntime,
   FixedTimestepLoop: () => FixedTimestepLoop,
@@ -64,6 +66,7 @@ __export(index_exports, {
   Md3Pipeline: () => Md3Pipeline,
   Md3SurfaceMesh: () => Md3SurfaceMesh,
   MusicSystem: () => MusicSystem,
+  NetworkMessageParser: () => NetworkMessageParser,
   PARTICLE_FRAGMENT_SHADER: () => PARTICLE_FRAGMENT_SHADER,
   PARTICLE_VERTEX_SHADER: () => PARTICLE_VERTEX_SHADER,
   PakArchive: () => PakArchive,
@@ -74,6 +77,7 @@ __export(index_exports, {
   PakValidator: () => PakValidator,
   ParticleRenderer: () => ParticleRenderer,
   ParticleSystem: () => ParticleSystem,
+  PlaybackState: () => PlaybackState,
   RERELEASE_KNOWN_PAKS: () => RERELEASE_KNOWN_PAKS,
   SKYBOX_FRAGMENT_SHADER: () => SKYBOX_FRAGMENT_SHADER,
   SKYBOX_VERTEX_SHADER: () => SKYBOX_VERTEX_SHADER,
@@ -463,6 +467,193 @@ function configStringSize(index) {
   return CS_MAX_STRING_LENGTH;
 }
 var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
+var ServerCommand = /* @__PURE__ */ ((ServerCommand2) => {
+  ServerCommand2[ServerCommand2["bad"] = 0] = "bad";
+  ServerCommand2[ServerCommand2["muzzleflash"] = 1] = "muzzleflash";
+  ServerCommand2[ServerCommand2["muzzleflash2"] = 2] = "muzzleflash2";
+  ServerCommand2[ServerCommand2["temp_entity"] = 3] = "temp_entity";
+  ServerCommand2[ServerCommand2["layout"] = 4] = "layout";
+  ServerCommand2[ServerCommand2["inventory"] = 5] = "inventory";
+  ServerCommand2[ServerCommand2["nop"] = 6] = "nop";
+  ServerCommand2[ServerCommand2["disconnect"] = 7] = "disconnect";
+  ServerCommand2[ServerCommand2["reconnect"] = 8] = "reconnect";
+  ServerCommand2[ServerCommand2["sound"] = 9] = "sound";
+  ServerCommand2[ServerCommand2["print"] = 10] = "print";
+  ServerCommand2[ServerCommand2["stufftext"] = 11] = "stufftext";
+  ServerCommand2[ServerCommand2["serverdata"] = 12] = "serverdata";
+  ServerCommand2[ServerCommand2["configstring"] = 13] = "configstring";
+  ServerCommand2[ServerCommand2["spawnbaseline"] = 14] = "spawnbaseline";
+  ServerCommand2[ServerCommand2["centerprint"] = 15] = "centerprint";
+  ServerCommand2[ServerCommand2["download"] = 16] = "download";
+  ServerCommand2[ServerCommand2["playerinfo"] = 17] = "playerinfo";
+  ServerCommand2[ServerCommand2["packetentities"] = 18] = "packetentities";
+  ServerCommand2[ServerCommand2["deltapacketentities"] = 19] = "deltapacketentities";
+  ServerCommand2[ServerCommand2["frame"] = 20] = "frame";
+  return ServerCommand2;
+})(ServerCommand || {});
+var TempEntity = /* @__PURE__ */ ((TempEntity2) => {
+  TempEntity2[TempEntity2["GUNSHOT"] = 0] = "GUNSHOT";
+  TempEntity2[TempEntity2["BLOOD"] = 1] = "BLOOD";
+  TempEntity2[TempEntity2["BLASTER"] = 2] = "BLASTER";
+  TempEntity2[TempEntity2["RAILTRAIL"] = 3] = "RAILTRAIL";
+  TempEntity2[TempEntity2["SHOTGUN"] = 4] = "SHOTGUN";
+  TempEntity2[TempEntity2["EXPLOSION1"] = 5] = "EXPLOSION1";
+  TempEntity2[TempEntity2["EXPLOSION2"] = 6] = "EXPLOSION2";
+  TempEntity2[TempEntity2["ROCKET_EXPLOSION"] = 7] = "ROCKET_EXPLOSION";
+  TempEntity2[TempEntity2["GRENADE_EXPLOSION"] = 8] = "GRENADE_EXPLOSION";
+  TempEntity2[TempEntity2["SPARKS"] = 9] = "SPARKS";
+  TempEntity2[TempEntity2["SPLASH"] = 10] = "SPLASH";
+  TempEntity2[TempEntity2["BUBBLETRAIL"] = 11] = "BUBBLETRAIL";
+  TempEntity2[TempEntity2["SCREEN_SPARKS"] = 12] = "SCREEN_SPARKS";
+  TempEntity2[TempEntity2["SHIELD_SPARKS"] = 13] = "SHIELD_SPARKS";
+  TempEntity2[TempEntity2["BULLET_SPARKS"] = 14] = "BULLET_SPARKS";
+  TempEntity2[TempEntity2["LASER_SPARKS"] = 15] = "LASER_SPARKS";
+  TempEntity2[TempEntity2["PARASITE_ATTACK"] = 16] = "PARASITE_ATTACK";
+  TempEntity2[TempEntity2["ROCKET_EXPLOSION_WATER"] = 17] = "ROCKET_EXPLOSION_WATER";
+  TempEntity2[TempEntity2["GRENADE_EXPLOSION_WATER"] = 18] = "GRENADE_EXPLOSION_WATER";
+  TempEntity2[TempEntity2["MEDIC_CABLE_ATTACK"] = 19] = "MEDIC_CABLE_ATTACK";
+  TempEntity2[TempEntity2["BFG_EXPLOSION"] = 20] = "BFG_EXPLOSION";
+  TempEntity2[TempEntity2["BFG_BIGEXPLOSION"] = 21] = "BFG_BIGEXPLOSION";
+  TempEntity2[TempEntity2["BOSSTPORT"] = 22] = "BOSSTPORT";
+  TempEntity2[TempEntity2["BFG_LASER"] = 23] = "BFG_LASER";
+  TempEntity2[TempEntity2["GRAPPLE_CABLE"] = 24] = "GRAPPLE_CABLE";
+  TempEntity2[TempEntity2["WELDING_SPARKS"] = 25] = "WELDING_SPARKS";
+  TempEntity2[TempEntity2["GREENBLOOD"] = 26] = "GREENBLOOD";
+  TempEntity2[TempEntity2["BLUEHYPERBLASTER"] = 27] = "BLUEHYPERBLASTER";
+  TempEntity2[TempEntity2["PLASMA_EXPLOSION"] = 28] = "PLASMA_EXPLOSION";
+  TempEntity2[TempEntity2["TUNNEL_SPARKS"] = 29] = "TUNNEL_SPARKS";
+  TempEntity2[TempEntity2["BLASTER2"] = 30] = "BLASTER2";
+  TempEntity2[TempEntity2["RAILTRAIL2"] = 31] = "RAILTRAIL2";
+  TempEntity2[TempEntity2["FLAME"] = 32] = "FLAME";
+  TempEntity2[TempEntity2["LIGHTNING"] = 33] = "LIGHTNING";
+  TempEntity2[TempEntity2["DEBUGTRAIL"] = 34] = "DEBUGTRAIL";
+  TempEntity2[TempEntity2["PLAIN_EXPLOSION"] = 35] = "PLAIN_EXPLOSION";
+  TempEntity2[TempEntity2["FLASHLIGHT"] = 36] = "FLASHLIGHT";
+  TempEntity2[TempEntity2["FORCEWALL"] = 37] = "FORCEWALL";
+  TempEntity2[TempEntity2["HEATBEAM"] = 38] = "HEATBEAM";
+  TempEntity2[TempEntity2["MONSTER_HEATBEAM"] = 39] = "MONSTER_HEATBEAM";
+  TempEntity2[TempEntity2["STEAM"] = 40] = "STEAM";
+  TempEntity2[TempEntity2["BUBBLETRAIL2"] = 41] = "BUBBLETRAIL2";
+  TempEntity2[TempEntity2["MOREBLOOD"] = 42] = "MOREBLOOD";
+  TempEntity2[TempEntity2["HEATBEAM_SPARKS"] = 43] = "HEATBEAM_SPARKS";
+  TempEntity2[TempEntity2["HEATBEAM_STEAM"] = 44] = "HEATBEAM_STEAM";
+  TempEntity2[TempEntity2["CHAINFIST_SMOKE"] = 45] = "CHAINFIST_SMOKE";
+  TempEntity2[TempEntity2["ELECTRIC_SPARKS"] = 46] = "ELECTRIC_SPARKS";
+  TempEntity2[TempEntity2["TRACKER_EXPLOSION"] = 47] = "TRACKER_EXPLOSION";
+  TempEntity2[TempEntity2["TELEPORT_EFFECT"] = 48] = "TELEPORT_EFFECT";
+  TempEntity2[TempEntity2["DBALL_GOAL"] = 49] = "DBALL_GOAL";
+  TempEntity2[TempEntity2["WIDOWBEAMOUT"] = 50] = "WIDOWBEAMOUT";
+  TempEntity2[TempEntity2["NUKEBLAST"] = 51] = "NUKEBLAST";
+  TempEntity2[TempEntity2["WIDOWSPLASH"] = 52] = "WIDOWSPLASH";
+  TempEntity2[TempEntity2["EXPLOSION1_BIG"] = 53] = "EXPLOSION1_BIG";
+  TempEntity2[TempEntity2["EXPLOSION1_NP"] = 54] = "EXPLOSION1_NP";
+  TempEntity2[TempEntity2["FLECHETTE"] = 55] = "FLECHETTE";
+  return TempEntity2;
+})(TempEntity || {});
+var BinaryStream = class {
+  constructor(buffer) {
+    if (buffer instanceof Uint8Array) {
+      this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    } else {
+      this.view = new DataView(buffer);
+    }
+    this.offset = 0;
+    this.length = this.view.byteLength;
+  }
+  getPosition() {
+    return this.offset;
+  }
+  seek(position) {
+    if (position < 0 || position > this.length) {
+      throw new Error(`Seek out of bounds: ${position} (length: ${this.length})`);
+    }
+    this.offset = position;
+  }
+  hasMore() {
+    return this.offset < this.length;
+  }
+  readChar() {
+    const value = this.view.getInt8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readByte() {
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readShort() {
+    const value = this.view.getInt16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+  readLong() {
+    const value = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readFloat() {
+    const value = this.view.getFloat32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readString() {
+    let str = "";
+    while (this.offset < this.length) {
+      const charCode = this.readChar();
+      if (charCode === -1 || charCode === 0) {
+        break;
+      }
+      str += String.fromCharCode(charCode);
+    }
+    return str;
+  }
+  readStringLine() {
+    let str = "";
+    while (this.offset < this.length) {
+      const charCode = this.readChar();
+      if (charCode === -1 || charCode === 0 || charCode === 10) {
+        break;
+      }
+      str += String.fromCharCode(charCode);
+    }
+    return str;
+  }
+  readCoord() {
+    return this.readShort() * (1 / 8);
+  }
+  readAngle() {
+    return this.readChar() * (360 / 256);
+  }
+  readAngle16() {
+    return this.readShort() * 360 / 65536;
+  }
+  readData(length) {
+    if (this.offset + length > this.length) {
+      throw new Error(`Read out of bounds: ${this.offset + length} (length: ${this.length})`);
+    }
+    const data = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, length);
+    this.offset += length;
+    return new Uint8Array(data);
+  }
+  readPos(out) {
+    out.x = this.readCoord();
+    out.y = this.readCoord();
+    out.z = this.readCoord();
+  }
+  readDir(out) {
+    const b = this.readByte();
+    if (b >= 162) {
+      out.x = 0;
+      out.y = 0;
+      out.z = 0;
+      return;
+    }
+    out.x = 0;
+    out.y = 0;
+    out.z = 0;
+  }
+};
 
 // src/configstrings.ts
 function assertWithinBounds(index) {
@@ -5608,6 +5799,686 @@ function spawnTrail(context) {
   }
 }
 
+// src/demo/demoReader.ts
+var DemoReader = class {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer);
+    this.offset = 0;
+  }
+  /**
+   * Checks if there are more blocks to read.
+   */
+  hasMore() {
+    return this.offset < this.buffer.byteLength;
+  }
+  /**
+   * Reads the next message block from the demo file.
+   * Format is [Length (4 bytes)] + [Message Block (Length bytes)].
+   * Returns null if end of file or incomplete block.
+   */
+  readNextBlock() {
+    if (this.offset + 4 > this.buffer.byteLength) {
+      return null;
+    }
+    const length = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    if (length < 0 || length > 262144) {
+      console.warn(`DemoReader: Invalid block length ${length} at offset ${this.offset - 4}`);
+      return null;
+    }
+    if (this.offset + length > this.buffer.byteLength) {
+      console.warn(`DemoReader: Incomplete block. Expected ${length} bytes, but only ${this.buffer.byteLength - this.offset} remain.`);
+      return null;
+    }
+    const blockData = this.buffer.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return {
+      length,
+      data: new BinaryStream(blockData)
+    };
+  }
+  /**
+   * Resets the reader to the beginning.
+   */
+  reset() {
+    this.offset = 0;
+  }
+  getOffset() {
+    return this.offset;
+  }
+};
+
+// src/demo/parser.ts
+var U_ORIGIN1 = 1 << 0;
+var U_ORIGIN2 = 1 << 1;
+var U_ANGLE2 = 1 << 2;
+var U_ANGLE3 = 1 << 3;
+var U_FRAME8 = 1 << 4;
+var U_EVENT = 1 << 5;
+var U_REMOVE = 1 << 6;
+var U_MOREBITS1 = 1 << 7;
+var U_NUMBER16 = 1 << 8;
+var U_ORIGIN3 = 1 << 9;
+var U_ANGLE1 = 1 << 10;
+var U_MODEL = 1 << 11;
+var U_RENDERFX8 = 1 << 12;
+var U_EFFECTS8 = 1 << 14;
+var U_MOREBITS2 = 1 << 15;
+var U_SKIN8 = 1 << 16;
+var U_FRAME16 = 1 << 17;
+var U_RENDERFX16 = 1 << 18;
+var U_EFFECTS16 = 1 << 19;
+var U_MODEL2 = 1 << 20;
+var U_MODEL3 = 1 << 21;
+var U_MODEL4 = 1 << 22;
+var U_MOREBITS3 = 1 << 23;
+var U_OLDORIGIN = 1 << 24;
+var U_SKIN16 = 1 << 25;
+var U_SOUND = 1 << 26;
+var U_SOLID = 1 << 27;
+var createEmptyEntityState = () => ({
+  number: 0,
+  modelindex: 0,
+  modelindex2: 0,
+  modelindex3: 0,
+  modelindex4: 0,
+  frame: 0,
+  skinnum: 0,
+  effects: 0,
+  renderfx: 0,
+  origin: { x: 0, y: 0, z: 0 },
+  old_origin: { x: 0, y: 0, z: 0 },
+  angles: { x: 0, y: 0, z: 0 },
+  sound: 0,
+  event: 0,
+  solid: 0
+});
+var NetworkMessageParser = class {
+  constructor(stream) {
+    this.stream = stream;
+  }
+  parseMessage() {
+    while (this.stream.hasMore()) {
+      const cmd = this.stream.readByte();
+      if (cmd === -1) {
+        break;
+      }
+      switch (cmd) {
+        case ServerCommand.nop:
+          break;
+        case ServerCommand.disconnect:
+          console.log("Server disconnected");
+          break;
+        case ServerCommand.reconnect:
+          console.log("Server reconnect");
+          break;
+        case ServerCommand.print:
+          const printId = this.stream.readByte();
+          const printMsg = this.stream.readString();
+          console.log(`[Server Print ${printId}]: ${printMsg}`);
+          break;
+        case ServerCommand.serverdata:
+          this.parseServerData();
+          break;
+        case ServerCommand.configstring:
+          this.parseConfigString();
+          break;
+        case ServerCommand.spawnbaseline:
+          this.parseSpawnBaseline();
+          break;
+        case ServerCommand.centerprint:
+          const centerMsg = this.stream.readString();
+          console.log(`[Center Print]: ${centerMsg}`);
+          break;
+        case ServerCommand.download:
+          this.parseDownload();
+          break;
+        case ServerCommand.frame:
+          this.parseFrame();
+          break;
+        case ServerCommand.packetentities:
+          this.parsePacketEntities(false);
+          break;
+        case ServerCommand.deltapacketentities:
+          this.parsePacketEntities(true);
+          break;
+        case ServerCommand.stufftext:
+          const text = this.stream.readString();
+          console.log(`[StuffText]: ${text}`);
+          break;
+        case ServerCommand.layout:
+          const layout = this.stream.readString();
+          break;
+        case ServerCommand.inventory:
+          this.parseInventory();
+          break;
+        case ServerCommand.sound:
+          this.parseSound();
+          break;
+        case ServerCommand.muzzleflash:
+          this.parseMuzzleFlash();
+          break;
+        case ServerCommand.muzzleflash2:
+          this.parseMuzzleFlash2();
+          break;
+        case ServerCommand.temp_entity:
+          this.parseTempEntity();
+          break;
+        default:
+          console.warn(`Unknown server command: ${cmd}`);
+          return;
+      }
+    }
+  }
+  parseServerData() {
+    const protocol = this.stream.readLong();
+    const serverCount = this.stream.readLong();
+    const attractLoop = this.stream.readByte();
+    const gameDir = this.stream.readString();
+    const playerNum = this.stream.readShort();
+    const levelName = this.stream.readString();
+    console.log(`Server Data: Protocol ${protocol}, Level ${levelName}, GameDir ${gameDir}`);
+  }
+  parseConfigString() {
+    const index = this.stream.readShort();
+    const str = this.stream.readString();
+  }
+  parseDownload() {
+    const size = this.stream.readShort();
+    const percent = this.stream.readByte();
+    if (size > 0) {
+      this.stream.readData(size);
+    }
+  }
+  parseInventory() {
+    const MAX_ITEMS2 = 256;
+    for (let i = 0; i < MAX_ITEMS2; i++) {
+      this.stream.readShort();
+    }
+  }
+  parseSound() {
+    const flags = this.stream.readByte();
+    const soundNum = this.stream.readByte();
+    if (flags & 1) {
+      this.stream.readByte();
+    }
+    if (flags & 2) {
+      this.stream.readByte();
+    }
+    if (flags & 16) {
+      this.stream.readByte();
+    }
+    if (flags & 8) {
+      this.stream.readShort();
+    }
+    if (flags & 4) {
+      const pos = { x: 0, y: 0, z: 0 };
+      this.stream.readPos(pos);
+    }
+  }
+  parseMuzzleFlash() {
+    const ent = this.stream.readShort();
+    const weapon = this.stream.readByte();
+  }
+  parseMuzzleFlash2() {
+    const ent = this.stream.readShort();
+    const weapon = this.stream.readByte();
+  }
+  parseTempEntity() {
+    const type = this.stream.readByte();
+    const pos = { x: 0, y: 0, z: 0 };
+    const pos2 = { x: 0, y: 0, z: 0 };
+    const dir = { x: 0, y: 0, z: 0 };
+    switch (type) {
+      case TempEntity.BLOOD:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.GUNSHOT:
+      case TempEntity.SPARKS:
+      case TempEntity.BULLET_SPARKS:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.SCREEN_SPARKS:
+      case TempEntity.SHIELD_SPARKS:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.SHOTGUN:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.SPLASH:
+        this.stream.readByte();
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        this.stream.readByte();
+        break;
+      case TempEntity.LASER_SPARKS:
+        this.stream.readByte();
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        this.stream.readByte();
+        break;
+      case TempEntity.BLUEHYPERBLASTER:
+        this.stream.readPos(pos);
+        this.stream.readPos(dir);
+        break;
+      case TempEntity.BLASTER:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.RAILTRAIL:
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        break;
+      case TempEntity.EXPLOSION2:
+      case TempEntity.GRENADE_EXPLOSION:
+      case TempEntity.GRENADE_EXPLOSION_WATER:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.PLASMA_EXPLOSION:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.EXPLOSION1:
+      case TempEntity.EXPLOSION1_BIG:
+      case TempEntity.ROCKET_EXPLOSION:
+      case TempEntity.ROCKET_EXPLOSION_WATER:
+      case TempEntity.EXPLOSION1_NP:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.BFG_EXPLOSION:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.BFG_BIGEXPLOSION:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.BFG_LASER:
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        break;
+      case TempEntity.BUBBLETRAIL:
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        break;
+      case TempEntity.PARASITE_ATTACK:
+      case TempEntity.MEDIC_CABLE_ATTACK:
+        this.stream.readShort();
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        break;
+      case TempEntity.BOSSTPORT:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.GRAPPLE_CABLE:
+        this.stream.readShort();
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        this.stream.readPos(dir);
+        break;
+      case TempEntity.WELDING_SPARKS:
+        this.stream.readByte();
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        this.stream.readByte();
+        break;
+      case TempEntity.GREENBLOOD:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.TUNNEL_SPARKS:
+        this.stream.readByte();
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        this.stream.readByte();
+        break;
+      case TempEntity.BLASTER2:
+      case TempEntity.FLECHETTE:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.LIGHTNING:
+        this.stream.readShort();
+        this.stream.readShort();
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        break;
+      case TempEntity.DEBUGTRAIL:
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        break;
+      case TempEntity.PLAIN_EXPLOSION:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.FLASHLIGHT:
+        this.stream.readPos(pos);
+        this.stream.readShort();
+        break;
+      case TempEntity.FORCEWALL:
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        this.stream.readByte();
+        break;
+      case TempEntity.HEATBEAM:
+        this.stream.readShort();
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        this.stream.readPos(dir);
+        break;
+      case TempEntity.MONSTER_HEATBEAM:
+        this.stream.readShort();
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        this.stream.readPos(dir);
+        break;
+      case TempEntity.HEATBEAM_SPARKS:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.HEATBEAM_STEAM:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.STEAM:
+        const steamId = this.stream.readShort();
+        if (steamId !== -1) {
+          this.stream.readByte();
+          this.stream.readPos(pos);
+          this.stream.readDir(dir);
+          this.stream.readByte();
+          this.stream.readShort();
+          this.stream.readLong();
+        } else {
+          this.stream.readByte();
+          this.stream.readPos(pos);
+          this.stream.readDir(dir);
+          this.stream.readByte();
+          this.stream.readShort();
+        }
+        break;
+      case TempEntity.BUBBLETRAIL2:
+        this.stream.readPos(pos);
+        this.stream.readPos(pos2);
+        break;
+      case TempEntity.MOREBLOOD:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.CHAINFIST_SMOKE:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.ELECTRIC_SPARKS:
+        this.stream.readPos(pos);
+        this.stream.readDir(dir);
+        break;
+      case TempEntity.TRACKER_EXPLOSION:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.TELEPORT_EFFECT:
+      case TempEntity.DBALL_GOAL:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.WIDOWBEAMOUT:
+        const wbId = this.stream.readShort();
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.NUKEBLAST:
+        this.stream.readPos(pos);
+        break;
+      case TempEntity.WIDOWSPLASH:
+        this.stream.readPos(pos);
+        break;
+      default:
+        console.warn(`CL_ParseTEnt: bad type ${type}`);
+        break;
+    }
+  }
+  parseSpawnBaseline() {
+    const bits = this.parseEntityBits();
+    this.parseDelta(createEmptyEntityState(), createEmptyEntityState(), bits.number, bits.bits);
+  }
+  parseFrame() {
+    const serverFrame = this.stream.readLong();
+    const deltaFrame = this.stream.readLong();
+    const surpressCount = this.stream.readByte();
+    const areaBytes = this.stream.readByte();
+    this.stream.readData(areaBytes);
+    const piCmd = this.stream.readByte();
+    if (piCmd !== ServerCommand.playerinfo) {
+      throw new Error(`Expected svc_playerinfo after svc_frame, got ${piCmd}`);
+    }
+    this.parsePlayerState();
+    const peCmd = this.stream.readByte();
+    if (peCmd !== ServerCommand.packetentities && peCmd !== ServerCommand.deltapacketentities) {
+      throw new Error(`Expected svc_packetentities after svc_playerinfo, got ${peCmd}`);
+    }
+    this.parsePacketEntities(peCmd === ServerCommand.deltapacketentities);
+  }
+  parsePlayerState() {
+    const flags = this.stream.readShort();
+    if (flags & 1) this.stream.readByte();
+    if (flags & 2) {
+      this.stream.readShort();
+      this.stream.readShort();
+      this.stream.readShort();
+    }
+    if (flags & 4) {
+      this.stream.readShort();
+      this.stream.readShort();
+      this.stream.readShort();
+    }
+    if (flags & 8) this.stream.readByte();
+    if (flags & 16) this.stream.readByte();
+    if (flags & 32) this.stream.readShort();
+    if (flags & 64) {
+      this.stream.readShort();
+      this.stream.readShort();
+      this.stream.readShort();
+    }
+    if (flags & 128) {
+      this.stream.readChar();
+      this.stream.readChar();
+      this.stream.readChar();
+    }
+    if (flags & 256) {
+      this.stream.readAngle16();
+      this.stream.readAngle16();
+      this.stream.readAngle16();
+    }
+    if (flags & 512) {
+      this.stream.readChar();
+      this.stream.readChar();
+      this.stream.readChar();
+    }
+    if (flags & 4096) this.stream.readByte();
+    if (flags & 8192) {
+      this.stream.readByte();
+      this.stream.readChar();
+      this.stream.readChar();
+      this.stream.readChar();
+      this.stream.readChar();
+      this.stream.readChar();
+      this.stream.readChar();
+    }
+    if (flags & 1024) {
+      this.stream.readByte();
+      this.stream.readByte();
+      this.stream.readByte();
+      this.stream.readByte();
+    }
+    if (flags & 2048) this.stream.readByte();
+    if (flags & 16384) this.stream.readByte();
+    const statbits = this.stream.readLong();
+    for (let i = 0; i < 32; i++) {
+      if (statbits & 1 << i) {
+        this.stream.readShort();
+      }
+    }
+  }
+  parsePacketEntities(delta) {
+    while (true) {
+      const bits = this.parseEntityBits();
+      if (bits.number === 0) {
+        break;
+      }
+      this.parseDelta(createEmptyEntityState(), createEmptyEntityState(), bits.number, bits.bits);
+    }
+  }
+  parseEntityBits() {
+    let total = this.stream.readByte();
+    if (total & U_MOREBITS1) {
+      total |= this.stream.readByte() << 8;
+    }
+    if (total & U_MOREBITS2) {
+      total |= this.stream.readByte() << 16;
+    }
+    if (total & U_MOREBITS3) {
+      total |= this.stream.readByte() << 24;
+    }
+    let number;
+    if (total & U_NUMBER16) {
+      number = this.stream.readShort();
+    } else {
+      number = this.stream.readByte();
+    }
+    return { number, bits: total };
+  }
+  parseDelta(from, to, number, bits) {
+    to.number = from.number;
+    to.modelindex = from.modelindex;
+    to.modelindex2 = from.modelindex2;
+    to.modelindex3 = from.modelindex3;
+    to.modelindex4 = from.modelindex4;
+    to.frame = from.frame;
+    to.skinnum = from.skinnum;
+    to.effects = from.effects;
+    to.renderfx = from.renderfx;
+    to.origin.x = from.origin.x;
+    to.origin.y = from.origin.y;
+    to.origin.z = from.origin.z;
+    to.old_origin.x = from.origin.x;
+    to.old_origin.y = from.origin.y;
+    to.old_origin.z = from.origin.z;
+    to.angles.x = from.angles.x;
+    to.angles.y = from.angles.y;
+    to.angles.z = from.angles.z;
+    to.sound = from.sound;
+    to.event = from.event;
+    to.solid = from.solid;
+    to.number = number;
+    if (bits & U_MODEL) to.modelindex = this.stream.readByte();
+    if (bits & U_MODEL2) to.modelindex2 = this.stream.readByte();
+    if (bits & U_MODEL3) to.modelindex3 = this.stream.readByte();
+    if (bits & U_MODEL4) to.modelindex4 = this.stream.readByte();
+    if (bits & U_FRAME8) to.frame = this.stream.readByte();
+    if (bits & U_FRAME16) to.frame = this.stream.readShort();
+    if (bits & U_SKIN8 && bits & U_SKIN16) {
+      to.skinnum = this.stream.readLong();
+    } else if (bits & U_SKIN8) {
+      to.skinnum = this.stream.readByte();
+    } else if (bits & U_SKIN16) {
+      to.skinnum = this.stream.readShort();
+    }
+    if (bits & U_EFFECTS8 && bits & U_EFFECTS16) {
+      to.effects = this.stream.readLong();
+    } else if (bits & U_EFFECTS8) {
+      to.effects = this.stream.readByte();
+    } else if (bits & U_EFFECTS16) {
+      to.effects = this.stream.readShort();
+    }
+    if (bits & U_RENDERFX8 && bits & U_RENDERFX16) {
+      to.renderfx = this.stream.readLong();
+    } else if (bits & U_RENDERFX8) {
+      to.renderfx = this.stream.readByte();
+    } else if (bits & U_RENDERFX16) {
+      to.renderfx = this.stream.readShort();
+    }
+    if (bits & U_ORIGIN1) to.origin.x = this.stream.readCoord();
+    if (bits & U_ORIGIN2) to.origin.y = this.stream.readCoord();
+    if (bits & U_ORIGIN3) to.origin.z = this.stream.readCoord();
+    if (bits & U_ANGLE1) to.angles.x = this.stream.readAngle();
+    if (bits & U_ANGLE2) to.angles.y = this.stream.readAngle();
+    if (bits & U_ANGLE3) to.angles.z = this.stream.readAngle();
+    if (bits & U_OLDORIGIN) {
+      this.stream.readPos(to.old_origin);
+    }
+    if (bits & U_SOUND) to.sound = this.stream.readByte();
+    if (bits & U_EVENT) {
+      to.event = this.stream.readByte();
+    } else {
+      to.event = 0;
+    }
+    if (bits & U_SOLID) to.solid = this.stream.readShort();
+  }
+};
+
+// src/demo/playback.ts
+var PlaybackState = /* @__PURE__ */ ((PlaybackState2) => {
+  PlaybackState2[PlaybackState2["Stopped"] = 0] = "Stopped";
+  PlaybackState2[PlaybackState2["Playing"] = 1] = "Playing";
+  PlaybackState2[PlaybackState2["Paused"] = 2] = "Paused";
+  PlaybackState2[PlaybackState2["Finished"] = 3] = "Finished";
+  return PlaybackState2;
+})(PlaybackState || {});
+var DemoPlaybackController = class {
+  // ms (10Hz default)
+  constructor() {
+    this.reader = null;
+    this.state = 0 /* Stopped */;
+    this.playbackSpeed = 1;
+    // Timing
+    this.accumulatedTime = 0;
+    this.frameDuration = 100;
+  }
+  loadDemo(buffer) {
+    this.reader = new DemoReader(buffer);
+    this.state = 0 /* Stopped */;
+    this.accumulatedTime = 0;
+  }
+  play() {
+    if (this.reader) {
+      this.state = 1 /* Playing */;
+    }
+  }
+  pause() {
+    if (this.state === 1 /* Playing */) {
+      this.state = 2 /* Paused */;
+    }
+  }
+  stop() {
+    this.state = 0 /* Stopped */;
+    if (this.reader) {
+      this.reader.reset();
+    }
+    this.accumulatedTime = 0;
+  }
+  update(dt) {
+    if (this.state !== 1 /* Playing */ || !this.reader) {
+      return;
+    }
+    this.accumulatedTime += dt * 1e3 * this.playbackSpeed;
+    while (this.accumulatedTime >= this.frameDuration) {
+      if (!this.reader.hasMore()) {
+        this.state = 3 /* Finished */;
+        return;
+      }
+      const block = this.reader.readNextBlock();
+      if (!block) {
+        this.state = 3 /* Finished */;
+        return;
+      }
+      const parser = new NetworkMessageParser(block.data);
+      parser.parseMessage();
+      this.accumulatedTime -= this.frameDuration;
+    }
+  }
+  getState() {
+    return this.state;
+  }
+};
+
 // src/index.ts
 function createEngine(imports) {
   return {
@@ -5646,6 +6517,8 @@ function createEngine(imports) {
   ConfigStringRegistry,
   Cvar,
   CvarRegistry,
+  DemoPlaybackController,
+  DemoReader,
   EngineHost,
   EngineRuntime,
   FixedTimestepLoop,
@@ -5667,6 +6540,7 @@ function createEngine(imports) {
   Md3Pipeline,
   Md3SurfaceMesh,
   MusicSystem,
+  NetworkMessageParser,
   PARTICLE_FRAGMENT_SHADER,
   PARTICLE_VERTEX_SHADER,
   PakArchive,
@@ -5677,6 +6551,7 @@ function createEngine(imports) {
   PakValidator,
   ParticleRenderer,
   ParticleSystem,
+  PlaybackState,
   RERELEASE_KNOWN_PAKS,
   SKYBOX_FRAGMENT_SHADER,
   SKYBOX_VERTEX_SHADER,