quake2ts 0.0.298 → 0.0.301

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

@@ -22,15 +22,15 @@ var index_exports = {};
 __export(index_exports, {
   ClientConfigStrings: () => ClientConfigStrings,
   ClientMode: () => ClientMode,
-  ClientPrediction: () => import_cgame4.ClientPrediction,
+  ClientPrediction: () => import_cgame5.ClientPrediction,
   InputAction: () => InputAction,
   InputBindings: () => InputBindings,
   InputCommandBuffer: () => InputCommandBuffer,
   InputController: () => InputController,
-  ViewEffects: () => import_cgame5.ViewEffects,
+  ViewEffects: () => import_cgame6.ViewEffects,
   createClient: () => createClient,
   createDefaultBindings: () => createDefaultBindings,
-  interpolatePredictionState: () => import_cgame4.interpolatePredictionState,
+  interpolatePredictionState: () => import_cgame5.interpolatePredictionState,
   normalizeCommand: () => normalizeCommand,
   normalizeInputCode: () => normalizeInputCode
 });
@@ -8341,6 +8341,13 @@ var NetworkMessageParser = class _NetworkMessageParser {
     if (bitsHigh & U_OLD_FRAME_HIGH) to.oldFrame = this.stream.readShort();
   }
 };
+var PlaybackState = /* @__PURE__ */ ((PlaybackState22) => {
+  PlaybackState22[PlaybackState22["Stopped"] = 0] = "Stopped";
+  PlaybackState22[PlaybackState22["Playing"] = 1] = "Playing";
+  PlaybackState22[PlaybackState22["Paused"] = 2] = "Paused";
+  PlaybackState22[PlaybackState22["Finished"] = 3] = "Finished";
+  return PlaybackState22;
+})(PlaybackState || {});
 var DemoPlaybackController = class {
   // ms (10Hz default)
   constructor() {
@@ -9655,8 +9662,8 @@ var AmmoType2 = /* @__PURE__ */ ((AmmoType22) => {
 var AMMO_TYPE_COUNT2 = Object.keys(AmmoType2).length / 2;
 
 // src/index.ts
-var import_cgame2 = require("@quake2ts/cgame");
 var import_cgame3 = require("@quake2ts/cgame");
+var import_cgame4 = require("@quake2ts/cgame");
 
 // src/cgameBridge.ts
 function createCGameImport(imports, state) {
@@ -9706,6 +9713,24 @@ function createCGameImport(imports, state) {
         flags
       });
     },
+    Cvar_Get: (name, value, flags) => {
+      if (!imports.host || !imports.host.cvars) {
+        return { value: parseInt(value) || 0 };
+      }
+      let existing = imports.host.cvars.get(name);
+      if (!existing) {
+        existing = imports.host.cvars.register({
+          name,
+          defaultValue: value,
+          flags
+        });
+      }
+      return {
+        get value() {
+          return existing.number;
+        }
+      };
+    },
     cvar_set: (name, value) => {
       imports.host?.cvars?.setValue(name, value);
     },
@@ -11643,6 +11668,7 @@ var BrowserWebSocketNetDriver = class {
 };
 
 // src/net/connection.ts
+var import_cgame2 = require("@quake2ts/cgame");
 var MultiplayerConnection = class {
   constructor(options) {
     this.state = 0 /* Disconnected */;
@@ -11660,6 +11686,8 @@ var MultiplayerConnection = class {
     this.connectPacketTime = 0;
     this.latestServerFrame = 0;
     this.commandHistory = [];
+    // Prediction
+    this.prediction = null;
     this.driver = new BrowserWebSocketNetDriver();
     this.options = options;
     this.netchan = new NetChan();
@@ -11667,6 +11695,9 @@ var MultiplayerConnection = class {
     this.driver.onClose(() => this.handleDisconnect());
     this.driver.onError((err2) => console.error("Network Error:", err2));
   }
+  setPrediction(prediction) {
+    this.prediction = prediction;
+  }
   async connect(url) {
     if (this.state !== 0 /* Disconnected */) {
       this.disconnect();
@@ -11704,6 +11735,9 @@ var MultiplayerConnection = class {
     if (this.commandHistory.length > CMD_BACKUP) {
       this.commandHistory.shift();
     }
+    if (this.prediction) {
+      this.prediction.enqueueCommand(commandWithFrame);
+    }
     const writer = new BinaryWriter2();
     writer.writeByte(ClientCommand.move);
     writer.writeByte(0);
@@ -11801,6 +11835,31 @@ var MultiplayerConnection = class {
     if (frame.serverFrame > this.latestServerFrame) {
       this.latestServerFrame = frame.serverFrame;
     }
+    if (this.prediction && frame.playerState) {
+      const ps = frame.playerState;
+      const predState = {
+        ...(0, import_cgame2.defaultPredictionState)(),
+        // Manual mapping due to type mismatch (MutableVec3 vs Vec3, and property names)
+        origin: { x: ps.origin.x, y: ps.origin.y, z: ps.origin.z },
+        velocity: { x: ps.velocity.x, y: ps.velocity.y, z: ps.velocity.z },
+        viewAngles: { x: ps.viewangles.x, y: ps.viewangles.y, z: ps.viewangles.z },
+        deltaAngles: { x: ps.delta_angles.x, y: ps.delta_angles.y, z: ps.delta_angles.z },
+        pmFlags: ps.pm_flags,
+        pmType: ps.pm_type,
+        gravity: ps.gravity,
+        // Copy other matching fields
+        health: ps.stats[0]
+        // Assuming stat 0 is health? Or generic copy
+        // ...
+      };
+      const gameFrame = {
+        frame: frame.serverFrame,
+        timeMs: 0,
+        // Should be server time, but frame doesn't always have it explicitly?
+        state: predState
+      };
+      this.prediction.setAuthoritative(gameFrame);
+    }
   }
   // Stubs for other handlers
   onCenterPrint(msg) {
@@ -11828,6 +11887,89 @@ var MultiplayerConnection = class {
   }
 };
 
+// src/ui/demo-controls.ts
+var DemoControls = class {
+  constructor(playback) {
+    this.isVisible = true;
+    this.playback = playback;
+  }
+  render(renderer, width, height) {
+    if (!this.isVisible) return;
+    const state = this.playback.getState();
+    const isPlaying = state === PlaybackState.Playing;
+    const overlayHeight = 60;
+    const y = height - overlayHeight;
+    renderer.drawfillRect(0, y, width, overlayHeight, [0, 0, 0, 0.5]);
+    const iconSize = 24;
+    const iconY = y + (overlayHeight - iconSize) / 2;
+    const iconX = 20;
+    const statusText = isPlaying ? "PAUSE" : "PLAY";
+    renderer.drawString(iconX, iconY, statusText);
+    const speed = this.playback.getSpeed();
+    const speedText = `Speed: ${speed}x`;
+    renderer.drawCenterString(iconY, speedText);
+    const currentTime = this.playback.getCurrentTime();
+    const currentFormatted = this.formatTime(currentTime);
+    const totalFormatted = "--:--";
+    const timeText = `${currentFormatted} / ${totalFormatted}`;
+    const timeX = width - 150;
+    renderer.drawString(timeX, iconY, timeText);
+    const timelineY = y + 5;
+    const timelineHeight = 4;
+    const timelineWidth = width - 40;
+    const timelineX = 20;
+    renderer.drawfillRect(timelineX, timelineY, timelineWidth, timelineHeight, [0.3, 0.3, 0.3, 1]);
+    const progress = 0;
+    const progressWidth = timelineWidth * progress;
+    renderer.drawfillRect(timelineX, timelineY, progressWidth, timelineHeight, [1, 1, 1, 1]);
+    const markerX = timelineX + progressWidth;
+    renderer.drawfillRect(markerX - 2, timelineY - 2, 4, timelineHeight + 4, [1, 0, 0, 1]);
+    const helpText = "[Space] Toggle  [< >] Step  [ [ ] ] Speed  [Esc] Stop";
+    renderer.drawCenterString(y + 35, helpText);
+  }
+  handleInput(key, down) {
+    if (!down) return false;
+    switch (key.toLowerCase()) {
+      case " ":
+        if (this.playback.getState() === PlaybackState.Playing) {
+          this.playback.pause();
+        } else if (this.playback.getState() === PlaybackState.Paused) {
+          this.playback.play();
+        }
+        return true;
+      case "arrowright":
+        this.playback.stepForward();
+        return true;
+      case "arrowleft":
+        this.playback.stepBackward();
+        return true;
+      case "]":
+        this.changeSpeed(2);
+        return true;
+      case "[":
+        this.changeSpeed(0.5);
+        return true;
+      case "escape":
+        this.playback.stop();
+        return true;
+    }
+    return false;
+  }
+  changeSpeed(factor) {
+    const current = this.playback.getSpeed();
+    let newSpeed = current * factor;
+    if (newSpeed < 0.1) newSpeed = 0.1;
+    if (newSpeed > 16) newSpeed = 16;
+    this.playback.setSpeed(newSpeed);
+  }
+  formatTime(ms) {
+    const totalSeconds = Math.floor(ms / 1e3);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+  }
+};
+
 // src/input/bindings.ts
 var DEFAULT_BINDINGS = [
   { code: "KeyW", command: "+forward" },
@@ -11992,6 +12134,7 @@ var InputController = class {
     this.touchButtons = /* @__PURE__ */ new Map();
     this.touchMove = { x: 0, y: 0 };
     this.touchLook = { x: 0, y: 0 };
+    this.sequence = 0;
     this.bindings = bindings;
     this.forwardSpeed = options.forwardSpeed ?? DEFAULT_FORWARD_SPEED;
     this.sideSpeed = options.sideSpeed ?? DEFAULT_SIDE_SPEED;
@@ -12130,6 +12273,7 @@ var InputController = class {
       buttons |= PlayerButton.Any;
     }
     this.anyPressed = false;
+    this.sequence++;
     return {
       msec,
       buttons,
@@ -12137,7 +12281,10 @@ var InputController = class {
       forwardmove,
       sidemove,
       upmove,
-      serverFrame
+      serverFrame,
+      sequence: this.sequence,
+      lightlevel: 0,
+      impulse: 0
     };
   }
   consumeConsoleCommands() {
@@ -12317,8 +12464,8 @@ var InputCommandBuffer = class {
 };
 
 // src/index.ts
-var import_cgame4 = require("@quake2ts/cgame");
 var import_cgame5 = require("@quake2ts/cgame");
+var import_cgame6 = require("@quake2ts/cgame");
 var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
 var ClientMode = /* @__PURE__ */ ((ClientMode2) => {
   ClientMode2[ClientMode2["Normal"] = 0] = "Normal";
@@ -12332,9 +12479,10 @@ function createClient(imports) {
     const tr = imports.engine.trace(point, point, zero3, zero3);
     return tr.contents || 0;
   };
-  const prediction = new import_cgame2.ClientPrediction(imports.engine.trace, pointContents);
-  const view = new import_cgame3.ViewEffects();
+  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 demoHandler = new ClientNetworkHandler(imports);
   demoHandler.setView(view);
   let isDemoPlaying = false;
@@ -12375,7 +12523,7 @@ function createClient(imports) {
     }
   };
   const cgameImport = createCGameImport(imports, stateProvider);
-  const cg = (0, import_cgame2.GetCGameAPI)(cgameImport);
+  const cg = (0, import_cgame3.GetCGameAPI)(cgameImport);
   const multiplayer = new MultiplayerConnection({
     get username() {
       return imports.host?.cvars?.get("name")?.string || "Player";
@@ -12529,6 +12677,11 @@ function createClient(imports) {
       return prediction.enqueueCommand(command);
     },
     handleInput(key, down) {
+      if (isDemoPlaying) {
+        if (demoControls.handleInput(key, down)) {
+          return true;
+        }
+      }
       if (!menuSystem.isActive()) return false;
       if (!down) return true;
       const lowerKey = key.toLowerCase();
@@ -12614,7 +12767,7 @@ function createClient(imports) {
           latestFrame = sample.latest;
         }
         if (sample.previous?.state && sample.latest?.state) {
-          lastRendered = (0, import_cgame2.interpolatePredictionState)(sample.previous.state, sample.latest.state, sample.alpha);
+          lastRendered = (0, import_cgame3.interpolatePredictionState)(sample.previous.state, sample.latest.state, sample.alpha);
           if (sample.latest.state.packetEntities && sample.previous.state.packetEntities) {
             renderEntities = buildRenderableEntities(
               sample.latest.state.packetEntities,
@@ -12748,6 +12901,9 @@ function createClient(imports) {
       if (menuSystem.isActive()) {
         Draw_Menu(imports.engine.renderer, menuSystem.getState(), imports.engine.renderer.width, imports.engine.renderer.height);
       }
+      if (isDemoPlaying) {
+        demoControls.render(imports.engine.renderer, imports.engine.renderer.width, imports.engine.renderer.height);
+      }
       if (lastRendered && lastRendered.client) {
         wheelMenuSystem.render(imports.engine.renderer, imports.engine.renderer.width, imports.engine.renderer.height, lastRendered.client);
       }