quake2ts 0.0.298 → 0.0.299

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
 });
@@ -9655,8 +9655,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 +9706,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 +11661,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 +11679,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 +11688,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 +11728,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 +11828,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) {
@@ -11992,6 +12044,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 +12183,7 @@ var InputController = class {
       buttons |= PlayerButton.Any;
     }
     this.anyPressed = false;
+    this.sequence++;
     return {
       msec,
       buttons,
@@ -12137,7 +12191,10 @@ var InputController = class {
       forwardmove,
       sidemove,
       upmove,
-      serverFrame
+      serverFrame,
+      sequence: this.sequence,
+      lightlevel: 0,
+      impulse: 0
     };
   }
   consumeConsoleCommands() {
@@ -12317,8 +12374,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,8 +12389,8 @@ 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 demoHandler = new ClientNetworkHandler(imports);
   demoHandler.setView(view);
@@ -12375,7 +12432,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";
@@ -12614,7 +12671,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,