@quake2ts/cgame 0.0.739

package/dist/index.js

@@ -0,0 +1,1346 @@
+import { angleVectors, clampViewAngles, ZERO_VEC3, hasPmFlag, PmFlag, dotVec3, PmType, WaterLevel, subtractVec3, lengthVec3, scaleVec3, angleMod, applyPmove, PlayerStat, PowerupId, G_GetPowerupStat, WEAPON_WHEEL_ORDER, WEAPON_AMMO_MAP, G_GetAmmoStat, ConfigStringIndex, MAX_MODELS, MAX_SOUNDS, MAX_IMAGES } 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;
+var crosshairColor = [1, 1, 1, 1];
+var CROSSHAIR_NAMES = ["ch1", "ch2", "ch3"];
+var crosshairPics = [null, null, null];
+var Init_Crosshair = (cgi3) => {
+  for (let i = 0; i < CROSSHAIR_NAMES.length; i++) {
+    const name = CROSSHAIR_NAMES[i];
+    try {
+      crosshairPics[i] = cgi3.Draw_RegisterPic(`pics/${name}.pcx`);
+    } catch (e) {
+      if (i === 0) {
+        try {
+          crosshairPics[i] = cgi3.Draw_RegisterPic("pics/crosshair.pcx");
+        } catch (e2) {
+          cgi3.Com_Print("Failed to load crosshair image\n");
+        }
+      }
+    }
+  }
+  crosshairPic = crosshairPics[0];
+};
+var Draw_Crosshair = (cgi3, width, height) => {
+  if (crosshairPic) {
+    const size = cgi3.Draw_GetPicSize(crosshairPic);
+    const x = (width - size.width) / 2;
+    const y = (height - size.height) / 2;
+    cgi3.SCR_DrawColorPic(x, y, crosshairPic, { x: crosshairColor[0], y: crosshairColor[1], z: crosshairColor[2] }, crosshairColor[3]);
+  }
+};
+
+// src/hud/icons.ts
+var iconPics = /* @__PURE__ */ new Map();
+var ICON_NAMES = [
+  // Weapons
+  "w_blaster",
+  "w_shotgun",
+  "w_sshotgun",
+  "w_machinegun",
+  "w_chaingun",
+  "w_glauncher",
+  "w_rlauncher",
+  "w_hyperblaster",
+  "w_railgun",
+  "w_bfg",
+  "w_grapple",
+  // Ammo
+  "a_grenades",
+  "a_bullets",
+  "a_cells",
+  "a_rockets",
+  "a_shells",
+  "a_slugs",
+  // Powerups
+  "p_quad",
+  "p_invulnerability",
+  "p_silencer",
+  "p_rebreather",
+  "p_envirosuit",
+  "p_adrenaline",
+  "p_megahealth",
+  // Armor
+  "i_jacketarmor",
+  "i_combatarmor",
+  "i_bodyarmor",
+  "i_powerscreen",
+  "i_powershield",
+  // Keys
+  "k_datacd",
+  "k_powercube",
+  "k_pyramid",
+  "k_dataspin",
+  "k_security",
+  "k_bluekey",
+  "k_redkey"
+];
+var Init_Icons = (cgi3) => {
+  for (const name of ICON_NAMES) {
+    try {
+      const pic = cgi3.Draw_RegisterPic(`pics/${name}.pcx`);
+      iconPics.set(name, pic);
+    } catch (e) {
+      cgi3.Com_Print(`Failed to load HUD image: pics/${name}.pcx
+`);
+    }
+  }
+};
+var damagePics = /* @__PURE__ */ new Map();
+var DAMAGE_INDICATOR_NAMES = [
+  "d_left",
+  "d_right",
+  "d_up",
+  "d_down"
+];
+var Init_Damage = (cgi3) => {
+  for (const name of DAMAGE_INDICATOR_NAMES) {
+    try {
+      const pic = cgi3.Draw_RegisterPic(`pics/${name}.pcx`);
+      damagePics.set(name, pic);
+    } catch (e) {
+      cgi3.Com_Print(`Failed to load HUD image: pics/${name}.pcx
+`);
+    }
+  }
+};
+var WHITE = { x: 1, y: 1, z: 1 };
+var Draw_Damage = (cgi3, ps, width, height) => {
+  if ((!ps.damageAlpha || ps.damageAlpha <= 0) && (!ps.damageIndicators || ps.damageIndicators.length === 0)) {
+    return;
+  }
+  if (!ps.damageIndicators || ps.damageIndicators.length === 0) {
+    return;
+  }
+  const cx = width * 0.5;
+  const cy = height * 0.5;
+  const { forward, right } = angleVectors(ps.viewAngles);
+  const radius = Math.min(width, height) * 0.25;
+  for (const indicator of ps.damageIndicators) {
+    const localRight = dotVec3(indicator.direction, right);
+    const localForward = dotVec3(indicator.direction, forward);
+    const angle2 = Math.atan2(localForward, localRight) * (180 / Math.PI);
+    let picName = "";
+    let xOff = 0;
+    let yOff = 0;
+    if (angle2 >= 45 && angle2 < 135) {
+      picName = "d_up";
+      yOff = -radius;
+    } else if (angle2 >= -45 && angle2 < 45) {
+      picName = "d_right";
+      xOff = radius;
+    } else if (angle2 >= -135 && angle2 < -45) {
+      picName = "d_down";
+      yOff = radius;
+    } else {
+      picName = "d_left";
+      xOff = -radius;
+    }
+    const pic = damagePics.get(picName);
+    if (pic) {
+      const size = cgi3.Draw_GetPicSize(pic);
+      const x = cx + xOff - size.width * 0.5;
+      const y = cy + yOff - size.height * 0.5;
+      const alpha = Math.max(0, Math.min(1, indicator.strength));
+      cgi3.SCR_DrawColorPic(x, y, pic, WHITE, alpha);
+    }
+  }
+};
+
+// src/hud/messages.ts
+var CENTER_PRINT_DURATION = 3e3;
+var NOTIFY_DURATION = 5e3;
+var MAX_NOTIFY_MESSAGES = 4;
+var MessageSystem = class {
+  constructor() {
+    this.centerPrintMsg = null;
+    this.notifyMessages = [];
+  }
+  addCenterPrint(text, now) {
+    this.centerPrintMsg = {
+      text,
+      startTime: now,
+      duration: CENTER_PRINT_DURATION
+    };
+  }
+  addNotify(text, now) {
+    this.notifyMessages.push({
+      text,
+      startTime: now,
+      duration: NOTIFY_DURATION
+    });
+    if (this.notifyMessages.length > MAX_NOTIFY_MESSAGES) {
+      this.notifyMessages.shift();
+    }
+  }
+  // Additional methods for cgame API
+  setCenterPrint(text, now) {
+    this.centerPrintMsg = {
+      text,
+      startTime: now,
+      duration: CENTER_PRINT_DURATION
+    };
+  }
+  addNotification(text, is_chat, now) {
+    this.notifyMessages.push({
+      text,
+      startTime: now,
+      duration: NOTIFY_DURATION
+    });
+    if (this.notifyMessages.length > MAX_NOTIFY_MESSAGES) {
+      this.notifyMessages.shift();
+    }
+  }
+  clearNotifications() {
+    this.notifyMessages = [];
+  }
+  clearCenterPrint() {
+    this.centerPrintMsg = null;
+  }
+  drawCenterPrint(cgi3, now, layout) {
+    if (!this.centerPrintMsg) return;
+    if (now > this.centerPrintMsg.startTime + this.centerPrintMsg.duration) {
+      this.centerPrintMsg = null;
+      return;
+    }
+    const y = layout.CENTER_PRINT_Y;
+    cgi3.SCR_DrawCenterString(y, this.centerPrintMsg.text);
+  }
+  drawNotifications(cgi3, now) {
+    while (this.notifyMessages.length > 0 && now > this.notifyMessages[0].startTime + this.notifyMessages[0].duration) {
+      this.notifyMessages.shift();
+    }
+    let y = 10;
+    for (const msg of this.notifyMessages) {
+      cgi3.SCR_DrawFontString(10, y, msg.text);
+      y += cgi3.SCR_FontLineHeight();
+    }
+  }
+};
+
+// src/hud/subtitles.ts
+var SUBTITLE_DURATION = 3e3;
+var SubtitleSystem = class {
+  constructor() {
+    this.subtitle = null;
+  }
+  addSubtitle(text, now) {
+    this.subtitle = {
+      text,
+      startTime: now,
+      duration: SUBTITLE_DURATION
+    };
+  }
+  drawSubtitles(cgi3, now) {
+    if (!this.subtitle) {
+      return;
+    }
+    if (now > this.subtitle.startTime + this.subtitle.duration) {
+      this.subtitle = null;
+      return;
+    }
+    const y = 200;
+    cgi3.SCR_DrawCenterString(y, this.subtitle.text);
+  }
+};
+
+// src/hud/blends.ts
+var Draw_Blends = (cgi3, ps, width, height) => {
+  if (!ps.blend) return;
+  const [r, g, b, a] = ps.blend;
+};
+
+// src/hud/pickup.ts
+var Draw_Pickup = (cgi3, ps, width, height) => {
+  if (!ps.pickupIcon) return;
+  const icon = iconPics.get(ps.pickupIcon);
+  if (icon) {
+    const size = cgi3.Draw_GetPicSize(icon);
+    const x = width - size.width - 10;
+    const y = height - size.height - 10;
+    cgi3.SCR_DrawPic(x, y, icon);
+  }
+};
+
+// src/hud/numbers.ts
+var Draw_Number = (cgi3, x, y, value, pics, width, color) => {
+  const s = Math.abs(value).toString();
+  for (let i = 0; i < s.length; i++) {
+    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 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] || 0;
+  const armorIconIdx = ps.stats[PlayerStat.STAT_ARMOR_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, 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);
+  }
+  if (armorIconIdx > 0) {
+    const iconName = cgi3.get_configstring(ConfigStringIndex.Images + armorIconIdx);
+    if (iconName) {
+      const icon = cgi3.Draw_RegisterPic(iconName);
+      if (icon) {
+        cgi3.SCR_DrawPic(layout.ARMOR_X - 24, layout.ARMOR_Y - 2, icon);
+      }
+    }
+  }
+  if (ps.pickupIcon) {
+    const icon = cgi3.Draw_RegisterPic(ps.pickupIcon);
+    if (icon) {
+      cgi3.SCR_DrawPic(layout.WEAPON_ICON_X, layout.WEAPON_ICON_Y, icon);
+    }
+  } else {
+    const selectedIconIdx = ps.stats[PlayerStat.STAT_SELECTED_ICON] || 0;
+    if (selectedIconIdx > 0) {
+      const iconName = cgi3.get_configstring(ConfigStringIndex.Images + selectedIconIdx);
+      if (iconName) {
+        const icon = cgi3.Draw_RegisterPic(iconName);
+        if (icon) {
+          cgi3.SCR_DrawPic(layout.WEAPON_ICON_X, layout.WEAPON_ICON_Y, icon);
+        }
+      }
+    }
+  }
+};
+
+// src/hud/layout.ts
+var REFERENCE_WIDTH = 640;
+var REFERENCE_HEIGHT = 480;
+var getHudLayout = (width, height) => {
+  const scaleX = width / REFERENCE_WIDTH;
+  const scaleY = height / REFERENCE_HEIGHT;
+  const scale2 = Math.min(scaleX, scaleY);
+  return {
+    // Status bar numbers - Anchored Bottom-Left / Center / Right
+    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) * scale2,
+    // Center print messages - Center
+    CENTER_PRINT_X: width / 2,
+    CENTER_PRINT_Y: 100 * scale2,
+    // Top anchor
+    // Weapon and powerup icons
+    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
+  };
+};
+
+// src/screen.ts
+var cgi = null;
+var hudNumberPics = [];
+var numberWidth = 0;
+var messageSystem = new MessageSystem();
+var subtitleSystem = new SubtitleSystem();
+function CG_InitScreen(imports) {
+  cgi = imports;
+}
+function CG_TouchPics() {
+  if (!cgi) return;
+  hudNumberPics.length = 0;
+  for (let i = 0; i < 10; i++) {
+    try {
+      const pic = cgi.Draw_RegisterPic(`pics/hud/num_${i}.pcx`);
+      hudNumberPics.push(pic);
+      if (i === 0) {
+        const size = cgi.Draw_GetPicSize(pic);
+        numberWidth = size.width;
+      }
+    } catch (e) {
+      cgi.Com_Print(`Warning: Failed to load HUD image: pics/hud/num_${i}.pcx
+`);
+    }
+  }
+  Init_Crosshair(cgi);
+  Init_Icons(cgi);
+  Init_Damage(cgi);
+}
+function CG_DrawHUD(isplit, data, hud_vrect, hud_safe, scale2, playernum, ps) {
+  if (!cgi) {
+    console.error("CG_DrawHUD: cgame imports not initialized");
+    return;
+  }
+  const timeMs = cgi.CL_ClientTime();
+  const layout = getHudLayout(hud_vrect.width, hud_vrect.height);
+  Draw_Blends(cgi, ps, hud_vrect.width, hud_vrect.height);
+  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) {
+    const lines = ps.centerPrint.split("\n");
+    let y = hud_vrect.height / 2 - lines.length * 10;
+    for (const line of lines) {
+      cgi.SCR_DrawCenterString(y, line);
+      y += 16;
+    }
+  }
+  messageSystem.drawCenterPrint(cgi, timeMs, layout);
+  messageSystem.drawNotifications(cgi, timeMs);
+  subtitleSystem.drawSubtitles(cgi, timeMs);
+  Draw_Crosshair(cgi, hud_vrect.width, hud_vrect.height);
+}
+function CG_GetMessageSystem() {
+  return messageSystem;
+}
+function CG_GetSubtitleSystem() {
+  return subtitleSystem;
+}
+function CG_ParseConfigString(cgi3, i, s) {
+  if (i >= ConfigStringIndex.Models && i < ConfigStringIndex.Models + MAX_MODELS) {
+    cgi3.RegisterModel(s);
+  } else if (i >= ConfigStringIndex.Sounds && i < ConfigStringIndex.Sounds + MAX_SOUNDS) {
+    cgi3.RegisterSound(s);
+  } else if (i >= ConfigStringIndex.Images && i < ConfigStringIndex.Images + MAX_IMAGES) {
+    cgi3.Draw_RegisterPic(s);
+  }
+}
+
+// ../../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,
+  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;
+    let kickX = 0;
+    let kickY = 0;
+    let kickZ = 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;
+      if (this.kick.origin) {
+        kickX += ratio * this.kick.origin.x;
+        kickY += ratio * this.kick.origin.y;
+        kickZ += ratio * this.kick.origin.z;
+      }
+      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: kickX, y: kickY, z: bobHeight + kickZ };
+    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,
+  errorTolerance: 0.1,
+  errorSnapThreshold: 10
+};
+var DEFAULT_GRAVITY = 800;
+var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
+var CMD_BACKUP = 64;
+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,
+    watertype: 0,
+    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,
+    kick_origin: ZERO_VEC32,
+    gunoffset: ZERO_VEC32,
+    gunangles: ZERO_VEC32,
+    gunindex: 0,
+    // New fields
+    pm_time: 0,
+    pm_type: PmType.Normal,
+    pm_flags: PmFlag.OnGround,
+    gun_frame: 0,
+    rdflags: 0,
+    fov: 90,
+    renderfx: 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, pointContents) {
+  const pmoveCmd = {
+    forwardmove: cmd.forwardmove,
+    sidemove: cmd.sidemove,
+    upmove: cmd.upmove,
+    buttons: cmd.buttons,
+    angles: cmd.angles
+    // Added missing property
+  };
+  const newState = applyPmove(state, pmoveCmd, trace, pointContents);
+  const { viewangles } = clampViewAngles({
+    pmFlags: state.pmFlags,
+    cmdAngles: cmd.angles,
+    deltaAngles: state.deltaAngles ?? ZERO_VEC32
+  });
+  return {
+    ...newState,
+    viewAngles: viewangles
+  };
+}
+var ClientPrediction = class {
+  constructor(physics, settings = {}) {
+    this.enabled = true;
+    this.baseFrame = {
+      frame: 0,
+      timeMs: 0,
+      state: defaultPredictionState()
+    };
+    this.commands = [];
+    this.predicted = defaultPredictionState();
+    this.predictionError = ZERO_VEC32;
+    this.settings = { ...DEFAULTS, ...settings };
+    this.physics = physics;
+    this.predicted = this.baseFrame.state ?? defaultPredictionState();
+  }
+  setPredictionEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  setAuthoritative(frame) {
+    const normalized = normalizeState(frame.state);
+    if (frame.frame <= this.baseFrame.frame) {
+      return this.predicted;
+    }
+    if (this.enabled) {
+      let predictedAtFrame;
+      const relevantCommands = this.commands.filter((c) => c.sequence <= frame.frame && c.sequence > this.baseFrame.frame);
+      if (relevantCommands.length > 0 || this.baseFrame.frame === frame.frame) {
+        let tempState = normalizeState(this.baseFrame.state);
+        for (const cmd of relevantCommands) {
+          tempState = simulateCommand(tempState, cmd, this.settings, this.physics.trace, this.physics.pointContents);
+        }
+        predictedAtFrame = tempState;
+      }
+      if (predictedAtFrame) {
+        const error = subtractVec3(predictedAtFrame.origin, normalized.origin);
+        const errorLen = lengthVec3(error);
+        if (errorLen > this.settings.errorSnapThreshold) {
+          this.predictionError = ZERO_VEC32;
+        } else if (errorLen > this.settings.errorTolerance) {
+          this.predictionError = error;
+        } else {
+          this.predictionError = ZERO_VEC32;
+        }
+      } else {
+        this.predictionError = ZERO_VEC32;
+      }
+    } else {
+      this.predictionError = ZERO_VEC32;
+    }
+    this.baseFrame = { ...frame, state: normalized };
+    this.commands = this.commands.filter((cmd) => cmd.sequence > frame.frame);
+    return this.recompute();
+  }
+  getPredictionError() {
+    return this.predictionError;
+  }
+  // Decay error over time - usually called once per client frame
+  decayError(frametime) {
+    const len2 = lengthVec3(this.predictionError);
+    if (len2 > 0) {
+      const decay = len2 * 10 * frametime;
+      const scale2 = Math.max(0, len2 - decay) / len2;
+      this.predictionError = scaleVec3(this.predictionError, scale2);
+    }
+  }
+  enqueueCommand(cmd) {
+    this.commands.push(cmd);
+    if (this.commands.length > CMD_BACKUP) {
+      this.commands.shift();
+    }
+    return this.recompute();
+  }
+  getCommand(sequence) {
+    return this.commands.find((c) => c.sequence === sequence);
+  }
+  getPredictedState() {
+    return this.predicted;
+  }
+  recompute() {
+    let state = normalizeState(this.baseFrame.state);
+    if (this.enabled) {
+      for (const cmd of this.commands) {
+        state = simulateCommand(state, cmd, this.settings, this.physics.trace, this.physics.pointContents);
+      }
+    }
+    this.predicted = state;
+    return state;
+  }
+};
+
+// src/index.ts
+var cgi2 = null;
+var cg_predict = null;
+function Init() {
+  if (!cgi2) {
+    console.error("CGame Init: cgame imports not set");
+    return;
+  }
+  cgi2.Com_Print("===== CGame Initialization =====\n");
+  CG_InitScreen(cgi2);
+  cg_predict = cgi2.Cvar_Get("cg_predict", "1", 0);
+  cgi2.Cvar_Get("cg_showmiss", "0", 0);
+  cgi2.Com_Print("CGame initialized\n");
+}
+function Shutdown() {
+  if (cgi2) {
+    cgi2.Com_Print("CGame shutdown\n");
+  }
+  cgi2 = null;
+}
+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();
+}
+function GetLayoutFlags(ps) {
+  return 0;
+}
+function GetActiveWeaponWheelWeapon(ps) {
+  return ps.stats[PlayerStat.STAT_ACTIVE_WHEEL_WEAPON] ?? 0;
+}
+function GetOwnedWeaponWheelWeapons(ps) {
+  const owned = [];
+  const bits1 = ps.stats[PlayerStat.STAT_WEAPONS_OWNED_1] || 0;
+  const bits2 = ps.stats[PlayerStat.STAT_WEAPONS_OWNED_2] || 0;
+  const fullBits = bits1 | bits2 << 16;
+  for (let i = 0; i < WEAPON_WHEEL_ORDER.length; i++) {
+    if (fullBits & 1 << i) {
+      owned.push(i);
+    }
+  }
+  return owned;
+}
+function GetWeaponWheelAmmoCount(ps, weapon) {
+  if (weapon < 0 || weapon >= WEAPON_WHEEL_ORDER.length) {
+    return 0;
+  }
+  const weaponId = WEAPON_WHEEL_ORDER[weapon];
+  const ammoType = WEAPON_AMMO_MAP[weaponId];
+  if (ammoType === null) {
+    return -1;
+  }
+  return G_GetAmmoStat(ps.stats, ammoType);
+}
+function GetPowerupWheelCount(ps) {
+  let count = 0;
+  const powerups = Object.values(PowerupId);
+  for (const id of powerups) {
+    if (G_GetPowerupStat(ps.stats, id) > 0) {
+      count++;
+    }
+  }
+  return count;
+}
+function GetHitMarkerDamage(ps) {
+  return ps.stats[PlayerStat.STAT_HIT_MARKER] ?? 0;
+}
+function Pmove(pmove) {
+  const pm = pmove;
+  if (!pm || !pm.s || !pm.cmd || !cgi2) {
+    return;
+  }
+  if (cg_predict && cg_predict.value === 0) {
+    return;
+  }
+  const traceAdapter = (start, end, mins, maxs) => {
+    const zero2 = { x: 0, y: 0, z: 0 };
+    return cgi2.PM_Trace(
+      start,
+      end,
+      mins || zero2,
+      maxs || zero2
+    );
+  };
+  const pointContentsAdapter = (point) => {
+    const zero2 = { x: 0, y: 0, z: 0 };
+    const tr = cgi2.PM_Trace(point, point, zero2, zero2);
+    return tr.contents || 0;
+  };
+  const newState = applyPmove(pm.s, pm.cmd, traceAdapter, pointContentsAdapter);
+  pm.s.origin = newState.origin;
+  pm.s.velocity = newState.velocity;
+  pm.s.onGround = newState.onGround;
+  pm.s.waterLevel = newState.waterLevel;
+}
+function ParseConfigString(i, s) {
+  if (!cgi2) return;
+  CG_ParseConfigString(cgi2, i, s);
+}
+function ParseCenterPrint(str2, isplit, instant) {
+  if (!cgi2) return;
+  const messageSystem2 = CG_GetMessageSystem();
+  messageSystem2.setCenterPrint(str2, cgi2.CL_ClientTime());
+}
+function NotifyMessage(isplit, msg, is_chat) {
+  if (!cgi2) return;
+  const messageSystem2 = CG_GetMessageSystem();
+  messageSystem2.addNotification(msg, is_chat, cgi2.CL_ClientTime());
+}
+function ClearNotify(isplit) {
+  const messageSystem2 = CG_GetMessageSystem();
+  messageSystem2.clearNotifications();
+}
+function ClearCenterprint(isplit) {
+  const messageSystem2 = CG_GetMessageSystem();
+  messageSystem2.clearCenterPrint();
+}
+function ShowSubtitle(text, soundName) {
+  if (!cgi2) return;
+  const subtitleSystem2 = CG_GetSubtitleSystem();
+  subtitleSystem2.addSubtitle(text, cgi2.CL_ClientTime());
+}
+function GetMonsterFlashOffset(id) {
+  return { x: 0, y: 0, z: 0 };
+}
+function GetExtension(name) {
+  return null;
+}
+function GetCGameAPI(imports) {
+  cgi2 = imports;
+  return {
+    // Lifecycle
+    Init,
+    Shutdown,
+    // Rendering
+    DrawHUD,
+    TouchPics,
+    // Layout
+    LayoutFlags: GetLayoutFlags,
+    // Weapon wheel
+    GetActiveWeaponWheelWeapon,
+    GetOwnedWeaponWheelWeapons,
+    GetWeaponWheelAmmoCount,
+    GetPowerupWheelCount,
+    // Hit markers
+    GetHitMarkerDamage,
+    // Prediction
+    Pmove,
+    // Parsing
+    ParseConfigString,
+    ParseCenterPrint,
+    NotifyMessage,
+    ShowSubtitle,
+    // State management
+    ClearNotify,
+    ClearCenterprint,
+    // Effects
+    GetMonsterFlashOffset,
+    // Extension
+    GetExtension
+  };
+}
+
+export { ClientPrediction, GetCGameAPI, ViewEffects, defaultPredictionState, interpolatePredictionState, updateCamera };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map