quake2ts 0.0.403 → 0.0.405

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

@@ -295,6 +295,9 @@ var CommandRegistry = class {
     this.commands.set(name, command);
     return command;
   }
+  registerCommand(name, callback) {
+    this.register(name, callback);
+  }
   get(name) {
     return this.commands.get(name);
   }
@@ -310,10 +313,33 @@ var CommandRegistry = class {
       command.execute(args);
       return true;
     }
+    this.onConsoleOutput?.(`Unknown command "${name}"`);
     return false;
   }
+  executeCommand(cmd) {
+    this.execute(cmd);
+  }
   tokenize(text) {
-    return text.trim().split(/\s+/);
+    const args = [];
+    let currentArg = "";
+    let inQuote = false;
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      if (char === '"') {
+        inQuote = !inQuote;
+      } else if (char === " " && !inQuote) {
+        if (currentArg.length > 0) {
+          args.push(currentArg);
+          currentArg = "";
+        }
+      } else {
+        currentArg += char;
+      }
+    }
+    if (currentArg.length > 0) {
+      args.push(currentArg);
+    }
+    return args;
   }
   list() {
     return [...this.commands.values()].sort((a, b) => a.name.localeCompare(b.name));
@@ -1508,13 +1534,21 @@ var CvarRegistry = class {
     if (existing) {
       return existing;
     }
-    const cvar = new Cvar(def);
+    const originalOnChange = def.onChange;
+    const wrappedOnChange = (cvar2, prev) => {
+      originalOnChange?.(cvar2, prev);
+      this.onCvarChange?.(cvar2.name, cvar2.string);
+    };
+    const cvar = new Cvar({ ...def, onChange: wrappedOnChange });
     this.cvars.set(def.name, cvar);
     return cvar;
   }
   get(name) {
     return this.cvars.get(name);
   }
+  getCvar(name) {
+    return this.get(name);
+  }
   setValue(name, value) {
     const cvar = this.get(name);
     if (!cvar) {
@@ -1523,6 +1557,9 @@ var CvarRegistry = class {
     cvar.set(value);
     return cvar;
   }
+  setCvar(name, value) {
+    this.setValue(name, value);
+  }
   resetAll() {
     for (const cvar of this.cvars.values()) {
       cvar.reset();
@@ -1538,6 +1575,15 @@ var CvarRegistry = class {
   list() {
     return [...this.cvars.values()].sort((a, b) => a.name.localeCompare(b.name));
   }
+  listCvars() {
+    return this.list().map((cvar) => ({
+      name: cvar.name,
+      value: cvar.string,
+      defaultValue: cvar.defaultValue,
+      flags: cvar.flags,
+      description: cvar.description
+    }));
+  }
 };
 
 // src/host.ts
@@ -12627,6 +12673,165 @@ var NetworkMessageParser = class _NetworkMessageParser {
   }
 };
 
+// src/demo/analyzer.ts
+var DemoAnalyzer = class {
+  constructor(buffer) {
+    this.events = [];
+    this.summary = {
+      totalKills: 0,
+      totalDeaths: 0,
+      damageDealt: 0,
+      damageReceived: 0,
+      weaponUsage: /* @__PURE__ */ new Map()
+    };
+    this.header = null;
+    this.configStrings = /* @__PURE__ */ new Map();
+    this.serverInfo = {};
+    this.statistics = null;
+    this.playerStats = /* @__PURE__ */ new Map();
+    // By playerNum
+    this.weaponStats = /* @__PURE__ */ new Map();
+    this.buffer = buffer;
+  }
+  analyze() {
+    const reader = new DemoReader(this.buffer);
+    let currentFrameIndex = -1;
+    let currentTime = 0;
+    let frameDuration = 0.1;
+    let protocolVersion = 0;
+    const handler = {
+      onServerData: (protocol, serverCount, attractLoop, gameDir, playerNum, levelName, tickRate, demoType) => {
+        protocolVersion = protocol;
+        this.header = {
+          protocolVersion: protocol,
+          gameDir,
+          levelName,
+          playerNum,
+          serverCount,
+          spawnCount: serverCount,
+          // Mapping generic arg
+          tickRate,
+          demoType
+        };
+        if (tickRate && tickRate > 0) {
+          frameDuration = 1 / tickRate;
+        }
+      },
+      onConfigString: (index, str) => {
+        this.configStrings.set(index, str);
+        if (index === 0) {
+          this.parseServerInfo(str);
+        }
+      },
+      onSpawnBaseline: (entity) => {
+      },
+      onFrame: (frame) => {
+      },
+      onPrint: (level, msg) => {
+        if (msg.includes("died") || msg.includes("killed")) {
+          this.summary.totalDeaths++;
+          this.recordEvent({
+            type: 4 /* Death */,
+            frame: currentFrameIndex,
+            time: currentTime,
+            description: msg.trim()
+          });
+        }
+      },
+      onCenterPrint: () => {
+      },
+      onStuffText: () => {
+      },
+      onSound: () => {
+      },
+      onTempEntity: () => {
+      },
+      onLayout: () => {
+      },
+      onInventory: () => {
+      },
+      onMuzzleFlash: (ent, weapon) => {
+        this.handleWeaponFire(ent, weapon, currentFrameIndex, currentTime);
+      },
+      onMuzzleFlash2: (ent, weapon) => {
+        this.handleWeaponFire(ent, weapon, currentFrameIndex, currentTime);
+      },
+      onMuzzleFlash3: (ent, weapon) => {
+        this.handleWeaponFire(ent, weapon, currentFrameIndex, currentTime);
+      },
+      onDisconnect: () => {
+      },
+      onReconnect: () => {
+      },
+      onDownload: () => {
+      },
+      // Rerelease specific
+      onDamage: (indicators) => {
+        for (const ind of indicators) {
+          this.recordEvent({
+            type: 2 /* DamageReceived */,
+            frame: currentFrameIndex,
+            time: currentTime,
+            value: ind.damage,
+            position: ind.dir,
+            description: `Took ${ind.damage} damage`
+          });
+          this.summary.damageReceived += ind.damage;
+        }
+      }
+    };
+    while (reader.hasMore()) {
+      const block = reader.readNextBlock();
+      if (!block) break;
+      currentFrameIndex++;
+      currentTime = currentFrameIndex * frameDuration;
+      const parser = new NetworkMessageParser(block.data, handler);
+      parser.setProtocolVersion(protocolVersion);
+      parser.parseMessage();
+      protocolVersion = parser.getProtocolVersion();
+    }
+    this.statistics = {
+      duration: currentTime,
+      frameCount: currentFrameIndex + 1,
+      averageFps: (currentFrameIndex + 1) / (currentTime || 1),
+      mapName: this.header?.levelName || "unknown",
+      playerCount: 1
+      // Default to 1 for SP/client demo
+    };
+    return {
+      events: this.events,
+      summary: this.summary,
+      header: this.header,
+      configStrings: this.configStrings,
+      serverInfo: this.serverInfo,
+      statistics: this.statistics
+    };
+  }
+  handleWeaponFire(ent, weapon, frame, time) {
+    this.recordEvent({
+      type: 0 /* WeaponFire */,
+      frame,
+      time,
+      entityId: ent,
+      value: weapon,
+      description: `Weapon ${weapon} fired by ${ent}`
+    });
+    const count = this.summary.weaponUsage.get(weapon) || 0;
+    this.summary.weaponUsage.set(weapon, count + 1);
+  }
+  recordEvent(event) {
+    this.events.push(event);
+  }
+  parseServerInfo(str) {
+    const parts = str.split("\\");
+    for (let i = 1; i < parts.length; i += 2) {
+      if (i + 1 < parts.length) {
+        this.serverInfo[parts[i]] = parts[i + 1];
+      }
+    }
+  }
+};
+
 // src/demo/playback.ts
 var PlaybackState = /* @__PURE__ */ ((PlaybackState2) => {
   PlaybackState2[PlaybackState2["Stopped"] = 0] = "Stopped";
@@ -12638,6 +12843,8 @@ var PlaybackState = /* @__PURE__ */ ((PlaybackState2) => {
 var DemoPlaybackController = class {
   constructor() {
     this.reader = null;
+    this.buffer = null;
+    // Keep reference for analysis
     this.state = 0 /* Stopped */;
     this.playbackSpeed = 1;
     this.currentProtocolVersion = 0;
@@ -12653,6 +12860,13 @@ var DemoPlaybackController = class {
     this.snapshotInterval = 100;
     // frames
     this.snapshots = /* @__PURE__ */ new Map();
+    // Analysis Cache
+    this.cachedEvents = null;
+    this.cachedSummary = null;
+    this.cachedHeader = null;
+    this.cachedConfigStrings = null;
+    this.cachedServerInfo = null;
+    this.cachedStatistics = null;
   }
   setHandler(handler) {
     this.handler = handler;
@@ -12661,6 +12875,7 @@ var DemoPlaybackController = class {
     this.callbacks = callbacks;
   }
   loadDemo(buffer) {
+    this.buffer = buffer;
     this.reader = new DemoReader(buffer);
     this.transitionState(0 /* Stopped */);
     this.accumulatedTime = 0;
@@ -12668,6 +12883,12 @@ var DemoPlaybackController = class {
     this.currentFrameIndex = -1;
     this.snapshots.clear();
     this.lastFrameData = null;
+    this.cachedEvents = null;
+    this.cachedSummary = null;
+    this.cachedHeader = null;
+    this.cachedConfigStrings = null;
+    this.cachedServerInfo = null;
+    this.cachedStatistics = null;
   }
   play() {
     if (this.reader && this.state !== 1 /* Playing */) {
@@ -12980,6 +13201,57 @@ var DemoPlaybackController = class {
     this.seek(originalFrame);
     return trajectory;
   }
+  // 3.2.3 Event Log Extraction & 3.3 Metadata
+  getDemoEvents() {
+    this.ensureAnalysis();
+    return this.cachedEvents || [];
+  }
+  filterEvents(type, entityId) {
+    const events = this.getDemoEvents();
+    return events.filter((e) => {
+      if (e.type !== type) return false;
+      if (entityId !== void 0 && e.entityId !== entityId) return false;
+      return true;
+    });
+  }
+  getEventSummary() {
+    this.ensureAnalysis();
+    return this.cachedSummary || {
+      totalKills: 0,
+      totalDeaths: 0,
+      damageDealt: 0,
+      damageReceived: 0,
+      weaponUsage: /* @__PURE__ */ new Map()
+    };
+  }
+  getDemoHeader() {
+    this.ensureAnalysis();
+    return this.cachedHeader;
+  }
+  getDemoConfigStrings() {
+    this.ensureAnalysis();
+    return this.cachedConfigStrings || /* @__PURE__ */ new Map();
+  }
+  getDemoServerInfo() {
+    this.ensureAnalysis();
+    return this.cachedServerInfo || {};
+  }
+  getDemoStatistics() {
+    this.ensureAnalysis();
+    return this.cachedStatistics;
+  }
+  ensureAnalysis() {
+    if (!this.cachedEvents && this.buffer) {
+      const analyzer = new DemoAnalyzer(this.buffer);
+      const result = analyzer.analyze();
+      this.cachedEvents = result.events;
+      this.cachedSummary = result.summary;
+      this.cachedHeader = result.header;
+      this.cachedConfigStrings = result.configStrings;
+      this.cachedServerInfo = result.serverInfo;
+      this.cachedStatistics = result.statistics;
+    }
+  }
 };
 
 // src/demo/recorder.ts