quake2ts 0.0.403 → 0.0.407

package/packages/client/dist/cjs/index.cjs

@@ -23,6 +23,7 @@ __export(index_exports, {
   ClientConfigStrings: () => ClientConfigStrings,
   ClientMode: () => ClientMode,
   ClientPrediction: () => import_cgame5.ClientPrediction,
+  DemoCameraMode: () => DemoCameraMode,
   GameSession: () => GameSession,
   InputAction: () => InputAction,
   InputBindings: () => InputBindings,
@@ -1855,6 +1856,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);
   }
@@ -1870,10 +1874,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));
@@ -2958,13 +2985,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) {
@@ -2973,6 +3008,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();
@@ -2988,6 +3026,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
+    }));
+  }
 };
 var EngineHost = class {
   constructor(game, client, options = {}) {
@@ -8796,6 +8843,162 @@ var NetworkMessageParser = class _NetworkMessageParser {
     }
   }
 };
+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();
+    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, str3) => {
+        this.configStrings.set(index, str3);
+        if (index === 0) {
+          this.parseServerInfo(str3);
+        }
+      },
+      onSpawnBaseline: (entity) => {
+      },
+      onFrame: (frame) => {
+      },
+      onPrint: (level, msg) => {
+        if (msg.includes("died") || msg.includes("killed")) {
+          this.summary.totalDeaths++;
+          this.recordEvent({
+            type: 4,
+            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,
+            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,
+      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(str3) {
+    const parts = str3.split("\\");
+    for (let i = 1; i < parts.length; i += 2) {
+      if (i + 1 < parts.length) {
+        this.serverInfo[parts[i]] = parts[i + 1];
+      }
+    }
+  }
+};
 var PlaybackState = /* @__PURE__ */ ((PlaybackState22) => {
   PlaybackState22[PlaybackState22["Stopped"] = 0] = "Stopped";
   PlaybackState22[PlaybackState22["Playing"] = 1] = "Playing";
@@ -8806,6 +9009,7 @@ var PlaybackState = /* @__PURE__ */ ((PlaybackState22) => {
 var DemoPlaybackController = class {
   constructor() {
     this.reader = null;
+    this.buffer = null;
     this.state = 0;
     this.playbackSpeed = 1;
     this.currentProtocolVersion = 0;
@@ -8815,6 +9019,12 @@ var DemoPlaybackController = class {
     this.frameDuration = 100;
     this.snapshotInterval = 100;
     this.snapshots = /* @__PURE__ */ new Map();
+    this.cachedEvents = null;
+    this.cachedSummary = null;
+    this.cachedHeader = null;
+    this.cachedConfigStrings = null;
+    this.cachedServerInfo = null;
+    this.cachedStatistics = null;
   }
   setHandler(handler) {
     this.handler = handler;
@@ -8823,6 +9033,7 @@ var DemoPlaybackController = class {
     this.callbacks = callbacks;
   }
   loadDemo(buffer) {
+    this.buffer = buffer;
     this.reader = new DemoReader(buffer);
     this.transitionState(
       0
@@ -8833,6 +9044,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) {
@@ -9160,6 +9377,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;
+    }
+  }
 };
 var DemoRecorder = class {
   // -1 means start of demo
@@ -9239,12 +9507,56 @@ var __export3 = (target, all) => {
 };
 var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
 var DEG_TO_RAD2 = Math.PI / 180;
+var PITCH = 0;
+var YAW = 1;
+var ROLL = 2;
 var DEG2RAD_FACTOR2 = Math.PI / 180;
 var RAD2DEG_FACTOR2 = 180 / Math.PI;
+function axisComponent(vec, axis) {
+  switch (axis) {
+    case PITCH:
+      return vec.x;
+    case YAW:
+      return vec.y;
+    case ROLL:
+    default:
+      return vec.z;
+  }
+}
+function degToRad(degrees) {
+  return degrees * DEG2RAD_FACTOR2;
+}
 function angleMod(angle2) {
   const value = angle2 % 360;
   return value < 0 ? 360 + value : value;
 }
+function angleVectors(angles) {
+  const yaw = degToRad(axisComponent(angles, YAW));
+  const pitch = degToRad(axisComponent(angles, PITCH));
+  const roll = degToRad(axisComponent(angles, ROLL));
+  const sy = Math.sin(yaw);
+  const cy = Math.cos(yaw);
+  const sp = Math.sin(pitch);
+  const cp = Math.cos(pitch);
+  const sr = Math.sin(roll);
+  const cr = Math.cos(roll);
+  const forward = {
+    x: cp * cy,
+    y: cp * sy,
+    z: -sp
+  };
+  const right = {
+    x: -sr * sp * cy - cr * -sy,
+    y: -sr * sp * sy - cr * cy,
+    z: -sr * cp
+  };
+  const up = {
+    x: cr * sp * cy - sr * -sy,
+    y: cr * sp * sy - sr * cy,
+    z: cr * cp
+  };
+  return { forward, right, up };
+}
 var ANORMS2 = [
   [-0.525731, 0, 0.850651],
   [-0.442863, 0.238856, 0.864188],
@@ -13140,10 +13452,11 @@ var MultiplayerConnection = class {
 
 // src/ui/demo-controls.ts
 var DemoControls = class {
-  constructor(playback) {
+  constructor(playback, onSpeedChange) {
     this.isVisible = true;
     this.demoName = null;
     this.playback = playback;
+    this.onSpeedChange = onSpeedChange;
   }
   setDemoName(name) {
     this.demoName = name;
@@ -13221,6 +13534,9 @@ var DemoControls = class {
     if (newSpeed < 0.1) newSpeed = 0.1;
     if (newSpeed > 16) newSpeed = 16;
     this.playback.setSpeed(newSpeed);
+    if (this.onSpeedChange) {
+      this.onSpeedChange(newSpeed);
+    }
   }
   formatTime(ms) {
     const totalSeconds = Math.floor(ms / 1e3);
@@ -13230,6 +13546,15 @@ var DemoControls = class {
   }
 };
 
+// src/demo/camera.ts
+var DemoCameraMode = /* @__PURE__ */ ((DemoCameraMode2) => {
+  DemoCameraMode2[DemoCameraMode2["FirstPerson"] = 0] = "FirstPerson";
+  DemoCameraMode2[DemoCameraMode2["ThirdPerson"] = 1] = "ThirdPerson";
+  DemoCameraMode2[DemoCameraMode2["Free"] = 2] = "Free";
+  DemoCameraMode2[DemoCameraMode2["Follow"] = 3] = "Follow";
+  return DemoCameraMode2;
+})(DemoCameraMode || {});
+
 // src/effects.ts
 function addDLight(dlights, origin, color, intensity, minLight = 0, die = 0) {
   dlights.push({
@@ -13917,13 +14242,28 @@ function createClient(imports) {
   const prediction = new import_cgame3.ClientPrediction(imports.engine.trace, pointContents);
   const view = new import_cgame4.ViewEffects();
   const demoPlayback = new DemoPlaybackController();
-  const demoControls = new DemoControls(demoPlayback);
+  const demoControls = new DemoControls(demoPlayback, (speed) => {
+    if (imports.engine.audio) {
+      const audio = imports.engine.audio;
+      if (typeof audio.setPlaybackRate === "function") {
+        audio.setPlaybackRate(speed);
+      }
+    }
+  });
   const demoHandler = new ClientNetworkHandler(imports);
   const demoRecorder = new DemoRecorder();
   demoHandler.setView(view);
   let isDemoPlaying = false;
   let currentDemoName = null;
   let clientMode = 0 /* Normal */;
+  const demoCameraState = {
+    mode: 0 /* FirstPerson */,
+    thirdPersonDistance: 80,
+    thirdPersonOffset: { x: 0, y: 0, z: 0 },
+    freeCameraOrigin: { x: 0, y: 0, z: 0 },
+    freeCameraAngles: { x: 0, y: 0, z: 0 },
+    followEntityId: -1
+  };
   const menuSystem = new MenuSystem();
   const loadingScreen = new LoadingScreen();
   const errorDialog = new ErrorDialog();
@@ -14138,6 +14478,8 @@ function createClient(imports) {
     },
     handleInput(key, down) {
       if (isDemoPlaying) {
+        if (demoCameraState.mode === 2 /* Free */) {
+        }
         if (demoControls.handleInput(key, down)) {
           return true;
         }
@@ -14223,18 +14565,51 @@ function createClient(imports) {
         lastRenderTime = now;
         demoPlayback.update(dt);
         lastRendered = demoHandler.getPredictionState(demoPlayback.getCurrentTime());
-        const frameDuration = 100;
         renderEntities = demoHandler.getRenderableEntities(1, configStrings);
         if (demoHandler.latestFrame && demoHandler.latestFrame.packetEntities) {
           currentPacketEntities = demoHandler.latestFrame.packetEntities.entities;
         }
         if (lastRendered) {
           const demoCamera = demoHandler.getDemoCamera(1);
-          if (demoCamera) {
-            lastRendered.origin = demoCamera.origin;
-            lastRendered.viewAngles = demoCamera.angles;
-            if (demoCamera.fov) {
-              lastRendered.fov = demoCamera.fov;
+          if (demoCameraState.mode === 0 /* FirstPerson */) {
+            if (demoCamera) {
+              lastRendered.origin = demoCamera.origin;
+              lastRendered.viewAngles = demoCamera.angles;
+              if (demoCamera.fov) {
+                lastRendered.fov = demoCamera.fov;
+              }
+            }
+          } else if (demoCameraState.mode === 1 /* ThirdPerson */) {
+            if (demoCamera) {
+              const vectors = angleVectors(demoCamera.angles);
+              const forward = vectors.forward;
+              const dist2 = demoCameraState.thirdPersonDistance;
+              const camOrigin = { ...demoCamera.origin };
+              camOrigin.x -= forward.x * dist2;
+              camOrigin.y -= forward.y * dist2;
+              camOrigin.z -= forward.z * dist2;
+              const traceStart = demoCamera.origin;
+              const traceEnd = camOrigin;
+              const mins = { x: -4, y: -4, z: -4 };
+              const maxs = { x: 4, y: 4, z: 4 };
+              const trace = imports.engine.trace(traceStart, traceEnd, mins, maxs);
+              if (trace.fraction < 1) {
+                lastRendered.origin = trace.endpos;
+              } else {
+                lastRendered.origin = camOrigin;
+              }
+              lastRendered.viewAngles = demoCamera.angles;
+            }
+          } else if (demoCameraState.mode === 2 /* Free */) {
+            lastRendered.origin = demoCameraState.freeCameraOrigin;
+            lastRendered.viewAngles = demoCameraState.freeCameraAngles;
+          } else if (demoCameraState.mode === 3 /* Follow */) {
+            if (demoCameraState.followEntityId !== -1) {
+              const ent = renderEntities.find((e) => e.id === demoCameraState.followEntityId);
+              if (ent) {
+                const mat = ent.transform;
+                lastRendered.origin = { x: mat[12], y: mat[13], z: mat[14] };
+              }
             }
           }
         }
@@ -14274,8 +14649,10 @@ function createClient(imports) {
         const { origin, viewAngles } = lastRendered;
         camera = new Camera();
         camera.position = vec3_exports.fromValues(origin.x, origin.y, origin.z);
-        const viewOffset = lastView?.offset ?? { x: 0, y: 0, z: 0 };
-        vec3_exports.add(camera.position, camera.position, [viewOffset.x, viewOffset.y, viewOffset.z]);
+        if (!isDemoPlaying || demoCameraState.mode === 0 /* FirstPerson */) {
+          const viewOffset = lastView?.offset ?? { x: 0, y: 0, z: 0 };
+          vec3_exports.add(camera.position, camera.position, [viewOffset.x, viewOffset.y, viewOffset.z]);
+        }
         const effectAngles = lastView?.angles ?? { x: 0, y: 0, z: 0 };
         camera.angles = vec3_exports.fromValues(viewAngles.x + effectAngles.x, viewAngles.y + effectAngles.y, viewAngles.z + effectAngles.z);
         if (isDemoPlaying && lastRendered.fov) {
@@ -14508,7 +14885,21 @@ function createClient(imports) {
     },
     demoHandler,
     multiplayer,
-    configStrings
+    configStrings,
+    // Demo Camera API
+    setDemoCameraMode(mode) {
+      demoCameraState.mode = mode;
+    },
+    setDemoThirdPersonDistance(dist2) {
+      demoCameraState.thirdPersonDistance = dist2;
+    },
+    setDemoThirdPersonOffset(offset) {
+      demoCameraState.thirdPersonOffset = offset;
+    },
+    setDemoFreeCamera(origin, angles) {
+      demoCameraState.freeCameraOrigin = origin;
+      demoCameraState.freeCameraAngles = angles;
+    }
   };
   return clientExports;
 }
@@ -14517,6 +14908,7 @@ function createClient(imports) {
   ClientConfigStrings,
   ClientMode,
   ClientPrediction,
+  DemoCameraMode,
   GameSession,
   InputAction,
   InputBindings,