quake2ts 0.0.298 → 0.0.301

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

@@ -8309,6 +8309,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() {
@@ -9623,7 +9630,7 @@ var AmmoType2 = /* @__PURE__ */ ((AmmoType22) => {
 var AMMO_TYPE_COUNT2 = Object.keys(AmmoType2).length / 2;
 
 // src/index.ts
-import { ClientPrediction, interpolatePredictionState as interpolatePredictionState2, GetCGameAPI } from "@quake2ts/cgame";
+import { ClientPrediction as ClientPrediction2, interpolatePredictionState as interpolatePredictionState2, GetCGameAPI } from "@quake2ts/cgame";
 import { ViewEffects as ViewEffects2 } from "@quake2ts/cgame";
 
 // src/cgameBridge.ts
@@ -9674,6 +9681,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);
     },
@@ -11611,6 +11636,7 @@ var BrowserWebSocketNetDriver = class {
 };
 
 // src/net/connection.ts
+import { defaultPredictionState as defaultPredictionState2 } from "@quake2ts/cgame";
 var MultiplayerConnection = class {
   constructor(options) {
     this.state = 0 /* Disconnected */;
@@ -11628,6 +11654,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();
@@ -11635,6 +11663,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();
@@ -11672,6 +11703,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);
@@ -11769,6 +11803,31 @@ var MultiplayerConnection = class {
     if (frame.serverFrame > this.latestServerFrame) {
       this.latestServerFrame = frame.serverFrame;
     }
+    if (this.prediction && frame.playerState) {
+      const ps = frame.playerState;
+      const predState = {
+        ...defaultPredictionState2(),
+        // 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) {
@@ -11796,6 +11855,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" },
@@ -11960,6 +12102,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;
@@ -12098,6 +12241,7 @@ var InputController = class {
       buttons |= PlayerButton.Any;
     }
     this.anyPressed = false;
+    this.sequence++;
     return {
       msec,
       buttons,
@@ -12105,7 +12249,10 @@ var InputController = class {
       forwardmove,
       sidemove,
       upmove,
-      serverFrame
+      serverFrame,
+      sequence: this.sequence,
+      lightlevel: 0,
+      impulse: 0
     };
   }
   consumeConsoleCommands() {
@@ -12286,7 +12433,7 @@ var InputCommandBuffer = class {
 
 // src/index.ts
 import {
-  ClientPrediction as ClientPrediction2,
+  ClientPrediction as ClientPrediction3,
   interpolatePredictionState as interpolatePredictionState3
 } from "@quake2ts/cgame";
 import { ViewEffects as ViewEffects3 } from "@quake2ts/cgame";
@@ -12303,9 +12450,10 @@ function createClient(imports) {
     const tr = imports.engine.trace(point, point, zero3, zero3);
     return tr.contents || 0;
   };
-  const prediction = new ClientPrediction(imports.engine.trace, pointContents);
+  const prediction = new ClientPrediction2(imports.engine.trace, pointContents);
   const view = new ViewEffects2();
   const demoPlayback = new DemoPlaybackController();
+  const demoControls = new DemoControls(demoPlayback);
   const demoHandler = new ClientNetworkHandler(imports);
   demoHandler.setView(view);
   let isDemoPlaying = false;
@@ -12500,6 +12648,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();
@@ -12719,6 +12872,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);
       }
@@ -12803,7 +12959,7 @@ function createClient(imports) {
 export {
   ClientConfigStrings,
   ClientMode,
-  ClientPrediction2 as ClientPrediction,
+  ClientPrediction3 as ClientPrediction,
   InputAction,
   InputBindings,
   InputCommandBuffer,