quake2ts 0.0.85 → 0.0.87

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

@@ -1,4 +1,9 @@
 // ../shared/dist/esm/index.js
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
 var STOP_EPSILON = 0.1;
 var DEG_TO_RAD = Math.PI / 180;
@@ -441,6 +446,41 @@ var ConfigStringIndex = ((ConfigStringIndex2) => {
   return ConfigStringIndex2;
 })(ConfigStringIndex || {});
 var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+var replay_exports = {};
+__export(replay_exports, {
+  addReplayFrame: () => addReplayFrame,
+  createReplaySession: () => createReplaySession,
+  deserializeReplay: () => deserializeReplay,
+  serializeReplay: () => serializeReplay
+});
+function serializeReplay(session) {
+  return JSON.stringify(session, null, 2);
+}
+function deserializeReplay(json) {
+  const session = JSON.parse(json);
+  if (!session.metadata || !Array.isArray(session.frames)) {
+    throw new Error("Invalid replay format: missing metadata or frames");
+  }
+  return session;
+}
+function createReplaySession(map, seed) {
+  return {
+    metadata: {
+      map,
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "1.0",
+      seed
+    },
+    frames: []
+  };
+}
+function addReplayFrame(session, cmd, serverFrame, startTime) {
+  session.frames.push({
+    serverFrame,
+    cmd,
+    timestamp: Date.now() - startTime
+  });
+}
 var WaterLevel = /* @__PURE__ */ ((WaterLevel3) => {
   WaterLevel3[WaterLevel3["None"] = 0] = "None";
   WaterLevel3[WaterLevel3["Feet"] = 1] = "Feet";
@@ -910,8 +950,23 @@ var ENTITY_FIELD_METADATA = [
 // src/physics/movement.ts
 function runGravity(ent, gravity, frametime) {
   if (ent.movetype === 7 /* Toss */) {
-    ent.velocity = addVec3(ent.velocity, scaleVec3(gravity, ent.gravity * frametime));
-    ent.origin = addVec3(ent.origin, scaleVec3(ent.velocity, frametime));
+    if (ent.waterlevel > 1) {
+      const speed = Math.sqrt(ent.velocity.x * ent.velocity.x + ent.velocity.y * ent.velocity.y + ent.velocity.z * ent.velocity.z);
+      if (speed > 1) {
+        const newspeed = speed - frametime * speed * 2;
+        if (newspeed < 0) {
+          ent.velocity = { x: 0, y: 0, z: 0 };
+        } else {
+          const scale = newspeed / speed;
+          ent.velocity = scaleVec3(ent.velocity, scale);
+        }
+      }
+      ent.velocity = addVec3(ent.velocity, scaleVec3(gravity, ent.gravity * frametime * 0.1));
+      ent.origin = addVec3(ent.origin, scaleVec3(ent.velocity, frametime));
+    } else {
+      ent.velocity = addVec3(ent.velocity, scaleVec3(gravity, ent.gravity * frametime));
+      ent.origin = addVec3(ent.origin, scaleVec3(ent.velocity, frametime));
+    }
   }
 }
 function runBouncing(ent, imports, frametime) {
@@ -1060,6 +1115,64 @@ function runPush(pusher, system, imports, frametime) {
   return true;
 }
 
+// src/physics/fluid.ts
+function checkWater2(ent, system, imports) {
+  const origin = ent.origin;
+  const mins = ent.mins;
+  const maxs = ent.maxs;
+  const point = {
+    x: origin.x + (mins.x + maxs.x) * 0.5,
+    y: origin.y + (mins.y + maxs.y) * 0.5,
+    z: origin.z + mins.z + 1
+  };
+  let cont = imports.pointcontents(point);
+  if ((cont & MASK_WATER) === 0) {
+    if (ent.waterlevel > 0) {
+      playLeaveWaterSound(ent, system);
+      ent.flags &= ~2 /* Swim */;
+    }
+    ent.waterlevel = 0;
+    ent.watertype = 0;
+    return;
+  }
+  ent.watertype = cont;
+  ent.waterlevel = 1;
+  const waistZ = origin.z + mins.z + (maxs.z - mins.z) * 0.5;
+  const headZ = origin.z + maxs.z - 1;
+  const waistPoint = { ...point, z: waistZ };
+  cont = imports.pointcontents(waistPoint);
+  if (cont & MASK_WATER) {
+    ent.waterlevel = 2;
+    const headPoint = { ...point, z: headZ };
+    cont = imports.pointcontents(headPoint);
+    if (cont & MASK_WATER) {
+      ent.waterlevel = 3;
+    }
+  }
+  if ((ent.flags & 2 /* Swim */) === 0) {
+    playEnterWaterSound(ent, system);
+    ent.flags |= 2 /* Swim */;
+  }
+}
+function playEnterWaterSound(ent, system) {
+  if (ent.watertype & CONTENTS_LAVA) {
+    system.sound(ent, 0, "player/lava_in.wav", 1, 1, 0);
+  } else if (ent.watertype & CONTENTS_SLIME) {
+    system.sound(ent, 0, "player/watr_in.wav", 1, 1, 0);
+  } else if (ent.watertype & CONTENTS_WATER) {
+    system.sound(ent, 0, "player/watr_in.wav", 1, 1, 0);
+  }
+}
+function playLeaveWaterSound(ent, system) {
+  if (ent.watertype & CONTENTS_LAVA) {
+    system.sound(ent, 0, "player/lava_out.wav", 1, 1, 0);
+  } else if (ent.watertype & CONTENTS_SLIME) {
+    system.sound(ent, 0, "player/watr_out.wav", 1, 1, 0);
+  } else if (ent.watertype & CONTENTS_WATER) {
+    system.sound(ent, 0, "player/watr_out.wav", 1, 1, 0);
+  }
+}
+
 // src/entities/pool.ts
 var MAX_EDICTS = 2048;
 var WORLD_INDEX = 0;
@@ -1527,6 +1640,9 @@ var EntitySystem = class {
       if (!ent.inUse || ent.freePending) {
         continue;
       }
+      if (ent.movetype !== 0 /* None */ && ent.movetype !== 2 /* Push */ && ent.movetype !== 3 /* Stop */ && ent.movetype !== 1 /* Noclip */) {
+        checkWater2(ent, this, this.imports);
+      }
       const frametime = this.currentTimeSeconds - (ent.timestamp || 0);
       switch (ent.movetype) {
         case 7 /* Toss */:
@@ -3661,6 +3777,131 @@ function ai_charge(self, distance2, deltaSeconds) {
     walkMove(self, self.angles.y, distance2);
   }
 }
+function CheckGround(self, context) {
+  if (self.movetype === 1 /* Noclip */) {
+    return;
+  }
+  const point = {
+    x: self.origin.x,
+    y: self.origin.y,
+    z: self.origin.z + self.mins.z - 1
+  };
+  const trace = context.trace(self.origin, self.mins, self.maxs, point, self, MASK_MONSTERSOLID);
+  self.groundentity = trace.ent;
+  if (!self.groundentity && !trace.allsolid && !trace.startsolid && trace.fraction === 1) {
+    const content = context.pointcontents(point);
+    if (content & MASK_WATER) {
+      self.waterlevel = 1;
+      self.watertype = content;
+    } else {
+      self.waterlevel = 0;
+      self.watertype = 0;
+    }
+  }
+}
+function M_CheckBottom(self, context) {
+  const mins = {
+    x: self.origin.x + self.mins.x,
+    y: self.origin.y + self.mins.y,
+    z: self.origin.z + self.mins.z
+  };
+  const maxs = {
+    x: self.origin.x + self.maxs.x,
+    y: self.origin.y + self.maxs.y,
+    z: self.origin.z + self.maxs.z
+  };
+  let start = { x: 0, y: 0, z: 0 };
+  let stop = { x: 0, y: 0, z: 0 };
+  for (let i = 0; i < 2; i++) {
+    if (i === 1) start = { x: mins.x, y: mins.y, z: 0 };
+    else start = { x: maxs.x, y: mins.y, z: 0 };
+    start.z = mins.z - 1;
+    if (context.pointcontents(start) !== 0) return true;
+    stop = { ...start };
+    stop.z = start.z - 60;
+    const trace = context.trace(start, null, null, stop, self, MASK_MONSTERSOLID);
+    if (trace.fraction < 1) return true;
+    if (i === 1) start = { x: mins.x, y: maxs.y, z: 0 };
+    else start = { x: maxs.x, y: maxs.y, z: 0 };
+    start.z = mins.z - 1;
+    if (context.pointcontents(start) !== 0) return true;
+    stop = { ...start };
+    stop.z = start.z - 60;
+    const trace2 = context.trace(start, null, null, stop, self, MASK_MONSTERSOLID);
+    if (trace2.fraction < 1) return true;
+  }
+  return false;
+}
+function M_walkmove(self, yawDegrees, distance2, context) {
+  if (!((self.flags & (2 /* Swim */ | 1 /* Fly */)) !== 0) && self.movetype !== 1 /* Noclip */) {
+    if (!self.groundentity && self.waterlevel === 0) {
+      return false;
+    }
+  }
+  const delta = yawVector(yawDegrees, distance2);
+  if ((self.monsterinfo.aiflags & 1024 /* NoStep */) !== 0 && (self.monsterinfo.aiflags & 1073741824 /* Pathing */) !== 0) {
+  }
+  const dest = {
+    x: self.origin.x + delta.x,
+    y: self.origin.y + delta.y,
+    z: self.origin.z + delta.z
+  };
+  const trace = context.trace(self.origin, self.mins, self.maxs, dest, self, MASK_MONSTERSOLID);
+  if (trace.fraction < 1) {
+    return false;
+  }
+  const oldOrigin = { ...self.origin };
+  self.origin.x = dest.x;
+  self.origin.y = dest.y;
+  self.origin.z = dest.z;
+  if (!((self.flags & (2 /* Swim */ | 1 /* Fly */)) !== 0) && self.movetype !== 1 /* Noclip */) {
+    if (!M_CheckBottom(self, context)) {
+      self.origin.x = oldOrigin.x;
+      self.origin.y = oldOrigin.y;
+      self.origin.z = oldOrigin.z;
+      return false;
+    }
+  }
+  if (!((self.flags & (2 /* Swim */ | 1 /* Fly */)) !== 0)) {
+    CheckGround(self, context);
+  }
+  return true;
+}
+function SV_StepDirection(self, yaw, dist, context) {
+  for (let i = 0; i <= 90; i += 45) {
+    if (M_walkmove(self, yaw + i, dist, context)) {
+      if (i !== 0) {
+        self.ideal_yaw = angleMod(yaw + i);
+      }
+      return true;
+    }
+    if (i !== 0) {
+      if (M_walkmove(self, yaw - i, dist, context)) {
+        self.ideal_yaw = angleMod(yaw - i);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function SV_NewChaseDir(self, enemy, dist, context) {
+  if (!enemy) return;
+  const olddir = angleMod(self.ideal_yaw - self.angles.y);
+  const turnaround = Math.abs(olddir - 180) < 20;
+  const dx = enemy.origin.x - self.origin.x;
+  const dy = enemy.origin.y - self.origin.y;
+  if (Math.abs(dx) > Math.abs(dy)) {
+    if (dx > 0) self.ideal_yaw = 0;
+    else self.ideal_yaw = 180;
+  } else {
+    if (dy > 0) self.ideal_yaw = 90;
+    else self.ideal_yaw = 270;
+  }
+  if (turnaround) {
+    self.ideal_yaw = angleMod(self.ideal_yaw + 180);
+  }
+  SV_StepDirection(self, self.ideal_yaw, dist, context);
+}
 
 // src/ai/targeting.ts
 function setIdealYawTowards2(self, other) {
@@ -5965,6 +6206,7 @@ export {
   AmmoItemId,
   AmmoType,
   ArmorType,
+  CheckGround,
   DamageFlags,
   DamageMod,
   DeadFlag,
@@ -5978,7 +6220,9 @@ export {
   HEALTH_ITEMS,
   KEY_ITEMS,
   KeyId,
+  M_CheckBottom,
   M_MoveFrame,
+  M_walkmove,
   MoveType,
   ORDERED_DAMAGE_MODS,
   POWERUP_ITEMS,
@@ -5989,6 +6233,8 @@ export {
   RangeCategory,
   SAVE_FORMAT_VERSION,
   SPAWNFLAG_MONSTER_AMBUSH,
+  SV_NewChaseDir,
+  SV_StepDirection,
   SaveStorage,
   ServerFlags,
   Solid,