quake2ts 0.0.266 → 0.0.269

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

@@ -512,12 +512,12 @@ function addReplayFrame(session, cmd, serverFrame, startTime) {
     timestamp: Date.now() - startTime
   });
 }
-var WaterLevel = /* @__PURE__ */ ((WaterLevel3) => {
-  WaterLevel3[WaterLevel3["None"] = 0] = "None";
-  WaterLevel3[WaterLevel3["Feet"] = 1] = "Feet";
-  WaterLevel3[WaterLevel3["Waist"] = 2] = "Waist";
-  WaterLevel3[WaterLevel3["Under"] = 3] = "Under";
-  return WaterLevel3;
+var WaterLevel = /* @__PURE__ */ ((WaterLevel4) => {
+  WaterLevel4[WaterLevel4["None"] = 0] = "None";
+  WaterLevel4[WaterLevel4["Feet"] = 1] = "Feet";
+  WaterLevel4[WaterLevel4["Waist"] = 2] = "Waist";
+  WaterLevel4[WaterLevel4["Under"] = 3] = "Under";
+  return WaterLevel4;
 })(WaterLevel || {});
 function applyPmoveFriction(params) {
   const {
@@ -594,12 +594,14 @@ function buildWaterWish(params) {
   let wishvel = {
     x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
     y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
-    z: 0
+    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 });
   }
@@ -987,6 +989,13 @@ var U_MODEL3 = 1 << 1;
 var U_MODEL4 = 1 << 2;
 var U_REMOVE = 32768;
 var FRAMETIME = 0.025;
+var MASK_WATER2 = 33554432;
+var WaterLevel3 = {
+  None: 0,
+  Feet: 1,
+  Waist: 2,
+  Under: 3
+};
 var categorizePosition2 = (state, trace) => {
   const point = { ...state.origin };
   point.z -= 0.25;
@@ -998,12 +1007,26 @@ var categorizePosition2 = (state, trace) => {
 };
 var checkWater = (state, pointContents2) => {
   const point = { ...state.origin };
-  point.z += state.mins.z + 1;
+  const { mins, maxs } = state;
+  point.z = state.origin.z + mins.z + 1;
   const contents = pointContents2(point);
-  if (contents & 33554432) {
-    return { ...state, waterLevel: 1 };
-  }
-  return { ...state, waterLevel: 0 };
+  if (!(contents & MASK_WATER2)) {
+    return { ...state, waterLevel: WaterLevel3.None };
+  }
+  let waterLevel = WaterLevel3.Feet;
+  const waist = state.origin.z + (mins.z + maxs.z) * 0.5;
+  point.z = waist;
+  const waistContents = pointContents2(point);
+  if (waistContents & MASK_WATER2) {
+    waterLevel = WaterLevel3.Waist;
+    const head = state.origin.z + 22;
+    point.z = head;
+    const headContents = pointContents2(point);
+    if (headContents & MASK_WATER2) {
+      waterLevel = WaterLevel3.Under;
+    }
+  }
+  return { ...state, waterLevel };
 };
 var applyPmove = (state, cmd, trace, pointContents2) => {
   let newState = { ...state };
@@ -1043,7 +1066,8 @@ var applyPmove = (state, cmd, trace, pointContents2) => {
     velocity: frictionedVelocity,
     wishdir: wish.wishdir,
     wishspeed: wish.wishspeed,
-    accel: onGround ? 10 : 1,
+    // Water movement uses ground acceleration (10), not air acceleration (1)
+    accel: onGround || waterLevel >= 2 ? 10 : 1,
     frametime: FRAMETIME
   });
   const traceResult = trace(origin, {
@@ -3112,6 +3136,9 @@ var EntitySystem = class {
     this.random = createRandomGenerator();
     this.currentTimeSeconds = 0;
     this.frameNumber = 0;
+    // Persistent state for cross-level logic
+    this.crossLevelFlags = 0;
+    this.crossUnitFlags = 0;
     this.pool = new EntityPool(maxEntities);
     this.thinkScheduler = new ThinkScheduler();
     this.engine = engine;
@@ -3437,11 +3464,15 @@ var EntitySystem = class {
         sound2EntityIndex: this.targetAwareness.sound2Entity?.index ?? null,
         sound2EntityFrame: this.targetAwareness.sound2EntityFrame,
         sightClientIndex: this.targetAwareness.sightClient?.index ?? null
-      }
+      },
+      crossLevelFlags: this.crossLevelFlags,
+      crossUnitFlags: this.crossUnitFlags
     };
   }
   restore(snapshot, callbackRegistry) {
     this.currentTimeSeconds = snapshot.timeSeconds;
+    this.crossLevelFlags = snapshot.crossLevelFlags ?? 0;
+    this.crossUnitFlags = snapshot.crossUnitFlags ?? 0;
     this.pool.restore(snapshot.pool);
     const indexToEntity = /* @__PURE__ */ new Map();
     for (const entity of this.pool) {
@@ -4434,6 +4465,131 @@ function useTargetBlaster(self, other, activator, context) {
   }
   context.entities.sound(self, 2, "weapons/laser2.wav", 1, ATTN_NORM, 0);
 }
+var TARGET_LASER_START_ON = 1;
+var TARGET_LASER_RED = 2;
+var TARGET_LASER_GREEN = 4;
+var TARGET_LASER_BLUE = 8;
+var TARGET_LASER_YELLOW = 16;
+var TARGET_LASER_ORANGE = 32;
+var TARGET_LASER_FAT = 64;
+function target_laser_think(self, context) {
+  let count;
+  if (self.spawnflags & 2147483648) {
+    count = 8;
+  } else {
+    count = 4;
+  }
+  if (self.enemy) {
+    const last_movedir = { ...self.movedir };
+    const size = subtractVec3(self.enemy.maxs, self.enemy.mins);
+    const centerOffset = scaleVec3(size, 0.5);
+    const enemyCenter = addVec3(self.enemy.mins, centerOffset);
+    const dir = subtractVec3(enemyCenter, self.origin);
+    self.movedir = normalizeVec3(dir);
+    if (Math.abs(self.movedir.x - last_movedir.x) > 1e-3 || Math.abs(self.movedir.y - last_movedir.y) > 1e-3 || Math.abs(self.movedir.z - last_movedir.z) > 1e-3) {
+      self.spawnflags |= 2147483648;
+    }
+  }
+  let ignore = self;
+  let start = { ...self.origin };
+  const end = addVec3(start, scaleVec3(self.movedir, 2048));
+  let traceResult;
+  while (true) {
+    traceResult = context.entities.trace(start, end, ZERO_VEC3, ZERO_VEC3, ignore, CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_DEADMONSTER);
+    if (!traceResult.ent) {
+      break;
+    }
+    const trEnt = traceResult.ent;
+    if (trEnt.takedamage && !(trEnt.flags & 2)) {
+      T_Damage(trEnt, self, self.activator, self.movedir, traceResult.endpos, ZERO_VEC3, self.dmg, 1, 4 /* ENERGY */, 31 /* TARGET_LASER */, context.entities.timeSeconds);
+    }
+    if (!(trEnt.svflags & 1) && !trEnt.client) {
+      if (self.spawnflags & 2147483648) {
+        self.spawnflags &= ~2147483648;
+        context.entities.multicast(traceResult.endpos, 1 /* Pvs */, ServerCommand.temp_entity, TempEntity.LASER_SPARKS, count, traceResult.endpos, traceResult.plane?.normal || ZERO_VEC3, self.skin);
+      }
+      break;
+    }
+    ignore = trEnt;
+    start = { ...traceResult.endpos };
+  }
+  self.old_origin = { ...traceResult.endpos };
+  self.nextthink = context.entities.timeSeconds + 0.1;
+}
+function target_laser_on(self, context) {
+  if (!self.activator) {
+    self.activator = self;
+  }
+  self.spawnflags |= 2147483649;
+  self.svflags &= ~1 /* NoClient */;
+  target_laser_think(self, context);
+}
+function target_laser_off(self) {
+  self.spawnflags &= ~1;
+  self.svflags |= 1 /* NoClient */;
+  self.nextthink = 0;
+}
+function target_laser_use(self, other, activator, context) {
+  self.activator = activator;
+  if (self.spawnflags & 1) {
+    target_laser_off(self);
+  } else {
+    target_laser_on(self, context);
+  }
+}
+function target_laser_start(self, context) {
+  self.movetype = 0 /* None */;
+  self.solid = 0 /* Not */;
+  self.renderfx |= 8 | 64;
+  self.modelindex = 1;
+  if (self.spawnflags & TARGET_LASER_FAT) {
+    self.frame = 16;
+  } else {
+    self.frame = 4;
+  }
+  if (self.spawnflags & TARGET_LASER_RED) {
+    self.skin = 4076007664;
+  } else if (self.spawnflags & TARGET_LASER_GREEN) {
+    self.skin = 3503411923;
+  } else if (self.spawnflags & TARGET_LASER_BLUE) {
+    self.skin = 4092850673;
+  } else if (self.spawnflags & TARGET_LASER_YELLOW) {
+    self.skin = 3705528031;
+  } else if (self.spawnflags & TARGET_LASER_ORANGE) {
+    self.skin = 3772900067;
+  }
+  if (!self.enemy) {
+    if (self.target) {
+      let found = null;
+      context.entities.forEachEntity((ent) => {
+        if (ent.targetname === self.target) {
+          found = ent;
+        }
+      });
+      if (found) {
+        self.enemy = found;
+      } else {
+        context.warn(`${self.classname} at ${self.origin}: ${self.target} is a bad target`);
+        self.movedir = setMovedir(self.angles);
+      }
+    } else {
+      self.movedir = setMovedir(self.angles);
+    }
+  }
+  self.use = (s, o, a) => target_laser_use(s, o, a || null, context);
+  self.think = (s) => target_laser_think(s, context);
+  if (!self.dmg) {
+    self.dmg = 1;
+  }
+  self.absmin = addVec3(self.origin, { x: -8, y: -8, z: -8 });
+  self.absmax = addVec3(self.origin, { x: 8, y: 8, z: 8 });
+  context.entities.linkentity(self);
+  if (self.spawnflags & TARGET_LASER_START_ON) {
+    target_laser_on(self, context);
+  } else {
+    target_laser_off(self);
+  }
+}
 function registerTargetSpawns(registry) {
   registry.register("target_temp_entity", (entity, context) => {
     entity.style = context.keyValues.style ? parseInt(context.keyValues.style) : 0;
@@ -4516,6 +4672,55 @@ function registerTargetSpawns(registry) {
     if (!entity.speed) entity.speed = 1e3;
     entity.svflags |= 1 /* NoClient */;
   });
+  registry.register("target_laser", (entity, context) => {
+    entity.think = (self) => target_laser_start(self, context);
+    entity.think = (self) => target_laser_start(self, context);
+    entity.nextthink = context.entities.timeSeconds + 1;
+  });
+  registry.register("target_crosslevel_trigger", (entity, context) => {
+    entity.svflags |= 1 /* NoClient */;
+    entity.use = (self) => {
+      context.entities.crossLevelFlags |= self.spawnflags;
+      context.free(self);
+    };
+  });
+  registry.register("target_crosslevel_target", (entity, context) => {
+    entity.svflags |= 1 /* NoClient */;
+    if (!entity.delay) {
+      entity.delay = 1;
+    }
+    const SFL_CROSS_TRIGGER_MASK = 4294967295;
+    entity.think = (self) => {
+      const flags = self.spawnflags & SFL_CROSS_TRIGGER_MASK;
+      if ((context.entities.crossLevelFlags & flags) === flags) {
+        context.entities.useTargets(self, self);
+        context.free(self);
+      }
+    };
+    context.entities.scheduleThink(entity, context.entities.timeSeconds + entity.delay);
+  });
+  registry.register("target_crossunit_trigger", (entity, context) => {
+    entity.svflags |= 1 /* NoClient */;
+    entity.use = (self) => {
+      context.entities.crossUnitFlags |= self.spawnflags;
+      context.free(self);
+    };
+  });
+  registry.register("target_crossunit_target", (entity, context) => {
+    entity.svflags |= 1 /* NoClient */;
+    if (!entity.delay) {
+      entity.delay = 1;
+    }
+    const SFL_CROSS_TRIGGER_MASK = 4294967295;
+    entity.think = (self) => {
+      const flags = self.spawnflags & SFL_CROSS_TRIGGER_MASK;
+      if ((context.entities.crossUnitFlags & flags) === flags) {
+        context.entities.useTargets(self, self);
+        context.free(self);
+      }
+    };
+    context.entities.scheduleThink(entity, context.entities.timeSeconds + entity.delay);
+  });
 }
 
 // src/entities/triggers.ts
@@ -14579,7 +14784,9 @@ function parseEntitySnapshot(raw) {
     pool: parsePool(snapshot.pool),
     entities: parseEntities(snapshot.entities),
     thinks: parseThinkEntries(snapshot.thinks),
-    awareness: parseAwareness(snapshot.awareness)
+    awareness: parseAwareness(snapshot.awareness),
+    crossLevelFlags: ensureNumberOrDefault(snapshot.crossLevelFlags, "entities.crossLevelFlags", 0),
+    crossUnitFlags: ensureNumberOrDefault(snapshot.crossUnitFlags, "entities.crossUnitFlags", 0)
   };
 }
 function parseCvars(raw) {
@@ -14940,7 +15147,9 @@ function buildEntitySnapshot(entities, levelTimeSeconds, capacityHint) {
     pool: { capacity, activeOrder, freeList, pendingFree: [] },
     entities: serialized,
     thinks: [],
-    awareness: dummyAwareness
+    awareness: dummyAwareness,
+    crossLevelFlags: 0,
+    crossUnitFlags: 0
   };
 }
 function buildLevelState(level) {