quake2ts 0.0.193 → 0.0.195

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

@@ -21,16 +21,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ClientConfigStrings: () => ClientConfigStrings,
-  ClientPrediction: () => ClientPrediction,
+  ClientPrediction: () => import_cgame4.ClientPrediction,
   InputAction: () => InputAction,
   InputBindings: () => InputBindings,
   InputCommandBuffer: () => InputCommandBuffer,
   InputController: () => InputController,
-  ViewEffects: () => ViewEffects,
+  ViewEffects: () => import_cgame5.ViewEffects,
   createClient: () => createClient,
   createDefaultBindings: () => createDefaultBindings,
-  defaultPredictionState: () => defaultPredictionState,
-  interpolatePredictionState: () => interpolatePredictionState,
+  interpolatePredictionState: () => import_cgame4.interpolatePredictionState,
   normalizeCommand: () => normalizeCommand,
   normalizeInputCode: () => normalizeInputCode
 });
@@ -3527,25 +3526,9 @@ var __export3 = (target, all) => {
 };
 var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
 var DEG_TO_RAD2 = Math.PI / 180;
-function addVec3(a, b) {
-  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
-}
-function scaleVec3(a, scalar) {
-  return { x: a.x * scalar, y: a.y * scalar, z: a.z * scalar };
-}
 function dotVec3(a, b) {
   return a.x * b.x + a.y * b.y + a.z * b.z;
 }
-function lengthSquaredVec3(a) {
-  return dotVec3(a, a);
-}
-function lengthVec3(a) {
-  return Math.sqrt(lengthSquaredVec3(a));
-}
-function normalizeVec3(a) {
-  const len2 = lengthVec3(a);
-  return len2 === 0 ? a : scaleVec3(a, 1 / len2);
-}
 var PITCH = 0;
 var YAW = 1;
 var ROLL = 2;
@@ -3756,16 +3739,6 @@ var PmFlag = /* @__PURE__ */ ((PmFlag22) => {
 function hasPmFlag(flags, flag) {
   return (flags & flag) !== 0;
 }
-var PmType = /* @__PURE__ */ ((PmType22) => {
-  PmType22[PmType22["Normal"] = 0] = "Normal";
-  PmType22[PmType22["Grapple"] = 1] = "Grapple";
-  PmType22[PmType22["NoClip"] = 2] = "NoClip";
-  PmType22[PmType22["Spectator"] = 3] = "Spectator";
-  PmType22[PmType22["Dead"] = 4] = "Dead";
-  PmType22[PmType22["Gib"] = 5] = "Gib";
-  PmType22[PmType22["Freeze"] = 6] = "Freeze";
-  return PmType22;
-})(PmType || {});
 var PlayerButton = /* @__PURE__ */ ((PlayerButton2) => {
   PlayerButton2[PlayerButton2["None"] = 0] = "None";
   PlayerButton2[PlayerButton2["Attack"] = 1] = "Attack";
@@ -3776,153 +3749,7 @@ var PlayerButton = /* @__PURE__ */ ((PlayerButton2) => {
   PlayerButton2[PlayerButton2["Any"] = 128] = "Any";
   return PlayerButton2;
 })(PlayerButton || {});
-function applyPmoveFriction(params) {
-  const {
-    velocity,
-    frametime,
-    onGround,
-    groundIsSlick,
-    onLadder,
-    waterlevel,
-    pmFriction,
-    pmStopSpeed,
-    pmWaterFriction
-  } = params;
-  const speed = lengthVec3(velocity);
-  if (speed < 1) {
-    return { x: 0, y: 0, z: velocity.z };
-  }
-  let drop = 0;
-  if (onGround && !groundIsSlick || onLadder) {
-    const control = speed < pmStopSpeed ? pmStopSpeed : speed;
-    const friction = pmFriction;
-    drop += control * friction * frametime;
-  }
-  if (waterlevel > 0 && !onLadder) {
-    drop += speed * pmWaterFriction * waterlevel * frametime;
-  }
-  let newspeed = speed - drop;
-  if (newspeed < 0) {
-    newspeed = 0;
-  }
-  if (newspeed === speed) {
-    return velocity;
-  }
-  const scale3 = newspeed / speed;
-  return scaleVec3(velocity, scale3);
-}
-function applyPmoveAccelerate(params) {
-  const { velocity, wishdir, wishspeed, accel, frametime } = params;
-  const currentSpeed = dotVec3(velocity, wishdir);
-  const addSpeed = wishspeed - currentSpeed;
-  if (addSpeed <= 0) {
-    return velocity;
-  }
-  let accelSpeed = accel * frametime * wishspeed;
-  if (accelSpeed > addSpeed) {
-    accelSpeed = addSpeed;
-  }
-  return {
-    x: velocity.x + wishdir.x * accelSpeed,
-    y: velocity.y + wishdir.y * accelSpeed,
-    z: velocity.z + wishdir.z * accelSpeed
-  };
-}
-function applyPmoveAirAccelerate(params) {
-  const { velocity, wishdir, wishspeed, accel, frametime } = params;
-  const wishspd = Math.min(wishspeed, 30);
-  const currentSpeed = dotVec3(velocity, wishdir);
-  const addSpeed = wishspd - currentSpeed;
-  if (addSpeed <= 0) {
-    return velocity;
-  }
-  let accelSpeed = accel * wishspeed * frametime;
-  if (accelSpeed > addSpeed) {
-    accelSpeed = addSpeed;
-  }
-  return {
-    x: velocity.x + wishdir.x * accelSpeed,
-    y: velocity.y + wishdir.y * accelSpeed,
-    z: velocity.z + wishdir.z * accelSpeed
-  };
-}
-function buildAirGroundWish(params) {
-  const { forward, right, cmd, maxSpeed } = params;
-  let wishvel = {
-    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
-    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
-    z: 0
-  };
-  let wishspeed = lengthVec3(wishvel);
-  if (wishspeed > maxSpeed) {
-    const scale3 = maxSpeed / wishspeed;
-    wishvel = scaleVec3(wishvel, scale3);
-    wishspeed = maxSpeed;
-  }
-  return {
-    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
-    wishspeed
-  };
-}
-function buildWaterWish(params) {
-  const { forward, right, cmd, maxSpeed } = params;
-  let wishvel = {
-    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
-    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
-    z: 0
-  };
-  if (cmd.upmove > 10) {
-    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
-  } else if (cmd.upmove < -10) {
-    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
-  } else {
-    wishvel = addVec3(wishvel, { x: 0, y: 0, z: 10 });
-  }
-  let wishspeed = lengthVec3(wishvel);
-  if (wishspeed > maxSpeed) {
-    const scale3 = maxSpeed / wishspeed;
-    wishvel = scaleVec3(wishvel, scale3);
-    wishspeed = maxSpeed;
-  }
-  wishspeed *= 0.5;
-  return {
-    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
-    wishspeed
-  };
-}
 var WATERJUMP_CLEAR2 = 8 | 16 | 32 | 1024;
-function addAngles(cmdAngles, deltaAngles) {
-  return {
-    x: cmdAngles.x + deltaAngles.x,
-    y: cmdAngles.y + deltaAngles.y,
-    z: cmdAngles.z + deltaAngles.z
-  };
-}
-function clampPitch(pitch) {
-  if (pitch > 89 && pitch < 180) {
-    return 89;
-  }
-  if (pitch < 271 && pitch >= 180) {
-    return 271;
-  }
-  return pitch;
-}
-function clampViewAngles(params) {
-  const { pmFlags, cmdAngles, deltaAngles } = params;
-  let viewangles;
-  if ((pmFlags & 32) !== 0) {
-    viewangles = {
-      x: 0,
-      y: cmdAngles.y + deltaAngles.y,
-      z: 0
-    };
-  } else {
-    viewangles = addAngles(cmdAngles, deltaAngles);
-    viewangles = { ...viewangles, x: clampPitch(viewangles.x) };
-  }
-  const vectors = angleVectors(viewangles);
-  return { viewangles, ...vectors };
-}
 var DEFAULT_FORWARD_SPEED = 200;
 var DEFAULT_SIDE_SPEED = 200;
 var DEFAULT_UP_SPEED = 200;
@@ -4012,303 +3839,9 @@ var AmmoType2 = /* @__PURE__ */ ((AmmoType22) => {
 })(AmmoType2 || {});
 var AMMO_TYPE_COUNT2 = Object.keys(AmmoType2).length / 2;
 
-// src/prediction.ts
-var DEFAULTS = {
-  pmFriction: 6,
-  pmStopSpeed: 100,
-  pmAccelerate: 10,
-  pmAirAccelerate: 1,
-  pmWaterAccelerate: 4,
-  pmWaterFriction: 1,
-  pmMaxSpeed: 300,
-  pmDuckSpeed: 100,
-  pmWaterSpeed: 400,
-  groundIsSlick: false
-};
-var DEFAULT_GRAVITY = 800;
-var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
-var MSEC_MAX = 250;
-function defaultPredictionState() {
-  return {
-    origin: ZERO_VEC32,
-    velocity: ZERO_VEC32,
-    viewangles: ZERO_VEC32,
-    pmFlags: PmFlag.OnGround,
-    pmType: PmType.Normal,
-    waterlevel: WaterLevel.None,
-    gravity: DEFAULT_GRAVITY,
-    deltaAngles: ZERO_VEC32,
-    health: 0,
-    armor: 0,
-    ammo: 0,
-    blend: [0, 0, 0, 0],
-    damageAlpha: 0,
-    damageIndicators: []
-  };
-}
-function normalizeState(state) {
-  if (!state) return defaultPredictionState();
-  return {
-    ...defaultPredictionState(),
-    ...state,
-    origin: { ...state.origin },
-    velocity: { ...state.velocity },
-    viewangles: { ...state.viewangles },
-    deltaAngles: state.deltaAngles ? { ...state.deltaAngles } : ZERO_VEC32,
-    blend: state.blend ? [...state.blend] : [0, 0, 0, 0],
-    damageIndicators: state.damageIndicators ? [...state.damageIndicators] : []
-  };
-}
-function lerp2(a, b, t) {
-  return a + (b - a) * t;
-}
-function lerpAngle(a, b, t) {
-  let delta = angleMod(b - a);
-  if (delta > 180) {
-    delta -= 360;
-  }
-  return angleMod(a + delta * t);
-}
-function interpolatePredictionState(previous, latest, alpha) {
-  const clamped = Math.max(0, Math.min(alpha, 1));
-  return {
-    origin: {
-      x: lerp2(previous.origin.x, latest.origin.x, clamped),
-      y: lerp2(previous.origin.y, latest.origin.y, clamped),
-      z: lerp2(previous.origin.z, latest.origin.z, clamped)
-    },
-    velocity: {
-      x: lerp2(previous.velocity.x, latest.velocity.x, clamped),
-      y: lerp2(previous.velocity.y, latest.velocity.y, clamped),
-      z: lerp2(previous.velocity.z, latest.velocity.z, clamped)
-    },
-    viewangles: {
-      x: lerpAngle(previous.viewangles.x, latest.viewangles.x, clamped),
-      y: lerpAngle(previous.viewangles.y, latest.viewangles.y, clamped),
-      z: lerpAngle(previous.viewangles.z, latest.viewangles.z, clamped)
-    },
-    pmFlags: latest.pmFlags,
-    pmType: latest.pmType,
-    waterlevel: latest.waterlevel,
-    gravity: latest.gravity,
-    deltaAngles: latest.deltaAngles,
-    client: latest.client,
-    health: lerp2(previous.health, latest.health, clamped),
-    armor: lerp2(previous.armor, latest.armor, clamped),
-    ammo: lerp2(previous.ammo, latest.ammo, clamped),
-    centerPrint: latest.centerPrint,
-    notify: latest.notify,
-    blend: latest.blend,
-    pickupIcon: latest.pickupIcon,
-    damageAlpha: latest.damageAlpha,
-    damageIndicators: latest.damageIndicators
-  };
-}
-function simulateCommand(state, cmd, settings, trace) {
-  const frametime = Math.min(Math.max(cmd.msec, 0), MSEC_MAX) / 1e3;
-  const onGround = hasPmFlag(state.pmFlags, PmFlag.OnGround);
-  const onLadder = hasPmFlag(state.pmFlags, PmFlag.OnLadder);
-  let velocity = applyPmoveFriction({
-    velocity: state.velocity,
-    frametime,
-    onGround,
-    groundIsSlick: settings.groundIsSlick,
-    onLadder,
-    waterlevel: state.waterlevel,
-    pmFriction: settings.pmFriction,
-    pmStopSpeed: settings.pmStopSpeed,
-    pmWaterFriction: settings.pmWaterFriction
-  });
-  const { viewangles, forward, right } = clampViewAngles({
-    pmFlags: state.pmFlags,
-    cmdAngles: cmd.angles,
-    deltaAngles: state.deltaAngles ?? ZERO_VEC32
-  });
-  const wish = state.waterlevel > WaterLevel.None ? buildWaterWish({ forward, right, cmd, maxSpeed: settings.pmWaterSpeed }) : buildAirGroundWish({ forward, right, cmd, maxSpeed: settings.pmMaxSpeed });
-  if (state.waterlevel > WaterLevel.None) {
-    velocity = applyPmoveAccelerate({
-      velocity,
-      wishdir: wish.wishdir,
-      wishspeed: wish.wishspeed,
-      accel: settings.pmWaterAccelerate,
-      frametime
-    });
-  } else if (onGround || onLadder) {
-    const maxSpeed = hasPmFlag(state.pmFlags, PmFlag.Ducked) ? settings.pmDuckSpeed : settings.pmMaxSpeed;
-    const clampedWish = wish.wishspeed > maxSpeed ? {
-      wishdir: wish.wishdir,
-      wishspeed: maxSpeed
-    } : wish;
-    velocity = applyPmoveAccelerate({
-      velocity,
-      wishdir: clampedWish.wishdir,
-      wishspeed: clampedWish.wishspeed,
-      accel: settings.pmAccelerate,
-      frametime
-    });
-  } else {
-    velocity = applyPmoveAirAccelerate({
-      velocity,
-      wishdir: wish.wishdir,
-      wishspeed: wish.wishspeed,
-      accel: settings.pmAirAccelerate,
-      frametime
-    });
-    velocity = { ...velocity, z: velocity.z - state.gravity * frametime };
-  }
-  const traceResult = trace(state.origin, addVec3(state.origin, scaleVec3(velocity, frametime)));
-  const origin = traceResult.endpos;
-  return {
-    ...state,
-    origin,
-    velocity,
-    viewangles
-  };
-}
-var ClientPrediction = class {
-  constructor(trace, settings = {}) {
-    this.baseFrame = {
-      frame: 0,
-      timeMs: 0,
-      state: defaultPredictionState()
-    };
-    this.commands = [];
-    this.predicted = defaultPredictionState();
-    this.settings = { ...DEFAULTS, ...settings };
-    this.trace = trace;
-    this.predicted = this.baseFrame.state ?? defaultPredictionState();
-  }
-  setAuthoritative(frame) {
-    const normalized = normalizeState(frame.state);
-    this.baseFrame = { ...frame, state: normalized };
-    this.commands = this.commands.filter((cmd) => (cmd.serverFrame ?? Number.MAX_SAFE_INTEGER) > frame.frame);
-    return this.recompute();
-  }
-  enqueueCommand(cmd) {
-    this.commands.push(cmd);
-    return this.recompute();
-  }
-  getPredictedState() {
-    return this.predicted;
-  }
-  recompute() {
-    let state = normalizeState(this.baseFrame.state);
-    for (const cmd of this.commands) {
-      state = simulateCommand(state, cmd, this.settings, this.trace);
-    }
-    this.predicted = state;
-    return state;
-  }
-};
-
-// src/view-effects.ts
-var DEFAULT_SETTINGS = {
-  runPitch: 2e-3,
-  runRoll: 0.01,
-  // Changed from 0.005 to match Quake 2 slope (2.0 / 200.0)
-  bobUp: 5e-3,
-  bobPitch: 2e-3,
-  bobRoll: 2e-3,
-  maxBobHeight: 6,
-  maxBobAngle: 1.2
-};
-function clampViewOffset(offset) {
-  return {
-    x: Math.max(-14, Math.min(14, offset.x)),
-    y: Math.max(-14, Math.min(14, offset.y)),
-    z: Math.max(-22, Math.min(30, offset.z))
-  };
-}
-function computeBobMove(xyspeed, onGround, frameTimeMs) {
-  if (!onGround) return 0;
-  if (xyspeed > 210) return frameTimeMs / 400;
-  if (xyspeed > 100) return frameTimeMs / 800;
-  return frameTimeMs / 1600;
-}
-function computeBobValues(previousBobTime, xyspeed, pmFlags, onGround, frameTimeMs) {
-  if (xyspeed < 5) {
-    return { bobTime: 0, bobCycle: 0, bobCycleRun: 0, bobFracSin: 0 };
-  }
-  const bobMove = computeBobMove(xyspeed, onGround, frameTimeMs);
-  const bobTimeRun = previousBobTime + bobMove;
-  const crouched = hasPmFlag(pmFlags, PmFlag.Ducked) && onGround;
-  const bobTime = crouched ? bobTimeRun * 4 : bobTimeRun;
-  return {
-    bobTime: bobTimeRun,
-    bobCycle: Math.floor(bobTime),
-    bobCycleRun: Math.floor(bobTimeRun),
-    bobFracSin: Math.abs(Math.sin(bobTime * Math.PI))
-  };
-}
-var ViewEffects = class {
-  constructor(settings = {}) {
-    this.bobTime = 0;
-    this.bobCycle = 0;
-    this.bobCycleRun = 0;
-    this.bobFracSin = 0;
-    this.settings = { ...DEFAULT_SETTINGS, ...settings };
-  }
-  addKick(kick) {
-    if (kick.durationMs <= 0) return;
-    this.kick = { ...kick, remainingMs: kick.durationMs };
-  }
-  get last() {
-    return this.lastSample;
-  }
-  sample(state, frameTimeMs) {
-    const { forward, right } = angleVectors(
-      clampViewAngles({ pmFlags: state.pmFlags, cmdAngles: state.viewangles, deltaAngles: state.deltaAngles ?? ZERO_VEC3 }).viewangles
-    );
-    const xyspeed = Math.sqrt(state.velocity.x * state.velocity.x + state.velocity.y * state.velocity.y);
-    const onGround = hasPmFlag(state.pmFlags, PmFlag.OnGround);
-    const bobValues = computeBobValues(this.bobTime, xyspeed, state.pmFlags, onGround, frameTimeMs);
-    this.bobTime = bobValues.bobTime;
-    this.bobCycle = bobValues.bobCycle;
-    this.bobCycleRun = bobValues.bobCycleRun;
-    this.bobFracSin = bobValues.bobFracSin;
-    let pitchTilt = dotVec3(state.velocity, forward) * this.settings.runPitch;
-    const side = dotVec3(state.velocity, right);
-    const sign = side < 0 ? -1 : 1;
-    const absSide = Math.abs(side);
-    let rollTilt = absSide * this.settings.runRoll;
-    if (rollTilt > 2) {
-      rollTilt = 2;
-    }
-    rollTilt *= sign;
-    let pitchDelta = this.bobFracSin * this.settings.bobPitch * xyspeed;
-    let rollDelta = this.bobFracSin * this.settings.bobRoll * xyspeed;
-    if (hasPmFlag(state.pmFlags, PmFlag.Ducked) && onGround) {
-      pitchDelta *= 6;
-      rollDelta *= 6;
-    }
-    pitchTilt += Math.min(pitchDelta, this.settings.maxBobAngle);
-    rollDelta = Math.min(rollDelta, this.settings.maxBobAngle);
-    if (this.bobCycle & 1) rollDelta = -rollDelta;
-    rollTilt += rollDelta;
-    const bobHeight = Math.min(this.bobFracSin * xyspeed * this.settings.bobUp, this.settings.maxBobHeight);
-    let kickPitch = 0;
-    let kickRoll = 0;
-    if (this.kick && this.kick.remainingMs > 0) {
-      const ratio = Math.max(0, Math.min(1, this.kick.remainingMs / this.kick.durationMs));
-      kickPitch += ratio * this.kick.pitch;
-      kickRoll += ratio * this.kick.roll;
-      this.kick.remainingMs = Math.max(0, this.kick.remainingMs - frameTimeMs);
-      if (this.kick.remainingMs === 0) this.kick = void 0;
-    }
-    const angles = { x: pitchTilt + kickPitch, y: 0, z: rollTilt + kickRoll };
-    const offset = { x: 0, y: 0, z: bobHeight };
-    const sample = {
-      angles,
-      offset: clampViewOffset(offset),
-      bobCycle: this.bobCycle,
-      bobCycleRun: this.bobCycleRun,
-      bobFracSin: this.bobFracSin,
-      xyspeed
-    };
-    this.lastSample = sample;
-    return sample;
-  }
-};
+// src/index.ts
+var import_cgame2 = require("@quake2ts/cgame");
+var import_cgame3 = require("@quake2ts/cgame");
 
 // src/hud/crosshair.ts
 var crosshairPic = null;
@@ -4771,6 +4304,9 @@ var SubtitleSystem = class {
   }
 };
 
+// src/demo/handler.ts
+var import_cgame = require("@quake2ts/cgame");
+
 // src/demo/itemMapping.ts
 var import_game3 = require("@quake2ts/game");
 var import_game4 = require("@quake2ts/game");
@@ -5149,15 +4685,15 @@ var ClientNetworkHandler = class {
     }
     const origin = { ...ps.origin };
     const velocity = { ...ps.velocity };
-    const viewangles = { ...ps.viewangles };
+    const viewAngles = { ...ps.viewangles };
     const deltaAngles = { ...ps.delta_angles };
     return {
       origin,
       velocity,
-      viewangles,
+      viewAngles,
       pmFlags: ps.pm_flags,
       pmType: ps.pm_type,
-      waterlevel: WaterLevel.None,
+      waterLevel: WaterLevel.None,
       gravity: ps.gravity,
       deltaAngles,
       client: {
@@ -5177,11 +4713,21 @@ var ClientNetworkHandler = class {
       // No blend from demo frame currently (need to parse svc_playerinfo more fully)
       damageAlpha: 0,
       // Need to extract from renderfx/flash
-      damageIndicators: []
+      damageIndicators: [],
+      // Stubs
+      stats: [...ps.stats],
+      kick_angles: ZERO_VEC3,
+      gunoffset: ZERO_VEC3,
+      gunangles: ZERO_VEC3,
+      gunindex: 0,
+      onGround: false,
+      // Infer from pmFlags?
+      mins: { x: -16, y: -16, z: -24 },
+      maxs: { x: 16, y: 16, z: 32 }
     };
   }
   getPredictionState(timeMs) {
-    if (!this.latestFrame) return defaultPredictionState();
+    if (!this.latestFrame) return (0, import_cgame.defaultPredictionState)();
     const latestState = this.convertFrameToPredictionState(this.latestFrame);
     if (this.previousFrame && timeMs !== void 0) {
       const latestServerTime = this.latestFrame.serverFrame * 100;
@@ -5189,7 +4735,7 @@ var ClientNetworkHandler = class {
       if (timeMs >= previousServerTime && timeMs <= latestServerTime) {
         const alpha = (timeMs - previousServerTime) / (latestServerTime - previousServerTime);
         const previousState = this.convertFrameToPredictionState(this.previousFrame);
-        return interpolatePredictionState(previousState, latestState, Math.max(0, Math.min(1, alpha)));
+        return (0, import_cgame.interpolatePredictionState)(previousState, latestState, Math.max(0, Math.min(1, alpha)));
       }
     }
     return latestState;
@@ -6098,7 +5644,7 @@ function normalizeCommand(command) {
 }
 
 // src/input/controller.ts
-var MSEC_MAX2 = 250;
+var MSEC_MAX = 250;
 var KeyButton = class {
   constructor() {
     this.activeCodes = /* @__PURE__ */ new Set();
@@ -6328,7 +5874,7 @@ var InputController = class {
     sidemove = this.clampMove(sidemove, this.sideSpeed);
     upmove = this.clampMove(upmove, this.upSpeed);
     let buttons = this.collectButtonBits(frameMsec, now);
-    const msec = Math.min(Math.max(Math.round(frameMsec), 1), MSEC_MAX2);
+    const msec = Math.min(Math.max(Math.round(frameMsec), 1), MSEC_MAX);
     if (this.anyPressed || buttons !== PlayerButton.None) {
       buttons |= PlayerButton.Any;
     }
@@ -6520,11 +6066,14 @@ var InputCommandBuffer = class {
 };
 
 // src/index.ts
-function lerp3(a, b, t) {
+var import_cgame4 = require("@quake2ts/cgame");
+var import_cgame5 = require("@quake2ts/cgame");
+var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
+function lerp2(a, b, t) {
   return a + (b - a) * t;
 }
-function lerpAngle2(a, b, t) {
-  return lerp3(a, b, t);
+function lerpAngle(a, b, t) {
+  return lerp2(a, b, t);
 }
 function buildRenderableEntities(latestEntities, previousEntities, alpha, configStrings, imports) {
   const renderables = [];
@@ -6538,14 +6087,14 @@ function buildRenderableEntities(latestEntities, previousEntities, alpha, config
     const model = assets.getMd2Model(modelName) || assets.getMd3Model(modelName);
     if (!model) continue;
     const origin = {
-      x: lerp3(prev.origin.x, ent.origin.x, alpha),
-      y: lerp3(prev.origin.y, ent.origin.y, alpha),
-      z: lerp3(prev.origin.z, ent.origin.z, alpha)
+      x: lerp2(prev.origin.x, ent.origin.x, alpha),
+      y: lerp2(prev.origin.y, ent.origin.y, alpha),
+      z: lerp2(prev.origin.z, ent.origin.z, alpha)
     };
     const angles = {
-      x: lerpAngle2(prev.angles.x, ent.angles.x, alpha),
-      y: lerpAngle2(prev.angles.y, ent.angles.y, alpha),
-      z: lerpAngle2(prev.angles.z, ent.angles.z, alpha)
+      x: lerpAngle(prev.angles.x, ent.angles.x, alpha),
+      y: lerpAngle(prev.angles.y, ent.angles.y, alpha),
+      z: lerpAngle(prev.angles.z, ent.angles.z, alpha)
     };
     const frame = ent.frame;
     const prevFrame = prev.frame;
@@ -6584,8 +6133,8 @@ function buildRenderableEntities(latestEntities, previousEntities, alpha, config
   return renderables;
 }
 function createClient(imports) {
-  const prediction = new ClientPrediction(imports.engine.trace);
-  const view = new ViewEffects();
+  const prediction = new import_cgame2.ClientPrediction(imports.engine.trace);
+  const view = new import_cgame3.ViewEffects();
   const messageSystem = new MessageSystem();
   const subtitleSystem = new SubtitleSystem();
   const demoPlayback = new DemoPlaybackController();
@@ -6784,7 +6333,7 @@ function createClient(imports) {
           latestFrame = sample.latest;
         }
         if (sample.previous?.state && sample.latest?.state) {
-          lastRendered = interpolatePredictionState(sample.previous.state, sample.latest.state, sample.alpha);
+          lastRendered = (0, import_cgame2.interpolatePredictionState)(sample.previous.state, sample.latest.state, sample.alpha);
           if (sample.latest.state.packetEntities && sample.previous.state.packetEntities) {
             renderEntities = buildRenderableEntities(
               sample.latest.state.packetEntities,
@@ -6802,13 +6351,13 @@ function createClient(imports) {
       lastView = view.sample(lastRendered, frameTimeMs);
       const command = {};
       if (lastRendered) {
-        const { origin, viewangles } = lastRendered;
+        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]);
         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);
+        camera.angles = vec3_exports.fromValues(viewAngles.x + effectAngles.x, viewAngles.y + effectAngles.y, viewAngles.z + effectAngles.z);
         camera.fov = isZooming ? 40 : fovValue;
         camera.aspect = 4 / 3;
         if (imports.engine.renderer) {
@@ -6863,9 +6412,9 @@ function createClient(imports) {
         const playerState = {
           origin: lastRendered.origin,
           velocity: lastRendered.velocity,
-          viewAngles: lastRendered.viewangles,
+          viewAngles: lastRendered.viewAngles,
           onGround: hasPmFlag(lastRendered.pmFlags, PmFlag.OnGround),
-          waterLevel: lastRendered.waterlevel,
+          waterLevel: lastRendered.waterLevel,
           mins: { x: -16, y: -16, z: -24 },
           maxs: { x: 16, y: 16, z: 32 },
           damageAlpha: lastRendered.damageAlpha ?? 0,
@@ -6874,7 +6423,13 @@ function createClient(imports) {
           pickupIcon: lastRendered.pickupIcon,
           centerPrint: messageSystem["centerPrintMsg"]?.text,
           // Hack to get text for legacy state? No, Draw_Hud uses messageSystem directly now.
-          notify: void 0
+          notify: void 0,
+          // Stubs for new fields
+          stats: [],
+          kick_angles: ZERO_VEC32,
+          gunoffset: ZERO_VEC32,
+          gunangles: ZERO_VEC32,
+          gunindex: 0
         };
         const playbackState = demoPlayback.getState();
         const hudTimeMs = playbackState === PlaybackState.Playing || playbackState === PlaybackState.Paused ? (demoHandler.latestFrame?.serverFrame || 0) * 100 : timeMs;
@@ -6882,9 +6437,9 @@ function createClient(imports) {
           imports.engine.renderer,
           playerState,
           lastRendered.client,
-          lastRendered.health,
-          lastRendered.armor,
-          lastRendered.ammo,
+          lastRendered.health ?? 0,
+          lastRendered.armor ?? 0,
+          lastRendered.ammo ?? 0,
           stats,
           messageSystem,
           subtitleSystem,
@@ -6983,7 +6538,6 @@ function createClient(imports) {
   ViewEffects,
   createClient,
   createDefaultBindings,
-  defaultPredictionState,
   interpolatePredictionState,
   normalizeCommand,
   normalizeInputCode