quake2ts 0.0.464 → 0.0.465

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

@@ -3975,6 +3975,333 @@ function checkTriggers(ent, system) {
   }
 }
 
+// src/combat/specialDamage.ts
+init_esm();
+
+// src/combat/damage.ts
+init_esm();
+init_armor();
+init_damageFlags();
+init_esm();
+
+// src/imports.ts
+var MulticastType = /* @__PURE__ */ ((MulticastType2) => {
+  MulticastType2[MulticastType2["All"] = 0] = "All";
+  MulticastType2[MulticastType2["Pvs"] = 1] = "Pvs";
+  MulticastType2[MulticastType2["Phs"] = 2] = "Phs";
+  return MulticastType2;
+})(MulticastType || {});
+
+// src/combat/damage.ts
+var EntityDamageFlags = /* @__PURE__ */ ((EntityDamageFlags2) => {
+  EntityDamageFlags2[EntityDamageFlags2["GODMODE"] = 1] = "GODMODE";
+  EntityDamageFlags2[EntityDamageFlags2["IMMORTAL"] = 2] = "IMMORTAL";
+  EntityDamageFlags2[EntityDamageFlags2["NO_KNOCKBACK"] = 4] = "NO_KNOCKBACK";
+  EntityDamageFlags2[EntityDamageFlags2["NO_DAMAGE_EFFECTS"] = 8] = "NO_DAMAGE_EFFECTS";
+  return EntityDamageFlags2;
+})(EntityDamageFlags || {});
+function getDamageModifier(attacker, time) {
+  if (!attacker) {
+    return 1;
+  }
+  const client = attacker.client;
+  if (!client) {
+    return 1;
+  }
+  let modifier = 1;
+  if (client.quad_time && client.quad_time > time) {
+    modifier *= 4;
+  }
+  if (client.double_time && client.double_time > time) {
+    modifier *= 2;
+  }
+  return modifier;
+}
+function applyKnockback(targ, attacker, dir, knockback, dflags) {
+  const hasNoKnockback = hasAnyDamageFlag(dflags, 8 /* NO_KNOCKBACK */) || ((targ.flags ?? 0) & 4 /* NO_KNOCKBACK */) !== 0;
+  if (hasNoKnockback || knockback === 0) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  const mass = Math.max(50, targ.mass ?? 200);
+  const normalized = normalizeVec3(dir);
+  const scale = attacker === targ ? 1600 : 500;
+  const delta = scaleVec3(normalized, scale * knockback / mass);
+  targ.velocity = addVec3(targ.velocity, delta);
+  return delta;
+}
+function applyProtection(targ, point, normal, damage, dflags) {
+  let take = damage;
+  let psave = 0;
+  let asave = 0;
+  let remainingCells;
+  let remainingArmor;
+  if (targ.powerArmor) {
+    const result = applyPowerArmor(damage, dflags, point, normal, targ.powerArmor);
+    psave = result.saved;
+    remainingCells = result.remainingCells;
+    take -= psave;
+  }
+  if (targ.regularArmor) {
+    const result = applyRegularArmor(take, dflags, targ.regularArmor);
+    asave = result.saved;
+    remainingArmor = result.remainingArmor;
+    take -= asave;
+  }
+  return [Math.max(0, take), psave, asave, remainingCells, remainingArmor];
+}
+function targetCenter(ent) {
+  if (ent.mins && ent.maxs) {
+    return {
+      x: ent.origin.x + (ent.mins.x + ent.maxs.x) * 0.5,
+      y: ent.origin.y + (ent.mins.y + ent.maxs.y) * 0.5,
+      z: ent.origin.z + (ent.mins.z + ent.maxs.z) * 0.5
+    };
+  }
+  return ent.origin;
+}
+function T_Damage(targ, inflictor, attacker, dir, point, normal, damage, knockback, dflags, mod, time, multicast) {
+  if (!targ.takedamage) {
+    return null;
+  }
+  const modifier = getDamageModifier(attacker, time);
+  const modifiedDamage = damage * modifier;
+  const modifiedKnockback = knockback * modifier;
+  const protectedByGod = !hasAnyDamageFlag(dflags, 32 /* NO_PROTECTION */) && ((targ.flags ?? 0) & 1 /* GODMODE */) !== 0 && modifiedDamage > 0;
+  if (protectedByGod) {
+    return {
+      take: 0,
+      psave: 0,
+      asave: modifiedDamage,
+      knocked: { x: 0, y: 0, z: 0 },
+      killed: false
+    };
+  }
+  const knocked = applyKnockback(targ, attacker, dir, modifiedKnockback, dflags);
+  let [take, psave, asave, remainingCells, remainingArmor] = applyProtection(targ, point, normal, modifiedDamage, dflags);
+  if (targ.monsterinfo && targ.monsterinfo.freeze_time > time && modifiedDamage > 0) {
+    take = targ.health + 100;
+    psave = 0;
+    asave = 0;
+  }
+  if (targ.powerArmor && remainingCells !== void 0) {
+    targ.powerArmor.cellCount = remainingCells;
+  }
+  if (targ.regularArmor) {
+    targ.regularArmor.armorCount = remainingArmor ?? targ.regularArmor.armorCount;
+  }
+  let actualTake = take;
+  if (actualTake > 0) {
+    targ.health -= actualTake;
+    if (multicast && !hasAnyDamageFlag(dflags, 1024 /* NO_DAMAGE_EFFECTS */)) {
+      if (targ.classname === "player" || targ.monsterinfo) {
+        multicast(point, 1 /* Pvs */, ServerCommand.temp_entity, TempEntity.BLOOD, point, normal);
+      } else {
+      }
+    }
+  }
+  const killed = targ.health <= 0;
+  if (killed) {
+    if (targ.flags && targ.flags & 2 /* IMMORTAL */) {
+      targ.health = Math.max(1, targ.health);
+    } else if (targ.die) {
+      targ.die(targ, inflictor, attacker, actualTake, point, mod);
+    }
+  } else if (actualTake > 0 && targ.pain) {
+    targ.pain(targ, attacker, knockback, actualTake, mod);
+  }
+  return { take: actualTake, psave, asave, knocked, killed, remainingCells, remainingArmor };
+}
+function T_RadiusDamage(entities, inflictor, attacker, damage, ignore, radius, dflags, mod, time, options = {}, multicast) {
+  const hits = [];
+  const inflictorCenter = targetCenter(inflictor);
+  const canDamage = options.canDamage ?? (() => true);
+  for (const ent of entities) {
+    if (ent === ignore || !ent.takedamage || !canDamage(ent, inflictor)) {
+      continue;
+    }
+    const entCenter = ent.mins && ent.maxs ? closestPointToBox(inflictorCenter, addVec3(ent.origin, ent.mins), addVec3(ent.origin, ent.maxs)) : targetCenter(ent);
+    const toTarget = subtractVec3(inflictorCenter, entCenter);
+    const distance4 = lengthVec3(toTarget);
+    if (radius > 0 && distance4 > radius) {
+      continue;
+    }
+    const points = damage - 0.5 * distance4;
+    if (points <= 0) {
+      continue;
+    }
+    let adjustedDamage = points;
+    if (ent === attacker) {
+      adjustedDamage = points * 0.5;
+    }
+    const adjustedKnockback = adjustedDamage;
+    const dir = normalizeVec3(subtractVec3(ent.origin, inflictorCenter));
+    const result = T_Damage(ent, inflictor, attacker, dir, entCenter, dir, adjustedDamage, adjustedKnockback, dflags | 1 /* RADIUS */, mod, time, multicast);
+    hits.push({ target: ent, result, appliedDamage: adjustedDamage });
+  }
+  return hits;
+}
+
+// src/combat/specialDamage.ts
+var ZERO2 = { x: 0, y: 0, z: 0 };
+var EnvironmentalFlags = /* @__PURE__ */ ((EnvironmentalFlags2) => {
+  EnvironmentalFlags2[EnvironmentalFlags2["IN_WATER"] = 1] = "IN_WATER";
+  EnvironmentalFlags2[EnvironmentalFlags2["IMMUNE_LAVA"] = 2] = "IMMUNE_LAVA";
+  EnvironmentalFlags2[EnvironmentalFlags2["IMMUNE_SLIME"] = 4] = "IMMUNE_SLIME";
+  return EnvironmentalFlags2;
+})(EnvironmentalFlags || {});
+function applyDamageEvent(target, amount, mod, time) {
+  return T_Damage(target, null, null, ZERO2, target.origin, ZERO2, amount, 0, 2 /* NO_ARMOR */, mod, time);
+}
+function applyEnvironmentalDamage(target, nowMs) {
+  const events = [];
+  let flags = target.environmentFlags ?? 0;
+  let enteredWater = false;
+  let leftWater = false;
+  if (target.waterlevel === WaterLevel.None) {
+    if ((flags & 1 /* IN_WATER */) !== 0) {
+      flags &= ~1 /* IN_WATER */;
+      leftWater = true;
+    }
+    if (target.airFinished < nowMs && target.painDebounceTime <= nowMs) {
+      const elapsedSeconds = Math.floor((nowMs - target.airFinished) / 1e3);
+      const amount = Math.min(15, 2 + 2 * elapsedSeconds);
+      const result = applyDamageEvent(target, amount, 17 /* WATER */, nowMs / 1e3);
+      target.painDebounceTime = nowMs + 1e3;
+      events.push({ mod: 17 /* WATER */, amount, result });
+    }
+  } else {
+    target.airFinished = nowMs + 9e3;
+    if ((flags & 1 /* IN_WATER */) === 0) {
+      flags |= 1 /* IN_WATER */;
+      enteredWater = true;
+      target.damageDebounceTime = 0;
+    }
+    if (target.damageDebounceTime <= nowMs) {
+      if ((target.watertype & CONTENTS_LAVA) !== 0 && (flags & 2 /* IMMUNE_LAVA */) === 0) {
+        const amount = 10 * target.waterlevel;
+        const result = applyDamageEvent(target, amount, 19 /* LAVA */, nowMs / 1e3);
+        target.damageDebounceTime = nowMs + 100;
+        events.push({ mod: 19 /* LAVA */, amount, result });
+      } else if ((target.watertype & CONTENTS_SLIME) !== 0 && (flags & 4 /* IMMUNE_SLIME */) === 0) {
+        const amount = 4 * target.waterlevel;
+        const result = applyDamageEvent(target, amount, 18 /* SLIME */, nowMs / 1e3);
+        target.damageDebounceTime = nowMs + 100;
+        events.push({ mod: 18 /* SLIME */, amount, result });
+      }
+    }
+  }
+  target.environmentFlags = flags;
+  return { events, enteredWater, leftWater };
+}
+function calculateFallingDamage(context) {
+  const {
+    impactDelta,
+    waterLevel,
+    onLadder = false,
+    isDead = false,
+    isPlayerModel = true,
+    isNoClip = false,
+    grappleBlockingFallDamage = false,
+    clampFreeFall = false,
+    skipDamage = false
+  } = context;
+  if (isDead || !isPlayerModel || isNoClip || grappleBlockingFallDamage || waterLevel === WaterLevel.Under) {
+    return { damage: 0, event: null, fallValue: 0, adjustedDelta: 0 };
+  }
+  let delta = impactDelta * impactDelta * 1e-4;
+  if (waterLevel === WaterLevel.Waist) {
+    delta *= 0.25;
+  } else if (waterLevel === WaterLevel.Feet) {
+    delta *= 0.5;
+  }
+  if (clampFreeFall) {
+    delta = Math.min(30, delta);
+  }
+  if (delta < 1) {
+    return { damage: 0, event: null, fallValue: 0, adjustedDelta: delta };
+  }
+  let event = null;
+  let damage = 0;
+  let fallValue = 0;
+  if (delta < 15) {
+    event = onLadder ? null : "footstep";
+  } else {
+    fallValue = Math.min(delta * 0.5, 40);
+    if (delta > 30) {
+      event = delta >= 55 ? "fallfar" : "fall";
+      damage = Math.max(1, (delta - 30) * 0.5);
+    } else {
+      event = "fallshort";
+    }
+  }
+  if (skipDamage) {
+    damage = 0;
+  }
+  return { damage, event, fallValue, adjustedDelta: delta };
+}
+function applyFallingDamage(target, context) {
+  const result = calculateFallingDamage(context);
+  if (result.damage > 0 && !context.skipDamage) {
+    T_Damage(
+      target,
+      null,
+      null,
+      { x: 0, y: 0, z: 1 },
+      target.origin,
+      ZERO2,
+      result.damage,
+      0,
+      2 /* NO_ARMOR */,
+      23 /* FALLING */,
+      0
+    );
+  }
+  return result;
+}
+function applyCrushDamage(crusher, target, options = {}) {
+  const nonLivingDamage = options.nonLivingDamage ?? 1e5;
+  const gibDamage = options.gibDamage ?? 100;
+  const baseDamage = options.baseDamage ?? crusher.dmg ?? 10;
+  const amount = !target.isMonster && !target.isClient ? nonLivingDamage : target.health < 1 ? gibDamage : baseDamage;
+  const result = T_Damage(target, crusher, crusher, ZERO2, target.origin, ZERO2, amount, 1, 0 /* NONE */, 20 /* CRUSH */, 0);
+  return { amount, result };
+}
+function absoluteBounds(ent) {
+  const mins = ent.mins ?? ZERO2;
+  const maxs = ent.maxs ?? ZERO2;
+  return {
+    mins: addVec3(ent.origin, mins),
+    maxs: addVec3(ent.origin, maxs)
+  };
+}
+function killBox(teleporter, targets, options = {}) {
+  if (teleporter.movetype === 1 /* Noclip */) {
+    return { events: [], cleared: true };
+  }
+  const mod = options.mod ?? 21 /* TELEFRAG */;
+  const teleBounds = absoluteBounds(teleporter);
+  const events = [];
+  let cleared = true;
+  for (const target of targets) {
+    if (target === teleporter || target.inUse === false) {
+      continue;
+    }
+    const solidity = target.solid ?? 0 /* Not */;
+    if (!target.takedamage || solidity === 0 /* Not */ || solidity === 1 /* Trigger */ || solidity === 3 /* Bsp */) {
+      continue;
+    }
+    if (!boxesIntersect(teleBounds, absoluteBounds(target))) {
+      continue;
+    }
+    const result = T_Damage(target, teleporter, teleporter, ZERO2, target.origin, ZERO2, 1e5, 0, 32 /* NO_PROTECTION */, mod, 0);
+    events.push({ target, result });
+    if (!result || !result.killed || target.health > 0) {
+      cleared = false;
+    }
+  }
+  return { events, cleared };
+}
+
 // src/physics/movement.ts
 var WATER_FRICTION = 2;
 var WATER_GRAVITY_SCALE = 0.1;
@@ -4064,6 +4391,14 @@ function runStep(ent, system, imports, gravity, frametime) {
     }
     timeLeft -= timeLeft * trace.fraction;
     if (trace.plane) {
+      if (trace.plane.normal.z > 0.7 && velocity.z < 0) {
+        const impactDelta = Math.abs(velocity.z);
+        applyFallingDamage(ent, {
+          impactDelta,
+          waterLevel: ent.waterlevel,
+          isDead: ent.deadflag !== 0
+        });
+      }
       velocity = clipVelocityVec3(velocity, trace.plane.normal, 1);
     }
     const speed = velocity.x * velocity.x + velocity.y * velocity.y + velocity.z * velocity.z;
@@ -5190,239 +5525,76 @@ var EntitySystem = class {
     }
     for (const ref of pendingEntityRefs) {
       const target = ref.targetIndex === null ? null : indexToEntity.get(ref.targetIndex) ?? null;
-      assignField(ref.entity, ref.name, target);
-    }
-    this.thinkScheduler.restore(snapshot.thinks, (index) => indexToEntity.get(index));
-  }
-  runTouches() {
-    const world = this.pool.world;
-    const activeEntities = [];
-    for (const entity of this.pool) {
-      if (entity === world) continue;
-      if (!entity.inUse || entity.freePending || entity.solid === 0 /* Not */) continue;
-      activeEntities.push(entity);
-    }
-    for (const first of activeEntities) {
-      const candidates = this.findInBox(first.absmin, first.absmax);
-      const firstBounds = computeBounds(first);
-      for (const second of candidates) {
-        if (first === second) continue;
-        if (!first.touch) continue;
-        const secondBounds = computeBounds(second);
-        if (!boundsIntersect(firstBounds, secondBounds)) continue;
-        first.touch(first, second);
-      }
-    }
-  }
-  registerTarget(entity) {
-    if (!entity.targetname) {
-      return;
-    }
-    let bucket = this.targetNameIndex.get(entity.targetname);
-    if (!bucket) {
-      bucket = /* @__PURE__ */ new Set();
-      this.targetNameIndex.set(entity.targetname, bucket);
-    }
-    bucket.add(entity);
-  }
-  unregisterTarget(entity) {
-    if (!entity.targetname) {
-      return;
-    }
-    const bucket = this.targetNameIndex.get(entity.targetname);
-    if (!bucket) {
-      return;
-    }
-    bucket.delete(entity);
-    if (bucket.size === 0) {
-      this.targetNameIndex.delete(entity.targetname);
-    }
-  }
-  useTargetsImmediate(entity, activator) {
-    if (entity.target) {
-      for (const target of this.findByTargetName(entity.target)) {
-        if (target === entity) {
-          continue;
-        }
-        target.use?.(target, entity, activator);
-      }
-    }
-    if (entity.killtarget) {
-      for (const victim of this.findByTargetName(entity.killtarget)) {
-        if (victim === entity) {
-          continue;
-        }
-        this.free(victim);
-      }
-    }
-  }
-};
-
-// src/entities/misc.ts
-init_esm();
-
-// src/combat/damage.ts
-init_esm();
-init_armor();
-init_damageFlags();
-init_esm();
-
-// src/imports.ts
-var MulticastType = /* @__PURE__ */ ((MulticastType2) => {
-  MulticastType2[MulticastType2["All"] = 0] = "All";
-  MulticastType2[MulticastType2["Pvs"] = 1] = "Pvs";
-  MulticastType2[MulticastType2["Phs"] = 2] = "Phs";
-  return MulticastType2;
-})(MulticastType || {});
-
-// src/combat/damage.ts
-var EntityDamageFlags = /* @__PURE__ */ ((EntityDamageFlags2) => {
-  EntityDamageFlags2[EntityDamageFlags2["GODMODE"] = 1] = "GODMODE";
-  EntityDamageFlags2[EntityDamageFlags2["IMMORTAL"] = 2] = "IMMORTAL";
-  EntityDamageFlags2[EntityDamageFlags2["NO_KNOCKBACK"] = 4] = "NO_KNOCKBACK";
-  EntityDamageFlags2[EntityDamageFlags2["NO_DAMAGE_EFFECTS"] = 8] = "NO_DAMAGE_EFFECTS";
-  return EntityDamageFlags2;
-})(EntityDamageFlags || {});
-function getDamageModifier(attacker, time) {
-  if (!attacker) {
-    return 1;
-  }
-  const client = attacker.client;
-  if (!client) {
-    return 1;
-  }
-  let modifier = 1;
-  if (client.quad_time && client.quad_time > time) {
-    modifier *= 4;
-  }
-  if (client.double_time && client.double_time > time) {
-    modifier *= 2;
-  }
-  return modifier;
-}
-function applyKnockback(targ, attacker, dir, knockback, dflags) {
-  const hasNoKnockback = hasAnyDamageFlag(dflags, 8 /* NO_KNOCKBACK */) || ((targ.flags ?? 0) & 4 /* NO_KNOCKBACK */) !== 0;
-  if (hasNoKnockback || knockback === 0) {
-    return { x: 0, y: 0, z: 0 };
-  }
-  const mass = Math.max(50, targ.mass ?? 200);
-  const normalized = normalizeVec3(dir);
-  const scale = attacker === targ ? 1600 : 500;
-  const delta = scaleVec3(normalized, scale * knockback / mass);
-  targ.velocity = addVec3(targ.velocity, delta);
-  return delta;
-}
-function applyProtection(targ, point, normal, damage, dflags) {
-  let take = damage;
-  let psave = 0;
-  let asave = 0;
-  let remainingCells;
-  let remainingArmor;
-  if (targ.powerArmor) {
-    const result = applyPowerArmor(damage, dflags, point, normal, targ.powerArmor);
-    psave = result.saved;
-    remainingCells = result.remainingCells;
-    take -= psave;
-  }
-  if (targ.regularArmor) {
-    const result = applyRegularArmor(take, dflags, targ.regularArmor);
-    asave = result.saved;
-    remainingArmor = result.remainingArmor;
-    take -= asave;
-  }
-  return [Math.max(0, take), psave, asave, remainingCells, remainingArmor];
-}
-function targetCenter(ent) {
-  if (ent.mins && ent.maxs) {
-    return {
-      x: ent.origin.x + (ent.mins.x + ent.maxs.x) * 0.5,
-      y: ent.origin.y + (ent.mins.y + ent.maxs.y) * 0.5,
-      z: ent.origin.z + (ent.mins.z + ent.maxs.z) * 0.5
-    };
-  }
-  return ent.origin;
-}
-function T_Damage(targ, inflictor, attacker, dir, point, normal, damage, knockback, dflags, mod, time, multicast) {
-  if (!targ.takedamage) {
-    return null;
-  }
-  const modifier = getDamageModifier(attacker, time);
-  const modifiedDamage = damage * modifier;
-  const modifiedKnockback = knockback * modifier;
-  const protectedByGod = !hasAnyDamageFlag(dflags, 32 /* NO_PROTECTION */) && ((targ.flags ?? 0) & 1 /* GODMODE */) !== 0 && modifiedDamage > 0;
-  if (protectedByGod) {
-    return {
-      take: 0,
-      psave: 0,
-      asave: modifiedDamage,
-      knocked: { x: 0, y: 0, z: 0 },
-      killed: false
-    };
-  }
-  const knocked = applyKnockback(targ, attacker, dir, modifiedKnockback, dflags);
-  let [take, psave, asave, remainingCells, remainingArmor] = applyProtection(targ, point, normal, modifiedDamage, dflags);
-  if (targ.monsterinfo && targ.monsterinfo.freeze_time > time && modifiedDamage > 0) {
-    take = targ.health + 100;
-    psave = 0;
-    asave = 0;
-  }
-  if (targ.powerArmor && remainingCells !== void 0) {
-    targ.powerArmor.cellCount = remainingCells;
-  }
-  if (targ.regularArmor) {
-    targ.regularArmor.armorCount = remainingArmor ?? targ.regularArmor.armorCount;
-  }
-  let actualTake = take;
-  if (actualTake > 0) {
-    targ.health -= actualTake;
-    if (multicast && !hasAnyDamageFlag(dflags, 1024 /* NO_DAMAGE_EFFECTS */)) {
-      if (targ.classname === "player" || targ.monsterinfo) {
-        multicast(point, 1 /* Pvs */, ServerCommand.temp_entity, TempEntity.BLOOD, point, normal);
-      } else {
+      assignField(ref.entity, ref.name, target);
+    }
+    this.thinkScheduler.restore(snapshot.thinks, (index) => indexToEntity.get(index));
+  }
+  runTouches() {
+    const world = this.pool.world;
+    const activeEntities = [];
+    for (const entity of this.pool) {
+      if (entity === world) continue;
+      if (!entity.inUse || entity.freePending || entity.solid === 0 /* Not */) continue;
+      activeEntities.push(entity);
+    }
+    for (const first of activeEntities) {
+      const candidates = this.findInBox(first.absmin, first.absmax);
+      const firstBounds = computeBounds(first);
+      for (const second of candidates) {
+        if (first === second) continue;
+        if (!first.touch) continue;
+        const secondBounds = computeBounds(second);
+        if (!boundsIntersect(firstBounds, secondBounds)) continue;
+        first.touch(first, second);
       }
     }
   }
-  const killed = targ.health <= 0;
-  if (killed) {
-    if (targ.flags && targ.flags & 2 /* IMMORTAL */) {
-      targ.health = Math.max(1, targ.health);
-    } else if (targ.die) {
-      targ.die(targ, inflictor, attacker, actualTake, point, mod);
+  registerTarget(entity) {
+    if (!entity.targetname) {
+      return;
     }
-  } else if (actualTake > 0 && targ.pain) {
-    targ.pain(targ, attacker, knockback, actualTake, mod);
+    let bucket = this.targetNameIndex.get(entity.targetname);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      this.targetNameIndex.set(entity.targetname, bucket);
+    }
+    bucket.add(entity);
   }
-  return { take: actualTake, psave, asave, knocked, killed, remainingCells, remainingArmor };
-}
-function T_RadiusDamage(entities, inflictor, attacker, damage, ignore, radius, dflags, mod, time, options = {}, multicast) {
-  const hits = [];
-  const inflictorCenter = targetCenter(inflictor);
-  const canDamage = options.canDamage ?? (() => true);
-  for (const ent of entities) {
-    if (ent === ignore || !ent.takedamage || !canDamage(ent, inflictor)) {
-      continue;
+  unregisterTarget(entity) {
+    if (!entity.targetname) {
+      return;
     }
-    const entCenter = ent.mins && ent.maxs ? closestPointToBox(inflictorCenter, addVec3(ent.origin, ent.mins), addVec3(ent.origin, ent.maxs)) : targetCenter(ent);
-    const toTarget = subtractVec3(inflictorCenter, entCenter);
-    const distance4 = lengthVec3(toTarget);
-    if (radius > 0 && distance4 > radius) {
-      continue;
+    const bucket = this.targetNameIndex.get(entity.targetname);
+    if (!bucket) {
+      return;
     }
-    const points = damage - 0.5 * distance4;
-    if (points <= 0) {
-      continue;
+    bucket.delete(entity);
+    if (bucket.size === 0) {
+      this.targetNameIndex.delete(entity.targetname);
     }
-    let adjustedDamage = points;
-    if (ent === attacker) {
-      adjustedDamage = points * 0.5;
+  }
+  useTargetsImmediate(entity, activator) {
+    if (entity.target) {
+      for (const target of this.findByTargetName(entity.target)) {
+        if (target === entity) {
+          continue;
+        }
+        target.use?.(target, entity, activator);
+      }
+    }
+    if (entity.killtarget) {
+      for (const victim of this.findByTargetName(entity.killtarget)) {
+        if (victim === entity) {
+          continue;
+        }
+        this.free(victim);
+      }
     }
-    const adjustedKnockback = adjustedDamage;
-    const dir = normalizeVec3(subtractVec3(ent.origin, inflictorCenter));
-    const result = T_Damage(ent, inflictor, attacker, dir, entCenter, dir, adjustedDamage, adjustedKnockback, dflags | 1 /* RADIUS */, mod, time, multicast);
-    hits.push({ target: ent, result, appliedDamage: adjustedDamage });
   }
-  return hits;
-}
+};
+
+// src/entities/misc.ts
+init_esm();
 
 // src/entities/misc/flyers.ts
 init_esm();
@@ -25826,168 +25998,6 @@ function populatePlayerStats(player, timeSeconds) {
 // src/index.ts
 init_esm();
 
-// src/combat/specialDamage.ts
-init_esm();
-var ZERO2 = { x: 0, y: 0, z: 0 };
-var EnvironmentalFlags = /* @__PURE__ */ ((EnvironmentalFlags2) => {
-  EnvironmentalFlags2[EnvironmentalFlags2["IN_WATER"] = 1] = "IN_WATER";
-  EnvironmentalFlags2[EnvironmentalFlags2["IMMUNE_LAVA"] = 2] = "IMMUNE_LAVA";
-  EnvironmentalFlags2[EnvironmentalFlags2["IMMUNE_SLIME"] = 4] = "IMMUNE_SLIME";
-  return EnvironmentalFlags2;
-})(EnvironmentalFlags || {});
-function applyDamageEvent(target, amount, mod, time) {
-  return T_Damage(target, null, null, ZERO2, target.origin, ZERO2, amount, 0, 2 /* NO_ARMOR */, mod, time);
-}
-function applyEnvironmentalDamage(target, nowMs) {
-  const events = [];
-  let flags = target.environmentFlags ?? 0;
-  let enteredWater = false;
-  let leftWater = false;
-  if (target.waterlevel === WaterLevel.None) {
-    if ((flags & 1 /* IN_WATER */) !== 0) {
-      flags &= ~1 /* IN_WATER */;
-      leftWater = true;
-    }
-    if (target.airFinished < nowMs && target.painDebounceTime <= nowMs) {
-      const elapsedSeconds = Math.floor((nowMs - target.airFinished) / 1e3);
-      const amount = Math.min(15, 2 + 2 * elapsedSeconds);
-      const result = applyDamageEvent(target, amount, 17 /* WATER */, nowMs / 1e3);
-      target.painDebounceTime = nowMs + 1e3;
-      events.push({ mod: 17 /* WATER */, amount, result });
-    }
-  } else {
-    target.airFinished = nowMs + 9e3;
-    if ((flags & 1 /* IN_WATER */) === 0) {
-      flags |= 1 /* IN_WATER */;
-      enteredWater = true;
-      target.damageDebounceTime = 0;
-    }
-    if (target.damageDebounceTime <= nowMs) {
-      if ((target.watertype & CONTENTS_LAVA) !== 0 && (flags & 2 /* IMMUNE_LAVA */) === 0) {
-        const amount = 10 * target.waterlevel;
-        const result = applyDamageEvent(target, amount, 19 /* LAVA */, nowMs / 1e3);
-        target.damageDebounceTime = nowMs + 100;
-        events.push({ mod: 19 /* LAVA */, amount, result });
-      } else if ((target.watertype & CONTENTS_SLIME) !== 0 && (flags & 4 /* IMMUNE_SLIME */) === 0) {
-        const amount = 4 * target.waterlevel;
-        const result = applyDamageEvent(target, amount, 18 /* SLIME */, nowMs / 1e3);
-        target.damageDebounceTime = nowMs + 100;
-        events.push({ mod: 18 /* SLIME */, amount, result });
-      }
-    }
-  }
-  target.environmentFlags = flags;
-  return { events, enteredWater, leftWater };
-}
-function calculateFallingDamage(context) {
-  const {
-    impactDelta,
-    waterLevel,
-    onLadder = false,
-    isDead = false,
-    isPlayerModel = true,
-    isNoClip = false,
-    grappleBlockingFallDamage = false,
-    clampFreeFall = false,
-    skipDamage = false
-  } = context;
-  if (isDead || !isPlayerModel || isNoClip || grappleBlockingFallDamage || waterLevel === WaterLevel.Under) {
-    return { damage: 0, event: null, fallValue: 0, adjustedDelta: 0 };
-  }
-  let delta = impactDelta * impactDelta * 1e-4;
-  if (waterLevel === WaterLevel.Waist) {
-    delta *= 0.25;
-  } else if (waterLevel === WaterLevel.Feet) {
-    delta *= 0.5;
-  }
-  if (clampFreeFall) {
-    delta = Math.min(30, delta);
-  }
-  if (delta < 1) {
-    return { damage: 0, event: null, fallValue: 0, adjustedDelta: delta };
-  }
-  let event = null;
-  let damage = 0;
-  let fallValue = 0;
-  if (delta < 15) {
-    event = onLadder ? null : "footstep";
-  } else {
-    fallValue = Math.min(delta * 0.5, 40);
-    if (delta > 30) {
-      event = delta >= 55 ? "fallfar" : "fall";
-      damage = Math.max(1, (delta - 30) * 0.5);
-    } else {
-      event = "fallshort";
-    }
-  }
-  if (skipDamage) {
-    damage = 0;
-  }
-  return { damage, event, fallValue, adjustedDelta: delta };
-}
-function applyFallingDamage(target, context) {
-  const result = calculateFallingDamage(context);
-  if (result.damage > 0 && !context.skipDamage) {
-    T_Damage(
-      target,
-      null,
-      null,
-      { x: 0, y: 0, z: 1 },
-      target.origin,
-      ZERO2,
-      result.damage,
-      0,
-      2 /* NO_ARMOR */,
-      23 /* FALLING */,
-      0
-    );
-  }
-  return result;
-}
-function applyCrushDamage(crusher, target, options = {}) {
-  const nonLivingDamage = options.nonLivingDamage ?? 1e5;
-  const gibDamage = options.gibDamage ?? 100;
-  const baseDamage = options.baseDamage ?? crusher.dmg ?? 10;
-  const amount = !target.isMonster && !target.isClient ? nonLivingDamage : target.health < 1 ? gibDamage : baseDamage;
-  const result = T_Damage(target, crusher, crusher, ZERO2, target.origin, ZERO2, amount, 1, 0 /* NONE */, 20 /* CRUSH */, 0);
-  return { amount, result };
-}
-function absoluteBounds(ent) {
-  const mins = ent.mins ?? ZERO2;
-  const maxs = ent.maxs ?? ZERO2;
-  return {
-    mins: addVec3(ent.origin, mins),
-    maxs: addVec3(ent.origin, maxs)
-  };
-}
-function killBox(teleporter, targets, options = {}) {
-  if (teleporter.movetype === 1 /* Noclip */) {
-    return { events: [], cleared: true };
-  }
-  const mod = options.mod ?? 21 /* TELEFRAG */;
-  const teleBounds = absoluteBounds(teleporter);
-  const events = [];
-  let cleared = true;
-  for (const target of targets) {
-    if (target === teleporter || target.inUse === false) {
-      continue;
-    }
-    const solidity = target.solid ?? 0 /* Not */;
-    if (!target.takedamage || solidity === 0 /* Not */ || solidity === 1 /* Trigger */ || solidity === 3 /* Bsp */) {
-      continue;
-    }
-    if (!boxesIntersect(teleBounds, absoluteBounds(target))) {
-      continue;
-    }
-    const result = T_Damage(target, teleporter, teleporter, ZERO2, target.origin, ZERO2, 1e5, 0, 32 /* NO_PROTECTION */, mod, 0);
-    events.push({ target, result });
-    if (!result || !result.killed || target.health > 0) {
-      cleared = false;
-    }
-  }
-  return { events, cleared };
-}
-
 // src/combat/weapon.ts
 var WeaponType = /* @__PURE__ */ ((WeaponType2) => {
   WeaponType2[WeaponType2["BLASTER"] = 0] = "BLASTER";