quake2ts 0.0.7 → 0.0.39

package/packages/client/dist/esm/index.js

@@ -1,32 +1,1206 @@
+// ../shared/dist/esm/index.js
+var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
+var DEG_TO_RAD = Math.PI / 180;
+function addVec3(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function scaleVec3(a, scalar) {
+  return { x: a.x * scalar, y: a.y * scalar, z: a.z * scalar };
+}
+function dotVec3(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function lengthSquaredVec3(a) {
+  return dotVec3(a, a);
+}
+function lengthVec3(a) {
+  return Math.sqrt(lengthSquaredVec3(a));
+}
+function normalizeVec3(a) {
+  const len = lengthVec3(a);
+  return len === 0 ? a : scaleVec3(a, 1 / len);
+}
+var PITCH = 0;
+var YAW = 1;
+var ROLL = 2;
+var DEG2RAD_FACTOR = Math.PI / 180;
+var RAD2DEG_FACTOR = 180 / Math.PI;
+function axisComponent(vec, axis) {
+  switch (axis) {
+    case PITCH:
+      return vec.x;
+    case YAW:
+      return vec.y;
+    case ROLL:
+    default:
+      return vec.z;
+  }
+}
+function degToRad(degrees) {
+  return degrees * DEG2RAD_FACTOR;
+}
+function angleMod(angle) {
+  const value = angle % 360;
+  return value < 0 ? 360 + value : value;
+}
+function angleVectors(angles) {
+  const yaw = degToRad(axisComponent(angles, YAW));
+  const pitch = degToRad(axisComponent(angles, PITCH));
+  const roll = degToRad(axisComponent(angles, ROLL));
+  const sy = Math.sin(yaw);
+  const cy = Math.cos(yaw);
+  const sp = Math.sin(pitch);
+  const cp = Math.cos(pitch);
+  const sr = Math.sin(roll);
+  const cr = Math.cos(roll);
+  const forward = {
+    x: cp * cy,
+    y: cp * sy,
+    z: -sp
+  };
+  const right = {
+    x: -sr * sp * cy - cr * -sy,
+    y: -sr * sp * sy - cr * cy,
+    z: -sr * cp
+  };
+  const up = {
+    x: cr * sp * cy - sr * -sy,
+    y: cr * sp * sy - sr * cy,
+    z: cr * cp
+  };
+  return { forward, right, up };
+}
+var CONTENTS_SOLID = 1 << 0;
+var CONTENTS_WINDOW = 1 << 1;
+var CONTENTS_AUX = 1 << 2;
+var CONTENTS_LAVA = 1 << 3;
+var CONTENTS_SLIME = 1 << 4;
+var CONTENTS_WATER = 1 << 5;
+var CONTENTS_MIST = 1 << 6;
+var CONTENTS_NO_WATERJUMP = 1 << 13;
+var CONTENTS_PROJECTILECLIP = 1 << 14;
+var CONTENTS_AREAPORTAL = 1 << 15;
+var CONTENTS_PLAYERCLIP = 1 << 16;
+var CONTENTS_MONSTERCLIP = 1 << 17;
+var CONTENTS_CURRENT_0 = 1 << 18;
+var CONTENTS_CURRENT_90 = 1 << 19;
+var CONTENTS_CURRENT_180 = 1 << 20;
+var CONTENTS_CURRENT_270 = 1 << 21;
+var CONTENTS_CURRENT_UP = 1 << 22;
+var CONTENTS_CURRENT_DOWN = 1 << 23;
+var CONTENTS_ORIGIN = 1 << 24;
+var CONTENTS_MONSTER = 1 << 25;
+var CONTENTS_DEADMONSTER = 1 << 26;
+var CONTENTS_DETAIL = 1 << 27;
+var CONTENTS_TRANSLUCENT = 1 << 28;
+var CONTENTS_LADDER = 1 << 29;
+var CONTENTS_PLAYER = 1 << 30;
+var CONTENTS_PROJECTILE = 1 << 31;
+var SURF_LIGHT = 1 << 0;
+var SURF_SLICK = 1 << 1;
+var SURF_SKY = 1 << 2;
+var SURF_WARP = 1 << 3;
+var SURF_TRANS33 = 1 << 4;
+var SURF_TRANS66 = 1 << 5;
+var SURF_FLOWING = 1 << 6;
+var SURF_NODRAW = 1 << 7;
+var SURF_ALPHATEST = 1 << 25;
+var SURF_N64_UV = 1 << 28;
+var SURF_N64_SCROLL_X = 1 << 29;
+var SURF_N64_SCROLL_Y = 1 << 30;
+var SURF_N64_SCROLL_FLIP = 1 << 31;
+var MASK_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_PLAYERSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_DEADSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_MONSTERSOLID = CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_WATER = CONTENTS_WATER | CONTENTS_LAVA | CONTENTS_SLIME;
+var MASK_OPAQUE = CONTENTS_SOLID | CONTENTS_SLIME | CONTENTS_LAVA;
+var MASK_SHOT = CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_WINDOW | CONTENTS_DEADMONSTER;
+var MASK_CURRENT = CONTENTS_CURRENT_0 | CONTENTS_CURRENT_90 | CONTENTS_CURRENT_180 | CONTENTS_CURRENT_270 | CONTENTS_CURRENT_UP | CONTENTS_CURRENT_DOWN;
+var MASK_BLOCK_SIGHT = CONTENTS_SOLID | CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_LADDER_NAV_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_WALK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTERCLIP;
+var MASK_PROJECTILE = MASK_SHOT | CONTENTS_PROJECTILECLIP;
+var MAX_CHECKCOUNT = Number.MAX_SAFE_INTEGER - 1;
+var MAX_CLIENTS = 256;
+var MAX_LIGHTSTYLES = 256;
+var MAX_MODELS = 8192;
+var MAX_SOUNDS = 2048;
+var MAX_IMAGES = 512;
+var MAX_ITEMS = 256;
+var MAX_GENERAL = MAX_CLIENTS * 2;
+var MAX_SHADOW_LIGHTS = 256;
+var MAX_WHEEL_ITEMS = 32;
+var ConfigStringIndex = ((ConfigStringIndex2) => {
+  ConfigStringIndex2[ConfigStringIndex2["Name"] = 0] = "Name";
+  ConfigStringIndex2[ConfigStringIndex2["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex2[ConfigStringIndex2["Sky"] = 2] = "Sky";
+  ConfigStringIndex2[ConfigStringIndex2["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex2[ConfigStringIndex2["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex2[ConfigStringIndex2["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex2[ConfigStringIndex2["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex2[ConfigStringIndex2["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex2[ConfigStringIndex2["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex2[ConfigStringIndex2["Models"] = 62] = "Models";
+  ConfigStringIndex2[ConfigStringIndex2["Sounds"] = 62 + MAX_MODELS] = "Sounds";
+  ConfigStringIndex2[ConfigStringIndex2["Images"] = ConfigStringIndex2.Sounds + MAX_SOUNDS] = "Images";
+  ConfigStringIndex2[ConfigStringIndex2["Lights"] = ConfigStringIndex2.Images + MAX_IMAGES] = "Lights";
+  ConfigStringIndex2[ConfigStringIndex2["ShadowLights"] = ConfigStringIndex2.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
+  ConfigStringIndex2[ConfigStringIndex2["Items"] = ConfigStringIndex2.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
+  ConfigStringIndex2[ConfigStringIndex2["PlayerSkins"] = ConfigStringIndex2.Items + MAX_ITEMS] = "PlayerSkins";
+  ConfigStringIndex2[ConfigStringIndex2["General"] = ConfigStringIndex2.PlayerSkins + MAX_CLIENTS] = "General";
+  ConfigStringIndex2[ConfigStringIndex2["WheelWeapons"] = ConfigStringIndex2.General + MAX_GENERAL] = "WheelWeapons";
+  ConfigStringIndex2[ConfigStringIndex2["WheelAmmo"] = ConfigStringIndex2.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
+  ConfigStringIndex2[ConfigStringIndex2["WheelPowerups"] = ConfigStringIndex2.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
+  ConfigStringIndex2[ConfigStringIndex2["CdLoopCount"] = ConfigStringIndex2.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
+  ConfigStringIndex2[ConfigStringIndex2["GameStyle"] = ConfigStringIndex2.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex2[ConfigStringIndex2["MaxConfigStrings"] = ConfigStringIndex2.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex2;
+})(ConfigStringIndex || {});
+var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+var WaterLevel = /* @__PURE__ */ ((WaterLevel3) => {
+  WaterLevel3[WaterLevel3["None"] = 0] = "None";
+  WaterLevel3[WaterLevel3["Feet"] = 1] = "Feet";
+  WaterLevel3[WaterLevel3["Waist"] = 2] = "Waist";
+  WaterLevel3[WaterLevel3["Under"] = 3] = "Under";
+  return WaterLevel3;
+})(WaterLevel || {});
+var PmFlag = /* @__PURE__ */ ((PmFlag2) => {
+  PmFlag2[PmFlag2["Ducked"] = 1] = "Ducked";
+  PmFlag2[PmFlag2["JumpHeld"] = 2] = "JumpHeld";
+  PmFlag2[PmFlag2["OnGround"] = 4] = "OnGround";
+  PmFlag2[PmFlag2["TimeWaterJump"] = 8] = "TimeWaterJump";
+  PmFlag2[PmFlag2["TimeLand"] = 16] = "TimeLand";
+  PmFlag2[PmFlag2["TimeTeleport"] = 32] = "TimeTeleport";
+  PmFlag2[PmFlag2["NoPositionalPrediction"] = 64] = "NoPositionalPrediction";
+  PmFlag2[PmFlag2["OnLadder"] = 128] = "OnLadder";
+  PmFlag2[PmFlag2["NoAngularPrediction"] = 256] = "NoAngularPrediction";
+  PmFlag2[PmFlag2["IgnorePlayerCollision"] = 512] = "IgnorePlayerCollision";
+  PmFlag2[PmFlag2["TimeTrick"] = 1024] = "TimeTrick";
+  return PmFlag2;
+})(PmFlag || {});
+function hasPmFlag(flags, flag) {
+  return (flags & flag) !== 0;
+}
+var PmType = /* @__PURE__ */ ((PmType2) => {
+  PmType2[PmType2["Normal"] = 0] = "Normal";
+  PmType2[PmType2["Grapple"] = 1] = "Grapple";
+  PmType2[PmType2["NoClip"] = 2] = "NoClip";
+  PmType2[PmType2["Spectator"] = 3] = "Spectator";
+  PmType2[PmType2["Dead"] = 4] = "Dead";
+  PmType2[PmType2["Gib"] = 5] = "Gib";
+  PmType2[PmType2["Freeze"] = 6] = "Freeze";
+  return PmType2;
+})(PmType || {});
+var PlayerButton = /* @__PURE__ */ ((PlayerButton2) => {
+  PlayerButton2[PlayerButton2["None"] = 0] = "None";
+  PlayerButton2[PlayerButton2["Attack"] = 1] = "Attack";
+  PlayerButton2[PlayerButton2["Use"] = 2] = "Use";
+  PlayerButton2[PlayerButton2["Holster"] = 4] = "Holster";
+  PlayerButton2[PlayerButton2["Jump"] = 8] = "Jump";
+  PlayerButton2[PlayerButton2["Crouch"] = 16] = "Crouch";
+  PlayerButton2[PlayerButton2["Any"] = 128] = "Any";
+  return PlayerButton2;
+})(PlayerButton || {});
+function applyPmoveFriction(params) {
+  const {
+    velocity,
+    frametime,
+    onGround,
+    groundIsSlick,
+    onLadder,
+    waterlevel,
+    pmFriction,
+    pmStopSpeed,
+    pmWaterFriction
+  } = params;
+  const speed = lengthVec3(velocity);
+  if (speed < 1) {
+    return { x: 0, y: 0, z: velocity.z };
+  }
+  let drop = 0;
+  if (onGround && !groundIsSlick || onLadder) {
+    const control = speed < pmStopSpeed ? pmStopSpeed : speed;
+    const friction = pmFriction;
+    drop += control * friction * frametime;
+  }
+  if (waterlevel > 0 && !onLadder) {
+    drop += speed * pmWaterFriction * waterlevel * frametime;
+  }
+  let newspeed = speed - drop;
+  if (newspeed < 0) {
+    newspeed = 0;
+  }
+  if (newspeed === speed) {
+    return velocity;
+  }
+  const scale = newspeed / speed;
+  return scaleVec3(velocity, scale);
+}
+function applyPmoveAccelerate(params) {
+  const { velocity, wishdir, wishspeed, accel, frametime } = params;
+  const currentSpeed = dotVec3(velocity, wishdir);
+  const addSpeed = wishspeed - currentSpeed;
+  if (addSpeed <= 0) {
+    return velocity;
+  }
+  let accelSpeed = accel * frametime * wishspeed;
+  if (accelSpeed > addSpeed) {
+    accelSpeed = addSpeed;
+  }
+  return {
+    x: velocity.x + wishdir.x * accelSpeed,
+    y: velocity.y + wishdir.y * accelSpeed,
+    z: velocity.z + wishdir.z * accelSpeed
+  };
+}
+function applyPmoveAirAccelerate(params) {
+  const { velocity, wishdir, wishspeed, accel, frametime } = params;
+  const wishspd = Math.min(wishspeed, 30);
+  const currentSpeed = dotVec3(velocity, wishdir);
+  const addSpeed = wishspd - currentSpeed;
+  if (addSpeed <= 0) {
+    return velocity;
+  }
+  let accelSpeed = accel * wishspeed * frametime;
+  if (accelSpeed > addSpeed) {
+    accelSpeed = addSpeed;
+  }
+  return {
+    x: velocity.x + wishdir.x * accelSpeed,
+    y: velocity.y + wishdir.y * accelSpeed,
+    z: velocity.z + wishdir.z * accelSpeed
+  };
+}
+function buildAirGroundWish(params) {
+  const { forward, right, cmd, maxSpeed } = params;
+  let wishvel = {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+  let wishspeed = lengthVec3(wishvel);
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+  }
+  return {
+    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
+    wishspeed
+  };
+}
+function buildWaterWish(params) {
+  const { forward, right, cmd, maxSpeed } = params;
+  let wishvel = {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+  if (cmd.upmove > 10) {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
+  } else if (cmd.upmove < -10) {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
+  } else {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: 10 });
+  }
+  let wishspeed = lengthVec3(wishvel);
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+  }
+  wishspeed *= 0.5;
+  return {
+    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
+    wishspeed
+  };
+}
+var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
+function addAngles(cmdAngles, deltaAngles) {
+  return {
+    x: cmdAngles.x + deltaAngles.x,
+    y: cmdAngles.y + deltaAngles.y,
+    z: cmdAngles.z + deltaAngles.z
+  };
+}
+function clampPitch(pitch) {
+  if (pitch > 89 && pitch < 180) {
+    return 89;
+  }
+  if (pitch < 271 && pitch >= 180) {
+    return 271;
+  }
+  return pitch;
+}
+function clampViewAngles(params) {
+  const { pmFlags, cmdAngles, deltaAngles } = params;
+  let viewangles;
+  if ((pmFlags & 32) !== 0) {
+    viewangles = {
+      x: 0,
+      y: cmdAngles.y + deltaAngles.y,
+      z: 0
+    };
+  } else {
+    viewangles = addAngles(cmdAngles, deltaAngles);
+    viewangles = { ...viewangles, x: clampPitch(viewangles.x) };
+  }
+  const vectors = angleVectors(viewangles);
+  return { viewangles, ...vectors };
+}
+var DEFAULT_FORWARD_SPEED = 200;
+var DEFAULT_SIDE_SPEED = 200;
+var DEFAULT_UP_SPEED = 200;
+var DEFAULT_YAW_SPEED = 140;
+var DEFAULT_PITCH_SPEED = 150;
+var DEFAULT_MOUSE_SENSITIVITY = 3;
+function clampPitch2(pitch) {
+  const normalized = angleMod(pitch);
+  if (normalized > 89 && normalized < 180) return 89;
+  if (normalized < 271 && normalized >= 180) return 271;
+  return normalized;
+}
+function addViewAngles(current, delta) {
+  return {
+    x: clampPitch2(current.x + delta.x),
+    y: angleMod(current.y + delta.y),
+    z: angleMod(current.z + delta.z)
+  };
+}
+function mouseDeltaToViewDelta(delta, options) {
+  const yawScale = options.sensitivityX ?? options.sensitivity;
+  const pitchScale = (options.sensitivityY ?? options.sensitivity) * (options.invertY ? -1 : 1);
+  return {
+    x: delta.deltaY * pitchScale,
+    y: delta.deltaX * yawScale,
+    z: 0
+  };
+}
+
+// src/prediction.ts
+var DEFAULTS = {
+  pmFriction: 6,
+  pmStopSpeed: 100,
+  pmAccelerate: 10,
+  pmAirAccelerate: 1,
+  pmWaterAccelerate: 4,
+  pmWaterFriction: 1,
+  pmMaxSpeed: 300,
+  pmDuckSpeed: 100,
+  pmWaterSpeed: 400,
+  groundIsSlick: false
+};
+var DEFAULT_GRAVITY = 800;
+var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
+var MSEC_MAX = 250;
+function defaultPredictionState() {
+  return {
+    origin: ZERO_VEC32,
+    velocity: ZERO_VEC32,
+    viewangles: ZERO_VEC32,
+    pmFlags: PmFlag.OnGround,
+    pmType: PmType.Normal,
+    waterlevel: WaterLevel.None,
+    gravity: DEFAULT_GRAVITY,
+    deltaAngles: ZERO_VEC32
+  };
+}
+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
+  };
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpAngle(a, b, t) {
+  let delta = angleMod(b - a);
+  if (delta > 180) {
+    delta -= 360;
+  }
+  return angleMod(a + delta * t);
+}
+function interpolatePredictionState(previous, latest, alpha) {
+  const clamped = Math.max(0, Math.min(alpha, 1));
+  return {
+    origin: {
+      x: 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)
+    },
+    pmFlags: latest.pmFlags,
+    pmType: latest.pmType,
+    waterlevel: latest.waterlevel,
+    gravity: latest.gravity,
+    deltaAngles: latest.deltaAngles
+  };
+}
+function simulateCommand(state, cmd, settings) {
+  const frametime = Math.min(Math.max(cmd.msec, 0), MSEC_MAX) / 1e3;
+  const onGround = hasPmFlag(state.pmFlags, PmFlag.OnGround);
+  const onLadder = hasPmFlag(state.pmFlags, PmFlag.OnLadder);
+  let velocity = applyPmoveFriction({
+    velocity: state.velocity,
+    frametime,
+    onGround,
+    groundIsSlick: settings.groundIsSlick,
+    onLadder,
+    waterlevel: state.waterlevel,
+    pmFriction: settings.pmFriction,
+    pmStopSpeed: settings.pmStopSpeed,
+    pmWaterFriction: settings.pmWaterFriction
+  });
+  const { viewangles, forward, right } = clampViewAngles({
+    pmFlags: state.pmFlags,
+    cmdAngles: cmd.angles,
+    deltaAngles: state.deltaAngles ?? ZERO_VEC32
+  });
+  const wish = state.waterlevel > WaterLevel.None ? buildWaterWish({ forward, right, cmd, maxSpeed: settings.pmWaterSpeed }) : buildAirGroundWish({ forward, right, cmd, maxSpeed: settings.pmMaxSpeed });
+  if (state.waterlevel > WaterLevel.None) {
+    velocity = applyPmoveAccelerate({
+      velocity,
+      wishdir: wish.wishdir,
+      wishspeed: wish.wishspeed,
+      accel: settings.pmWaterAccelerate,
+      frametime
+    });
+  } else if (onGround || onLadder) {
+    const maxSpeed = hasPmFlag(state.pmFlags, PmFlag.Ducked) ? settings.pmDuckSpeed : settings.pmMaxSpeed;
+    const clampedWish = wish.wishspeed > maxSpeed ? {
+      wishdir: wish.wishdir,
+      wishspeed: maxSpeed
+    } : wish;
+    velocity = applyPmoveAccelerate({
+      velocity,
+      wishdir: clampedWish.wishdir,
+      wishspeed: clampedWish.wishspeed,
+      accel: settings.pmAccelerate,
+      frametime
+    });
+  } else {
+    velocity = applyPmoveAirAccelerate({
+      velocity,
+      wishdir: wish.wishdir,
+      wishspeed: wish.wishspeed,
+      accel: settings.pmAirAccelerate,
+      frametime
+    });
+    velocity = { ...velocity, z: velocity.z - state.gravity * frametime };
+  }
+  const originDelta = scaleVec3(velocity, frametime);
+  const origin = addVec3(state.origin, originDelta);
+  return {
+    ...state,
+    origin,
+    velocity,
+    viewangles
+  };
+}
+var ClientPrediction = class {
+  constructor(settings = {}) {
+    this.baseFrame = {
+      frame: 0,
+      timeMs: 0,
+      state: defaultPredictionState()
+    };
+    this.commands = [];
+    this.predicted = defaultPredictionState();
+    this.settings = { ...DEFAULTS, ...settings };
+    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.predicted = state;
+    return state;
+  }
+};
+
+// src/view-effects.ts
+var DEFAULT_SETTINGS = {
+  runPitch: 2e-3,
+  runRoll: 5e-3,
+  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;
+    let rollTilt = dotVec3(state.velocity, right) * this.settings.runRoll;
+    let pitchDelta = this.bobFracSin * this.settings.bobPitch * xyspeed;
+    let rollDelta = this.bobFracSin * this.settings.bobRoll * xyspeed;
+    if (hasPmFlag(state.pmFlags, PmFlag.Ducked) && onGround) {
+      pitchDelta *= 6;
+      rollDelta *= 6;
+    }
+    pitchTilt += Math.min(pitchDelta, this.settings.maxBobAngle);
+    rollDelta = Math.min(rollDelta, this.settings.maxBobAngle);
+    if (this.bobCycle & 1) rollDelta = -rollDelta;
+    rollTilt += rollDelta;
+    const bobHeight = Math.min(this.bobFracSin * xyspeed * this.settings.bobUp, this.settings.maxBobHeight);
+    let kickPitch = 0;
+    let kickRoll = 0;
+    if (this.kick && this.kick.remainingMs > 0) {
+      const ratio = Math.max(0, Math.min(1, this.kick.remainingMs / this.kick.durationMs));
+      kickPitch += ratio * this.kick.pitch;
+      kickRoll += ratio * this.kick.roll;
+      this.kick.remainingMs = Math.max(0, this.kick.remainingMs - frameTimeMs);
+      if (this.kick.remainingMs === 0) this.kick = void 0;
+    }
+    const angles = { x: pitchTilt + kickPitch, y: 0, z: rollTilt + kickRoll };
+    const offset = { x: 0, y: 0, z: bobHeight };
+    const sample = {
+      angles,
+      offset: clampViewOffset(offset),
+      bobCycle: this.bobCycle,
+      bobCycleRun: this.bobCycleRun,
+      bobFracSin: this.bobFracSin,
+      xyspeed
+    };
+    this.lastSample = sample;
+    return sample;
+  }
+};
+
+// src/input/bindings.ts
+var DEFAULT_BINDINGS = [
+  { code: "KeyW", command: "+forward" },
+  { code: "ArrowUp", command: "+forward" },
+  { code: "KeyS", command: "+back" },
+  { code: "ArrowDown", command: "+back" },
+  { code: "KeyA", command: "+moveleft" },
+  { code: "KeyD", command: "+moveright" },
+  { code: "Space", command: "+jump" },
+  { code: "ControlLeft", command: "+crouch" },
+  { code: "ShiftLeft", command: "+speed" },
+  { code: "Mouse1", command: "+attack" },
+  { code: "Mouse2", command: "+use" },
+  { code: "Mouse3", command: "+zoom" },
+  { code: "ArrowLeft", command: "+left" },
+  { code: "ArrowRight", command: "+right" },
+  { code: "PageUp", command: "+lookup" },
+  { code: "PageDown", command: "+lookdown" },
+  { code: "Gamepad0-Button7", command: "+attack" },
+  { code: "Gamepad0-Button6", command: "+zoom" },
+  { code: "Gamepad0-Button0", command: "+jump" },
+  { code: "Gamepad0-Button1", command: "+crouch" },
+  { code: "Gamepad0-Button2", command: "+use" },
+  { code: "Gamepad0-Button4", command: "prevweapon" },
+  { code: "Gamepad0-Button5", command: "nextweapon" },
+  { code: "Digit1", command: "weapon 1" },
+  { code: "Digit2", command: "weapon 2" },
+  { code: "Digit3", command: "weapon 3" },
+  { code: "Digit4", command: "weapon 4" },
+  { code: "Digit5", command: "weapon 5" },
+  { code: "Digit6", command: "weapon 6" },
+  { code: "Digit7", command: "weapon 7" },
+  { code: "Digit8", command: "weapon 8" },
+  { code: "Digit9", command: "weapon 9" },
+  { code: "Digit0", command: "weapon 10" }
+];
+var InputBindings = class {
+  constructor(entries = DEFAULT_BINDINGS) {
+    this.bindings = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      this.bind(entry.code, entry.command);
+    }
+  }
+  bind(code, command) {
+    this.bindings.set(code, command);
+  }
+  unbind(code) {
+    this.bindings.delete(code);
+  }
+  getBinding(code) {
+    return this.bindings.get(code);
+  }
+  entries() {
+    return new Map(this.bindings.entries());
+  }
+};
+function createDefaultBindings() {
+  return new InputBindings();
+}
+function normalizeInputCode(code) {
+  return code;
+}
+function normalizeCommand(command) {
+  return command.trim().toLowerCase();
+}
+
+// src/input/controller.ts
+var MSEC_MAX2 = 250;
+var KeyButton = class {
+  constructor() {
+    this.activeCodes = /* @__PURE__ */ new Set();
+    this.downTime = 0;
+    this.msec = 0;
+    this.pressed = false;
+  }
+  press(code, now) {
+    if (this.activeCodes.has(code)) return false;
+    this.activeCodes.add(code);
+    this.pressed = true;
+    if (this.activeCodes.size === 1) {
+      this.downTime = now;
+      return true;
+    }
+    return false;
+  }
+  release(code, now) {
+    if (!this.activeCodes.delete(code)) return false;
+    if (this.activeCodes.size === 0) {
+      this.msec += now - this.downTime;
+      this.downTime = 0;
+      return true;
+    }
+    return false;
+  }
+  sample(frameMsec, now) {
+    if (frameMsec <= 0) {
+      return { active: this.activeCodes.size > 0, wasPressed: this.pressed, fraction: 0 };
+    }
+    let total = this.msec;
+    if (this.activeCodes.size > 0) {
+      total += now - this.downTime;
+      this.downTime = now;
+    }
+    this.msec = 0;
+    const fraction = Math.min(total / frameMsec, 1);
+    const wasPressed = this.pressed;
+    this.pressed = false;
+    return { active: this.activeCodes.size > 0, wasPressed, fraction };
+  }
+};
+var InputAction = /* @__PURE__ */ ((InputAction2) => {
+  InputAction2["Forward"] = "+forward";
+  InputAction2["Back"] = "+back";
+  InputAction2["MoveLeft"] = "+moveleft";
+  InputAction2["MoveRight"] = "+moveright";
+  InputAction2["MoveUp"] = "+moveup";
+  InputAction2["MoveDown"] = "+movedown";
+  InputAction2["Jump"] = "+jump";
+  InputAction2["Crouch"] = "+crouch";
+  InputAction2["Attack"] = "+attack";
+  InputAction2["Use"] = "+use";
+  InputAction2["Holster"] = "+holster";
+  InputAction2["TurnLeft"] = "+left";
+  InputAction2["TurnRight"] = "+right";
+  InputAction2["LookUp"] = "+lookup";
+  InputAction2["LookDown"] = "+lookdown";
+  InputAction2["SpeedModifier"] = "+speed";
+  InputAction2["Zoom"] = "+zoom";
+  return InputAction2;
+})(InputAction || {});
+var BUTTON_ACTIONS = {
+  ["+attack" /* Attack */]: PlayerButton.Attack,
+  ["+use" /* Use */]: PlayerButton.Use,
+  ["+holster" /* Holster */]: PlayerButton.Holster,
+  ["+jump" /* Jump */]: PlayerButton.Jump,
+  ["+crouch" /* Crouch */]: PlayerButton.Crouch
+};
+var ACTION_LOOKUP = new Map(
+  Object.values(InputAction).map((action) => [normalizeCommand(action), action])
+);
+function commandToAction(command) {
+  return ACTION_LOOKUP.get(normalizeCommand(command));
+}
+function nowMs() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+var InputController = class {
+  constructor(options = {}, bindings = new InputBindings()) {
+    this.buttons = /* @__PURE__ */ new Map();
+    this.viewAngles = { x: 0, y: 0, z: 0 };
+    this.pointerLocked = false;
+    this.mouseDelta = { deltaX: 0, deltaY: 0 };
+    this.previousMouseDelta = { deltaX: 0, deltaY: 0 };
+    this.anyPressed = false;
+    this.commandQueue = [];
+    this.gamepadButtons = /* @__PURE__ */ new Map();
+    this.gamepadMove = { x: 0, y: 0 };
+    this.gamepadLook = { x: 0, y: 0 };
+    this.touchButtons = /* @__PURE__ */ new Map();
+    this.touchMove = { x: 0, y: 0 };
+    this.touchLook = { x: 0, y: 0 };
+    this.bindings = bindings;
+    this.forwardSpeed = options.forwardSpeed ?? DEFAULT_FORWARD_SPEED;
+    this.sideSpeed = options.sideSpeed ?? DEFAULT_SIDE_SPEED;
+    this.upSpeed = options.upSpeed ?? DEFAULT_UP_SPEED;
+    this.yawSpeed = options.yawSpeed ?? DEFAULT_YAW_SPEED;
+    this.pitchSpeed = options.pitchSpeed ?? DEFAULT_PITCH_SPEED;
+    this.sensitivity = options.sensitivity ?? DEFAULT_MOUSE_SENSITIVITY;
+    this.sensitivityX = options.sensitivityX;
+    this.sensitivityY = options.sensitivityY;
+    this.invertMouseY = options.invertMouseY ?? false;
+    this.runByDefault = options.runByDefault ?? true;
+    this.requirePointerLock = options.requirePointerLock ?? true;
+    this.jumpAddsUpMove = options.jumpAddsUpMove ?? true;
+    this.crouchAddsDownMove = options.crouchAddsDownMove ?? true;
+    this.mouseFilter = options.mouseFilter ?? false;
+    this.getGamepads = options.getGamepads;
+    this.gamepadDeadZone = options.gamepadDeadZone ?? 0.15;
+    this.gamepadLookScale = options.gamepadLookScale ?? 1;
+    this.invertGamepadY = options.invertGamepadY ?? this.invertMouseY;
+  }
+  handleKeyDown(code, eventTimeMs = nowMs()) {
+    const normalized = normalizeInputCode(code);
+    const binding = this.bindings.getBinding(normalized);
+    if (!binding) return;
+    this.applyCommand(binding, true, normalized, eventTimeMs);
+  }
+  handleKeyUp(code, eventTimeMs = nowMs()) {
+    const normalized = normalizeInputCode(code);
+    const binding = this.bindings.getBinding(normalized);
+    if (!binding) return;
+    this.applyCommand(binding, false, normalized, eventTimeMs);
+  }
+  handleMouseButtonDown(button, eventTimeMs = nowMs()) {
+    const code = this.mouseButtonToCode(button);
+    this.applyCommand(this.mouseButtonToCommand(code), true, code, eventTimeMs);
+  }
+  handleMouseButtonUp(button, eventTimeMs = nowMs()) {
+    const code = this.mouseButtonToCode(button);
+    this.applyCommand(this.mouseButtonToCommand(code), false, code, eventTimeMs);
+  }
+  handleMouseMove(deltaX, deltaY) {
+    if (this.requirePointerLock && !this.pointerLocked) return;
+    this.mouseDelta = {
+      deltaX: this.mouseDelta.deltaX + deltaX,
+      deltaY: this.mouseDelta.deltaY + deltaY
+    };
+  }
+  setPointerLocked(locked) {
+    this.pointerLocked = locked;
+  }
+  setGamepadState(gamepads) {
+    this.pendingGamepads = gamepads;
+  }
+  setTouchState(state) {
+    this.pendingTouchState = state;
+  }
+  buildCommand(frameMsec, now = nowMs(), serverFrame) {
+    this.pollGamepads(now);
+    this.applyTouchState(now);
+    const yawStep = this.yawSpeed * frameMsec / 1e3;
+    const pitchStep = this.pitchSpeed * frameMsec / 1e3;
+    const turnLeft = this.sample("+left" /* TurnLeft */, frameMsec, now);
+    const turnRight = this.sample("+right" /* TurnRight */, frameMsec, now);
+    const lookUp = this.sample("+lookup" /* LookUp */, frameMsec, now);
+    const lookDown = this.sample("+lookdown" /* LookDown */, frameMsec, now);
+    let viewDelta = {
+      x: (lookDown.fraction - lookUp.fraction) * pitchStep,
+      y: (turnRight.fraction - turnLeft.fraction) * yawStep,
+      z: 0
+    };
+    if (this.gamepadLook.x !== 0 || this.gamepadLook.y !== 0) {
+      const pitch = this.gamepadLook.y * (this.invertGamepadY ? -1 : 1);
+      viewDelta = {
+        x: viewDelta.x + pitch * pitchStep * this.gamepadLookScale,
+        y: viewDelta.y + this.gamepadLook.x * yawStep * this.gamepadLookScale,
+        z: 0
+      };
+    }
+    if (this.touchLook.x !== 0 || this.touchLook.y !== 0) {
+      const pitch = this.touchLook.y * (this.invertMouseY ? -1 : 1);
+      viewDelta = {
+        x: viewDelta.x + pitch * pitchStep,
+        y: viewDelta.y + this.touchLook.x * yawStep,
+        z: 0
+      };
+    }
+    if (this.pointerLocked || !this.requirePointerLock) {
+      const sampledDelta = this.sampleMouseDelta();
+      const mouseDelta = mouseDeltaToViewDelta(sampledDelta, {
+        sensitivity: this.sensitivity,
+        sensitivityX: this.sensitivityX,
+        sensitivityY: this.sensitivityY,
+        invertY: this.invertMouseY
+      });
+      viewDelta = {
+        x: viewDelta.x + mouseDelta.x,
+        y: viewDelta.y + mouseDelta.y,
+        z: 0
+      };
+    }
+    const angles = addViewAngles(this.viewAngles, viewDelta);
+    this.viewAngles = angles;
+    const forward = this.sample("+forward" /* Forward */, frameMsec, now);
+    const back = this.sample("+back" /* Back */, frameMsec, now);
+    const moveLeft = this.sample("+moveleft" /* MoveLeft */, frameMsec, now);
+    const moveRight = this.sample("+moveright" /* MoveRight */, frameMsec, now);
+    const moveUp = this.sample("+moveup" /* MoveUp */, frameMsec, now);
+    const moveDown = this.sample("+movedown" /* MoveDown */, frameMsec, now);
+    const speed = this.sample("+speed" /* SpeedModifier */, frameMsec, now);
+    const jump = this.sample("+jump" /* Jump */, frameMsec, now);
+    const crouch = this.sample("+crouch" /* Crouch */, frameMsec, now);
+    const speedScale = this.runByDefault ? speed.active ? 0.5 : 1 : speed.active ? 1 : 0.5;
+    let forwardmove = this.forwardSpeed * (forward.fraction - back.fraction) * speedScale;
+    let sidemove = this.sideSpeed * (moveRight.fraction - moveLeft.fraction) * speedScale;
+    let upmove = this.upSpeed * (moveUp.fraction - moveDown.fraction);
+    if (this.gamepadMove.x !== 0 || this.gamepadMove.y !== 0) {
+      forwardmove += this.forwardSpeed * this.gamepadMove.y * speedScale;
+      sidemove += this.sideSpeed * this.gamepadMove.x * speedScale;
+    }
+    if (this.touchMove.x !== 0 || this.touchMove.y !== 0) {
+      forwardmove += this.forwardSpeed * this.touchMove.y * speedScale;
+      sidemove += this.sideSpeed * this.touchMove.x * speedScale;
+    }
+    if (this.jumpAddsUpMove && jump.fraction > 0) {
+      upmove += this.upSpeed * jump.fraction;
+    }
+    if (this.crouchAddsDownMove && crouch.fraction > 0) {
+      upmove -= this.upSpeed * crouch.fraction;
+    }
+    forwardmove = this.clampMove(forwardmove, this.forwardSpeed);
+    sidemove = this.clampMove(sidemove, this.sideSpeed);
+    upmove = this.clampMove(upmove, this.upSpeed);
+    let buttons = this.collectButtonBits(frameMsec, now);
+    const msec = Math.min(Math.max(Math.round(frameMsec), 1), MSEC_MAX2);
+    if (this.anyPressed || buttons !== PlayerButton.None) {
+      buttons |= PlayerButton.Any;
+    }
+    this.anyPressed = false;
+    return {
+      msec,
+      buttons,
+      angles: { ...this.viewAngles },
+      forwardmove,
+      sidemove,
+      upmove,
+      serverFrame
+    };
+  }
+  consumeConsoleCommands() {
+    const commands = this.commandQueue;
+    this.commandQueue = [];
+    return commands;
+  }
+  pollGamepads(now) {
+    const gamepads = this.getGamepads?.() ?? this.pendingGamepads ?? [];
+    this.pendingGamepads = void 0;
+    this.gamepadMove = { x: 0, y: 0 };
+    this.gamepadLook = { x: 0, y: 0 };
+    const pressedThisFrame = /* @__PURE__ */ new Set();
+    for (const pad of gamepads) {
+      if (!pad || pad.connected === false) continue;
+      const index = pad.index ?? 0;
+      const axes = pad.axes ?? [];
+      this.gamepadMove = {
+        x: this.mergeAnalog(this.gamepadMove.x, this.applyDeadZone(axes[0] ?? 0)),
+        y: this.mergeAnalog(this.gamepadMove.y, -this.applyDeadZone(axes[1] ?? 0))
+      };
+      this.gamepadLook = {
+        x: this.mergeAnalog(this.gamepadLook.x, this.applyDeadZone(axes[2] ?? 0)),
+        y: this.mergeAnalog(this.gamepadLook.y, this.applyDeadZone(axes[3] ?? 0))
+      };
+      const buttons = pad.buttons ?? [];
+      for (let i = 0; i < buttons.length; i++) {
+        const button = buttons[i];
+        if (!button) continue;
+        const pressed = button.pressed || button.value > this.gamepadDeadZone;
+        const code = this.gamepadButtonCode(index, i);
+        if (pressed) pressedThisFrame.add(code);
+        const wasPressed = this.gamepadButtons.get(code) ?? false;
+        if (pressed !== wasPressed) {
+          this.applyCommand(this.bindings.getBinding(code), pressed, code, now);
+          this.gamepadButtons.set(code, pressed);
+        }
+      }
+    }
+    for (const [code, wasPressed] of this.gamepadButtons.entries()) {
+      if (wasPressed && !pressedThisFrame.has(code)) {
+        this.applyCommand(this.bindings.getBinding(code), false, code, now);
+        this.gamepadButtons.set(code, false);
+      }
+    }
+  }
+  applyTouchState(now) {
+    const state = this.pendingTouchState;
+    if (!state) return;
+    this.pendingTouchState = void 0;
+    if (state.move) {
+      this.touchMove = {
+        x: this.clampAnalog(state.move.x),
+        y: this.clampAnalog(state.move.y)
+      };
+    }
+    if (state.look) {
+      this.touchLook = {
+        x: this.clampAnalog(state.look.x),
+        y: this.clampAnalog(state.look.y)
+      };
+    }
+    if (state.buttons) {
+      for (const [action, pressed] of Object.entries(state.buttons)) {
+        if (pressed === void 0) continue;
+        const wasPressed = this.touchButtons.get(action) ?? false;
+        if (pressed !== wasPressed) {
+          this.applyCommand(action, pressed, this.touchButtonCode(action), now);
+          this.touchButtons.set(action, pressed);
+        }
+      }
+    }
+  }
+  applyCommand(command, isDown, code, eventTimeMs) {
+    if (!command) return;
+    const action = commandToAction(command);
+    if (action) {
+      const button = this.lookupButton(action);
+      if (isDown) {
+        if (button.press(code, eventTimeMs)) {
+          this.commandQueue.push(action);
+        }
+        this.anyPressed = true;
+      } else if (button.release(code, eventTimeMs)) {
+        this.commandQueue.push(action.replace("+", "-"));
+      }
+    } else if (isDown) {
+      this.commandQueue.push(command);
+    }
+  }
+  sampleMouseDelta() {
+    const delta = this.mouseDelta;
+    this.mouseDelta = { deltaX: 0, deltaY: 0 };
+    if (!this.mouseFilter) {
+      this.previousMouseDelta = delta;
+      return delta;
+    }
+    const filtered = {
+      deltaX: (delta.deltaX + this.previousMouseDelta.deltaX) * 0.5,
+      deltaY: (delta.deltaY + this.previousMouseDelta.deltaY) * 0.5
+    };
+    this.previousMouseDelta = delta;
+    return filtered;
+  }
+  collectButtonBits(frameMsec, now) {
+    let buttons = PlayerButton.None;
+    for (const [action, bit] of Object.entries(BUTTON_ACTIONS)) {
+      const sample = this.sample(action, frameMsec, now);
+      if (sample.fraction > 0 || sample.active || sample.wasPressed) {
+        buttons |= bit;
+      }
+    }
+    return buttons;
+  }
+  lookupButton(action) {
+    let button = this.buttons.get(action);
+    if (!button) {
+      button = new KeyButton();
+      this.buttons.set(action, button);
+    }
+    return button;
+  }
+  mouseButtonToCode(button) {
+    if (button === 0) return "Mouse1";
+    if (button === 1) return "Mouse3";
+    if (button === 2) return "Mouse2";
+    return `Mouse${button + 1}`;
+  }
+  mouseButtonToCommand(code) {
+    return this.bindings.getBinding(code);
+  }
+  sample(action, frameMsec, now) {
+    const button = this.lookupButton(action);
+    return button.sample(frameMsec, now);
+  }
+  gamepadButtonCode(index, button) {
+    return `Gamepad${index}-Button${button}`;
+  }
+  touchButtonCode(action) {
+    return `Touch-${action}`;
+  }
+  clampAnalog(value) {
+    return Math.max(-1, Math.min(1, value));
+  }
+  applyDeadZone(value) {
+    return Math.abs(value) < this.gamepadDeadZone ? 0 : value;
+  }
+  mergeAnalog(current, incoming) {
+    return Math.abs(incoming) > Math.abs(current) ? incoming : current;
+  }
+  clampMove(value, max) {
+    return Math.max(-max, Math.min(max, value));
+  }
+};
+
+// src/input/command-buffer.ts
+var InputCommandBuffer = class {
+  constructor(options, controller = new InputController(options)) {
+    this.queued = [];
+    this.controller = controller;
+  }
+  captureFrame(frameMsec, now, serverFrame) {
+    const command = this.controller.buildCommand(frameMsec, now, serverFrame);
+    const console = this.controller.consumeConsoleCommands();
+    const entry = { command, console };
+    this.queued.push(entry);
+    return entry;
+  }
+  consumeQueued() {
+    const queued = [...this.queued];
+    this.queued.length = 0;
+    return queued;
+  }
+  getController() {
+    return this.controller;
+  }
+};
+
 // src/index.ts
 function createClient(imports) {
+  const prediction = new ClientPrediction();
+  const view = new ViewEffects();
   let latestFrame;
+  let lastRendered;
+  let lastView;
   return {
     init(initial) {
       latestFrame = initial;
+      if (initial?.state) {
+        prediction.setAuthoritative(initial);
+      }
       void imports.engine.trace({ x: 0, y: 0, z: 0 }, { x: 1, y: 0, z: 0 });
     },
-    predict(next) {
-      const { origin, velocity } = next;
-      return {
-        origin: {
-          x: origin.x + velocity.x,
-          y: origin.y + velocity.y,
-          z: origin.z + velocity.z
-        },
-        velocity
-      };
+    predict(command) {
+      return prediction.enqueueCommand(command);
     },
     render(sample) {
-      latestFrame = sample.latest ?? latestFrame;
+      if (sample.latest?.state) {
+        prediction.setAuthoritative(sample.latest);
+        latestFrame = sample.latest;
+      }
+      if (sample.previous?.state && sample.latest?.state) {
+        lastRendered = interpolatePredictionState(sample.previous.state, sample.latest.state, sample.alpha);
+      } else {
+        lastRendered = sample.latest?.state ?? sample.previous?.state ?? prediction.getPredictedState();
+      }
+      const frameTimeMs = sample.latest && sample.previous ? Math.max(0, sample.latest.timeMs - sample.previous.timeMs) : 0;
+      lastView = view.sample(lastRendered, frameTimeMs);
+      void imports;
       void sample;
     },
     shutdown() {
       latestFrame = void 0;
+      lastRendered = void 0;
+    },
+    get prediction() {
+      return prediction;
+    },
+    get lastRendered() {
+      return lastRendered;
+    },
+    get view() {
+      return view;
+    },
+    get lastView() {
+      return lastView;
     }
   };
 }
 export {
-  createClient
+  ClientPrediction,
+  InputAction,
+  InputBindings,
+  InputCommandBuffer,
+  InputController,
+  ViewEffects,
+  createClient,
+  createDefaultBindings,
+  defaultPredictionState,
+  interpolatePredictionState,
+  normalizeCommand,
+  normalizeInputCode
 };
 //# sourceMappingURL=index.js.map