quake2ts 0.0.403 → 0.0.407

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

@@ -94,6 +94,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);
   }
@@ -109,10 +112,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));
@@ -1307,13 +1333,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) {
@@ -1322,6 +1356,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();
@@ -1337,6 +1374,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
@@ -1537,6 +1583,9 @@ var AudioApi = class {
   stop_entity_sounds(entnum) {
     this.system.stopEntitySounds(entnum);
   }
+  setPlaybackRate(rate) {
+    this.system.setPlaybackRate(rate);
+  }
   set_listener(listener) {
     this.system.setListener(listener);
   }
@@ -4359,6 +4408,7 @@ function spatializeOrigin(origin, listener, masterVolume, attenuation, isListene
 var AudioSystem = class {
   constructor(options) {
     this.activeSources = /* @__PURE__ */ new Map();
+    this.playbackRate = 1;
     this.contextController = options.context;
     this.registry = options.registry;
     this.playerEntity = options.playerEntity;
@@ -4380,6 +4430,15 @@ var AudioSystem = class {
   setSfxVolume(volume) {
     this.sfxVolume = volume;
   }
+  setPlaybackRate(rate) {
+    this.playbackRate = rate;
+    for (const active of this.activeSources.values()) {
+      if (active.source.playbackRate) {
+        active.source.playbackRate.value = rate;
+      }
+      this.updateSourceGain(active);
+    }
+  }
   async ensureRunning() {
     await this.contextController.resume();
   }
@@ -4402,6 +4461,9 @@ var AudioSystem = class {
     const source = ctx.createBufferSource();
     source.buffer = buffer;
     source.loop = request.looping ?? false;
+    if (source.playbackRate) {
+      source.playbackRate.value = this.playbackRate;
+    }
     const origin = request.origin ?? this.listener.origin;
     const gain = ctx.createGain();
     const panner = this.createPanner(ctx, request.attenuation);
@@ -4413,7 +4475,8 @@ var AudioSystem = class {
     const spatial = spatializeOrigin(origin, this.listener, request.volume, request.attenuation, isListenerSound);
     const attenuationScale = request.volume === 0 ? 0 : Math.max(spatial.left, spatial.right) / Math.max(1, request.volume);
     const gainValue = attenuationScale * (request.volume / 255) * this.masterVolume * this.sfxVolume;
-    gain.gain.value = gainValue * occlusionScale;
+    const playbackRateMute = Math.abs(this.playbackRate - 1) < 1e-3 ? 1 : 0;
+    gain.gain.value = gainValue * occlusionScale * playbackRateMute;
     const startTimeSec = ctx.currentTime + (request.timeOffsetMs ?? 0) / 1e3;
     const endTimeMs = (request.looping ? Number.POSITIVE_INFINITY : buffer.duration * 1e3) + startTimeSec * 1e3;
     source.connect(panner);
@@ -4561,9 +4624,15 @@ var AudioSystem = class {
     filter.frequency.value = clamp(cutoffHz, 10, 2e4);
     return filter;
   }
+  updateSourceGain(active) {
+    const occlusionScale = active.occlusion?.scale ?? 1;
+    const playbackRateMute = Math.abs(this.playbackRate - 1) < 1e-3 ? 1 : 0;
+    active.gain.gain.value = active.baseGain * occlusionScale * playbackRateMute;
+  }
   applyOcclusion(active, occlusion) {
     const scale = clamp01(occlusion?.gainScale ?? 1);
-    active.gain.gain.value = active.baseGain * scale;
+    const playbackRateMute = Math.abs(this.playbackRate - 1) < 1e-3 ? 1 : 0;
+    active.gain.gain.value = active.baseGain * scale * playbackRateMute;
     if (active.occlusion?.filter) {
       const cutoff = occlusion?.lowpassHz ?? 2e4;
       active.occlusion.filter.frequency.value = clamp(cutoff, 10, 2e4);
@@ -12426,6 +12495,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";
@@ -12437,6 +12665,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;
@@ -12452,6 +12682,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;
@@ -12460,6 +12697,7 @@ var DemoPlaybackController = class {
     this.callbacks = callbacks;
   }
   loadDemo(buffer) {
+    this.buffer = buffer;
     this.reader = new DemoReader(buffer);
     this.transitionState(0 /* Stopped */);
     this.accumulatedTime = 0;
@@ -12467,6 +12705,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 */) {
@@ -12779,6 +13023,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
@@ -13127,6 +13422,67 @@ var AssetPreviewGenerator = class {
   }
 };
 
+// src/assets/mapStatistics.ts
+var MapAnalyzer = class {
+  constructor(loader) {
+    this.loader = loader;
+  }
+  async getMapStatistics(mapName) {
+    const map = await this.loader.load(mapName);
+    const lightmapCount = map.faces.filter((f) => f.lightOffset !== -1).length;
+    const worldModel = map.models[0];
+    const bounds = worldModel ? {
+      mins: worldModel.mins,
+      maxs: worldModel.maxs
+    } : {
+      mins: [0, 0, 0],
+      maxs: [0, 0, 0]
+    };
+    return {
+      entityCount: map.entities.entities.length,
+      surfaceCount: map.faces.length,
+      lightmapCount,
+      vertexCount: map.vertices.length,
+      bounds
+    };
+  }
+  async getUsedTextures(mapName) {
+    const map = await this.loader.load(mapName);
+    const textures = /* @__PURE__ */ new Set();
+    for (const info of map.texInfo) {
+      if (info.texture) {
+        textures.add(info.texture);
+      }
+    }
+    return Array.from(textures).sort();
+  }
+  async getUsedModels(mapName) {
+    const map = await this.loader.load(mapName);
+    const models = /* @__PURE__ */ new Set();
+    for (const ent of map.entities.entities) {
+      if (ent.properties["model"] && !ent.properties["model"].startsWith("*")) {
+        models.add(ent.properties["model"]);
+      }
+    }
+    return Array.from(models).sort();
+  }
+  async getUsedSounds(mapName) {
+    const map = await this.loader.load(mapName);
+    const sounds = /* @__PURE__ */ new Set();
+    for (const ent of map.entities.entities) {
+      if (ent.properties["noise"]) {
+        sounds.add(ent.properties["noise"]);
+      }
+      for (const [key, value] of Object.entries(ent.properties)) {
+        if ((key === "noise" || key.endsWith("_sound") || key === "sound") && typeof value === "string") {
+          sounds.add(value);
+        }
+      }
+    }
+    return Array.from(sounds).sort();
+  }
+};
+
 // src/index.ts
 function createEngine(imports) {
   return {
@@ -13183,6 +13539,7 @@ export {
   MD2_VERTEX_SHADER,
   MD3_FRAGMENT_SHADER,
   MD3_VERTEX_SHADER,
+  MapAnalyzer,
   Md2Loader,
   Md2MeshBuffers,
   Md2ParseError,