quake2ts 0.0.296 → 0.0.298

package/packages/shared/dist/cjs/index.cjs

@@ -199,6 +199,7 @@ __export(index_exports, {
   applyPmoveAirMove: () => applyPmoveAirMove,
   applyPmoveFlyMove: () => applyPmoveFlyMove,
   applyPmoveFriction: () => applyPmoveFriction,
+  applyPmoveWalkMove: () => applyPmoveWalkMove,
   applyPmoveWaterMove: () => applyPmoveWaterMove,
   assertContract: () => assertContract,
   attenuationToDistanceMultiplier: () => attenuationToDistanceMultiplier,
@@ -274,6 +275,7 @@ __export(index_exports, {
   removePmFlag: () => removePmFlag,
   resolveSlideMove: () => resolveSlideMove,
   rotatePointAroundVector: () => rotatePointAroundVector,
+  runPmove: () => runPmove,
   scaleVec3: () => scaleVec3,
   slerpVec3: () => slerpVec3,
   slideClipVelocityVec3: () => slideClipVelocityVec3,
@@ -2132,206 +2134,301 @@ var PmType = /* @__PURE__ */ ((PmType2) => {
   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;
+var PlayerButton = /* @__PURE__ */ ((PlayerButton3) => {
+  PlayerButton3[PlayerButton3["None"] = 0] = "None";
+  PlayerButton3[PlayerButton3["Attack"] = 1] = "Attack";
+  PlayerButton3[PlayerButton3["Use"] = 2] = "Use";
+  PlayerButton3[PlayerButton3["Holster"] = 4] = "Holster";
+  PlayerButton3[PlayerButton3["Jump"] = 8] = "Jump";
+  PlayerButton3[PlayerButton3["Crouch"] = 16] = "Crouch";
+  PlayerButton3[PlayerButton3["Any"] = 128] = "Any";
+  return PlayerButton3;
 })(PlayerButton || {});
 
-// src/pmove/pmove.ts
-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 };
+// src/pmove/jump.ts
+var DEFAULT_JUMP_HEIGHT = 270;
+function hasButton(buttons, button) {
+  return (buttons & button) !== 0;
+}
+function checkJump(params) {
+  const { pmFlags, pmType, buttons, waterlevel, onGround, velocity, origin, jumpHeight = DEFAULT_JUMP_HEIGHT } = params;
+  if (pmFlags & 16 /* TimeLand */) {
+    return { pmFlags, onGround, velocity, origin, jumpSound: false, jumped: false };
   }
-  let drop = 0;
-  if (onGround && !groundIsSlick || onLadder) {
-    const control = speed < pmStopSpeed ? pmStopSpeed : speed;
-    const friction = pmFriction;
-    drop += control * friction * frametime;
+  const holdingJump = hasButton(buttons, 8 /* Jump */);
+  let nextFlags = pmFlags;
+  let nextOnGround = onGround;
+  let jumpSound = false;
+  let jumped = false;
+  let nextVelocity = velocity;
+  let nextOrigin = origin;
+  if (!holdingJump) {
+    nextFlags = removePmFlag(nextFlags, 2 /* JumpHeld */);
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
   }
-  if (waterlevel > 0 && !onLadder) {
-    drop += speed * pmWaterFriction * waterlevel * frametime;
+  if (hasPmJumpHold(nextFlags)) {
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
   }
-  let newspeed = speed - drop;
-  if (newspeed < 0) {
-    newspeed = 0;
+  if (pmType === 4 /* Dead */) {
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
   }
-  if (newspeed === speed) {
-    return velocity;
+  if (waterlevel >= 2 /* Waist */) {
+    nextOnGround = false;
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
   }
-  const scale = newspeed / speed;
-  return scaleVec3(velocity, scale);
+  if (!nextOnGround) {
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
+  }
+  nextFlags = addPmFlag(nextFlags, 2 /* JumpHeld */);
+  nextFlags = removePmFlag(nextFlags, 4 /* OnGround */);
+  nextOnGround = false;
+  jumpSound = true;
+  jumped = true;
+  const z = velocity.z + jumpHeight;
+  const finalZ = z < jumpHeight ? jumpHeight : z;
+  nextVelocity = { ...velocity, z: finalZ };
+  nextOrigin = { ...origin, z: origin.z + 1 };
+  return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
 }
-function applyPmoveAccelerate(params) {
-  const { velocity, wishdir, wishspeed, accel, frametime } = params;
-  const currentSpeed = dotVec3(velocity, wishdir);
-  const addSpeed = wishspeed - currentSpeed;
-  if (addSpeed <= 0) {
-    return velocity;
+function hasPmJumpHold(flags) {
+  return (flags & 2 /* JumpHeld */) !== 0;
+}
+
+// src/pmove/currents.ts
+var DEFAULT_GROUND_CURRENT_SCALE = 100;
+var DEFAULT_FORWARD_LADDER_CLAMP = 200;
+var DEFAULT_SIDE_LADDER_CLAMP = 150;
+var LADDER_HORIZONTAL_CAP = 25;
+var LADDER_ASCEND_PITCH_THRESHOLD = 15;
+var LADDER_TRACE_DISTANCE = 1;
+var UP_VECTOR = { x: 0, y: 0, z: 1 };
+var DEFAULT_TRACE = (_, end) => ({
+  fraction: 1,
+  endpos: end,
+  allsolid: false,
+  startsolid: false
+});
+function currentVectorFromContents(contents) {
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  if (contents & CONTENTS_CURRENT_0) {
+    x += 1;
   }
-  let accelSpeed = accel * frametime * wishspeed;
-  if (accelSpeed > addSpeed) {
-    accelSpeed = addSpeed;
+  if (contents & CONTENTS_CURRENT_90) {
+    y += 1;
   }
-  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;
+  if (contents & CONTENTS_CURRENT_180) {
+    x -= 1;
   }
-  let accelSpeed = accel * wishspeed * frametime;
-  if (accelSpeed > addSpeed) {
-    accelSpeed = addSpeed;
+  if (contents & CONTENTS_CURRENT_270) {
+    y -= 1;
   }
-  return {
-    x: velocity.x + wishdir.x * accelSpeed,
-    y: velocity.y + wishdir.y * accelSpeed,
-    z: velocity.z + wishdir.z * accelSpeed
-  };
-}
-function pmoveCmdScale(cmd, maxSpeed) {
-  const forward = Math.abs(cmd.forwardmove);
-  const side = Math.abs(cmd.sidemove);
-  const up = Math.abs(cmd.upmove);
-  const max = Math.max(forward, side, up);
-  if (max === 0) {
-    return 0;
+  if (contents & CONTENTS_CURRENT_UP) {
+    z += 1;
   }
-  const total = Math.sqrt(cmd.forwardmove * cmd.forwardmove + cmd.sidemove * cmd.sidemove + cmd.upmove * cmd.upmove);
-  return maxSpeed * max / (127 * total);
-}
-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;
+  if (contents & CONTENTS_CURRENT_DOWN) {
+    z -= 1;
   }
-  return {
-    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
-    wishspeed
-  };
+  if (x === 0 && y === 0 && z === 0) {
+    return ZERO_VEC3;
+  }
+  return { x, y, z };
 }
-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: forward.z * cmd.forwardmove + right.z * cmd.sidemove
-  };
-  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 if (Math.abs(cmd.forwardmove) < 10 && Math.abs(cmd.sidemove) < 10) {
-    wishvel = addVec3(wishvel, { x: 0, y: 0, z: -60 });
-  } else {
-    wishvel = addVec3(wishvel, { x: 0, y: 0, z: 10 });
+function waterCurrentVelocity(params) {
+  const { watertype, waterlevel, onGround, waterSpeed } = params;
+  if ((watertype & MASK_CURRENT) === 0) {
+    return ZERO_VEC3;
   }
-  let wishspeed = lengthVec3(wishvel);
-  if (wishspeed > maxSpeed) {
-    const scale = maxSpeed / wishspeed;
-    wishvel = scaleVec3(wishvel, scale);
-    wishspeed = maxSpeed;
+  const direction = currentVectorFromContents(watertype);
+  if (direction === ZERO_VEC3) {
+    return ZERO_VEC3;
   }
-  wishspeed *= 0.5;
-  return {
-    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
-    wishspeed
-  };
-}
-
-// src/pmove/slide.ts
-var DEFAULT_MAX_CLIP_PLANES = 5;
-var DEFAULT_MAX_BUMPS = 4;
-var DEFAULT_STEP_SIZE = 18;
-var MIN_STEP_NORMAL = 0.7;
-var SLIDEMOVE_BLOCKED_FLOOR = 1;
-var SLIDEMOVE_BLOCKED_WALL = 2;
-function resolveSlideMove(initialVelocity, planesEncountered, overbounce, maxClipPlanes = DEFAULT_MAX_CLIP_PLANES, primalVelocity = initialVelocity) {
-  if (planesEncountered.length === 0) {
-    return { velocity: initialVelocity, planes: [], stopped: false };
+  let scale = waterSpeed;
+  if (waterlevel === 1 /* Feet */ && onGround) {
+    scale *= 0.5;
   }
-  const planes = [];
-  let velocity = initialVelocity;
-  for (const plane of planesEncountered) {
-    if (planes.length >= maxClipPlanes) {
-      return { velocity: ZERO_VEC3, planes, stopped: true };
-    }
-    const duplicate = planes.find((existing) => dotVec3(existing, plane) > 0.99);
-    if (duplicate) {
-      continue;
-    }
-    planes.push(plane);
-    let clipped;
-    let i = 0;
-    for (; i < planes.length; i++) {
-      const candidate = clipVelocityVec3(velocity, planes[i], overbounce);
-      let j = 0;
-      for (; j < planes.length; j++) {
-        if (j === i) continue;
-        if (dotVec3(candidate, planes[j]) < 0) break;
-      }
-      if (j === planes.length) {
-        clipped = candidate;
-        break;
-      }
-    }
-    if (clipped) {
-      velocity = clipped;
-    } else {
-      if (planes.length !== 2) {
-        return { velocity: ZERO_VEC3, planes, stopped: true };
-      }
-      const dir = crossVec3(planes[0], planes[1]);
-      const d = dotVec3(dir, velocity);
-      velocity = scaleVec3(dir, d);
-    }
-    if (dotVec3(velocity, primalVelocity) <= 0) {
-      return { velocity: ZERO_VEC3, planes, stopped: true };
-    }
+  return scaleVec3(direction, scale);
+}
+function groundCurrentVelocity(params) {
+  const { groundContents, scale = DEFAULT_GROUND_CURRENT_SCALE } = params;
+  const direction = currentVectorFromContents(groundContents);
+  if (direction === ZERO_VEC3) {
+    return ZERO_VEC3;
   }
-  const stopped = velocity.x === 0 && velocity.y === 0 && velocity.z === 0;
-  return { velocity, planes, stopped };
+  return scaleVec3(direction, scale);
 }
-function slideMove(params) {
+function applyPmoveAddCurrents(params) {
   const {
-    origin: initialOrigin,
-    velocity: initialVelocity,
-    frametime,
-    overbounce,
-    trace,
+    wishVelocity,
+    onLadder,
+    onGround,
+    waterlevel,
+    watertype,
+    groundContents,
+    cmd,
+    viewPitch,
+    maxSpeed,
+    ladderMod,
+    waterSpeed,
+    forward,
+    origin,
+    mins,
+    maxs,
+    trace = DEFAULT_TRACE
+  } = params;
+  let adjusted = wishVelocity;
+  if (onLadder) {
+    adjusted = applyLadderAdjustments({
+      wishVelocity: adjusted,
+      cmd,
+      waterlevel,
+      viewPitch,
+      maxSpeed,
+      ladderMod,
+      onGround,
+      forward,
+      origin,
+      mins,
+      maxs,
+      trace
+    });
+  }
+  const waterVelocity = waterCurrentVelocity({ watertype, waterlevel, onGround, waterSpeed });
+  if (waterVelocity !== ZERO_VEC3) {
+    adjusted = addVec3(adjusted, waterVelocity);
+  }
+  if (onGround) {
+    const groundVelocity = groundCurrentVelocity({ groundContents });
+    if (groundVelocity !== ZERO_VEC3) {
+      adjusted = addVec3(adjusted, groundVelocity);
+    }
+  }
+  return adjusted;
+}
+function applyLadderAdjustments(params) {
+  const { wishVelocity, cmd, waterlevel, viewPitch, maxSpeed, ladderMod, onGround, forward, origin, mins, maxs, trace } = params;
+  const buttons = cmd.buttons ?? 0;
+  let adjusted = { ...wishVelocity };
+  if ((buttons & (8 /* Jump */ | 16 /* Crouch */)) !== 0) {
+    const ladderSpeed = isAtLeastWaistDeep(waterlevel) ? maxSpeed : DEFAULT_FORWARD_LADDER_CLAMP;
+    adjusted = {
+      ...adjusted,
+      z: buttons & 8 /* Jump */ ? ladderSpeed : -ladderSpeed
+    };
+  } else if (cmd.forwardmove) {
+    const clamped = clamp(cmd.forwardmove, -DEFAULT_FORWARD_LADDER_CLAMP, DEFAULT_FORWARD_LADDER_CLAMP);
+    if (cmd.forwardmove > 0) {
+      const climb = viewPitch < LADDER_ASCEND_PITCH_THRESHOLD ? clamped : -clamped;
+      adjusted = { ...adjusted, z: climb };
+    } else {
+      if (!onGround) {
+        adjusted = { ...adjusted, x: 0, y: 0 };
+      }
+      adjusted = { ...adjusted, z: clamped };
+    }
+  } else {
+    adjusted = { ...adjusted, z: 0 };
+  }
+  if (!onGround) {
+    if (cmd.sidemove) {
+      let sideSpeed = clamp(cmd.sidemove, -DEFAULT_SIDE_LADDER_CLAMP, DEFAULT_SIDE_LADDER_CLAMP);
+      if (waterlevel < 2 /* Waist */) {
+        sideSpeed *= ladderMod;
+      }
+      const flatForward = normalizeVec3({ x: forward.x, y: forward.y, z: 0 });
+      if (flatForward.x !== 0 || flatForward.y !== 0) {
+        const spot = addVec3(origin, scaleVec3(flatForward, LADDER_TRACE_DISTANCE));
+        const tr = trace(origin, spot, mins, maxs);
+        if (tr.fraction !== 1 && !tr.allsolid && tr.contents !== void 0 && (tr.contents & CONTENTS_LADDER) !== 0 && tr.planeNormal) {
+          const right = crossVec3(tr.planeNormal, UP_VECTOR);
+          adjusted = { ...adjusted, x: 0, y: 0 };
+          adjusted = addVec3(adjusted, scaleVec3(right, -sideSpeed));
+        }
+      }
+    } else {
+      adjusted = {
+        ...adjusted,
+        x: clampHorizontal(adjusted.x),
+        y: clampHorizontal(adjusted.y)
+      };
+    }
+  }
+  return adjusted;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function clampHorizontal(value) {
+  if (value < -LADDER_HORIZONTAL_CAP) {
+    return -LADDER_HORIZONTAL_CAP;
+  }
+  if (value > LADDER_HORIZONTAL_CAP) {
+    return LADDER_HORIZONTAL_CAP;
+  }
+  return value;
+}
+
+// src/pmove/slide.ts
+var DEFAULT_MAX_CLIP_PLANES = 5;
+var DEFAULT_MAX_BUMPS = 4;
+var DEFAULT_STEP_SIZE = 18;
+var MIN_STEP_NORMAL = 0.7;
+var SLIDEMOVE_BLOCKED_FLOOR = 1;
+var SLIDEMOVE_BLOCKED_WALL = 2;
+function resolveSlideMove(initialVelocity, planesEncountered, overbounce, maxClipPlanes = DEFAULT_MAX_CLIP_PLANES, primalVelocity = initialVelocity) {
+  if (planesEncountered.length === 0) {
+    return { velocity: initialVelocity, planes: [], stopped: false };
+  }
+  const planes = [];
+  let velocity = initialVelocity;
+  for (const plane of planesEncountered) {
+    if (planes.length >= maxClipPlanes) {
+      return { velocity: ZERO_VEC3, planes, stopped: true };
+    }
+    const duplicate = planes.find((existing) => dotVec3(existing, plane) > 0.99);
+    if (duplicate) {
+      continue;
+    }
+    planes.push(plane);
+    let clipped;
+    let i = 0;
+    for (; i < planes.length; i++) {
+      const candidate = clipVelocityVec3(velocity, planes[i], overbounce);
+      let j = 0;
+      for (; j < planes.length; j++) {
+        if (j === i) continue;
+        if (dotVec3(candidate, planes[j]) < 0) break;
+      }
+      if (j === planes.length) {
+        clipped = candidate;
+        break;
+      }
+    }
+    if (clipped) {
+      velocity = clipped;
+    } else {
+      if (planes.length !== 2) {
+        return { velocity: ZERO_VEC3, planes, stopped: true };
+      }
+      const dir = crossVec3(planes[0], planes[1]);
+      const d = dotVec3(dir, velocity);
+      velocity = scaleVec3(dir, d);
+    }
+    if (dotVec3(velocity, primalVelocity) <= 0) {
+      return { velocity: ZERO_VEC3, planes, stopped: true };
+    }
+  }
+  const stopped = velocity.x === 0 && velocity.y === 0 && velocity.z === 0;
+  return { velocity, planes, stopped };
+}
+function slideMove(params) {
+  const {
+    origin: initialOrigin,
+    velocity: initialVelocity,
+    frametime,
+    overbounce,
+    trace,
     maxBumps = DEFAULT_MAX_BUMPS,
     maxClipPlanes = DEFAULT_MAX_CLIP_PLANES,
     mins,
@@ -2430,250 +2527,45 @@ function stepSlideMove(params) {
   };
 }
 
-// src/pmove/stuck.ts
-var AXES = ["x", "y", "z"];
-var SIDE_CHECKS = [
-  { normal: [0, 0, 1], mins: [-1, -1, 0], maxs: [1, 1, 0] },
-  { normal: [0, 0, -1], mins: [-1, -1, 0], maxs: [1, 1, 0] },
-  { normal: [1, 0, 0], mins: [0, -1, -1], maxs: [0, 1, 1] },
-  { normal: [-1, 0, 0], mins: [0, -1, -1], maxs: [0, 1, 1] },
-  { normal: [0, 1, 0], mins: [-1, 0, -1], maxs: [1, 0, 1] },
-  { normal: [0, -1, 0], mins: [-1, 0, -1], maxs: [1, 0, 1] }
-];
-var ZERO_VEC = { x: 0, y: 0, z: 0 };
-function cloneMutable(vec) {
-  return { x: vec.x, y: vec.y, z: vec.z };
-}
-function tupleToVec3(tuple) {
-  return { x: tuple[0], y: tuple[1], z: tuple[2] };
-}
-function adjustAxis(vec, axis, delta) {
-  if (delta === 0) return;
-  switch (axis) {
-    case "x":
-      vec.x += delta;
-      break;
-    case "y":
-      vec.y += delta;
-      break;
-    case "z":
-      vec.z += delta;
-      break;
-  }
-}
-function setAxis(vec, axis, value) {
-  switch (axis) {
-    case "x":
-      vec.x = value;
-      break;
-    case "y":
-      vec.y = value;
-      break;
-    case "z":
-      vec.z = value;
-      break;
-  }
-}
-function axisValue(vec, axis) {
-  switch (axis) {
-    case "x":
-      return vec.x;
-    case "y":
-      return vec.y;
-    case "z":
-    default:
-      return vec.z;
-  }
-}
-function boundValue(code, axis, mins, maxs) {
-  if (code === -1) {
-    return axisValue(mins, axis);
-  }
-  if (code === 1) {
-    return axisValue(maxs, axis);
-  }
-  return 0;
-}
-function applySideOffset(base, side, mins, maxs) {
-  const result = cloneMutable(base);
-  for (let i = 0; i < AXES.length; i++) {
-    const axis = AXES[i];
-    const normal = side.normal[i];
-    if (normal < 0) {
-      adjustAxis(result, axis, axisValue(mins, axis));
-    } else if (normal > 0) {
-      adjustAxis(result, axis, axisValue(maxs, axis));
-    }
-  }
-  return result;
-}
-function buildSideBounds(side, mins, maxs) {
-  const localMins = cloneMutable(ZERO_VEC);
-  const localMaxs = cloneMutable(ZERO_VEC);
-  for (let i = 0; i < AXES.length; i++) {
-    const axis = AXES[i];
-    setAxis(localMins, axis, boundValue(side.mins[i], axis, mins, maxs));
-    setAxis(localMaxs, axis, boundValue(side.maxs[i], axis, mins, maxs));
-  }
-  return { mins: localMins, maxs: localMaxs };
-}
-function addEpsilon(source, axis, direction) {
-  if (!axis || direction === 0) {
-    return source;
-  }
-  const clone = cloneMutable(source);
-  adjustAxis(clone, axis, direction);
-  return clone;
-}
-function addEpsilonImmutable(vec, axis, direction) {
-  if (!axis || direction === 0) {
-    return vec;
-  }
-  switch (axis) {
-    case "x":
-      return { ...vec, x: vec.x + direction };
-    case "y":
-      return { ...vec, y: vec.y + direction };
-    case "z":
-    default:
-      return { ...vec, z: vec.z + direction };
-  }
-}
-function fixStuckObjectGeneric(params) {
-  const { origin, mins, maxs, trace } = params;
-  const initial = trace(origin, mins, maxs, origin);
-  if (!initial.startsolid) {
-    return { result: "good-position", origin: { ...origin } };
-  }
-  const candidates = [];
-  for (let i = 0; i < SIDE_CHECKS.length; i++) {
-    const side = SIDE_CHECKS[i];
-    const { mins: localMins, maxs: localMaxs } = buildSideBounds(side, mins, maxs);
-    let start = applySideOffset(origin, side, mins, maxs);
-    let tr = trace(start, localMins, localMaxs, start);
-    let epsilonAxis;
-    let epsilonDir = 0;
-    if (tr.startsolid) {
-      for (let axisIndex = 0; axisIndex < AXES.length; axisIndex++) {
-        if (side.normal[axisIndex] !== 0) {
-          continue;
-        }
-        const axis = AXES[axisIndex];
-        let epsilonStart = cloneMutable(start);
-        adjustAxis(epsilonStart, axis, 1);
-        tr = trace(epsilonStart, localMins, localMaxs, epsilonStart);
-        if (!tr.startsolid) {
-          start = epsilonStart;
-          epsilonAxis = axis;
-          epsilonDir = 1;
-          break;
-        }
-        epsilonStart = cloneMutable(start);
-        adjustAxis(epsilonStart, axis, -1);
-        tr = trace(epsilonStart, localMins, localMaxs, epsilonStart);
-        if (!tr.startsolid) {
-          start = epsilonStart;
-          epsilonAxis = axis;
-          epsilonDir = -1;
-          break;
-        }
-      }
-    }
-    if (tr.startsolid) {
-      continue;
-    }
-    const otherSide = SIDE_CHECKS[i ^ 1];
-    let oppositeStart = applySideOffset(origin, otherSide, mins, maxs);
-    oppositeStart = addEpsilon(oppositeStart, epsilonAxis, epsilonDir);
-    tr = trace(start, localMins, localMaxs, oppositeStart);
-    if (tr.startsolid) {
-      continue;
-    }
-    const normal = tupleToVec3(side.normal);
-    const end = addVec3(tr.endpos ?? oppositeStart, scaleVec3(normal, 0.125));
-    const delta = subtractVec3(end, oppositeStart);
-    let newOrigin = addVec3(origin, delta);
-    newOrigin = addEpsilonImmutable(newOrigin, epsilonAxis, epsilonDir);
-    const validation = trace(newOrigin, mins, maxs, newOrigin);
-    if (validation.startsolid) {
-      continue;
-    }
-    candidates.push({ origin: newOrigin, distance: lengthSquaredVec3(delta) });
-  }
-  if (candidates.length === 0) {
-    return { result: "no-good-position", origin: { ...origin } };
-  }
-  candidates.sort((a, b) => a.distance - b.distance);
-  return { result: "fixed", origin: { ...candidates[0].origin } };
-}
-
-// src/pmove/currents.ts
-var DEFAULT_GROUND_CURRENT_SCALE = 100;
-var DEFAULT_FORWARD_LADDER_CLAMP = 200;
-var DEFAULT_SIDE_LADDER_CLAMP = 150;
-var LADDER_HORIZONTAL_CAP = 25;
-var LADDER_ASCEND_PITCH_THRESHOLD = 15;
-var LADDER_TRACE_DISTANCE = 1;
-var UP_VECTOR = { x: 0, y: 0, z: 1 };
-var DEFAULT_TRACE = (_, end) => ({
-  fraction: 1,
-  endpos: end,
-  allsolid: false,
-  startsolid: false
-});
-function currentVectorFromContents(contents) {
-  let x = 0;
-  let y = 0;
-  let z = 0;
-  if (contents & CONTENTS_CURRENT_0) {
-    x += 1;
-  }
-  if (contents & CONTENTS_CURRENT_90) {
-    y += 1;
-  }
-  if (contents & CONTENTS_CURRENT_180) {
-    x -= 1;
-  }
-  if (contents & CONTENTS_CURRENT_270) {
-    y -= 1;
-  }
-  if (contents & CONTENTS_CURRENT_UP) {
-    z += 1;
-  }
-  if (contents & CONTENTS_CURRENT_DOWN) {
-    z -= 1;
-  }
-  if (x === 0 && y === 0 && z === 0) {
-    return ZERO_VEC3;
-  }
-  return { x, y, z };
-}
-function waterCurrentVelocity(params) {
-  const { watertype, waterlevel, onGround, waterSpeed } = params;
-  if ((watertype & MASK_CURRENT) === 0) {
-    return ZERO_VEC3;
-  }
-  const direction = currentVectorFromContents(watertype);
-  if (direction === ZERO_VEC3) {
-    return ZERO_VEC3;
-  }
-  let scale = waterSpeed;
-  if (waterlevel === 1 /* Feet */ && onGround) {
-    scale *= 0.5;
-  }
-  return scaleVec3(direction, scale);
-}
-function groundCurrentVelocity(params) {
-  const { groundContents, scale = DEFAULT_GROUND_CURRENT_SCALE } = params;
-  const direction = currentVectorFromContents(groundContents);
-  if (direction === ZERO_VEC3) {
-    return ZERO_VEC3;
-  }
-  return scaleVec3(direction, scale);
-}
-function applyPmoveAddCurrents(params) {
+// src/pmove/move.ts
+var DEFAULT_AIR_ACCELERATE = 1;
+var WATER_DRIFT_SPEED = 60;
+var DEFAULT_STEP_OVERBOUNCE = 1.01;
+function applyPmoveAirMove(params) {
   const {
-    wishVelocity,
+    origin,
+    frametime,
+    mins,
+    maxs,
+    trace,
+    overbounce = DEFAULT_STEP_OVERBOUNCE,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime,
+    forward,
+    right,
+    cmd,
+    pmFlags,
+    onGround,
+    gravity,
+    pmType,
+    pmAccelerate,
+    pmAirAccelerate = DEFAULT_AIR_ACCELERATE,
+    pmMaxSpeed,
+    pmDuckSpeed,
+    onLadder,
+    waterlevel,
+    watertype,
+    groundContents,
+    viewPitch,
+    ladderMod,
+    pmWaterSpeed
+  } = params;
+  let velocity = { ...params.velocity };
+  let wishvel = buildPlanarWishVelocity(forward, right, cmd);
+  wishvel = applyPmoveAddCurrents({
+    wishVelocity: wishvel,
     onLadder,
     onGround,
     waterlevel,
@@ -2681,223 +2573,354 @@ function applyPmoveAddCurrents(params) {
     groundContents,
     cmd,
     viewPitch,
-    maxSpeed,
+    maxSpeed: hasPmFlag(pmFlags, 1 /* Ducked */) ? pmDuckSpeed : pmMaxSpeed,
     ladderMod,
-    waterSpeed,
+    waterSpeed: pmWaterSpeed,
     forward,
     origin,
     mins,
     maxs,
-    trace = DEFAULT_TRACE
-  } = params;
-  let adjusted = wishVelocity;
+    trace
+  });
+  const ducked = hasPmFlag(pmFlags, 1 /* Ducked */);
+  const maxSpeed = ducked ? pmDuckSpeed : pmMaxSpeed;
+  let wishdir = wishvel;
+  let wishspeed = lengthVec3(wishdir);
+  if (wishspeed !== 0) {
+    wishdir = normalizeVec3(wishdir);
+  }
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+    if (wishspeed !== 0) {
+      wishdir = normalizeVec3(wishvel);
+    }
+  }
   if (onLadder) {
-    adjusted = applyLadderAdjustments({
-      wishVelocity: adjusted,
-      cmd,
-      waterlevel,
-      viewPitch,
-      maxSpeed,
-      ladderMod,
-      onGround,
-      forward,
+    velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmAccelerate, frametime });
+    if (Math.abs(wishvel.z) < Number.EPSILON) {
+      velocity = dampVerticalVelocity(velocity, gravity, frametime);
+    }
+    return runStepSlideMove({
       origin,
+      velocity,
+      frametime,
       mins,
       maxs,
-      trace
+      trace,
+      overbounce,
+      stepSize,
+      maxBumps,
+      maxClipPlanes,
+      hasTime
     });
   }
-  const waterVelocity = waterCurrentVelocity({ watertype, waterlevel, onGround, waterSpeed });
-  if (waterVelocity !== ZERO_VEC3) {
-    adjusted = addVec3(adjusted, waterVelocity);
-  }
   if (onGround) {
-    const groundVelocity = groundCurrentVelocity({ groundContents });
-    if (groundVelocity !== ZERO_VEC3) {
-      adjusted = addVec3(adjusted, groundVelocity);
+    velocity = { ...velocity, z: 0 };
+    velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmAccelerate, frametime });
+    if (gravity > 0) {
+      velocity = { ...velocity, z: 0 };
+    } else {
+      velocity = { ...velocity, z: velocity.z - gravity * frametime };
     }
-  }
-  return adjusted;
-}
-function applyLadderAdjustments(params) {
-  const { wishVelocity, cmd, waterlevel, viewPitch, maxSpeed, ladderMod, onGround, forward, origin, mins, maxs, trace } = params;
-  const buttons = cmd.buttons ?? 0;
-  let adjusted = { ...wishVelocity };
-  if ((buttons & (8 /* Jump */ | 16 /* Crouch */)) !== 0) {
-    const ladderSpeed = isAtLeastWaistDeep(waterlevel) ? maxSpeed : DEFAULT_FORWARD_LADDER_CLAMP;
-    adjusted = {
-      ...adjusted,
-      z: buttons & 8 /* Jump */ ? ladderSpeed : -ladderSpeed
-    };
-  } else if (cmd.forwardmove) {
-    const clamped = clamp(cmd.forwardmove, -DEFAULT_FORWARD_LADDER_CLAMP, DEFAULT_FORWARD_LADDER_CLAMP);
-    if (cmd.forwardmove > 0) {
-      const climb = viewPitch < LADDER_ASCEND_PITCH_THRESHOLD ? clamped : -clamped;
-      adjusted = { ...adjusted, z: climb };
-    } else {
-      if (!onGround) {
-        adjusted = { ...adjusted, x: 0, y: 0 };
-      }
-      adjusted = { ...adjusted, z: clamped };
-    }
-  } else {
-    adjusted = { ...adjusted, z: 0 };
-  }
-  if (!onGround) {
-    if (cmd.sidemove) {
-      let sideSpeed = clamp(cmd.sidemove, -DEFAULT_SIDE_LADDER_CLAMP, DEFAULT_SIDE_LADDER_CLAMP);
-      if (waterlevel < 2 /* Waist */) {
-        sideSpeed *= ladderMod;
-      }
-      const flatForward = normalizeVec3({ x: forward.x, y: forward.y, z: 0 });
-      if (flatForward.x !== 0 || flatForward.y !== 0) {
-        const spot = addVec3(origin, scaleVec3(flatForward, LADDER_TRACE_DISTANCE));
-        const tr = trace(origin, spot, mins, maxs);
-        if (tr.fraction !== 1 && !tr.allsolid && tr.contents !== void 0 && (tr.contents & CONTENTS_LADDER) !== 0 && tr.planeNormal) {
-          const right = crossVec3(tr.planeNormal, UP_VECTOR);
-          adjusted = { ...adjusted, x: 0, y: 0 };
-          adjusted = addVec3(adjusted, scaleVec3(right, -sideSpeed));
-        }
-      }
-    } else {
-      adjusted = {
-        ...adjusted,
-        x: clampHorizontal(adjusted.x),
-        y: clampHorizontal(adjusted.y)
+    if (velocity.x === 0 && velocity.y === 0) {
+      return {
+        origin,
+        velocity,
+        planes: [],
+        blocked: 0,
+        stopped: true,
+        stepped: false,
+        stepHeight: 0
       };
     }
+    return runStepSlideMove({
+      origin,
+      velocity,
+      frametime,
+      mins,
+      maxs,
+      trace,
+      overbounce,
+      stepSize,
+      maxBumps,
+      maxClipPlanes,
+      hasTime
+    });
   }
-  return adjusted;
-}
-function clamp(value, min, max) {
-  return Math.max(min, Math.min(max, value));
-}
-function clampHorizontal(value) {
-  if (value < -LADDER_HORIZONTAL_CAP) {
-    return -LADDER_HORIZONTAL_CAP;
+  if (pmAirAccelerate > 0) {
+    velocity = applyPmoveAirAccelerate({
+      velocity,
+      wishdir,
+      wishspeed,
+      accel: pmAirAccelerate,
+      frametime
+    });
+  } else {
+    velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: DEFAULT_AIR_ACCELERATE, frametime });
   }
-  if (value > LADDER_HORIZONTAL_CAP) {
-    return LADDER_HORIZONTAL_CAP;
+  if (pmType !== 1 /* Grapple */) {
+    velocity = { ...velocity, z: velocity.z - gravity * frametime };
   }
-  return value;
+  return runStepSlideMove({
+    origin,
+    velocity,
+    frametime,
+    mins,
+    maxs,
+    trace,
+    overbounce,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime
+  });
 }
-
-// src/pmove/fly.ts
-var FLY_FRICTION_MULTIPLIER = 1.5;
-var BUTTON_VERTICAL_SCALE = 0.5;
-var DEFAULT_OVERBOUNCE = 1.01;
-function applyPmoveFlyMove(params) {
+function applyPmoveWaterMove(params) {
   const {
     origin,
-    cmd,
     frametime,
-    pmFriction,
-    pmStopSpeed,
-    pmMaxSpeed,
-    pmAccelerate,
-    pmWaterSpeed,
-    doclip,
-    forward,
-    right,
     mins,
     maxs,
     trace,
-    overbounce = DEFAULT_OVERBOUNCE,
+    overbounce = DEFAULT_STEP_OVERBOUNCE,
     stepSize,
     maxBumps,
-    maxClipPlanes
-  } = params;
-  let velocity = applyFlyFriction({ velocity: params.velocity, pmFriction, pmStopSpeed, frametime });
-  const wishdirVelocity = buildFlyWishVelocity({
-    cmd,
+    maxClipPlanes,
+    hasTime,
     forward,
     right,
+    cmd,
+    pmFlags,
+    onGround,
     pmMaxSpeed,
-    pmWaterSpeed
+    pmDuckSpeed,
+    pmWaterAccelerate,
+    pmWaterSpeed,
+    onLadder,
+    watertype,
+    groundContents,
+    waterlevel,
+    viewPitch,
+    ladderMod
+  } = params;
+  let velocity = { ...params.velocity };
+  let wishvel = buildFullWishVelocity(forward, right, cmd);
+  if (isIdleInWater(cmd, onGround)) {
+    wishvel = { ...wishvel, z: wishvel.z - WATER_DRIFT_SPEED };
+  } else {
+    if (hasButton2(cmd, 16 /* Crouch */)) {
+      wishvel = addVec3(wishvel, { x: 0, y: 0, z: -pmWaterSpeed * 0.5 });
+    } else if (hasButton2(cmd, 8 /* Jump */)) {
+      wishvel = addVec3(wishvel, { x: 0, y: 0, z: pmWaterSpeed * 0.5 });
+    }
+  }
+  wishvel = applyPmoveAddCurrents({
+    wishVelocity: wishvel,
+    onLadder,
+    onGround,
+    waterlevel,
+    watertype,
+    groundContents,
+    cmd,
+    viewPitch,
+    maxSpeed: hasPmFlag(pmFlags, 1 /* Ducked */) ? pmDuckSpeed : pmMaxSpeed,
+    ladderMod,
+    waterSpeed: pmWaterSpeed,
+    forward,
+    origin,
+    mins,
+    maxs,
+    trace
   });
-  if (wishdirVelocity.wishspeed > 0) {
-    velocity = applyPmoveAccelerate({
-      velocity,
-      wishdir: wishdirVelocity.wishdir,
-      wishspeed: wishdirVelocity.accelSpeed,
-      accel: pmAccelerate,
-      frametime
-    });
+  let wishdir = wishvel;
+  let wishspeed = lengthVec3(wishdir);
+  if (wishspeed !== 0) {
+    wishdir = normalizeVec3(wishdir);
   }
-  if (!doclip) {
-    const originDelta = scaleVec3(velocity, frametime);
-    const nextOrigin = addVec3(origin, originDelta);
-    return {
-      origin: nextOrigin,
-      velocity,
-      planes: [],
-      blocked: 0,
-      stopped: velocity.x === 0 && velocity.y === 0 && velocity.z === 0,
-      stepped: false,
-      stepHeight: 0
-    };
+  if (wishspeed > pmMaxSpeed) {
+    const scale = pmMaxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = pmMaxSpeed;
+    if (wishspeed !== 0) {
+      wishdir = normalizeVec3(wishvel);
+    }
   }
-  if (!trace || !mins || !maxs) {
-    throw new Error("applyPmoveFlyMove: doclip=true requires trace/mins/maxs");
+  wishspeed *= 0.5;
+  const ducked = hasPmFlag(pmFlags, 1 /* Ducked */);
+  if (ducked && wishspeed > pmDuckSpeed) {
+    const scale = pmDuckSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = pmDuckSpeed;
+    if (wishspeed !== 0) {
+      wishdir = normalizeVec3(wishvel);
+    }
   }
-  return stepSlideMove({
+  velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmWaterAccelerate, frametime });
+  return runStepSlideMove({
     origin,
     velocity,
     frametime,
-    overbounce,
-    trace,
     mins,
     maxs,
+    trace,
+    overbounce,
     stepSize,
     maxBumps,
-    maxClipPlanes
+    maxClipPlanes,
+    hasTime
   });
 }
-function applyFlyFriction(params) {
-  const { velocity, pmFriction, pmStopSpeed, frametime } = params;
-  const speed = lengthVec3(velocity);
-  if (speed < 1) {
-    return { x: 0, y: 0, z: 0 };
-  }
-  const friction = pmFriction * FLY_FRICTION_MULTIPLIER;
-  const control = speed < pmStopSpeed ? pmStopSpeed : speed;
-  const drop = control * friction * frametime;
-  let newspeed = speed - drop;
-  if (newspeed < 0) {
-    newspeed = 0;
-  }
-  if (newspeed === speed) {
-    return velocity;
-  }
-  return scaleVec3(velocity, newspeed / speed);
-}
-function buildFlyWishVelocity(params) {
-  const { cmd, forward, right, pmMaxSpeed, pmWaterSpeed } = params;
-  const forwardNorm = normalizeVec3(forward);
-  const rightNorm = normalizeVec3(right);
-  const wishvel = {
-    x: forwardNorm.x * cmd.forwardmove + rightNorm.x * cmd.sidemove,
-    y: forwardNorm.y * cmd.forwardmove + rightNorm.y * cmd.sidemove,
-    z: forwardNorm.z * cmd.forwardmove + rightNorm.z * cmd.sidemove
-  };
-  let adjusted = wishvel;
-  const buttons = cmd.buttons ?? 0;
-  if (buttons & 8 /* Jump */) {
-    adjusted = addVec3(adjusted, { x: 0, y: 0, z: pmWaterSpeed * BUTTON_VERTICAL_SCALE });
-  }
-  if (buttons & 16 /* Crouch */) {
-    adjusted = addVec3(adjusted, { x: 0, y: 0, z: -pmWaterSpeed * BUTTON_VERTICAL_SCALE });
+function applyPmoveWalkMove(params) {
+  const {
+    origin,
+    frametime,
+    mins,
+    maxs,
+    trace,
+    overbounce = DEFAULT_STEP_OVERBOUNCE,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime,
+    forward,
+    right,
+    cmd,
+    pmFlags,
+    onGround,
+    gravity,
+    pmAccelerate,
+    pmMaxSpeed,
+    pmDuckSpeed,
+    onLadder,
+    waterlevel,
+    watertype,
+    groundContents,
+    viewPitch,
+    ladderMod,
+    pmWaterSpeed
+  } = params;
+  let velocity = { ...params.velocity };
+  let wishvel = buildPlanarWishVelocity(forward, right, cmd);
+  wishvel = applyPmoveAddCurrents({
+    wishVelocity: wishvel,
+    onLadder,
+    onGround,
+    waterlevel,
+    watertype,
+    groundContents,
+    cmd,
+    viewPitch,
+    maxSpeed: hasPmFlag(pmFlags, 1 /* Ducked */) ? pmDuckSpeed : pmMaxSpeed,
+    ladderMod,
+    waterSpeed: pmWaterSpeed,
+    forward,
+    origin,
+    mins,
+    maxs,
+    trace
+  });
+  const ducked = hasPmFlag(pmFlags, 1 /* Ducked */);
+  const maxSpeed = ducked ? pmDuckSpeed : pmMaxSpeed;
+  let wishdir = wishvel;
+  let wishspeed = lengthVec3(wishdir);
+  if (wishspeed !== 0) {
+    wishdir = normalizeVec3(wishdir);
   }
-  let wishspeed = lengthVec3(adjusted);
-  let wishdir = wishspeed === 0 ? { x: 0, y: 0, z: 0 } : normalizeVec3(adjusted);
-  if (wishspeed > pmMaxSpeed) {
-    const scale = pmMaxSpeed / wishspeed;
-    adjusted = scaleVec3(adjusted, scale);
-    wishspeed = pmMaxSpeed;
-    wishdir = wishspeed === 0 ? { x: 0, y: 0, z: 0 } : normalizeVec3(adjusted);
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+    if (wishspeed !== 0) {
+      wishdir = normalizeVec3(wishvel);
+    }
   }
-  const accelSpeed = wishspeed * 2;
-  return { wishdir, wishspeed, accelSpeed };
+  velocity = { ...velocity, z: 0 };
+  velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmAccelerate, frametime });
+  if (gravity > 0) {
+    velocity = { ...velocity, z: 0 };
+  } else {
+    velocity = { ...velocity, z: velocity.z - gravity * frametime };
+  }
+  if (velocity.x === 0 && velocity.y === 0) {
+    return {
+      origin,
+      velocity,
+      planes: [],
+      blocked: 0,
+      stopped: true,
+      stepped: false,
+      stepHeight: 0
+    };
+  }
+  return runStepSlideMove({
+    origin,
+    velocity,
+    frametime,
+    mins,
+    maxs,
+    trace,
+    overbounce,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime
+  });
+}
+function buildPlanarWishVelocity(forward, right, cmd) {
+  return {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+}
+function buildFullWishVelocity(forward, right, cmd) {
+  return {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: forward.z * cmd.forwardmove + right.z * cmd.sidemove
+  };
+}
+function hasButton2(cmd, button) {
+  return (cmd.buttons ?? 0) & button ? true : false;
+}
+function isIdleInWater(cmd, onGround) {
+  const noMove = cmd.forwardmove === 0 && cmd.sidemove === 0;
+  const noButtons = (cmd.buttons ?? 0) & (8 /* Jump */ | 16 /* Crouch */) ? false : true;
+  return noMove && noButtons && !onGround;
+}
+function dampVerticalVelocity(velocity, gravity, frametime) {
+  let z = velocity.z;
+  const delta = gravity * frametime;
+  if (z > 0) {
+    z -= delta;
+    if (z < 0) {
+      z = 0;
+    }
+  } else {
+    z += delta;
+    if (z > 0) {
+      z = 0;
+    }
+  }
+  return { ...velocity, z };
+}
+function runStepSlideMove(params) {
+  const { origin, velocity, frametime, mins, maxs, trace, overbounce = DEFAULT_STEP_OVERBOUNCE, stepSize, maxBumps, maxClipPlanes, hasTime } = params;
+  return stepSlideMove({
+    origin,
+    velocity,
+    frametime,
+    trace,
+    mins,
+    maxs,
+    overbounce,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime
+  });
 }
 
 // src/pmove/water.ts
@@ -2929,184 +2952,23 @@ function getWaterLevel(params) {
   return { waterlevel, watertype };
 }
 
-// src/pmove/jump.ts
-var DEFAULT_JUMP_HEIGHT = 270;
-function hasButton(buttons, button) {
-  return (buttons & button) !== 0;
-}
-function checkJump(params) {
-  const { pmFlags, pmType, buttons, waterlevel, onGround, velocity, jumpHeight = DEFAULT_JUMP_HEIGHT } = params;
-  if (pmFlags & 16 /* TimeLand */) {
-    return { pmFlags, onGround, velocity, jumpSound: false, jumped: false };
-  }
-  const holdingJump = hasButton(buttons, 8 /* Jump */);
-  let nextFlags = pmFlags;
-  let nextOnGround = onGround;
-  let jumpSound = false;
-  let jumped = false;
-  let nextVelocity = velocity;
-  if (!holdingJump) {
-    nextFlags = removePmFlag(nextFlags, 2 /* JumpHeld */);
-    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
-  }
-  if (hasPmJumpHold(nextFlags)) {
-    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
-  }
-  if (pmType === 4 /* Dead */) {
-    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
-  }
-  if (waterlevel >= 2 /* Waist */) {
-    nextOnGround = false;
-    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
-  }
-  if (!nextOnGround) {
-    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
-  }
-  nextFlags = addPmFlag(nextFlags, 2 /* JumpHeld */);
-  nextFlags = removePmFlag(nextFlags, 4 /* OnGround */);
-  nextOnGround = false;
-  jumpSound = true;
-  jumped = true;
-  const z = velocity.z + jumpHeight;
-  const finalZ = z < jumpHeight ? jumpHeight : z;
-  nextVelocity = { ...velocity, z: finalZ };
-  return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
-}
-function hasPmJumpHold(flags) {
-  return (flags & 2 /* JumpHeld */) !== 0;
-}
-
-// src/pmove/dimensions.ts
-function createVec3(x, y, z) {
-  return { x, y, z };
-}
-function computePlayerDimensions(pmType, pmFlags) {
-  const minsBase = createVec3(-16, -16, 0);
-  const maxsBase = createVec3(16, 16, 16);
-  if (pmType === 5 /* Gib */) {
-    return {
-      mins: minsBase,
-      maxs: maxsBase,
-      viewheight: 8
-    };
-  }
-  const ducked = pmType === 4 /* Dead */ || (pmFlags & 1 /* Ducked */) !== 0;
-  const mins = createVec3(minsBase.x, minsBase.y, -24);
-  const maxs = createVec3(maxsBase.x, maxsBase.y, ducked ? 4 : 32);
-  return {
-    mins,
-    maxs,
-    viewheight: ducked ? -2 : 22
-  };
-}
-
-// src/pmove/duck.ts
-var CROUCH_MAX_Z = 4;
-var STAND_MAX_Z = 32;
-var ABOVE_WATER_OFFSET = 8;
-function checkDuckState(params) {
-  const { pmType } = params;
-  if (pmType === 5 /* Gib */) {
-    const dims2 = computePlayerDimensions(pmType, params.pmFlags);
-    return { pmFlags: params.pmFlags, ducked: hasPmFlag(params.pmFlags, 1 /* Ducked */), changed: false, ...dims2 };
-  }
-  let flags = params.pmFlags;
-  let changed = false;
-  if (pmType === 4 /* Dead */) {
-    if (!hasPmFlag(flags, 1 /* Ducked */)) {
-      flags = addPmFlag(flags, 1 /* Ducked */);
-      changed = true;
-    }
-  } else if (shouldDuck(params)) {
-    if (!hasPmFlag(flags, 1 /* Ducked */) && !isDuckBlocked(params)) {
-      flags = addPmFlag(flags, 1 /* Ducked */);
-      changed = true;
-    }
-  } else if (hasPmFlag(flags, 1 /* Ducked */) && !isStandBlocked(params)) {
-    flags = removePmFlag(flags, 1 /* Ducked */);
-    changed = true;
-  }
-  const dims = computePlayerDimensions(pmType, flags);
-  const ducked = pmType === 4 /* Dead */ || hasPmFlag(flags, 1 /* Ducked */);
-  return { pmFlags: flags, ducked, changed, ...dims };
-}
-function shouldDuck(params) {
-  if ((params.buttons & 16 /* Crouch */) === 0) {
-    return false;
-  }
-  if (params.onLadder || params.n64Physics) {
-    return false;
-  }
-  if (params.hasGroundEntity) {
-    return true;
-  }
-  if (params.waterlevel <= 1 /* Feet */ && !isAboveWater(params)) {
-    return true;
-  }
-  return false;
-}
-function isDuckBlocked(params) {
-  const trace = params.trace({
-    start: params.origin,
-    end: params.origin,
-    mins: params.mins,
-    maxs: withZ(params.maxs, CROUCH_MAX_Z),
-    mask: MASK_SOLID
-  });
-  return trace.allsolid;
-}
-function isStandBlocked(params) {
-  const trace = params.trace({
-    start: params.origin,
-    end: params.origin,
-    mins: params.mins,
-    maxs: withZ(params.maxs, STAND_MAX_Z),
-    mask: MASK_SOLID
-  });
-  return trace.allsolid;
-}
-function isAboveWater(params) {
-  const below = { x: params.origin.x, y: params.origin.y, z: params.origin.z - ABOVE_WATER_OFFSET };
-  const solidTrace = params.trace({
-    start: params.origin,
-    end: below,
-    mins: params.mins,
-    maxs: params.maxs,
-    mask: MASK_SOLID
-  });
-  if (solidTrace.fraction < 1) {
-    return false;
-  }
-  const waterTrace = params.trace({
-    start: params.origin,
-    end: below,
-    mins: params.mins,
-    maxs: params.maxs,
-    mask: MASK_WATER
-  });
-  return waterTrace.fraction < 1;
-}
-function withZ(vec, z) {
-  return { x: vec.x, y: vec.y, z };
-}
-
-// src/pmove/categorize.ts
-var GROUND_PROBE_DISTANCE = 0.25;
-var LADDER_BYPASS_VELOCITY = 180;
-var TRICK_VELOCITY_THRESHOLD = 100;
-var SLANTED_NORMAL_THRESHOLD = 0.7;
-var TRICK_NORMAL_THRESHOLD = 0.9;
-var TRICK_PM_TIME = 64;
-var LAND_PM_TIME = 128;
-var IMPACT_CLIP_OVERBOUNCE = 1.01;
-var WATERJUMP_CLEAR = 8 /* TimeWaterJump */ | 16 /* TimeLand */ | 32 /* TimeTeleport */ | 1024 /* TimeTrick */;
-function categorizePosition(params) {
-  const {
-    pmType,
-    n64Physics,
-    velocity,
-    startVelocity,
-    origin,
+// src/pmove/categorize.ts
+var GROUND_PROBE_DISTANCE = 0.25;
+var LADDER_BYPASS_VELOCITY = 180;
+var TRICK_VELOCITY_THRESHOLD = 100;
+var SLANTED_NORMAL_THRESHOLD = 0.7;
+var TRICK_NORMAL_THRESHOLD = 0.9;
+var TRICK_PM_TIME = 64;
+var LAND_PM_TIME = 128;
+var IMPACT_CLIP_OVERBOUNCE = 1.01;
+var WATERJUMP_CLEAR = 8 /* TimeWaterJump */ | 16 /* TimeLand */ | 32 /* TimeTeleport */ | 1024 /* TimeTrick */;
+function categorizePosition(params) {
+  const {
+    pmType,
+    n64Physics,
+    velocity,
+    startVelocity,
+    origin,
     mins,
     maxs,
     viewheight,
@@ -3180,304 +3042,744 @@ function categorizePosition(params) {
   };
 }
 
-// src/pmove/move.ts
-var DEFAULT_AIR_ACCELERATE = 1;
-var WATER_DRIFT_SPEED = 60;
-var DEFAULT_STEP_OVERBOUNCE = 1.01;
-function applyPmoveAirMove(params) {
-  const {
-    origin,
-    frametime,
-    mins,
-    maxs,
-    trace,
-    overbounce = DEFAULT_STEP_OVERBOUNCE,
-    stepSize,
-    maxBumps,
-    maxClipPlanes,
-    hasTime,
-    forward,
-    right,
-    cmd,
-    pmFlags,
-    onGround,
-    gravity,
-    pmType,
-    pmAccelerate,
-    pmAirAccelerate = DEFAULT_AIR_ACCELERATE,
-    pmMaxSpeed,
-    pmDuckSpeed,
-    onLadder,
-    waterlevel,
-    watertype,
-    groundContents,
-    viewPitch,
-    ladderMod,
-    pmWaterSpeed
-  } = params;
-  let velocity = { ...params.velocity };
-  let wishvel = buildPlanarWishVelocity(forward, right, cmd);
-  wishvel = applyPmoveAddCurrents({
-    wishVelocity: wishvel,
-    onLadder,
-    onGround,
-    waterlevel,
-    watertype,
-    groundContents,
-    cmd,
-    viewPitch,
-    maxSpeed: hasPmFlag(pmFlags, 1 /* Ducked */) ? pmDuckSpeed : pmMaxSpeed,
-    ladderMod,
-    waterSpeed: pmWaterSpeed,
-    forward,
-    origin,
+// src/pmove/dimensions.ts
+function createVec3(x, y, z) {
+  return { x, y, z };
+}
+function computePlayerDimensions(pmType, pmFlags) {
+  const minsBase = createVec3(-16, -16, 0);
+  const maxsBase = createVec3(16, 16, 16);
+  if (pmType === 5 /* Gib */) {
+    return {
+      mins: minsBase,
+      maxs: maxsBase,
+      viewheight: 8
+    };
+  }
+  const ducked = pmType === 4 /* Dead */ || (pmFlags & 1 /* Ducked */) !== 0;
+  const mins = createVec3(minsBase.x, minsBase.y, -24);
+  const maxs = createVec3(maxsBase.x, maxsBase.y, ducked ? 4 : 32);
+  return {
     mins,
     maxs,
-    trace
-  });
-  const ducked = hasPmFlag(pmFlags, 1 /* Ducked */);
-  const maxSpeed = ducked ? pmDuckSpeed : pmMaxSpeed;
-  let wishdir = wishvel;
-  let wishspeed = lengthVec3(wishdir);
-  if (wishspeed !== 0) {
-    wishdir = normalizeVec3(wishdir);
+    viewheight: ducked ? -2 : 22
+  };
+}
+
+// src/pmove/duck.ts
+var CROUCH_MAX_Z = 4;
+var STAND_MAX_Z = 32;
+var ABOVE_WATER_OFFSET = 8;
+function checkDuckState(params) {
+  const { pmType } = params;
+  if (pmType === 5 /* Gib */) {
+    const dims2 = computePlayerDimensions(pmType, params.pmFlags);
+    return { pmFlags: params.pmFlags, ducked: hasPmFlag(params.pmFlags, 1 /* Ducked */), changed: false, ...dims2 };
   }
-  if (wishspeed > maxSpeed) {
-    const scale = maxSpeed / wishspeed;
-    wishvel = scaleVec3(wishvel, scale);
-    wishspeed = maxSpeed;
-    if (wishspeed !== 0) {
-      wishdir = normalizeVec3(wishvel);
+  let flags = params.pmFlags;
+  let changed = false;
+  if (pmType === 4 /* Dead */) {
+    if (!hasPmFlag(flags, 1 /* Ducked */)) {
+      flags = addPmFlag(flags, 1 /* Ducked */);
+      changed = true;
     }
-  }
-  if (onLadder) {
-    velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmAccelerate, frametime });
-    if (Math.abs(wishvel.z) < Number.EPSILON) {
-      velocity = dampVerticalVelocity(velocity, gravity, frametime);
+  } else if (shouldDuck(params)) {
+    if (!hasPmFlag(flags, 1 /* Ducked */) && !isDuckBlocked(params)) {
+      flags = addPmFlag(flags, 1 /* Ducked */);
+      changed = true;
     }
-    return runStepSlideMove({
-      origin,
-      velocity,
-      frametime,
-      mins,
-      maxs,
-      trace,
-      overbounce,
-      stepSize,
-      maxBumps,
-      maxClipPlanes,
-      hasTime
-    });
+  } else if (hasPmFlag(flags, 1 /* Ducked */) && !isStandBlocked(params)) {
+    flags = removePmFlag(flags, 1 /* Ducked */);
+    changed = true;
   }
-  if (onGround) {
-    velocity = { ...velocity, z: 0 };
-    velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmAccelerate, frametime });
-    if (gravity > 0) {
-      velocity = { ...velocity, z: 0 };
-    } else {
-      velocity = { ...velocity, z: velocity.z - gravity * frametime };
-    }
-    if (velocity.x === 0 && velocity.y === 0) {
-      return {
-        origin,
-        velocity,
-        planes: [],
-        blocked: 0,
-        stopped: true,
-        stepped: false,
-        stepHeight: 0
-      };
-    }
-    return runStepSlideMove({
-      origin,
-      velocity,
-      frametime,
-      mins,
-      maxs,
-      trace,
-      overbounce,
-      stepSize,
-      maxBumps,
-      maxClipPlanes,
-      hasTime
-    });
+  const dims = computePlayerDimensions(pmType, flags);
+  const ducked = pmType === 4 /* Dead */ || hasPmFlag(flags, 1 /* Ducked */);
+  return { pmFlags: flags, ducked, changed, ...dims };
+}
+function shouldDuck(params) {
+  if ((params.buttons & 16 /* Crouch */) === 0) {
+    return false;
   }
-  if (pmAirAccelerate > 0) {
-    velocity = applyPmoveAirAccelerate({
-      velocity,
-      wishdir,
-      wishspeed,
-      accel: pmAirAccelerate,
-      frametime
-    });
+  if (params.onLadder || params.n64Physics) {
+    return false;
+  }
+  if (params.hasGroundEntity) {
+    return true;
+  }
+  if (params.waterlevel <= 1 /* Feet */ && !isAboveWater(params)) {
+    return true;
+  }
+  return false;
+}
+function isDuckBlocked(params) {
+  const trace = params.trace({
+    start: params.origin,
+    end: params.origin,
+    mins: params.mins,
+    maxs: withZ(params.maxs, CROUCH_MAX_Z),
+    mask: MASK_SOLID
+  });
+  return trace.allsolid;
+}
+function isStandBlocked(params) {
+  const trace = params.trace({
+    start: params.origin,
+    end: params.origin,
+    mins: params.mins,
+    maxs: withZ(params.maxs, STAND_MAX_Z),
+    mask: MASK_SOLID
+  });
+  return trace.allsolid;
+}
+function isAboveWater(params) {
+  const below = { x: params.origin.x, y: params.origin.y, z: params.origin.z - ABOVE_WATER_OFFSET };
+  const solidTrace = params.trace({
+    start: params.origin,
+    end: below,
+    mins: params.mins,
+    maxs: params.maxs,
+    mask: MASK_SOLID
+  });
+  if (solidTrace.fraction < 1) {
+    return false;
+  }
+  const waterTrace = params.trace({
+    start: params.origin,
+    end: below,
+    mins: params.mins,
+    maxs: params.maxs,
+    mask: MASK_WATER
+  });
+  return waterTrace.fraction < 1;
+}
+function withZ(vec, z) {
+  return { x: vec.x, y: vec.y, z };
+}
+
+// src/pmove/pmove.ts
+var FRAMETIME = 0.025;
+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 pmoveCmdScale(cmd, maxSpeed) {
+  const forward = Math.abs(cmd.forwardmove);
+  const side = Math.abs(cmd.sidemove);
+  const up = Math.abs(cmd.upmove);
+  const max = Math.max(forward, side, up);
+  if (max === 0) {
+    return 0;
+  }
+  const total = Math.sqrt(cmd.forwardmove * cmd.forwardmove + cmd.sidemove * cmd.sidemove + cmd.upmove * cmd.upmove);
+  return maxSpeed * max / (127 * total);
+}
+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: forward.z * cmd.forwardmove + right.z * cmd.sidemove
+  };
+  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 if (Math.abs(cmd.forwardmove) < 10 && Math.abs(cmd.sidemove) < 10) {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: -60 });
   } else {
-    velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: DEFAULT_AIR_ACCELERATE, frametime });
+    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
+  };
+}
+function runPmove(state, imports) {
+  if (state.pmType === 4 /* Dead */) {
+    return state;
+  }
+  let nextState = { ...state };
+  const catResult = categorizePosition({
+    pmType: nextState.pmType,
+    pmFlags: nextState.pmFlags,
+    pmTime: 0,
+    n64Physics: false,
+    velocity: nextState.velocity,
+    startVelocity: nextState.velocity,
+    origin: nextState.origin,
+    mins: nextState.mins,
+    maxs: nextState.maxs,
+    viewheight: nextState.viewHeight,
+    trace: imports.trace,
+    pointContents: imports.pointcontents
+  });
+  nextState.pmFlags = catResult.pmFlags;
+  nextState.waterlevel = catResult.waterlevel;
+  nextState.watertype = catResult.watertype;
+  const duckResult = checkDuckState({
+    pmType: nextState.pmType,
+    pmFlags: nextState.pmFlags,
+    buttons: nextState.cmd.buttons,
+    waterlevel: nextState.waterlevel,
+    hasGroundEntity: (nextState.pmFlags & 4 /* OnGround */) !== 0,
+    onLadder: false,
+    n64Physics: false,
+    origin: nextState.origin,
+    mins: nextState.mins,
+    maxs: nextState.maxs,
+    trace: (params) => {
+      return imports.trace(params.start, params.end, params.mins, params.maxs);
+    }
+  });
+  nextState.pmFlags = duckResult.pmFlags;
+  nextState.mins = duckResult.mins;
+  nextState.maxs = duckResult.maxs;
+  nextState.viewHeight = duckResult.viewheight;
+  const jumpResult = checkJump({
+    pmFlags: nextState.pmFlags,
+    pmType: nextState.pmType,
+    buttons: nextState.cmd.buttons,
+    waterlevel: nextState.waterlevel,
+    onGround: (nextState.pmFlags & 4 /* OnGround */) !== 0,
+    velocity: nextState.velocity,
+    origin: nextState.origin
+  });
+  nextState.pmFlags = jumpResult.pmFlags;
+  nextState.velocity = jumpResult.velocity;
+  nextState.origin = jumpResult.origin;
+  if (jumpResult.onGround !== ((nextState.pmFlags & 4 /* OnGround */) !== 0)) {
+    if (jumpResult.onGround) {
+      nextState.pmFlags = addPmFlag(nextState.pmFlags, 4 /* OnGround */);
+    } else {
+      nextState.pmFlags = removePmFlag(nextState.pmFlags, 4 /* OnGround */);
+    }
+  }
+  const onGround = (nextState.pmFlags & 4 /* OnGround */) !== 0;
+  const velocityBeforeFriction = nextState.velocity;
+  nextState.velocity = applyPmoveFriction({
+    velocity: nextState.velocity,
+    frametime: FRAMETIME,
+    onGround,
+    groundIsSlick: false,
+    onLadder: false,
+    // Defaulting to false for now as ladder logic is complex
+    waterlevel: nextState.waterlevel,
+    pmFriction: 6,
+    // Default
+    pmStopSpeed: 100,
+    // Default
+    pmWaterFriction: 1
+    // Default
+  });
+  const { forward, right } = angleVectors(nextState.viewAngles);
+  if (nextState.pmType === 2 /* NoClip */) {
+    const wishvel = {
+      x: forward.x * nextState.cmd.forwardmove + right.x * nextState.cmd.sidemove,
+      y: forward.y * nextState.cmd.forwardmove + right.y * nextState.cmd.sidemove,
+      z: nextState.cmd.upmove
+    };
+    const scale = FRAMETIME;
+    nextState.velocity = wishvel;
+    nextState.origin = {
+      x: nextState.origin.x + wishvel.x * scale,
+      y: nextState.origin.y + wishvel.y * scale,
+      z: nextState.origin.z + wishvel.z * scale
+    };
+  } else if (nextState.waterlevel >= 2) {
+    const outcome = applyPmoveWaterMove({
+      origin: nextState.origin,
+      velocity: nextState.velocity,
+      frametime: FRAMETIME,
+      mins: nextState.mins,
+      maxs: nextState.maxs,
+      trace: imports.trace,
+      cmd: nextState.cmd,
+      forward,
+      right,
+      pmFlags: nextState.pmFlags,
+      onGround,
+      pmMaxSpeed: 300,
+      pmDuckSpeed: 100,
+      pmWaterAccelerate: 4,
+      pmWaterSpeed: 400,
+      onLadder: false,
+      watertype: nextState.watertype,
+      groundContents: 0,
+      // Should be passed in?
+      waterlevel: nextState.waterlevel,
+      viewPitch: nextState.viewAngles.x,
+      ladderMod: 1,
+      stepSize: 18
+      // Added stepSize for consistency, though water move might not use it heavily
+    });
+    nextState.origin = outcome.origin;
+    nextState.velocity = outcome.velocity;
+  } else if ((nextState.pmFlags & 4 /* OnGround */) === 0) {
+    const outcome = applyPmoveAirMove({
+      origin: nextState.origin,
+      velocity: nextState.velocity,
+      frametime: FRAMETIME,
+      mins: nextState.mins,
+      maxs: nextState.maxs,
+      trace: imports.trace,
+      cmd: nextState.cmd,
+      forward,
+      right,
+      pmFlags: nextState.pmFlags,
+      onGround,
+      gravity: nextState.gravity,
+      pmType: nextState.pmType,
+      pmAccelerate: 10,
+      pmAirAccelerate: 1,
+      pmMaxSpeed: 300,
+      pmDuckSpeed: 100,
+      onLadder: false,
+      waterlevel: nextState.waterlevel,
+      watertype: nextState.watertype,
+      groundContents: 0,
+      viewPitch: nextState.viewAngles.x,
+      ladderMod: 1,
+      pmWaterSpeed: 400,
+      stepSize: 18
+      // Added stepSize
+    });
+    nextState.origin = outcome.origin;
+    nextState.velocity = outcome.velocity;
+  } else {
+    const outcome = applyPmoveWalkMove({
+      origin: nextState.origin,
+      velocity: nextState.velocity,
+      frametime: FRAMETIME,
+      mins: nextState.mins,
+      maxs: nextState.maxs,
+      trace: imports.trace,
+      cmd: nextState.cmd,
+      forward,
+      right,
+      pmFlags: nextState.pmFlags,
+      onGround,
+      gravity: nextState.gravity,
+      pmType: nextState.pmType,
+      pmAccelerate: 10,
+      pmMaxSpeed: 300,
+      pmDuckSpeed: 100,
+      onLadder: false,
+      waterlevel: nextState.waterlevel,
+      watertype: nextState.watertype,
+      groundContents: 0,
+      viewPitch: nextState.viewAngles.x,
+      ladderMod: 1,
+      pmWaterSpeed: 400,
+      stepSize: 18
+      // Added stepSize
+    });
+    nextState.origin = outcome.origin;
+    nextState.velocity = outcome.velocity;
+  }
+  const catResultEnd = categorizePosition({
+    pmType: nextState.pmType,
+    pmFlags: nextState.pmFlags,
+    pmTime: 0,
+    n64Physics: false,
+    velocity: nextState.velocity,
+    startVelocity: nextState.velocity,
+    origin: nextState.origin,
+    mins: nextState.mins,
+    maxs: nextState.maxs,
+    viewheight: nextState.viewHeight,
+    trace: imports.trace,
+    pointContents: imports.pointcontents
+  });
+  nextState.pmFlags = catResultEnd.pmFlags;
+  nextState.waterlevel = catResultEnd.waterlevel;
+  nextState.watertype = catResultEnd.watertype;
+  return nextState;
+}
+
+// src/pmove/stuck.ts
+var AXES = ["x", "y", "z"];
+var SIDE_CHECKS = [
+  { normal: [0, 0, 1], mins: [-1, -1, 0], maxs: [1, 1, 0] },
+  { normal: [0, 0, -1], mins: [-1, -1, 0], maxs: [1, 1, 0] },
+  { normal: [1, 0, 0], mins: [0, -1, -1], maxs: [0, 1, 1] },
+  { normal: [-1, 0, 0], mins: [0, -1, -1], maxs: [0, 1, 1] },
+  { normal: [0, 1, 0], mins: [-1, 0, -1], maxs: [1, 0, 1] },
+  { normal: [0, -1, 0], mins: [-1, 0, -1], maxs: [1, 0, 1] }
+];
+var ZERO_VEC = { x: 0, y: 0, z: 0 };
+function cloneMutable(vec) {
+  return { x: vec.x, y: vec.y, z: vec.z };
+}
+function tupleToVec3(tuple) {
+  return { x: tuple[0], y: tuple[1], z: tuple[2] };
+}
+function adjustAxis(vec, axis, delta) {
+  if (delta === 0) return;
+  switch (axis) {
+    case "x":
+      vec.x += delta;
+      break;
+    case "y":
+      vec.y += delta;
+      break;
+    case "z":
+      vec.z += delta;
+      break;
+  }
+}
+function setAxis(vec, axis, value) {
+  switch (axis) {
+    case "x":
+      vec.x = value;
+      break;
+    case "y":
+      vec.y = value;
+      break;
+    case "z":
+      vec.z = value;
+      break;
+  }
+}
+function axisValue(vec, axis) {
+  switch (axis) {
+    case "x":
+      return vec.x;
+    case "y":
+      return vec.y;
+    case "z":
+    default:
+      return vec.z;
+  }
+}
+function boundValue(code, axis, mins, maxs) {
+  if (code === -1) {
+    return axisValue(mins, axis);
+  }
+  if (code === 1) {
+    return axisValue(maxs, axis);
+  }
+  return 0;
+}
+function applySideOffset(base, side, mins, maxs) {
+  const result = cloneMutable(base);
+  for (let i = 0; i < AXES.length; i++) {
+    const axis = AXES[i];
+    const normal = side.normal[i];
+    if (normal < 0) {
+      adjustAxis(result, axis, axisValue(mins, axis));
+    } else if (normal > 0) {
+      adjustAxis(result, axis, axisValue(maxs, axis));
+    }
+  }
+  return result;
+}
+function buildSideBounds(side, mins, maxs) {
+  const localMins = cloneMutable(ZERO_VEC);
+  const localMaxs = cloneMutable(ZERO_VEC);
+  for (let i = 0; i < AXES.length; i++) {
+    const axis = AXES[i];
+    setAxis(localMins, axis, boundValue(side.mins[i], axis, mins, maxs));
+    setAxis(localMaxs, axis, boundValue(side.maxs[i], axis, mins, maxs));
+  }
+  return { mins: localMins, maxs: localMaxs };
+}
+function addEpsilon(source, axis, direction) {
+  if (!axis || direction === 0) {
+    return source;
+  }
+  const clone = cloneMutable(source);
+  adjustAxis(clone, axis, direction);
+  return clone;
+}
+function addEpsilonImmutable(vec, axis, direction) {
+  if (!axis || direction === 0) {
+    return vec;
+  }
+  switch (axis) {
+    case "x":
+      return { ...vec, x: vec.x + direction };
+    case "y":
+      return { ...vec, y: vec.y + direction };
+    case "z":
+    default:
+      return { ...vec, z: vec.z + direction };
+  }
+}
+function fixStuckObjectGeneric(params) {
+  const { origin, mins, maxs, trace } = params;
+  const initial = trace(origin, mins, maxs, origin);
+  if (!initial.startsolid) {
+    return { result: "good-position", origin: { ...origin } };
+  }
+  const candidates = [];
+  for (let i = 0; i < SIDE_CHECKS.length; i++) {
+    const side = SIDE_CHECKS[i];
+    const { mins: localMins, maxs: localMaxs } = buildSideBounds(side, mins, maxs);
+    let start = applySideOffset(origin, side, mins, maxs);
+    let tr = trace(start, localMins, localMaxs, start);
+    let epsilonAxis;
+    let epsilonDir = 0;
+    if (tr.startsolid) {
+      for (let axisIndex = 0; axisIndex < AXES.length; axisIndex++) {
+        if (side.normal[axisIndex] !== 0) {
+          continue;
+        }
+        const axis = AXES[axisIndex];
+        let epsilonStart = cloneMutable(start);
+        adjustAxis(epsilonStart, axis, 1);
+        tr = trace(epsilonStart, localMins, localMaxs, epsilonStart);
+        if (!tr.startsolid) {
+          start = epsilonStart;
+          epsilonAxis = axis;
+          epsilonDir = 1;
+          break;
+        }
+        epsilonStart = cloneMutable(start);
+        adjustAxis(epsilonStart, axis, -1);
+        tr = trace(epsilonStart, localMins, localMaxs, epsilonStart);
+        if (!tr.startsolid) {
+          start = epsilonStart;
+          epsilonAxis = axis;
+          epsilonDir = -1;
+          break;
+        }
+      }
+    }
+    if (tr.startsolid) {
+      continue;
+    }
+    const otherSide = SIDE_CHECKS[i ^ 1];
+    let oppositeStart = applySideOffset(origin, otherSide, mins, maxs);
+    oppositeStart = addEpsilon(oppositeStart, epsilonAxis, epsilonDir);
+    tr = trace(start, localMins, localMaxs, oppositeStart);
+    if (tr.startsolid) {
+      continue;
+    }
+    const normal = tupleToVec3(side.normal);
+    const end = addVec3(tr.endpos ?? oppositeStart, scaleVec3(normal, 0.125));
+    const delta = subtractVec3(end, oppositeStart);
+    let newOrigin = addVec3(origin, delta);
+    newOrigin = addEpsilonImmutable(newOrigin, epsilonAxis, epsilonDir);
+    const validation = trace(newOrigin, mins, maxs, newOrigin);
+    if (validation.startsolid) {
+      continue;
+    }
+    candidates.push({ origin: newOrigin, distance: lengthSquaredVec3(delta) });
   }
-  if (pmType !== 1 /* Grapple */) {
-    velocity = { ...velocity, z: velocity.z - gravity * frametime };
+  if (candidates.length === 0) {
+    return { result: "no-good-position", origin: { ...origin } };
   }
-  return runStepSlideMove({
-    origin,
-    velocity,
-    frametime,
-    mins,
-    maxs,
-    trace,
-    overbounce,
-    stepSize,
-    maxBumps,
-    maxClipPlanes,
-    hasTime
-  });
+  candidates.sort((a, b) => a.distance - b.distance);
+  return { result: "fixed", origin: { ...candidates[0].origin } };
 }
-function applyPmoveWaterMove(params) {
+
+// src/pmove/fly.ts
+var FLY_FRICTION_MULTIPLIER = 1.5;
+var BUTTON_VERTICAL_SCALE = 0.5;
+var DEFAULT_OVERBOUNCE = 1.01;
+function applyPmoveFlyMove(params) {
   const {
     origin,
+    cmd,
     frametime,
+    pmFriction,
+    pmStopSpeed,
+    pmMaxSpeed,
+    pmAccelerate,
+    pmWaterSpeed,
+    doclip,
+    forward,
+    right,
     mins,
     maxs,
     trace,
-    overbounce = DEFAULT_STEP_OVERBOUNCE,
+    overbounce = DEFAULT_OVERBOUNCE,
     stepSize,
     maxBumps,
-    maxClipPlanes,
-    hasTime,
-    forward,
-    right,
-    cmd,
-    pmFlags,
-    onGround,
-    pmMaxSpeed,
-    pmDuckSpeed,
-    pmWaterAccelerate,
-    pmWaterSpeed,
-    onLadder,
-    watertype,
-    groundContents,
-    waterlevel,
-    viewPitch,
-    ladderMod
+    maxClipPlanes
   } = params;
-  let velocity = { ...params.velocity };
-  let wishvel = buildFullWishVelocity(forward, right, cmd);
-  if (isIdleInWater(cmd, onGround)) {
-    wishvel = { ...wishvel, z: wishvel.z - WATER_DRIFT_SPEED };
-  } else {
-    if (hasButton2(cmd, 16 /* Crouch */)) {
-      wishvel = addVec3(wishvel, { x: 0, y: 0, z: -pmWaterSpeed * 0.5 });
-    } else if (hasButton2(cmd, 8 /* Jump */)) {
-      wishvel = addVec3(wishvel, { x: 0, y: 0, z: pmWaterSpeed * 0.5 });
-    }
-  }
-  wishvel = applyPmoveAddCurrents({
-    wishVelocity: wishvel,
-    onLadder,
-    onGround,
-    waterlevel,
-    watertype,
-    groundContents,
+  let velocity = applyFlyFriction({ velocity: params.velocity, pmFriction, pmStopSpeed, frametime });
+  const wishdirVelocity = buildFlyWishVelocity({
     cmd,
-    viewPitch,
-    maxSpeed: hasPmFlag(pmFlags, 1 /* Ducked */) ? pmDuckSpeed : pmMaxSpeed,
-    ladderMod,
-    waterSpeed: pmWaterSpeed,
     forward,
-    origin,
-    mins,
-    maxs,
-    trace
+    right,
+    pmMaxSpeed,
+    pmWaterSpeed
   });
-  let wishdir = wishvel;
-  let wishspeed = lengthVec3(wishdir);
-  if (wishspeed !== 0) {
-    wishdir = normalizeVec3(wishdir);
+  if (wishdirVelocity.wishspeed > 0) {
+    velocity = applyPmoveAccelerate({
+      velocity,
+      wishdir: wishdirVelocity.wishdir,
+      wishspeed: wishdirVelocity.accelSpeed,
+      accel: pmAccelerate,
+      frametime
+    });
   }
-  if (wishspeed > pmMaxSpeed) {
-    const scale = pmMaxSpeed / wishspeed;
-    wishvel = scaleVec3(wishvel, scale);
-    wishspeed = pmMaxSpeed;
-    if (wishspeed !== 0) {
-      wishdir = normalizeVec3(wishvel);
-    }
+  if (!doclip) {
+    const originDelta = scaleVec3(velocity, frametime);
+    const nextOrigin = addVec3(origin, originDelta);
+    return {
+      origin: nextOrigin,
+      velocity,
+      planes: [],
+      blocked: 0,
+      stopped: velocity.x === 0 && velocity.y === 0 && velocity.z === 0,
+      stepped: false,
+      stepHeight: 0
+    };
   }
-  wishspeed *= 0.5;
-  const ducked = hasPmFlag(pmFlags, 1 /* Ducked */);
-  if (ducked && wishspeed > pmDuckSpeed) {
-    const scale = pmDuckSpeed / wishspeed;
-    wishvel = scaleVec3(wishvel, scale);
-    wishspeed = pmDuckSpeed;
-    if (wishspeed !== 0) {
-      wishdir = normalizeVec3(wishvel);
-    }
+  if (!trace || !mins || !maxs) {
+    throw new Error("applyPmoveFlyMove: doclip=true requires trace/mins/maxs");
   }
-  velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmWaterAccelerate, frametime });
-  return runStepSlideMove({
+  return stepSlideMove({
     origin,
     velocity,
     frametime,
+    overbounce,
+    trace,
     mins,
     maxs,
-    trace,
-    overbounce,
     stepSize,
     maxBumps,
-    maxClipPlanes,
-    hasTime
+    maxClipPlanes
   });
 }
-function buildPlanarWishVelocity(forward, right, cmd) {
-  return {
-    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
-    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
-    z: 0
-  };
+function applyFlyFriction(params) {
+  const { velocity, pmFriction, pmStopSpeed, frametime } = params;
+  const speed = lengthVec3(velocity);
+  if (speed < 1) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  const friction = pmFriction * FLY_FRICTION_MULTIPLIER;
+  const control = speed < pmStopSpeed ? pmStopSpeed : speed;
+  const drop = control * friction * frametime;
+  let newspeed = speed - drop;
+  if (newspeed < 0) {
+    newspeed = 0;
+  }
+  if (newspeed === speed) {
+    return velocity;
+  }
+  return scaleVec3(velocity, newspeed / speed);
 }
-function buildFullWishVelocity(forward, right, cmd) {
-  return {
-    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
-    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
-    z: forward.z * cmd.forwardmove + right.z * cmd.sidemove
+function buildFlyWishVelocity(params) {
+  const { cmd, forward, right, pmMaxSpeed, pmWaterSpeed } = params;
+  const forwardNorm = normalizeVec3(forward);
+  const rightNorm = normalizeVec3(right);
+  const wishvel = {
+    x: forwardNorm.x * cmd.forwardmove + rightNorm.x * cmd.sidemove,
+    y: forwardNorm.y * cmd.forwardmove + rightNorm.y * cmd.sidemove,
+    z: forwardNorm.z * cmd.forwardmove + rightNorm.z * cmd.sidemove
   };
-}
-function hasButton2(cmd, button) {
-  return (cmd.buttons ?? 0) & button ? true : false;
-}
-function isIdleInWater(cmd, onGround) {
-  const noMove = cmd.forwardmove === 0 && cmd.sidemove === 0;
-  const noButtons = (cmd.buttons ?? 0) & (8 /* Jump */ | 16 /* Crouch */) ? false : true;
-  return noMove && noButtons && !onGround;
-}
-function dampVerticalVelocity(velocity, gravity, frametime) {
-  let z = velocity.z;
-  const delta = gravity * frametime;
-  if (z > 0) {
-    z -= delta;
-    if (z < 0) {
-      z = 0;
-    }
-  } else {
-    z += delta;
-    if (z > 0) {
-      z = 0;
-    }
+  let adjusted = wishvel;
+  const buttons = cmd.buttons ?? 0;
+  if (buttons & 8 /* Jump */) {
+    adjusted = addVec3(adjusted, { x: 0, y: 0, z: pmWaterSpeed * BUTTON_VERTICAL_SCALE });
   }
-  return { ...velocity, z };
-}
-function runStepSlideMove(params) {
-  const { origin, velocity, frametime, mins, maxs, trace, overbounce = DEFAULT_STEP_OVERBOUNCE, stepSize, maxBumps, maxClipPlanes, hasTime } = params;
-  return stepSlideMove({
-    origin,
-    velocity,
-    frametime,
-    trace,
-    mins,
-    maxs,
-    overbounce,
-    stepSize,
-    maxBumps,
-    maxClipPlanes,
-    hasTime
-  });
+  if (buttons & 16 /* Crouch */) {
+    adjusted = addVec3(adjusted, { x: 0, y: 0, z: -pmWaterSpeed * BUTTON_VERTICAL_SCALE });
+  }
+  let wishspeed = lengthVec3(adjusted);
+  let wishdir = wishspeed === 0 ? { x: 0, y: 0, z: 0 } : normalizeVec3(adjusted);
+  if (wishspeed > pmMaxSpeed) {
+    const scale = pmMaxSpeed / wishspeed;
+    adjusted = scaleVec3(adjusted, scale);
+    wishspeed = pmMaxSpeed;
+    wishdir = wishspeed === 0 ? { x: 0, y: 0, z: 0 } : normalizeVec3(adjusted);
+  }
+  const accelSpeed = wishspeed * 2;
+  return { wishdir, wishspeed, accelSpeed };
 }
 
 // src/pmove/special.ts
@@ -4421,7 +4723,7 @@ var U_MODEL4 = 1 << 2;
 var U_REMOVE = 32768;
 
 // src/pmove/apply.ts
-var FRAMETIME = 0.025;
+var FRAMETIME2 = 0.025;
 var MASK_WATER2 = 33554432;
 var WaterLevel3 = {
   None: 0,
@@ -4475,7 +4777,7 @@ var applyPmove = (state, cmd, trace, pointContents2) => {
   const { forward, right } = angleVectors(adjustedAngles);
   const frictionedVelocity = applyPmoveFriction({
     velocity,
-    frametime: FRAMETIME,
+    frametime: FRAMETIME2,
     onGround,
     groundIsSlick: false,
     onLadder: false,
@@ -4501,12 +4803,12 @@ var applyPmove = (state, cmd, trace, pointContents2) => {
     wishspeed: wish.wishspeed,
     // Water movement uses ground acceleration (10), not air acceleration (1)
     accel: onGround || waterLevel >= 2 ? 10 : 1,
-    frametime: FRAMETIME
+    frametime: FRAMETIME2
   });
   const traceResult = trace(origin, {
-    x: origin.x + finalVelocity.x * FRAMETIME,
-    y: origin.y + finalVelocity.y * FRAMETIME,
-    z: origin.z + finalVelocity.z * FRAMETIME
+    x: origin.x + finalVelocity.x * FRAMETIME2,
+    y: origin.y + finalVelocity.y * FRAMETIME2,
+    z: origin.z + finalVelocity.z * FRAMETIME2
   });
   return {
     ...newState,
@@ -5375,6 +5677,7 @@ function calculateMaxAudibleDistance(attenuation) {
   applyPmoveAirMove,
   applyPmoveFlyMove,
   applyPmoveFriction,
+  applyPmoveWalkMove,
   applyPmoveWaterMove,
   assertContract,
   attenuationToDistanceMultiplier,
@@ -5450,6 +5753,7 @@ function calculateMaxAudibleDistance(attenuation) {
   removePmFlag,
   resolveSlideMove,
   rotatePointAroundVector,
+  runPmove,
   scaleVec3,
   slerpVec3,
   slideClipVelocityVec3,