@quake2ts/cgame 0.0.739

package/dist/cjs/index.cjs

@@ -0,0 +1,947 @@
+'use strict';
+
+var shared = require('@quake2ts/shared');
+var glMatrix = require('gl-matrix');
+
+// src/index.ts
+
+// 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 } = shared.angleVectors(ps.viewAngles);
+  const radius = Math.min(width, height) * 0.25;
+  for (const indicator of ps.damageIndicators) {
+    const localRight = shared.dotVec3(indicator.direction, right);
+    const localForward = shared.dotVec3(indicator.direction, forward);
+    const angle = Math.atan2(localForward, localRight) * (180 / Math.PI);
+    let picName = "";
+    let xOff = 0;
+    let yOff = 0;
+    if (angle >= 45 && angle < 135) {
+      picName = "d_up";
+      yOff = -radius;
+    } else if (angle >= -45 && angle < 45) {
+      picName = "d_right";
+      xOff = radius;
+    } else if (angle >= -135 && angle < -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[shared.PlayerStat.STAT_HEALTH] || 0;
+  const armor = ps.stats[shared.PlayerStat.STAT_ARMOR] || 0;
+  const ammo = ps.stats[shared.PlayerStat.STAT_AMMO] || 0;
+  const armorIconIdx = ps.stats[shared.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(shared.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[shared.PlayerStat.STAT_SELECTED_ICON] || 0;
+    if (selectedIconIdx > 0) {
+      const iconName = cgi3.get_configstring(shared.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 scale = 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,
+    // Anchor right? 540 is near right (640)
+    AMMO_Y: height - (REFERENCE_HEIGHT - 450) * scale,
+    // Center print messages - Center
+    CENTER_PRINT_X: width / 2,
+    CENTER_PRINT_Y: 100 * scale,
+    // 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
+  };
+};
+
+// 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, scale, 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 >= shared.ConfigStringIndex.Models && i < shared.ConfigStringIndex.Models + shared.MAX_MODELS) {
+    cgi3.RegisterModel(s);
+  } else if (i >= shared.ConfigStringIndex.Sounds && i < shared.ConfigStringIndex.Sounds + shared.MAX_SOUNDS) {
+    cgi3.RegisterSound(s);
+  } else if (i >= shared.ConfigStringIndex.Images && i < shared.ConfigStringIndex.Images + shared.MAX_IMAGES) {
+    cgi3.Draw_RegisterPic(s);
+  }
+}
+var toGlMatrixVec3 = (v) => {
+  return glMatrix.vec3.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 = shared.hasPmFlag(pmFlags, shared.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 } = shared.angleVectors(
+      shared.clampViewAngles({ pmFlags: state.pmFlags, cmdAngles: state.viewAngles, deltaAngles: state.deltaAngles ?? shared.ZERO_VEC3 }).viewangles
+    );
+    const xyspeed = Math.sqrt(state.velocity.x * state.velocity.x + state.velocity.y * state.velocity.y);
+    const onGround = shared.hasPmFlag(state.pmFlags, shared.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 = shared.dotVec3(state.velocity, forward) * this.settings.runPitch;
+    const side = shared.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 (shared.hasPmFlag(state.pmFlags, shared.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: shared.PmFlag.OnGround,
+    pmType: shared.PmType.Normal,
+    waterLevel: shared.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: shared.PmType.Normal,
+    pm_flags: shared.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 lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpAngle(a, b, t) {
+  let delta = shared.angleMod(b - a);
+  if (delta > 180) {
+    delta -= 360;
+  }
+  return shared.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: lerp(previous.origin.x, latest.origin.x, clamped),
+      y: lerp(previous.origin.y, latest.origin.y, clamped),
+      z: lerp(previous.origin.z, latest.origin.z, clamped)
+    },
+    velocity: {
+      x: lerp(previous.velocity.x, latest.velocity.x, clamped),
+      y: lerp(previous.velocity.y, latest.velocity.y, clamped),
+      z: lerp(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: lerp(previous.damageAlpha, latest.damageAlpha, clamped),
+    blend: [
+      lerp(previous.blend[0], latest.blend[0], clamped),
+      lerp(previous.blend[1], latest.blend[1], clamped),
+      lerp(previous.blend[2], latest.blend[2], clamped),
+      lerp(previous.blend[3], latest.blend[3], clamped)
+    ],
+    // Interpolate health/armor for smooth HUD? Usually step.
+    health: lerp(previous.health || 0, latest.health || 0, clamped),
+    armor: lerp(previous.armor || 0, latest.armor || 0, clamped),
+    ammo: lerp(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 = shared.applyPmove(state, pmoveCmd, trace, pointContents);
+  const { viewangles } = shared.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 = shared.subtractVec3(predictedAtFrame.origin, normalized.origin);
+        const errorLen = shared.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 len = shared.lengthVec3(this.predictionError);
+    if (len > 0) {
+      const decay = len * 10 * frametime;
+      const scale = Math.max(0, len - decay) / len;
+      this.predictionError = shared.scaleVec3(this.predictionError, scale);
+    }
+  }
+  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, scale, playernum, ps) {
+  CG_DrawHUD(isplit, data, hud_vrect, hud_safe, scale, playernum, ps);
+}
+function TouchPics() {
+  CG_TouchPics();
+}
+function GetLayoutFlags(ps) {
+  return 0;
+}
+function GetActiveWeaponWheelWeapon(ps) {
+  return ps.stats[shared.PlayerStat.STAT_ACTIVE_WHEEL_WEAPON] ?? 0;
+}
+function GetOwnedWeaponWheelWeapons(ps) {
+  const owned = [];
+  const bits1 = ps.stats[shared.PlayerStat.STAT_WEAPONS_OWNED_1] || 0;
+  const bits2 = ps.stats[shared.PlayerStat.STAT_WEAPONS_OWNED_2] || 0;
+  const fullBits = bits1 | bits2 << 16;
+  for (let i = 0; i < shared.WEAPON_WHEEL_ORDER.length; i++) {
+    if (fullBits & 1 << i) {
+      owned.push(i);
+    }
+  }
+  return owned;
+}
+function GetWeaponWheelAmmoCount(ps, weapon) {
+  if (weapon < 0 || weapon >= shared.WEAPON_WHEEL_ORDER.length) {
+    return 0;
+  }
+  const weaponId = shared.WEAPON_WHEEL_ORDER[weapon];
+  const ammoType = shared.WEAPON_AMMO_MAP[weaponId];
+  if (ammoType === null) {
+    return -1;
+  }
+  return shared.G_GetAmmoStat(ps.stats, ammoType);
+}
+function GetPowerupWheelCount(ps) {
+  let count = 0;
+  const powerups = Object.values(shared.PowerupId);
+  for (const id of powerups) {
+    if (shared.G_GetPowerupStat(ps.stats, id) > 0) {
+      count++;
+    }
+  }
+  return count;
+}
+function GetHitMarkerDamage(ps) {
+  return ps.stats[shared.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 zero = { x: 0, y: 0, z: 0 };
+    return cgi2.PM_Trace(
+      start,
+      end,
+      mins || zero,
+      maxs || zero
+    );
+  };
+  const pointContentsAdapter = (point) => {
+    const zero = { x: 0, y: 0, z: 0 };
+    const tr = cgi2.PM_Trace(point, point, zero, zero);
+    return tr.contents || 0;
+  };
+  const newState = shared.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(str, isplit, instant) {
+  if (!cgi2) return;
+  const messageSystem2 = CG_GetMessageSystem();
+  messageSystem2.setCenterPrint(str, 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
+  };
+}
+
+exports.ClientPrediction = ClientPrediction;
+exports.GetCGameAPI = GetCGameAPI;
+exports.ViewEffects = ViewEffects;
+exports.defaultPredictionState = defaultPredictionState;
+exports.interpolatePredictionState = interpolatePredictionState;
+exports.updateCamera = updateCamera;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map