quake2ts 0.0.193 → 0.0.195

package/packages/cgame/dist/index.js

@@ -1,4 +1,10 @@
-import { WeaponId } from '@quake2ts/shared';
+import { angleVectors, clampViewAngles, ZERO_VEC3, hasPmFlag, PmFlag, dotVec3, WaterLevel, PmType, angleMod, applyPmoveFriction, buildWaterWish, buildAirGroundWish, applyPmoveAccelerate, applyPmoveAirAccelerate, addVec3, scaleVec3, PlayerStat, G_GetAmmoStat } from '@quake2ts/shared';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/hud/crosshair.ts
 var crosshairPic = null;
@@ -108,7 +114,7 @@ var Init_Damage = (cgi3) => {
   }
 };
 var Draw_Damage = (cgi3, ps, width, height) => {
-  if (!ps.damage_yaw && !ps.damage_pitch && !ps.damage_alpha) {
+  if ((!ps.damageAlpha || ps.damageAlpha <= 0) && (!ps.damageIndicators || ps.damageIndicators.length === 0)) {
     return;
   }
 };
@@ -210,87 +216,35 @@ var Draw_Number = (cgi3, x, y, value, pics, width, color) => {
     const digit = parseInt(s[i]);
     const pic = pics[digit];
     if (pic) {
-      {
+      if (color) {
+        cgi3.SCR_DrawColorPic(x + i * width, y, pic, { x: color[0], y: color[1], z: color[2] }, color[3]);
+      } else {
         cgi3.SCR_DrawPic(x + i * width, y, pic);
       }
     }
   }
 };
-var WEAPON_ICON_MAP = {
-  [WeaponId.Blaster]: "w_blaster",
-  [WeaponId.Shotgun]: "w_shotgun",
-  [WeaponId.SuperShotgun]: "w_sshotgun",
-  [WeaponId.Machinegun]: "w_machinegun",
-  [WeaponId.Chaingun]: "w_chaingun",
-  [WeaponId.GrenadeLauncher]: "w_glauncher",
-  [WeaponId.RocketLauncher]: "w_rlauncher",
-  [WeaponId.HyperBlaster]: "w_hyperblaster",
-  [WeaponId.Railgun]: "w_railgun",
-  [WeaponId.BFG10K]: "w_bfg",
-  [WeaponId.Grapple]: "w_grapple",
-  [WeaponId.ChainFist]: "w_chainfist",
-  [WeaponId.EtfRifle]: "w_etf_rifle",
-  [WeaponId.ProxLauncher]: "w_prox_launcher",
-  [WeaponId.IonRipper]: "w_ionripper",
-  [WeaponId.PlasmaBeam]: "w_plasmabeam",
-  [WeaponId.Phalanx]: "w_phalanx",
-  [WeaponId.Disruptor]: "w_disruptor"
-};
-var KEY_ICON_MAP = {
-  "blue": "k_bluekey",
-  "red": "k_redkey",
-  "green": "k_security",
-  "yellow": "k_pyramid"
-};
-var Draw_StatusBar = (cgi3, client, health, armor, ammo, hudNumberPics2, numberWidth2, timeMs, layout) => {
+var Draw_StatusBar = (cgi3, ps, hudNumberPics2, numberWidth2, timeMs, layout) => {
+  const health = ps.stats[PlayerStat.STAT_HEALTH] || 0;
+  const armor = ps.stats[PlayerStat.STAT_ARMOR] || 0;
+  const ammo = ps.stats[PlayerStat.STAT_AMMO] ? G_GetAmmoStat(ps.stats[PlayerStat.STAT_AMMO]) : 0;
+  ps.stats[PlayerStat.STAT_ARMOR_ICON] || 0;
+  ps.stats[PlayerStat.STAT_AMMO_ICON] || 0;
+  let healthColor = void 0;
+  if (health <= 25) {
+    {
+      healthColor = [1, 0, 0, 1];
+    }
+  }
   if (hudNumberPics2.length > 0) {
-    Draw_Number(cgi3, layout.HEALTH_X, layout.HEALTH_Y, health, hudNumberPics2, numberWidth2);
+    Draw_Number(cgi3, layout.HEALTH_X, layout.HEALTH_Y, health, hudNumberPics2, numberWidth2, healthColor);
     Draw_Number(cgi3, layout.ARMOR_X, layout.ARMOR_Y, armor, hudNumberPics2, numberWidth2);
     Draw_Number(cgi3, layout.AMMO_X, layout.AMMO_Y, ammo, hudNumberPics2, numberWidth2);
   }
-  const armorItem = client.inventory.armor;
-  if (armorItem && armorItem.armorCount > 0) {
-    const iconName = `i_${armorItem.armorType}armor`;
-    const icon = iconPics.get(iconName);
+  if (ps.pickupIcon) {
+    const icon = cgi3.Draw_RegisterPic(ps.pickupIcon);
     if (icon) {
-      cgi3.SCR_DrawPic(layout.ARMOR_X - 24, layout.ARMOR_Y - 2, icon);
-    }
-  }
-  const currentWeapon = client.inventory.currentWeapon;
-  if (currentWeapon) {
-    const iconName = WEAPON_ICON_MAP[currentWeapon];
-    if (iconName) {
-      const icon = iconPics.get(iconName);
-      if (icon) {
-        cgi3.SCR_DrawPic(layout.WEAPON_ICON_X, layout.WEAPON_ICON_Y, icon);
-      }
-    }
-  }
-  const keys = Array.from(client.inventory.keys).sort();
-  let keyY = layout.WEAPON_ICON_Y - 150 * layout.scale;
-  for (const key of keys) {
-    const iconName = KEY_ICON_MAP[key];
-    if (iconName) {
-      const icon = iconPics.get(iconName);
-      if (icon) {
-        const size = cgi3.Draw_GetPicSize(icon);
-        cgi3.SCR_DrawPic(layout.WEAPON_ICON_X, keyY, icon);
-        keyY += size.height + 2;
-      }
-    }
-  }
-  let powerupX = layout.POWERUP_X;
-  for (const [powerup, expiresAt] of Array.from(client.inventory.powerups.entries())) {
-    if (expiresAt && expiresAt > timeMs) {
-      const iconName = `p_${powerup}`;
-      const icon = iconPics.get(iconName);
-      if (icon) {
-        const size = cgi3.Draw_GetPicSize(icon);
-        cgi3.SCR_DrawPic(powerupX, layout.POWERUP_Y, icon);
-        const remainingSeconds = Math.ceil((expiresAt - timeMs) / 1e3);
-        Draw_Number(cgi3, powerupX + size.width + 2, layout.POWERUP_Y, remainingSeconds, hudNumberPics2, numberWidth2);
-        powerupX -= size.width + numberWidth2 * remainingSeconds.toString().length + 8;
-      }
+      cgi3.SCR_DrawPic(layout.WEAPON_ICON_X, layout.WEAPON_ICON_Y, icon);
     }
   }
 };
@@ -301,26 +255,26 @@ var REFERENCE_HEIGHT = 480;
 var getHudLayout = (width, height) => {
   const scaleX = width / REFERENCE_WIDTH;
   const scaleY = height / REFERENCE_HEIGHT;
-  const scale = Math.min(scaleX, scaleY);
+  const scale2 = Math.min(scaleX, scaleY);
   return {
     // Status bar numbers - Anchored Bottom-Left / Center / Right
-    HEALTH_X: 100 * scale,
-    HEALTH_Y: height - (REFERENCE_HEIGHT - 450) * scale,
-    ARMOR_X: 200 * scale,
-    ARMOR_Y: height - (REFERENCE_HEIGHT - 450) * scale,
-    AMMO_X: width - (REFERENCE_WIDTH - 540) * scale,
+    HEALTH_X: 100 * scale2,
+    HEALTH_Y: height - (REFERENCE_HEIGHT - 450) * scale2,
+    ARMOR_X: 200 * scale2,
+    ARMOR_Y: height - (REFERENCE_HEIGHT - 450) * scale2,
+    AMMO_X: width - (REFERENCE_WIDTH - 540) * scale2,
     // Anchor right? 540 is near right (640)
-    AMMO_Y: height - (REFERENCE_HEIGHT - 450) * scale,
+    AMMO_Y: height - (REFERENCE_HEIGHT - 450) * scale2,
     // Center print messages - Center
     CENTER_PRINT_X: width / 2,
-    CENTER_PRINT_Y: 100 * scale,
+    CENTER_PRINT_Y: 100 * scale2,
     // Top anchor
     // Weapon and powerup icons
-    WEAPON_ICON_X: 10 * scale,
-    WEAPON_ICON_Y: height - (REFERENCE_HEIGHT - 450) * scale,
-    POWERUP_X: width - (REFERENCE_WIDTH - 610) * scale,
-    POWERUP_Y: height - (REFERENCE_HEIGHT - 450) * scale,
-    scale
+    WEAPON_ICON_X: 10 * scale2,
+    WEAPON_ICON_Y: height - (REFERENCE_HEIGHT - 450) * scale2,
+    POWERUP_X: width - (REFERENCE_WIDTH - 610) * scale2,
+    POWERUP_Y: height - (REFERENCE_HEIGHT - 450) * scale2,
+    scale: scale2
   };
 };
 
@@ -352,7 +306,7 @@ function CG_TouchPics() {
   Init_Icons(cgi);
   Init_Damage(cgi);
 }
-function CG_DrawHUD(isplit, data, hud_vrect, hud_safe, scale, playernum, ps) {
+function CG_DrawHUD(isplit, data, hud_vrect, hud_safe, scale2, playernum, ps) {
   if (!cgi) {
     console.error("CG_DrawHUD: cgame imports not initialized");
     return;
@@ -360,19 +314,7 @@ function CG_DrawHUD(isplit, data, hud_vrect, hud_safe, scale, playernum, ps) {
   const timeMs = cgi.CL_ClientTime();
   const layout = getHudLayout(hud_vrect.width, hud_vrect.height);
   Draw_Blends(cgi, ps, hud_vrect.width, hud_vrect.height);
-  const tempClientState = {
-    inventory: {
-      armor: null,
-      // TODO: Map from ps.stats
-      powerups: /* @__PURE__ */ new Map(),
-      // TODO: Map from ps.stats
-      keys: /* @__PURE__ */ new Set(),
-      // TODO: Map from ps.stats
-      currentWeapon: void 0
-      // TODO: Map from ps.stats/gunindex
-    }
-  };
-  Draw_StatusBar(cgi, tempClientState, 100, 0, 0, hudNumberPics, numberWidth, timeMs, layout);
+  Draw_StatusBar(cgi, ps, hudNumberPics, numberWidth, timeMs, layout);
   Draw_Pickup(cgi, ps, hud_vrect.width, hud_vrect.height);
   Draw_Damage(cgi, ps, hud_vrect.width, hud_vrect.height);
   if (ps.centerPrint) {
@@ -389,6 +331,725 @@ function CG_GetMessageSystem() {
   return messageSystem;
 }
 
+// ../../node_modules/.pnpm/gl-matrix@3.4.4/node_modules/gl-matrix/esm/common.js
+var EPSILON = 1e-6;
+var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+var RANDOM = Math.random;
+function round(a) {
+  if (a >= 0) return Math.round(a);
+  return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
+}
+
+// ../../node_modules/.pnpm/gl-matrix@3.4.4/node_modules/gl-matrix/esm/vec3.js
+var vec3_exports = {};
+__export(vec3_exports, {
+  add: () => add,
+  angle: () => angle,
+  bezier: () => bezier,
+  ceil: () => ceil,
+  clone: () => clone,
+  copy: () => copy,
+  create: () => create,
+  cross: () => cross,
+  dist: () => dist,
+  distance: () => distance,
+  div: () => div,
+  divide: () => divide,
+  dot: () => dot,
+  equals: () => equals,
+  exactEquals: () => exactEquals,
+  floor: () => floor,
+  forEach: () => forEach,
+  fromValues: () => fromValues,
+  hermite: () => hermite,
+  inverse: () => inverse,
+  len: () => len,
+  length: () => length,
+  lerp: () => lerp,
+  max: () => max,
+  min: () => min,
+  mul: () => mul,
+  multiply: () => multiply,
+  negate: () => negate,
+  normalize: () => normalize,
+  random: () => random,
+  rotateX: () => rotateX,
+  rotateY: () => rotateY,
+  rotateZ: () => rotateZ,
+  round: () => round2,
+  scale: () => scale,
+  scaleAndAdd: () => scaleAndAdd,
+  set: () => set,
+  slerp: () => slerp,
+  sqrDist: () => sqrDist,
+  sqrLen: () => sqrLen,
+  squaredDistance: () => squaredDistance,
+  squaredLength: () => squaredLength,
+  str: () => str,
+  sub: () => sub,
+  subtract: () => subtract,
+  transformMat3: () => transformMat3,
+  transformMat4: () => transformMat4,
+  transformQuat: () => transformQuat,
+  zero: () => zero
+});
+function create() {
+  var out = new ARRAY_TYPE(3);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  return out;
+}
+function clone(a) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+function length(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  return Math.sqrt(x * x + y * y + z * z);
+}
+function fromValues(x, y, z) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function copy(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+function set(out, x, y, z) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function add(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  return out;
+}
+function subtract(out, a, b) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  out[2] = a[2] - b[2];
+  return out;
+}
+function multiply(out, a, b) {
+  out[0] = a[0] * b[0];
+  out[1] = a[1] * b[1];
+  out[2] = a[2] * b[2];
+  return out;
+}
+function divide(out, a, b) {
+  out[0] = a[0] / b[0];
+  out[1] = a[1] / b[1];
+  out[2] = a[2] / b[2];
+  return out;
+}
+function ceil(out, a) {
+  out[0] = Math.ceil(a[0]);
+  out[1] = Math.ceil(a[1]);
+  out[2] = Math.ceil(a[2]);
+  return out;
+}
+function floor(out, a) {
+  out[0] = Math.floor(a[0]);
+  out[1] = Math.floor(a[1]);
+  out[2] = Math.floor(a[2]);
+  return out;
+}
+function min(out, a, b) {
+  out[0] = Math.min(a[0], b[0]);
+  out[1] = Math.min(a[1], b[1]);
+  out[2] = Math.min(a[2], b[2]);
+  return out;
+}
+function max(out, a, b) {
+  out[0] = Math.max(a[0], b[0]);
+  out[1] = Math.max(a[1], b[1]);
+  out[2] = Math.max(a[2], b[2]);
+  return out;
+}
+function round2(out, a) {
+  out[0] = round(a[0]);
+  out[1] = round(a[1]);
+  out[2] = round(a[2]);
+  return out;
+}
+function scale(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  return out;
+}
+function scaleAndAdd(out, a, b, scale2) {
+  out[0] = a[0] + b[0] * scale2;
+  out[1] = a[1] + b[1] * scale2;
+  out[2] = a[2] + b[2] * scale2;
+  return out;
+}
+function distance(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  return Math.sqrt(x * x + y * y + z * z);
+}
+function squaredDistance(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  return x * x + y * y + z * z;
+}
+function squaredLength(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  return x * x + y * y + z * z;
+}
+function negate(out, a) {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  out[2] = -a[2];
+  return out;
+}
+function inverse(out, a) {
+  out[0] = 1 / a[0];
+  out[1] = 1 / a[1];
+  out[2] = 1 / a[2];
+  return out;
+}
+function normalize(out, a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var len2 = x * x + y * y + z * z;
+  if (len2 > 0) {
+    len2 = 1 / Math.sqrt(len2);
+  }
+  out[0] = a[0] * len2;
+  out[1] = a[1] * len2;
+  out[2] = a[2] * len2;
+  return out;
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(out, a, b) {
+  var ax = a[0], ay = a[1], az = a[2];
+  var bx = b[0], by = b[1], bz = b[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+function lerp(out, a, b, t) {
+  var ax = a[0];
+  var ay = a[1];
+  var az = a[2];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  out[2] = az + t * (b[2] - az);
+  return out;
+}
+function slerp(out, a, b, t) {
+  var angle2 = Math.acos(Math.min(Math.max(dot(a, b), -1), 1));
+  var sinTotal = Math.sin(angle2);
+  var ratioA = Math.sin((1 - t) * angle2) / sinTotal;
+  var ratioB = Math.sin(t * angle2) / sinTotal;
+  out[0] = ratioA * a[0] + ratioB * b[0];
+  out[1] = ratioA * a[1] + ratioB * b[1];
+  out[2] = ratioA * a[2] + ratioB * b[2];
+  return out;
+}
+function hermite(out, a, b, c, d, t) {
+  var factorTimes2 = t * t;
+  var factor1 = factorTimes2 * (2 * t - 3) + 1;
+  var factor2 = factorTimes2 * (t - 2) + t;
+  var factor3 = factorTimes2 * (t - 1);
+  var factor4 = factorTimes2 * (3 - 2 * t);
+  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+  return out;
+}
+function bezier(out, a, b, c, d, t) {
+  var inverseFactor = 1 - t;
+  var inverseFactorTimesTwo = inverseFactor * inverseFactor;
+  var factorTimes2 = t * t;
+  var factor1 = inverseFactorTimesTwo * inverseFactor;
+  var factor2 = 3 * t * inverseFactorTimesTwo;
+  var factor3 = 3 * factorTimes2 * inverseFactor;
+  var factor4 = factorTimes2 * t;
+  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+  return out;
+}
+function random(out, scale2) {
+  scale2 = scale2 === void 0 ? 1 : scale2;
+  var r = RANDOM() * 2 * Math.PI;
+  var z = RANDOM() * 2 - 1;
+  var zScale = Math.sqrt(1 - z * z) * scale2;
+  out[0] = Math.cos(r) * zScale;
+  out[1] = Math.sin(r) * zScale;
+  out[2] = z * scale2;
+  return out;
+}
+function transformMat4(out, a, m) {
+  var x = a[0], y = a[1], z = a[2];
+  var w = m[3] * x + m[7] * y + m[11] * z + m[15];
+  w = w || 1;
+  out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+  out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+  out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+  return out;
+}
+function transformMat3(out, a, m) {
+  var x = a[0], y = a[1], z = a[2];
+  out[0] = x * m[0] + y * m[3] + z * m[6];
+  out[1] = x * m[1] + y * m[4] + z * m[7];
+  out[2] = x * m[2] + y * m[5] + z * m[8];
+  return out;
+}
+function transformQuat(out, a, q) {
+  var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+  var vx = a[0], vy = a[1], vz = a[2];
+  var tx = qy * vz - qz * vy;
+  var ty = qz * vx - qx * vz;
+  var tz = qx * vy - qy * vx;
+  tx = tx + tx;
+  ty = ty + ty;
+  tz = tz + tz;
+  out[0] = vx + qw * tx + qy * tz - qz * ty;
+  out[1] = vy + qw * ty + qz * tx - qx * tz;
+  out[2] = vz + qw * tz + qx * ty - qy * tx;
+  return out;
+}
+function rotateX(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0];
+  r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
+  r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateY(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
+  r[1] = p[1];
+  r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateZ(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
+  r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
+  r[2] = p[2];
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function angle(a, b) {
+  var ax = a[0], ay = a[1], az = a[2], bx = b[0], by = b[1], bz = b[2], mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz)), cosine = mag && dot(a, b) / mag;
+  return Math.acos(Math.min(Math.max(cosine, -1), 1));
+}
+function zero(out) {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  return out;
+}
+function str(a) {
+  return "vec3(" + a[0] + ", " + a[1] + ", " + a[2] + ")";
+}
+function exactEquals(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+function equals(a, b) {
+  var a0 = a[0], a1 = a[1], a2 = a[2];
+  var b0 = b[0], b1 = b[1], b2 = b[2];
+  return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2));
+}
+var sub = subtract;
+var mul = multiply;
+var div = divide;
+var dist = distance;
+var sqrDist = squaredDistance;
+var len = length;
+var sqrLen = squaredLength;
+var forEach = (function() {
+  var vec = create();
+  return function(a, stride, offset, count, fn, arg) {
+    var i, l;
+    if (!stride) {
+      stride = 3;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];
+      vec[1] = a[i + 1];
+      vec[2] = a[i + 2];
+      fn(vec, vec, arg);
+      a[i] = vec[0];
+      a[i + 1] = vec[1];
+      a[i + 2] = vec[2];
+    }
+    return a;
+  };
+})();
+
+// src/view/camera.ts
+var toGlMatrixVec3 = (v) => {
+  return vec3_exports.fromValues(v.x, v.y, v.z);
+};
+var updateCamera = (camera, viewSample) => {
+  camera.bobAngles = toGlMatrixVec3(viewSample.angles);
+  camera.bobOffset = toGlMatrixVec3(viewSample.offset);
+};
+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;
+  }
+};
+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,
+    onGround: false,
+    // Physics fields
+    pmFlags: PmFlag.OnGround,
+    pmType: PmType.Normal,
+    waterLevel: WaterLevel.None,
+    gravity: DEFAULT_GRAVITY,
+    deltaAngles: ZERO_VEC32,
+    // Bounds
+    mins: { x: -16, y: -16, z: -24 },
+    maxs: { x: 16, y: 16, z: 32 },
+    // Visual/Game fields
+    damageAlpha: 0,
+    damageIndicators: [],
+    blend: [0, 0, 0, 0],
+    stats: [],
+    kick_angles: ZERO_VEC32,
+    gunoffset: ZERO_VEC32,
+    gunangles: ZERO_VEC32,
+    gunindex: 0,
+    // Optional fields
+    pickupIcon: void 0,
+    centerPrint: void 0,
+    notify: void 0,
+    client: void 0,
+    health: 0,
+    armor: 0,
+    ammo: 0
+  };
+}
+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] : [],
+    stats: state.stats ? [...state.stats] : []
+  };
+}
+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 {
+    ...latest,
+    // Default to latest for discrete fields
+    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)
+    },
+    damageAlpha: lerp2(previous.damageAlpha, latest.damageAlpha, clamped),
+    blend: [
+      lerp2(previous.blend[0], latest.blend[0], clamped),
+      lerp2(previous.blend[1], latest.blend[1], clamped),
+      lerp2(previous.blend[2], latest.blend[2], clamped),
+      lerp2(previous.blend[3], latest.blend[3], clamped)
+    ],
+    // Interpolate health/armor for smooth HUD? Usually step.
+    health: lerp2(previous.health || 0, latest.health || 0, clamped),
+    armor: lerp2(previous.armor || 0, latest.armor || 0, clamped),
+    ammo: lerp2(previous.ammo || 0, latest.ammo || 0, clamped)
+  };
+}
+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 ?? DEFAULT_GRAVITY) * frametime };
+  }
+  const traceResult = trace(state.origin, addVec3(state.origin, scaleVec3(velocity, frametime)));
+  const origin = traceResult.endpos;
+  return {
+    ...state,
+    origin,
+    velocity,
+    viewAngles: 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/index.ts
 var cgi2 = null;
 function Init() {
@@ -406,8 +1067,8 @@ function Shutdown() {
   }
   cgi2 = null;
 }
-function DrawHUD(isplit, data, hud_vrect, hud_safe, scale, playernum, ps) {
-  CG_DrawHUD(isplit, data, hud_vrect, hud_safe, scale, playernum, ps);
+function DrawHUD(isplit, data, hud_vrect, hud_safe, scale2, playernum, ps) {
+  CG_DrawHUD(isplit, data, hud_vrect, hud_safe, scale2, playernum, ps);
 }
 function TouchPics() {
   CG_TouchPics();
@@ -434,10 +1095,10 @@ function Pmove(pmove) {
 }
 function ParseConfigString(i, s) {
 }
-function ParseCenterPrint(str, isplit, instant) {
+function ParseCenterPrint(str2, isplit, instant) {
   if (!cgi2) return;
   const messageSystem2 = CG_GetMessageSystem();
-  messageSystem2.setCenterPrint(str, cgi2.CL_ClientTime());
+  messageSystem2.setCenterPrint(str2, cgi2.CL_ClientTime());
 }
 function NotifyMessage(isplit, msg, is_chat) {
   if (!cgi2) return;
@@ -492,6 +1153,6 @@ function GetCGameAPI(imports) {
   };
 }
 
-export { GetCGameAPI };
+export { ClientPrediction, GetCGameAPI, ViewEffects, defaultPredictionState, interpolatePredictionState, updateCamera };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map