@quake2ts/shared 0.0.1

package/src/pmove/duck.ts

@@ -0,0 +1,154 @@
+import { MASK_SOLID, MASK_WATER, type ContentsFlag } from '../bsp/contents.js';
+import type { Vec3 } from '../math/vec3.js';
+import {
+  PlayerButton,
+  PmFlag,
+  type PmFlags,
+  PmType,
+  WaterLevel,
+  addPmFlag,
+  hasPmFlag,
+  removePmFlag,
+} from './constants.js';
+import type { PmoveTraceResult } from './types.js';
+import { computePlayerDimensions, type PlayerDimensions } from './dimensions.js';
+
+const CROUCH_MAX_Z = 4;
+const STAND_MAX_Z = 32;
+const ABOVE_WATER_OFFSET = 8;
+
+export interface DuckTraceParams {
+  readonly start: Vec3;
+  readonly end: Vec3;
+  readonly mins: Vec3;
+  readonly maxs: Vec3;
+  readonly mask: ContentsFlag;
+}
+
+export type DuckTraceFn = (params: DuckTraceParams) => PmoveTraceResult;
+
+export interface CheckDuckParams {
+  readonly pmType: PmType;
+  readonly pmFlags: PmFlags;
+  readonly buttons: number;
+  readonly waterlevel: WaterLevel;
+  readonly hasGroundEntity: boolean;
+  readonly onLadder: boolean;
+  readonly n64Physics: boolean;
+  readonly origin: Vec3;
+  readonly mins: Vec3;
+  readonly maxs: Vec3;
+  readonly trace: DuckTraceFn;
+}
+
+export interface CheckDuckResult extends PlayerDimensions {
+  readonly pmFlags: PmFlags;
+  readonly ducked: boolean;
+  readonly changed: boolean;
+}
+
+/**
+ * Pure port of PM_CheckDuck from rerelease `p_move.cpp`. Updates the PMF_DUCKED flag
+ * based on crouch input, obstruction traces, and special cases (dead bodies) without
+ * mutating the provided mins/maxs. Returns the updated flag word plus the dimensions
+ * computed from PM_SetDimensions so callers can update collision bounds atomically.
+ */
+export function checkDuckState(params: CheckDuckParams): CheckDuckResult {
+  const { pmType } = params;
+
+  if (pmType === PmType.Gib) {
+    const dims = computePlayerDimensions(pmType, params.pmFlags);
+    return { pmFlags: params.pmFlags, ducked: hasPmFlag(params.pmFlags, PmFlag.Ducked), changed: false, ...dims };
+  }
+
+  let flags = params.pmFlags;
+  let changed = false;
+
+  if (pmType === PmType.Dead) {
+    if (!hasPmFlag(flags, PmFlag.Ducked)) {
+      flags = addPmFlag(flags, PmFlag.Ducked);
+      changed = true;
+    }
+  } else if (shouldDuck(params)) {
+    if (!hasPmFlag(flags, PmFlag.Ducked) && !isDuckBlocked(params)) {
+      flags = addPmFlag(flags, PmFlag.Ducked);
+      changed = true;
+    }
+  } else if (hasPmFlag(flags, PmFlag.Ducked) && !isStandBlocked(params)) {
+    flags = removePmFlag(flags, PmFlag.Ducked);
+    changed = true;
+  }
+
+  const dims = computePlayerDimensions(pmType, flags);
+  const ducked = pmType === PmType.Dead || hasPmFlag(flags, PmFlag.Ducked);
+
+  return { pmFlags: flags, ducked, changed, ...dims };
+}
+
+function shouldDuck(params: CheckDuckParams): boolean {
+  if ((params.buttons & PlayerButton.Crouch) === 0) {
+    return false;
+  }
+  if (params.onLadder || params.n64Physics) {
+    return false;
+  }
+  if (params.hasGroundEntity) {
+    return true;
+  }
+  if (params.waterlevel <= WaterLevel.Feet && !isAboveWater(params)) {
+    return true;
+  }
+  return false;
+}
+
+function isDuckBlocked(params: CheckDuckParams): boolean {
+  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: CheckDuckParams): boolean {
+  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: CheckDuckParams): boolean {
+  const below: Vec3 = { 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: Vec3, z: number): Vec3 {
+  return { x: vec.x, y: vec.y, z };
+}

package/src/pmove/fly.ts

@@ -0,0 +1,197 @@
+import { addVec3, lengthVec3, normalizeVec3, scaleVec3, type Vec3 } from '../math/vec3.js';
+import { PlayerButton } from './constants.js';
+import { applyPmoveAccelerate } from './pmove.js';
+import { stepSlideMove, type StepSlideMoveOutcome } from './slide.js';
+import type { PmoveCmd, PmoveTraceFn } from './types.js';
+
+const FLY_FRICTION_MULTIPLIER = 1.5;
+const BUTTON_VERTICAL_SCALE = 0.5;
+const DEFAULT_OVERBOUNCE = 1.01;
+
+export interface FlyMoveParams {
+  readonly origin: Vec3;
+  readonly velocity: Vec3;
+  readonly cmd: PmoveCmd;
+  readonly forward: Vec3;
+  readonly right: Vec3;
+  readonly frametime: number;
+  readonly pmFriction: number;
+  readonly pmStopSpeed: number;
+  readonly pmMaxSpeed: number;
+  readonly pmAccelerate: number;
+  readonly pmWaterSpeed: number;
+  readonly doclip: boolean;
+  readonly mins?: Vec3;
+  readonly maxs?: Vec3;
+  readonly trace?: PmoveTraceFn;
+  readonly overbounce?: number;
+  readonly stepSize?: number;
+  readonly maxBumps?: number;
+  readonly maxClipPlanes?: number;
+}
+
+export type FlyMoveResult = StepSlideMoveOutcome;
+
+/**
+ * Pure translation of PM_FlyMove from rerelease `p_move.cpp`: applies the
+ * spectator/noclip friction and acceleration rules, then either advances the
+ * origin freely or resolves movement through `stepSlideMove` when clipping is
+ * requested. This keeps the spectator and noclip physics deterministic between
+ * the client and server.
+ */
+export function applyPmoveFlyMove(params: FlyMoveParams): FlyMoveResult {
+  const {
+    origin,
+    cmd,
+    frametime,
+    pmFriction,
+    pmStopSpeed,
+    pmMaxSpeed,
+    pmAccelerate,
+    pmWaterSpeed,
+    doclip,
+    forward,
+    right,
+    mins,
+    maxs,
+    trace,
+    overbounce = DEFAULT_OVERBOUNCE,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+  } = params;
+
+  let velocity = applyFlyFriction({ velocity: params.velocity, pmFriction, pmStopSpeed, frametime });
+
+  const wishdirVelocity = buildFlyWishVelocity({
+    cmd,
+    forward,
+    right,
+    pmMaxSpeed,
+    pmWaterSpeed,
+  });
+
+  if (wishdirVelocity.wishspeed > 0) {
+    velocity = applyPmoveAccelerate({
+      velocity,
+      wishdir: wishdirVelocity.wishdir,
+      wishspeed: wishdirVelocity.accelSpeed,
+      accel: pmAccelerate,
+      frametime,
+    });
+  }
+
+  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 (!trace || !mins || !maxs) {
+    throw new Error('applyPmoveFlyMove: doclip=true requires trace/mins/maxs');
+  }
+
+  return stepSlideMove({
+    origin,
+    velocity,
+    frametime,
+    overbounce,
+    trace,
+    mins,
+    maxs,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+  });
+}
+
+interface FlyFrictionParams {
+  readonly velocity: Vec3;
+  readonly pmFriction: number;
+  readonly pmStopSpeed: number;
+  readonly frametime: number;
+}
+
+function applyFlyFriction(params: FlyFrictionParams): Vec3 {
+  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);
+}
+
+interface FlyWishVelocityParams {
+  readonly cmd: PmoveCmd;
+  readonly forward: Vec3;
+  readonly right: Vec3;
+  readonly pmMaxSpeed: number;
+  readonly pmWaterSpeed: number;
+}
+
+interface FlyWishVelocityResult {
+  readonly wishdir: Vec3;
+  readonly wishspeed: number;
+  readonly accelSpeed: number;
+}
+
+function buildFlyWishVelocity(params: FlyWishVelocityParams): FlyWishVelocityResult {
+  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,
+  } satisfies Vec3;
+
+  let adjusted = wishvel;
+  const buttons = cmd.buttons ?? 0;
+
+  if (buttons & PlayerButton.Jump) {
+    adjusted = addVec3(adjusted, { x: 0, y: 0, z: pmWaterSpeed * BUTTON_VERTICAL_SCALE });
+  }
+
+  if (buttons & PlayerButton.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 };
+}

package/src/pmove/index.ts

@@ -0,0 +1,18 @@
+
+export * from './apply.js';
+export * from './categorize.js';
+export * from './constants.js';
+export * from './currents.js';
+export * from './dimensions.js';
+export * from './duck.js';
+export * from './fly.js';
+export * from './jump.js';
+export * from './move.js';
+export * from './pmove.js';
+export * from './slide.js';
+export * from './snap.js';
+export * from './special.js';
+export * from './stuck.js';
+export * from './types.js';
+export * from './view.js';
+export * from './water.js';

package/src/pmove/jump.ts

@@ -0,0 +1,92 @@
+import type { Vec3 } from '../math/vec3.js';
+import { WaterLevel, type PmFlags, PmFlag, PmType, PlayerButton, addPmFlag, removePmFlag } from './constants.js';
+
+const DEFAULT_JUMP_HEIGHT = 270;
+
+export interface CheckJumpParams {
+  readonly pmFlags: PmFlags;
+  readonly pmType: PmType;
+  readonly buttons: number;
+  readonly waterlevel: WaterLevel;
+  readonly onGround: boolean;
+  readonly velocity: Vec3;
+  readonly origin: Vec3;
+  readonly jumpHeight?: number;
+}
+
+export interface CheckJumpResult {
+  readonly pmFlags: PmFlags;
+  readonly onGround: boolean;
+  readonly velocity: Vec3;
+  readonly origin: Vec3;
+  readonly jumpSound: boolean;
+  readonly jumped: boolean;
+}
+
+function hasButton(buttons: number, button: PlayerButton): boolean {
+  return (buttons & button) !== 0;
+}
+
+/**
+ * Pure translation of the rerelease `PM_CheckJump` helper from `p_move.cpp`.
+ * The function takes in the minimal pmove state that the original C++ logic
+ * touches and returns the updated flag/origin/velocity tuple so callers can
+ * apply the same semantics on both the server and client.
+ */
+export function checkJump(params: CheckJumpParams): CheckJumpResult {
+  const { pmFlags, pmType, buttons, waterlevel, onGround, velocity, origin, jumpHeight = DEFAULT_JUMP_HEIGHT } = params;
+
+  // PM_CheckJump immediately bails while the landing timer is active.
+  if (pmFlags & PmFlag.TimeLand) {
+    return { pmFlags, onGround, velocity, origin, jumpSound: false, jumped: false };
+  }
+
+  const holdingJump = hasButton(buttons, PlayerButton.Jump);
+  let nextFlags = pmFlags;
+  let nextOnGround = onGround;
+  let jumpSound = false;
+  let jumped = false;
+  let nextVelocity = velocity;
+  let nextOrigin = origin;
+
+  if (!holdingJump) {
+    nextFlags = removePmFlag(nextFlags, PmFlag.JumpHeld);
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
+  }
+
+  if (hasPmJumpHold(nextFlags)) {
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
+  }
+
+  if (pmType === PmType.Dead) {
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
+  }
+
+  if (waterlevel >= WaterLevel.Waist) {
+    nextOnGround = false;
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
+  }
+
+  if (!nextOnGround) {
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
+  }
+
+  nextFlags = addPmFlag(nextFlags, PmFlag.JumpHeld);
+  nextFlags = removePmFlag(nextFlags, PmFlag.OnGround);
+  nextOnGround = false;
+  jumpSound = true;
+  jumped = true;
+
+  const z = velocity.z + jumpHeight;
+  const finalZ = z < jumpHeight ? jumpHeight : z;
+  nextVelocity = { ...velocity, z: finalZ };
+
+  // Unstuck from ground: pm->s.origin[2] += 1;
+  nextOrigin = { ...origin, z: origin.z + 1 };
+
+  return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, origin: nextOrigin, jumpSound, jumped };
+}
+
+function hasPmJumpHold(flags: PmFlags): boolean {
+  return (flags & PmFlag.JumpHeld) !== 0;
+}