quake2ts 0.0.168 → 0.0.170

package/packages/game/dist/cjs/index.cjs

@@ -1581,6 +1581,10 @@ var Entity = class {
     this.max_health = 0;
     this.takedamage = false;
     this.dmg = 0;
+    this.radius_dmg = 0;
+    // Damage amount for radius damage (used by BFG, rockets, etc.)
+    this.dmg_radius = 0;
+    // Radius for damage effects
     this.speed = 0;
     this.accel = 0;
     this.decel = 0;
@@ -2934,7 +2938,7 @@ function deserializeInventory(value) {
   return parsed;
 }
 var EntitySystem = class {
-  constructor(engine, imports, gravity, maxEntities, callbackRegistry) {
+  constructor(engine, imports, gravity, maxEntities, callbackRegistry, deathmatch) {
     this.targetNameIndex = /* @__PURE__ */ new Map();
     this.random = createRandomGenerator();
     this.currentTimeSeconds = 0;
@@ -2942,6 +2946,7 @@ var EntitySystem = class {
     this.pool = new EntityPool(maxEntities);
     this.thinkScheduler = new ThinkScheduler();
     this.engine = engine;
+    this.deathmatch = deathmatch ?? false;
     this.imports = imports || {
       trace: () => ({
         allsolid: false,
@@ -5753,58 +5758,211 @@ function createBlasterBolt(sys, owner, start, dir, damage, speed, mod) {
   };
   sys.finalizeSpawn(bolt);
 }
+function fireBfgPiercingLaser(sys, bfg, target, damage) {
+  const start = { ...bfg.origin };
+  const targetCenter2 = {
+    x: (target.absmin.x + target.absmax.x) * 0.5,
+    y: (target.absmin.y + target.absmax.y) * 0.5,
+    z: (target.absmin.z + target.absmax.z) * 0.5
+  };
+  const dir = normalizeVec3(subtractVec3(targetCenter2, start));
+  const end = {
+    x: start.x + dir.x * 2048,
+    y: start.y + dir.y * 2048,
+    z: start.z + dir.z * 2048
+  };
+  const MAX_PIERCE = 16;
+  const pierced = [];
+  const piercedSolidities = [];
+  let currentStart = { ...start };
+  try {
+    for (let i = 0; i < MAX_PIERCE; i++) {
+      const tr = sys.trace(
+        currentStart,
+        null,
+        null,
+        end,
+        bfg,
+        CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_DEADMONSTER
+      );
+      if (!tr.ent || tr.fraction >= 1) {
+        break;
+      }
+      if (tr.ent.takedamage && tr.ent !== bfg.owner) {
+        T_Damage(
+          tr.ent,
+          bfg,
+          bfg.owner,
+          dir,
+          tr.endpos,
+          ZERO_VEC3,
+          damage,
+          1,
+          // kick
+          4 /* ENERGY */,
+          12 /* BFG_LASER */,
+          sys.multicast.bind(sys)
+        );
+      }
+      if (!(tr.ent.svflags & 4 /* Monster */) && !tr.ent.client && tr.ent.classname !== "misc_explobox") {
+        break;
+      }
+      pierced.push(tr.ent);
+      piercedSolidities.push(tr.ent.solid);
+      tr.ent.solid = 0 /* Not */;
+      currentStart = { ...tr.endpos };
+    }
+    const finalTrace = sys.trace(start, null, null, end, bfg, CONTENTS_SOLID);
+    sys.multicast(
+      bfg.origin,
+      2 /* Phs */,
+      ServerCommand.temp_entity,
+      TempEntity.BFG_LASER,
+      start,
+      finalTrace.endpos
+    );
+  } finally {
+    for (let i = 0; i < pierced.length; i++) {
+      pierced[i].solid = piercedSolidities[i];
+    }
+  }
+}
+function bfgThink(self, sys) {
+  const dmg = sys.deathmatch ? 5 : 10;
+  const nearbyEntities = sys.findByRadius(self.origin, 256);
+  for (const ent of nearbyEntities) {
+    if (ent === self || ent === self.owner) {
+      continue;
+    }
+    if (!ent.takedamage) {
+      continue;
+    }
+    if (!(ent.svflags & 4 /* Monster */) && !ent.client && ent.classname !== "misc_explobox") {
+      continue;
+    }
+    const point = {
+      x: (ent.absmin.x + ent.absmax.x) * 0.5,
+      y: (ent.absmin.y + ent.absmax.y) * 0.5,
+      z: (ent.absmin.z + ent.absmax.z) * 0.5
+    };
+    const sightTrace = sys.trace(self.origin, null, null, point, null, MASK_SOLID);
+    if (sightTrace.fraction < 1) {
+      continue;
+    }
+    fireBfgPiercingLaser(sys, self, ent, dmg);
+  }
+  sys.scheduleThink(self, sys.timeSeconds + 0.1);
+}
+function bfgExplode(self, sys) {
+  if (self.frame === void 0 || self.frame < 0) {
+    self.frame = 0;
+  }
+  if (self.frame === 0) {
+    const entities = sys.findByRadius(self.origin, self.dmg_radius || 100);
+    for (const ent of entities) {
+      if (!ent.takedamage) continue;
+      if (ent === self.owner) continue;
+      if (!(ent.svflags & 4 /* Monster */) && !ent.client && ent.classname !== "misc_explobox") {
+        continue;
+      }
+      const centroid = {
+        x: (ent.absmin.x + ent.absmax.x) * 0.5,
+        y: (ent.absmin.y + ent.absmax.y) * 0.5,
+        z: (ent.absmin.z + ent.absmax.z) * 0.5
+      };
+      const delta = subtractVec3(self.origin, centroid);
+      const dist = lengthVec3(delta);
+      const dmgRadius = self.dmg_radius || 100;
+      const points = (self.radius_dmg || 200) * (1 - Math.sqrt(dist / dmgRadius));
+      if (points > 0) {
+        T_Damage(
+          ent,
+          self,
+          self.owner,
+          self.velocity,
+          centroid,
+          ZERO_VEC3,
+          Math.floor(points),
+          0,
+          4 /* ENERGY */,
+          14 /* BFG_EFFECT */,
+          sys.multicast.bind(sys)
+        );
+      }
+    }
+  }
+  self.frame++;
+  if (self.frame >= 5) {
+    sys.free(self);
+    return;
+  }
+  sys.scheduleThink(self, sys.timeSeconds + 0.1);
+}
 function createBfgBall(sys, owner, start, dir, damage, speed, damageRadius) {
   const bfgBall = sys.spawn();
-  bfgBall.classname = "bfg_ball";
+  bfgBall.classname = "bfg blast";
   bfgBall.owner = owner;
   bfgBall.origin = { ...start };
   bfgBall.velocity = { x: dir.x * speed, y: dir.y * speed, z: dir.z * speed };
   bfgBall.movetype = 8 /* FlyMissile */;
   bfgBall.clipmask = 268566530;
   bfgBall.solid = 2 /* BoundingBox */;
-  bfgBall.modelindex = sys.modelIndex("models/objects/bfgball/tris.md2");
+  bfgBall.modelindex = sys.modelIndex("sprites/s_bfg1.sp2");
+  bfgBall.svflags = 128 /* Projectile */;
+  bfgBall.radius_dmg = damage;
+  bfgBall.dmg_radius = damageRadius;
   bfgBall.mins = { x: -10, y: -10, z: -10 };
   bfgBall.maxs = { x: 10, y: 10, z: 10 };
   bfgBall.touch = (self, other, plane, surf) => {
     if (other === self.owner) {
       return;
     }
-    const entities = sys.findByRadius(self.origin, damageRadius);
-    T_RadiusDamage(entities, self, self.owner, damage, self.owner, damageRadius, 0 /* NONE */, 13 /* BFG_BLAST */, {}, sys.multicast.bind(sys));
-    sys.multicast(self.origin, 2 /* Phs */, ServerCommand.temp_entity, TempEntity.BFG_EXPLOSION, self.origin);
-    if (self.owner) {
-      const targets = sys.findByRadius(self.origin, 1e3);
-      const playerOrigin = self.owner.origin;
-      for (const target of targets) {
-        if (target === self.owner || !target.takedamage) continue;
-        const tr = sys.trace(playerOrigin, null, null, target.origin, self.owner, 1 | 2);
-        if (tr.ent !== target && tr.fraction < 1) {
-          continue;
-        }
-        const dir2 = normalizeVec3(subtractVec3(target.origin, self.origin));
-        let laserDamage = 10;
-        T_Damage(
-          target,
-          self,
-          self.owner,
-          dir2,
-          target.origin,
-          ZERO_VEC3,
-          laserDamage,
-          10,
-          4 /* ENERGY */,
-          12 /* BFG_LASER */,
-          sys.multicast.bind(sys)
-        );
-        sys.multicast(self.origin, 2 /* Phs */, ServerCommand.temp_entity, TempEntity.BFG_LASER, playerOrigin, target.origin);
-      }
+    if (other && other.takedamage) {
+      T_Damage(
+        other,
+        self,
+        self.owner,
+        self.velocity,
+        self.origin,
+        plane ? plane.normal : ZERO_VEC3,
+        200,
+        0,
+        4 /* ENERGY */,
+        13 /* BFG_BLAST */,
+        sys.multicast.bind(sys)
+      );
     }
-    sys.free(self);
-  };
-  bfgBall.think = (self) => {
-    self.nextthink = sys.timeSeconds + 0.1;
-  };
-  sys.scheduleThink(bfgBall, sys.timeSeconds + 0.1);
+    const entities = sys.findByRadius(self.origin, 100);
+    T_RadiusDamage(
+      entities,
+      self,
+      self.owner,
+      200,
+      other,
+      100,
+      4 /* ENERGY */,
+      13 /* BFG_BLAST */,
+      {},
+      sys.multicast.bind(sys)
+    );
+    sys.multicast(
+      self.origin,
+      2 /* Phs */,
+      ServerCommand.temp_entity,
+      TempEntity.BFG_BIGEXPLOSION,
+      self.origin
+    );
+    self.solid = 0 /* Not */;
+    self.touch = void 0;
+    self.velocity = ZERO_VEC3;
+    self.modelindex = sys.modelIndex("sprites/s_bfg3.sp2");
+    self.frame = 0;
+    self.enemy = other;
+    self.think = (self2, context) => bfgExplode(self2, context);
+    sys.scheduleThink(self, sys.timeSeconds + 0.1);
+  };
+  bfgBall.think = (self, context) => bfgThink(self, context);
+  sys.scheduleThink(bfgBall, sys.timeSeconds + 0.016);
   sys.finalizeSpawn(bfgBall);
 }
 
@@ -12624,7 +12782,7 @@ function createGame({ trace, pointcontents, multicast, unicast }, engine, option
       z: ent.origin.z + ent.maxs.z
     };
   };
-  const entities = new EntitySystem(engine, { trace, pointcontents, linkentity, multicast, unicast }, gravity);
+  const entities = new EntitySystem(engine, { trace, pointcontents, linkentity, multicast, unicast }, gravity, void 0, void 0, deathmatch);
   frameLoop.addStage("prep", (context) => {
     levelClock.tick(context);
     entities.beginFrame(levelClock.current.timeSeconds);