quake2ts 0.0.7 → 0.0.39

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

@@ -409,6 +409,19 @@ var MersenneTwister19937 = class {
     }
     this.index = 0;
   }
+  getState() {
+    return {
+      index: this.index,
+      state: Array.from(this.state)
+    };
+  }
+  setState(snapshot) {
+    if (snapshot.state.length !== STATE_SIZE) {
+      throw new Error(`Expected ${STATE_SIZE} MT state values, received ${snapshot.state.length}`);
+    }
+    this.index = snapshot.index;
+    this.state = Uint32Array.from(snapshot.state, (value) => value >>> 0);
+  }
 };
 var RandomGenerator = class {
   constructor(options = {}) {
@@ -473,6 +486,12 @@ var RandomGenerator = class {
   randomIndex(container) {
     return this.irandom(container.length);
   }
+  getState() {
+    return { mt: this.mt.getState() };
+  }
+  setState(snapshot) {
+    this.mt.setState(snapshot.mt);
+  }
 };
 function createRandomGenerator(options) {
   return new RandomGenerator(options);
@@ -487,6 +506,7 @@ var CONTENTS_LAVA = 1 << 3;
 var CONTENTS_SLIME = 1 << 4;
 var CONTENTS_WATER = 1 << 5;
 var CONTENTS_MIST = 1 << 6;
+var CONTENTS_TRIGGER = 1073741824;
 var CONTENTS_NO_WATERJUMP = 1 << 13;
 var CONTENTS_PROJECTILECLIP = 1 << 14;
 var CONTENTS_AREAPORTAL = 1 << 15;
@@ -566,6 +586,8 @@ var PlaneSide = /* @__PURE__ */ ((PlaneSide2) => {
   return PlaneSide2;
 })(PlaneSide || {});
 var DIST_EPSILON = 0.03125;
+var MAX_CHECKCOUNT = Number.MAX_SAFE_INTEGER - 1;
+var globalBrushCheckCount = 1;
 function buildCollisionModel(lumps) {
   const planes = lumps.planes.map((plane) => ({
     ...plane,
@@ -605,7 +627,8 @@ function buildCollisionModel(lumps) {
     leaves,
     brushes,
     leafBrushes: lumps.leafBrushes,
-    bmodels
+    bmodels,
+    visibility: lumps.visibility
   };
 }
 function computePlaneSignBits(normal) {
@@ -752,6 +775,420 @@ function createDefaultTrace() {
     allsolid: false
   };
 }
+function findLeafIndex(point, model, headnode) {
+  let nodeIndex = headnode;
+  while (nodeIndex >= 0) {
+    const node = model.nodes[nodeIndex];
+    const dist = planeDistanceToPoint(node.plane, point);
+    nodeIndex = dist >= 0 ? node.children[0] : node.children[1];
+  }
+  return -1 - nodeIndex;
+}
+function computeLeafContents(model, leafIndex, point) {
+  const leaf = model.leaves[leafIndex];
+  let contents = leaf.contents;
+  const brushCheckCount = nextBrushCheckCount();
+  const start = leaf.firstLeafBrush;
+  const end = start + leaf.numLeafBrushes;
+  for (let i = start; i < end; i += 1) {
+    const brushIndex = model.leafBrushes[i];
+    const brush = model.brushes[brushIndex];
+    if (brush.checkcount === brushCheckCount) continue;
+    brush.checkcount = brushCheckCount;
+    if (brush.sides.length === 0) continue;
+    if (pointInsideBrush(point, brush)) {
+      contents |= brush.contents;
+    }
+  }
+  return contents;
+}
+function nextBrushCheckCount() {
+  const count = globalBrushCheckCount;
+  globalBrushCheckCount += 1;
+  if (globalBrushCheckCount >= MAX_CHECKCOUNT) {
+    globalBrushCheckCount = 1;
+  }
+  return count;
+}
+function isPointBounds(mins, maxs) {
+  return mins.x === 0 && mins.y === 0 && mins.z === 0 && maxs.x === 0 && maxs.y === 0 && maxs.z === 0;
+}
+function planeOffsetForBounds(plane, mins, maxs) {
+  if (isPointBounds(mins, maxs)) return 0;
+  const offset = plane.normal.x * (plane.normal.x < 0 ? maxs.x : mins.x) + plane.normal.y * (plane.normal.y < 0 ? maxs.y : mins.y) + plane.normal.z * (plane.normal.z < 0 ? maxs.z : mins.z);
+  return offset;
+}
+function planeOffsetMagnitude(plane, mins, maxs) {
+  return Math.abs(planeOffsetForBounds(plane, mins, maxs));
+}
+function lerpPoint(start, end, t) {
+  return addVec3(start, scaleVec3(subtractVec3(end, start), t));
+}
+function finalizeTrace(trace, start, end) {
+  const clampedFraction = trace.allsolid ? 0 : trace.fraction;
+  const endpos = lerpPoint(start, end, clampedFraction);
+  return {
+    fraction: clampedFraction,
+    endpos,
+    plane: trace.plane,
+    planeNormal: trace.startsolid ? void 0 : trace.plane?.normal,
+    contents: trace.contents,
+    surfaceFlags: trace.surfaceFlags,
+    startsolid: trace.startsolid,
+    allsolid: trace.allsolid
+  };
+}
+function clusterForPoint(point, model, headnode) {
+  const leafIndex = findLeafIndex(point, model, headnode);
+  return model.leaves[leafIndex]?.cluster ?? -1;
+}
+function clusterVisible(visibility, from, to, usePhs) {
+  if (!visibility || visibility.numClusters === 0) return true;
+  if (from < 0 || to < 0) return false;
+  if (from >= visibility.clusters.length || to >= visibility.numClusters) return false;
+  const cluster = visibility.clusters[from];
+  const set = usePhs ? cluster.phs : cluster.pvs;
+  const byte = set[to >> 3];
+  if (byte === void 0) return false;
+  return (byte & 1 << (to & 7)) !== 0;
+}
+function recursiveHullCheck(params) {
+  const {
+    model,
+    nodeIndex,
+    startFraction,
+    endFraction,
+    start,
+    end,
+    traceStart,
+    traceEnd,
+    mins,
+    maxs,
+    contentMask,
+    trace,
+    brushCheckCount
+  } = params;
+  if (trace.fraction <= startFraction) {
+    return;
+  }
+  if (nodeIndex < 0) {
+    const leafIndex = -1 - nodeIndex;
+    const leaf = model.leaves[leafIndex];
+    const brushStart = leaf.firstLeafBrush;
+    const brushEnd = brushStart + leaf.numLeafBrushes;
+    for (let i = brushStart; i < brushEnd; i += 1) {
+      const brushIndex = model.leafBrushes[i];
+      const brush = model.brushes[brushIndex];
+      if ((brush.contents & contentMask) === 0) continue;
+      if (!brush.sides.length) continue;
+      if (brush.checkcount === brushCheckCount) continue;
+      brush.checkcount = brushCheckCount;
+      clipBoxToBrush({ start: traceStart, end: traceEnd, mins, maxs, brush, trace });
+      if (trace.allsolid) {
+        return;
+      }
+    }
+    return;
+  }
+  const node = model.nodes[nodeIndex];
+  const plane = node.plane;
+  const offset = planeOffsetForBounds(plane, mins, maxs);
+  const startDist = planeDistanceToPoint(plane, start) + offset;
+  const endDist = planeDistanceToPoint(plane, end) + offset;
+  if (startDist >= 0 && endDist >= 0) {
+    recursiveHullCheck({
+      model,
+      nodeIndex: node.children[0],
+      startFraction,
+      endFraction,
+      start,
+      end,
+      traceStart,
+      traceEnd,
+      mins,
+      maxs,
+      contentMask,
+      trace,
+      brushCheckCount
+    });
+    return;
+  }
+  if (startDist < 0 && endDist < 0) {
+    recursiveHullCheck({
+      model,
+      nodeIndex: node.children[1],
+      startFraction,
+      endFraction,
+      start,
+      end,
+      traceStart,
+      traceEnd,
+      mins,
+      maxs,
+      contentMask,
+      trace,
+      brushCheckCount
+    });
+    return;
+  }
+  let side = 0;
+  let idist = 1 / (startDist - endDist);
+  let fraction1 = (startDist - DIST_EPSILON) * idist;
+  let fraction2 = (startDist + DIST_EPSILON) * idist;
+  if (startDist < endDist) {
+    side = 1;
+    fraction1 = (startDist + DIST_EPSILON) * idist;
+    fraction2 = (startDist - DIST_EPSILON) * idist;
+  }
+  if (fraction1 < 0) fraction1 = 0;
+  else if (fraction1 > 1) fraction1 = 1;
+  if (fraction2 < 0) fraction2 = 0;
+  else if (fraction2 > 1) fraction2 = 1;
+  const midFraction = startFraction + (endFraction - startFraction) * fraction1;
+  const midPoint = lerpPoint(start, end, fraction1);
+  recursiveHullCheck({
+    model,
+    nodeIndex: node.children[side],
+    startFraction,
+    endFraction: midFraction,
+    start,
+    end: midPoint,
+    traceStart,
+    traceEnd,
+    mins,
+    maxs,
+    contentMask,
+    trace,
+    brushCheckCount
+  });
+  const updatedFraction = trace.fraction;
+  if (updatedFraction <= midFraction) {
+    return;
+  }
+  const midFraction2 = startFraction + (endFraction - startFraction) * fraction2;
+  const midPoint2 = lerpPoint(start, end, fraction2);
+  recursiveHullCheck({
+    model,
+    nodeIndex: node.children[1 - side],
+    startFraction: midFraction2,
+    endFraction,
+    start: midPoint2,
+    end,
+    traceStart,
+    traceEnd,
+    mins,
+    maxs,
+    contentMask,
+    trace,
+    brushCheckCount
+  });
+}
+function traceBox(params) {
+  const { model, start, end } = params;
+  const mins = params.mins ?? ZERO_VEC3;
+  const maxs = params.maxs ?? ZERO_VEC3;
+  const contentMask = params.contentMask ?? 4294967295;
+  const headnode = params.headnode ?? 0;
+  const trace = createDefaultTrace();
+  const brushCheckCount = nextBrushCheckCount();
+  recursiveHullCheck({
+    model,
+    nodeIndex: headnode,
+    startFraction: 0,
+    endFraction: 1,
+    start,
+    end,
+    traceStart: start,
+    traceEnd: end,
+    mins,
+    maxs,
+    contentMask,
+    trace,
+    brushCheckCount
+  });
+  return finalizeTrace(trace, start, end);
+}
+function pointContents(point, model, headnode = 0) {
+  const leafIndex = findLeafIndex(point, model, headnode);
+  return computeLeafContents(model, leafIndex, point);
+}
+function pointContentsMany(points, model, headnode = 0) {
+  const leafCache = /* @__PURE__ */ new Map();
+  return points.map((point) => {
+    const leafIndex = findLeafIndex(point, model, headnode);
+    const leaf = model.leaves[leafIndex];
+    if (leaf.numLeafBrushes === 0) {
+      const cached = leafCache.get(leafIndex);
+      if (cached !== void 0) {
+        return cached;
+      }
+      leafCache.set(leafIndex, leaf.contents);
+      return leaf.contents;
+    }
+    return computeLeafContents(model, leafIndex, point);
+  });
+}
+function boxContents(origin, mins, maxs, model, headnode = 0) {
+  const brushCheckCount = nextBrushCheckCount();
+  let contents = 0;
+  function traverse(nodeIndex) {
+    if (nodeIndex < 0) {
+      const leafIndex = -1 - nodeIndex;
+      const leaf = model.leaves[leafIndex];
+      contents |= leaf.contents;
+      const brushStart = leaf.firstLeafBrush;
+      const brushEnd = brushStart + leaf.numLeafBrushes;
+      for (let i = brushStart; i < brushEnd; i += 1) {
+        const brushIndex = model.leafBrushes[i];
+        const brush = model.brushes[brushIndex];
+        if (brush.checkcount === brushCheckCount) continue;
+        brush.checkcount = brushCheckCount;
+        if (brush.sides.length === 0) continue;
+        const result = testBoxInBrush(origin, mins, maxs, brush);
+        if (result.startsolid) {
+          contents |= result.contents;
+        }
+      }
+      return;
+    }
+    const node = model.nodes[nodeIndex];
+    const plane = node.plane;
+    const offset = planeOffsetMagnitude(plane, mins, maxs);
+    const dist = planeDistanceToPoint(plane, origin);
+    if (offset === 0) {
+      traverse(dist >= 0 ? node.children[0] : node.children[1]);
+      return;
+    }
+    if (dist > offset) {
+      traverse(node.children[0]);
+      return;
+    }
+    if (dist < -offset) {
+      traverse(node.children[1]);
+      return;
+    }
+    traverse(node.children[0]);
+    traverse(node.children[1]);
+  }
+  traverse(headnode);
+  return contents;
+}
+function inPVS(p1, p2, model, headnode = 0) {
+  const { visibility } = model;
+  if (!visibility) return true;
+  const cluster1 = clusterForPoint(p1, model, headnode);
+  const cluster2 = clusterForPoint(p2, model, headnode);
+  return clusterVisible(visibility, cluster1, cluster2, false);
+}
+function inPHS(p1, p2, model, headnode = 0) {
+  const { visibility } = model;
+  if (!visibility) return true;
+  const cluster1 = clusterForPoint(p1, model, headnode);
+  const cluster2 = clusterForPoint(p2, model, headnode);
+  return clusterVisible(visibility, cluster1, cluster2, true);
+}
+function axisAlignedPlane(normal, dist, type) {
+  return { normal, dist, type, signbits: computePlaneSignBits(normal) };
+}
+function makeEntityBrush(link) {
+  const sx = link.surfaceFlags ?? 0;
+  const xMax = link.origin.x + link.maxs.x;
+  const xMin = link.origin.x + link.mins.x;
+  const yMax = link.origin.y + link.maxs.y;
+  const yMin = link.origin.y + link.mins.y;
+  const zMax = link.origin.z + link.maxs.z;
+  const zMin = link.origin.z + link.mins.z;
+  const planes = [
+    axisAlignedPlane({ x: 1, y: 0, z: 0 }, xMax, 0),
+    axisAlignedPlane({ x: -1, y: 0, z: 0 }, -xMin, 0),
+    axisAlignedPlane({ x: 0, y: 1, z: 0 }, yMax, 1),
+    axisAlignedPlane({ x: 0, y: -1, z: 0 }, -yMin, 1),
+    axisAlignedPlane({ x: 0, y: 0, z: 1 }, zMax, 2),
+    axisAlignedPlane({ x: 0, y: 0, z: -1 }, -zMin, 2)
+  ];
+  const sides = planes.map((plane) => ({ plane, surfaceFlags: sx }));
+  return { contents: link.contents, sides, checkcount: 0 };
+}
+function makeEntityState(link) {
+  const brush = makeEntityBrush(link);
+  return {
+    ...link,
+    brush,
+    bounds: {
+      mins: {
+        x: link.origin.x + link.mins.x,
+        y: link.origin.y + link.mins.y,
+        z: link.origin.z + link.mins.z
+      },
+      maxs: {
+        x: link.origin.x + link.maxs.x,
+        y: link.origin.y + link.maxs.y,
+        z: link.origin.z + link.maxs.z
+      }
+    }
+  };
+}
+function boundsIntersect(a, b) {
+  return !(a.mins.x > b.maxs.x || a.maxs.x < b.mins.x || a.mins.y > b.maxs.y || a.maxs.y < b.mins.y || a.mins.z > b.maxs.z || a.maxs.z < b.mins.z);
+}
+function pickBetterTrace(best, candidate) {
+  if (candidate.allsolid && !best.allsolid) return true;
+  if (candidate.startsolid && !best.startsolid) return true;
+  return candidate.fraction < best.fraction;
+}
+var CollisionEntityIndex = class {
+  constructor() {
+    this.entities = /* @__PURE__ */ new Map();
+  }
+  link(entity) {
+    this.entities.set(entity.id, makeEntityState(entity));
+  }
+  unlink(entityId) {
+    this.entities.delete(entityId);
+  }
+  trace(params) {
+    const { passId } = params;
+    const mins = params.mins ?? ZERO_VEC3;
+    const maxs = params.maxs ?? ZERO_VEC3;
+    const contentMask = params.contentMask ?? 4294967295;
+    let bestTrace;
+    let bestEntity = null;
+    if (params.model) {
+      bestTrace = traceBox(params);
+    } else {
+      bestTrace = finalizeTrace(createDefaultTrace(), params.start, params.end);
+    }
+    for (const entity of this.entities.values()) {
+      if (entity.id === passId) continue;
+      if ((entity.contents & contentMask) === 0) continue;
+      const trace = createDefaultTrace();
+      clipBoxToBrush({ start: params.start, end: params.end, mins, maxs, brush: entity.brush, trace });
+      if (trace.contents === 0) {
+        trace.contents = entity.contents;
+      }
+      const candidate = finalizeTrace(trace, params.start, params.end);
+      if (pickBetterTrace(bestTrace, candidate)) {
+        bestTrace = candidate;
+        bestEntity = entity.id;
+      }
+    }
+    return { ...bestTrace, entityId: bestEntity };
+  }
+  gatherTriggerTouches(origin, mins, maxs, mask = CONTENTS_TRIGGER) {
+    const results = [];
+    const queryBounds = {
+      mins: addVec3(origin, mins),
+      maxs: addVec3(origin, maxs)
+    };
+    for (const entity of this.entities.values()) {
+      if ((entity.contents & mask) === 0) continue;
+      if (boundsIntersect(queryBounds, entity.bounds)) {
+        results.push(entity.id);
+      }
+    }
+    return results;
+  }
+};
 
 // src/protocol/cvar.ts
 var CvarFlags = /* @__PURE__ */ ((CvarFlags2) => {
@@ -819,6 +1256,124 @@ function configStringSize(index) {
   return CS_MAX_STRING_LENGTH;
 }
 
+// src/protocol/contracts.ts
+function normalize(object) {
+  return object ?? {};
+}
+function validateContract(table, requiredKeys, options = {}) {
+  const normalized = normalize(table);
+  const missing = [];
+  const nonFunctions = [];
+  for (const key of requiredKeys) {
+    if (!(key in normalized)) {
+      missing.push(key);
+      continue;
+    }
+    if (typeof normalized[key] !== "function") {
+      nonFunctions.push(key);
+    }
+  }
+  const extras = options.allowExtra === false ? Object.keys(normalized).filter((key) => !requiredKeys.includes(key)) : [];
+  return { missing, nonFunctions, extras };
+}
+function assertContract(table, requiredKeys, options = {}) {
+  const { missing, nonFunctions, extras } = validateContract(table, requiredKeys, options);
+  if (missing.length === 0 && nonFunctions.length === 0 && extras.length === 0) {
+    return;
+  }
+  const pieces = [];
+  if (missing.length > 0) {
+    pieces.push(`missing: ${missing.join(", ")}`);
+  }
+  if (nonFunctions.length > 0) {
+    pieces.push(`non-functions: ${nonFunctions.join(", ")}`);
+  }
+  if (extras.length > 0) {
+    pieces.push(`extras: ${extras.join(", ")}`);
+  }
+  const label = options.name ?? "contract";
+  throw new Error(`${label} validation failed (${pieces.join("; ")})`);
+}
+var GAME_IMPORT_KEYS = [
+  "Broadcast_Print",
+  "Com_Print",
+  "Client_Print",
+  "Center_Print",
+  "sound",
+  "positioned_sound",
+  "local_sound",
+  "configstring",
+  "get_configstring",
+  "Com_Error",
+  "modelindex",
+  "soundindex",
+  "imageindex",
+  "setmodel",
+  "trace",
+  "clip",
+  "pointcontents",
+  "inPVS",
+  "inPHS",
+  "SetAreaPortalState",
+  "AreasConnected",
+  "linkentity",
+  "unlinkentity",
+  "BoxEdicts",
+  "multicast",
+  "unicast"
+];
+var GAME_EXPORT_KEYS = [
+  "PreInit",
+  "Init",
+  "Shutdown",
+  "SpawnEntities",
+  "WriteGameJson",
+  "ReadGameJson",
+  "WriteLevelJson",
+  "ReadLevelJson",
+  "CanSave",
+  "ClientConnect",
+  "ClientThink",
+  "RunFrame",
+  "Pmove"
+];
+var CGAME_IMPORT_KEYS = [
+  "Com_Print",
+  "get_configstring",
+  "Com_Error",
+  "TagMalloc",
+  "TagFree",
+  "AddCommandString",
+  "CL_FrameValid",
+  "CL_FrameTime",
+  "CL_ClientTime",
+  "CL_ServerFrame",
+  "Draw_RegisterPic",
+  "Draw_GetPicSize",
+  "SCR_DrawChar",
+  "SCR_DrawPic",
+  "SCR_DrawColorPic"
+];
+var CGAME_EXPORT_KEYS = [
+  "Init",
+  "Shutdown",
+  "DrawHUD",
+  "TouchPics",
+  "LayoutFlags",
+  "GetActiveWeaponWheelWeapon",
+  "GetOwnedWeaponWheelWeapons",
+  "GetWeaponWheelAmmoCount",
+  "GetPowerupWheelCount",
+  "GetHitMarkerDamage",
+  "Pmove",
+  "ParseConfigString",
+  "ParseCenterPrint",
+  "ClearNotify",
+  "ClearCenterprint",
+  "NotifyMessage",
+  "GetMonsterFlashOffset"
+];
+
 // src/pmove/constants.ts
 var WaterLevel = /* @__PURE__ */ ((WaterLevel3) => {
   WaterLevel3[WaterLevel3["None"] = 0] = "None";
@@ -1634,7 +2189,7 @@ function buildFlyWishVelocity(params) {
 
 // src/pmove/water.ts
 function getWaterLevel(params) {
-  const { origin, mins, viewheight, pointContents } = params;
+  const { origin, mins, viewheight, pointContents: pointContents2 } = params;
   const sample2 = viewheight - mins.z;
   const sample1 = sample2 / 2;
   const point = {
@@ -1642,18 +2197,18 @@ function getWaterLevel(params) {
     y: origin.y,
     z: origin.z + mins.z + 1
   };
-  let contents = pointContents(point);
+  let contents = pointContents2(point);
   if ((contents & MASK_WATER) === 0) {
     return { waterlevel: 0 /* None */, watertype: CONTENTS_NONE };
   }
   const watertype = contents;
   let waterlevel = 1 /* Feet */;
   let point2 = { x: point.x, y: point.y, z: origin.z + mins.z + sample1 };
-  contents = pointContents(point2);
+  contents = pointContents2(point2);
   if ((contents & MASK_WATER) !== 0) {
     waterlevel = 2 /* Waist */;
     let point3 = { x: point.x, y: point.y, z: origin.z + mins.z + sample2 };
-    contents = pointContents(point3);
+    contents = pointContents2(point3);
     if ((contents & MASK_WATER) !== 0) {
       waterlevel = 3 /* Under */;
     }
@@ -1843,7 +2398,7 @@ function categorizePosition(params) {
     maxs,
     viewheight,
     trace,
-    pointContents
+    pointContents: pointContents2
   } = params;
   let pmFlags = params.pmFlags;
   let pmTime = params.pmTime;
@@ -1898,7 +2453,7 @@ function categorizePosition(params) {
     origin,
     mins,
     viewheight,
-    pointContents
+    pointContents: pointContents2
   });
   return {
     pmFlags,
@@ -2240,7 +2795,7 @@ function checkSpecialMovement(params) {
     maxs,
     viewheight,
     trace,
-    pointContents,
+    pointContents: pointContents2,
     onGround,
     overbounce = DEFAULT_OVERBOUNCE2,
     stepSize = WATERJUMP_STEP_TOLERANCE,
@@ -2320,7 +2875,7 @@ function checkSpecialMovement(params) {
   if (onGround && Math.abs(origin.z - downTrace.endpos.z) <= stepSize) {
     return { pmFlags, pmTime, velocity, performedWaterJump: false };
   }
-  const landingWater = getWaterLevel({ origin: downTrace.endpos, mins, viewheight, pointContents });
+  const landingWater = getWaterLevel({ origin: downTrace.endpos, mins, viewheight, pointContents: pointContents2 });
   if (landingWater.waterlevel >= 2 /* Waist */) {
     return { pmFlags, pmTime, velocity, performedWaterJump: false };
   }
@@ -2416,7 +2971,39 @@ function clampViewAngles(params) {
   const vectors = angleVectors(viewangles);
   return { viewangles, ...vectors };
 }
+
+// src/protocol/usercmd.ts
+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
+  };
+}
 export {
+  CGAME_EXPORT_KEYS,
+  CGAME_IMPORT_KEYS,
   CONTENTS_AREAPORTAL,
   CONTENTS_AUX,
   CONTENTS_CURRENT_0,
@@ -2442,13 +3029,23 @@ export {
   CONTENTS_SLIME,
   CONTENTS_SOLID,
   CONTENTS_TRANSLUCENT,
+  CONTENTS_TRIGGER,
   CONTENTS_WATER,
   CONTENTS_WINDOW,
   CS_MAX_STRING_LENGTH,
   CS_MAX_STRING_LENGTH_OLD,
+  CollisionEntityIndex,
   ConfigStringIndex,
   CvarFlags,
+  DEFAULT_FORWARD_SPEED,
+  DEFAULT_MOUSE_SENSITIVITY,
+  DEFAULT_PITCH_SPEED,
+  DEFAULT_SIDE_SPEED,
+  DEFAULT_UP_SPEED,
+  DEFAULT_YAW_SPEED,
   DIST_EPSILON,
+  GAME_EXPORT_KEYS,
+  GAME_IMPORT_KEYS,
   LAST_VISIBLE_CONTENTS,
   MASK_ALL,
   MASK_BLOCK_SIGHT,
@@ -2513,6 +3110,7 @@ export {
   addPmFlag,
   addPointToBounds,
   addVec3,
+  addViewAngles,
   angleMod,
   angleVectors,
   applyPmoveAccelerate,
@@ -2522,6 +3120,8 @@ export {
   applyPmoveFlyMove,
   applyPmoveFriction,
   applyPmoveWaterMove,
+  assertContract,
+  boxContents,
   boxOnPlaneSide,
   boxesIntersect,
   buildAirGroundWish,
@@ -2557,18 +3157,23 @@ export {
   hasAnyContents,
   hasPmFlag,
   hasSurfaceFlags,
+  inPHS,
+  inPVS,
   initialSnapPosition,
   isAtLeastWaistDeep,
   isUnderwater,
   lengthSquaredVec3,
   lengthVec3,
   lerpAngle,
+  mouseDeltaToViewDelta,
   multiplyVec3,
   negateVec3,
   normalizeVec3,
   perpendicularVec3,
   planeDistanceToPoint,
   pmoveCmdScale,
+  pointContents,
+  pointContentsMany,
   pointInsideBrush,
   pointOnPlaneSide,
   projectPointOnPlane,
@@ -2587,6 +3192,8 @@ export {
   stepSlideMove,
   subtractVec3,
   testBoxInBrush,
+  traceBox,
+  validateContract,
   vectorToAngles,
   vectorToYaw,
   waterCurrentVelocity