quake2ts 0.0.494 → 0.0.497

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

@@ -811,36 +811,36 @@ var MAX_ITEMS = 256;
 var MAX_GENERAL = MAX_CLIENTS * 2;
 var MAX_SHADOW_LIGHTS = 256;
 var MAX_WHEEL_ITEMS = 32;
-var ConfigStringIndex = ((ConfigStringIndex2) => {
-  ConfigStringIndex2[ConfigStringIndex2["Name"] = 0] = "Name";
-  ConfigStringIndex2[ConfigStringIndex2["CdTrack"] = 1] = "CdTrack";
-  ConfigStringIndex2[ConfigStringIndex2["Sky"] = 2] = "Sky";
-  ConfigStringIndex2[ConfigStringIndex2["SkyAxis"] = 3] = "SkyAxis";
-  ConfigStringIndex2[ConfigStringIndex2["SkyRotate"] = 4] = "SkyRotate";
-  ConfigStringIndex2[ConfigStringIndex2["StatusBar"] = 5] = "StatusBar";
-  ConfigStringIndex2[ConfigStringIndex2["HealthBarName"] = 55] = "HealthBarName";
-  ConfigStringIndex2[ConfigStringIndex2["CONFIG_N64_PHYSICS"] = 56] = "CONFIG_N64_PHYSICS";
-  ConfigStringIndex2[ConfigStringIndex2["CONFIG_CTF_TEAMS"] = 57] = "CONFIG_CTF_TEAMS";
-  ConfigStringIndex2[ConfigStringIndex2["CONFIG_COOP_RESPAWN_STRING"] = 58] = "CONFIG_COOP_RESPAWN_STRING";
-  ConfigStringIndex2[ConfigStringIndex2["Story"] = 54] = "Story";
-  ConfigStringIndex2[ConfigStringIndex2["AirAccel"] = 59] = "AirAccel";
-  ConfigStringIndex2[ConfigStringIndex2["MaxClients"] = 60] = "MaxClients";
-  ConfigStringIndex2[ConfigStringIndex2["MapChecksum"] = 61] = "MapChecksum";
-  ConfigStringIndex2[ConfigStringIndex2["Models"] = 62] = "Models";
-  ConfigStringIndex2[ConfigStringIndex2["Sounds"] = 62 + MAX_MODELS] = "Sounds";
-  ConfigStringIndex2[ConfigStringIndex2["Images"] = ConfigStringIndex2.Sounds + MAX_SOUNDS] = "Images";
-  ConfigStringIndex2[ConfigStringIndex2["Lights"] = ConfigStringIndex2.Images + MAX_IMAGES] = "Lights";
-  ConfigStringIndex2[ConfigStringIndex2["ShadowLights"] = ConfigStringIndex2.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
-  ConfigStringIndex2[ConfigStringIndex2["Items"] = ConfigStringIndex2.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
-  ConfigStringIndex2[ConfigStringIndex2["PlayerSkins"] = ConfigStringIndex2.Items + MAX_ITEMS] = "PlayerSkins";
-  ConfigStringIndex2[ConfigStringIndex2["General"] = ConfigStringIndex2.PlayerSkins + MAX_CLIENTS] = "General";
-  ConfigStringIndex2[ConfigStringIndex2["WheelWeapons"] = ConfigStringIndex2.General + MAX_GENERAL] = "WheelWeapons";
-  ConfigStringIndex2[ConfigStringIndex2["WheelAmmo"] = ConfigStringIndex2.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
-  ConfigStringIndex2[ConfigStringIndex2["WheelPowerups"] = ConfigStringIndex2.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
-  ConfigStringIndex2[ConfigStringIndex2["CdLoopCount"] = ConfigStringIndex2.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
-  ConfigStringIndex2[ConfigStringIndex2["GameStyle"] = ConfigStringIndex2.CdLoopCount + 1] = "GameStyle";
-  ConfigStringIndex2[ConfigStringIndex2["MaxConfigStrings"] = ConfigStringIndex2.GameStyle + 1] = "MaxConfigStrings";
-  return ConfigStringIndex2;
+var ConfigStringIndex = ((ConfigStringIndex22) => {
+  ConfigStringIndex22[ConfigStringIndex22["Name"] = 0] = "Name";
+  ConfigStringIndex22[ConfigStringIndex22["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex22[ConfigStringIndex22["Sky"] = 2] = "Sky";
+  ConfigStringIndex22[ConfigStringIndex22["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex22[ConfigStringIndex22["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex22[ConfigStringIndex22["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex22[ConfigStringIndex22["HealthBarName"] = 55] = "HealthBarName";
+  ConfigStringIndex22[ConfigStringIndex22["CONFIG_N64_PHYSICS"] = 56] = "CONFIG_N64_PHYSICS";
+  ConfigStringIndex22[ConfigStringIndex22["CONFIG_CTF_TEAMS"] = 57] = "CONFIG_CTF_TEAMS";
+  ConfigStringIndex22[ConfigStringIndex22["CONFIG_COOP_RESPAWN_STRING"] = 58] = "CONFIG_COOP_RESPAWN_STRING";
+  ConfigStringIndex22[ConfigStringIndex22["Story"] = 54] = "Story";
+  ConfigStringIndex22[ConfigStringIndex22["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex22[ConfigStringIndex22["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex22[ConfigStringIndex22["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex22[ConfigStringIndex22["Models"] = 62] = "Models";
+  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS] = "Sounds";
+  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS] = "Images";
+  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES] = "Lights";
+  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
+  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
+  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS] = "PlayerSkins";
+  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS] = "General";
+  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL] = "WheelWeapons";
+  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
+  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
+  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
+  ConfigStringIndex22[ConfigStringIndex22["GameStyle"] = ConfigStringIndex22.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex22[ConfigStringIndex22["MaxConfigStrings"] = ConfigStringIndex22.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex22;
 })(ConfigStringIndex || {});
 var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
 var replay_exports = {};
@@ -5327,6 +5327,9 @@ var EntitySystem = class {
   soundIndex(sound) {
     return this.engine.soundIndex?.(sound) || 0;
   }
+  configStringIndex(str) {
+    return this.engine.configStringIndex?.(str) || 0;
+  }
   modelIndex(model) {
     return this.engine.modelIndex?.(model) || 0;
   }
@@ -5339,8 +5342,8 @@ var EntitySystem = class {
   unlink(ent) {
     this.spatialGrid.remove(ent);
   }
-  multicast(origin, type, ServerCommand6, ...args) {
-    this.imports.multicast(origin, type, ServerCommand6, ...args);
+  multicast(origin, type, ServerCommand7, ...args) {
+    this.imports.multicast(origin, type, ServerCommand7, ...args);
   }
   unicast(ent, reliable, event, ...args) {
     this.imports.unicast(ent, reliable, event, ...args);
@@ -6081,6 +6084,19 @@ function createTrap(context, owner, start, dir, speed) {
 // src/entities/projectiles.ts
 var BFG_LASER_RADIUS = 256;
 var BFG_LASER_RANGE = 2048;
+function createProjectile(sys, start, dir, speed, mod, damage, radiusDamage) {
+  const proj = sys.spawn();
+  proj.movetype = 8 /* FlyMissile */;
+  proj.solid = 2 /* BoundingBox */;
+  proj.origin = { ...start };
+  proj.velocity = { x: dir.x * speed, y: dir.y * speed, z: dir.z * speed };
+  proj.mins = { x: -4, y: -4, z: -4 };
+  proj.maxs = { x: 4, y: 4, z: 4 };
+  proj.angles = vectorToAngles(dir);
+  proj.takedamage = false;
+  sys.finalizeSpawn(proj);
+  return proj;
+}
 function createRocket(sys, owner, start, dir, damage, radiusDamage, speed, flashtype = 0) {
   const rocket = sys.spawn();
   rocket.classname = "rocket";
@@ -7932,170 +7948,7 @@ function registerTargetSpawns(registry) {
   });
 }
 
-// src/entities/triggers/fog.ts
-function clamp2(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-function lerp(start, end, t) {
-  return start + (end - start) * t;
-}
-var SPAWNFLAG_FOG_AFFECT_FOG = 1;
-var SPAWNFLAG_FOG_INSTANTANEOUS = 4;
-var SPAWNFLAG_FOG_FORCE = 8;
-var SPAWNFLAG_FOG_BLEND = 16;
-function trigger_fog_touch(self, other, context) {
-  if (!other || !other.client) return;
-  if (self.timestamp > context.timeSeconds) return;
-  self.timestamp = context.timeSeconds + (self.wait || 0);
-  let fog_value_storage = self;
-  if (self.movetarget) {
-    fog_value_storage = self.movetarget;
-  }
-  if (self.spawnflags & SPAWNFLAG_FOG_INSTANTANEOUS) {
-    if (other.client.pers) other.client.pers.fog_transition_time = 0;
-  } else {
-    if (other.client.pers) other.client.pers.fog_transition_time = fog_value_storage.delay || 0.5;
-  }
-  if (self.spawnflags & SPAWNFLAG_FOG_BLEND) {
-    const center = scaleVec3(addVec3(self.absmin, self.absmax), 0.5);
-    const half_size = addVec3(scaleVec3(self.size, 0.5), scaleVec3(other.size, 0.5));
-    const start = {
-      x: -self.movedir.x * half_size.x,
-      y: -self.movedir.y * half_size.y,
-      z: -self.movedir.z * half_size.z
-    };
-    const end = {
-      x: self.movedir.x * half_size.x,
-      y: self.movedir.y * half_size.y,
-      z: self.movedir.z * half_size.z
-    };
-    const delta = subtractVec3(other.origin, center);
-    const absMovedir = {
-      x: Math.abs(self.movedir.x),
-      y: Math.abs(self.movedir.y),
-      z: Math.abs(self.movedir.z)
-    };
-    const player_dist = {
-      x: delta.x * absMovedir.x,
-      y: delta.y * absMovedir.y,
-      z: delta.z * absMovedir.z
-    };
-    let dist = lengthVec3(subtractVec3(player_dist, start));
-    dist /= lengthVec3(subtractVec3(start, end));
-    dist = clamp2(dist, 0, 1);
-    if (self.spawnflags & SPAWNFLAG_FOG_AFFECT_FOG) {
-      const storage2 = fog_value_storage;
-      if (other.client.pers) {
-        other.client.pers.wanted_fog = {
-          density: lerp(storage2.fog_density_off || 0, storage2.fog_density || 0, dist),
-          r: lerp(storage2.fog_color_off?.[0] || 0, storage2.fog_color?.[0] || 0, dist),
-          g: lerp(storage2.fog_color_off?.[1] || 0, storage2.fog_color?.[1] || 0, dist),
-          b: lerp(storage2.fog_color_off?.[2] || 0, storage2.fog_color?.[2] || 0, dist),
-          sky_factor: lerp(storage2.fog_sky_factor_off || 0, storage2.fog_sky_factor || 0, dist)
-        };
-      }
-    }
-    return;
-  }
-  let use_on = true;
-  if (!(self.spawnflags & SPAWNFLAG_FOG_FORCE)) {
-    const len = lengthVec3(other.velocity);
-    if (len <= 1e-4) return;
-    const forward = normalizeVec3(other.velocity);
-    const dot = forward.x * self.movedir.x + forward.y * self.movedir.y + forward.z * self.movedir.z;
-    use_on = dot > 0;
-  }
-  const storage = fog_value_storage;
-  if (self.spawnflags & SPAWNFLAG_FOG_AFFECT_FOG) {
-    if (other.client.pers) {
-      if (use_on) {
-        other.client.pers.wanted_fog = {
-          density: storage.fog_density || 0,
-          r: storage.fog_color?.[0] || 0,
-          g: storage.fog_color?.[1] || 0,
-          b: storage.fog_color?.[2] || 0,
-          sky_factor: storage.fog_sky_factor || 0
-        };
-      } else {
-        other.client.pers.wanted_fog = {
-          density: storage.fog_density_off || 0,
-          r: storage.fog_color_off?.[0] || 0,
-          g: storage.fog_color_off?.[1] || 0,
-          b: storage.fog_color_off?.[2] || 0,
-          sky_factor: storage.fog_sky_factor_off || 0
-        };
-      }
-    }
-  }
-}
-function registerTriggerFog(registry) {
-  registry.register("trigger_fog", (entity, context) => {
-    entity.solid = 1 /* Trigger */;
-    entity.movetype = 0 /* None */;
-    entity.svflags |= 1 /* NoClient */;
-    const entAny = entity;
-    const kv = context.keyValues;
-    entAny.fog_density = parseFloat(kv.fog_density) || 0;
-    entAny.fog_color = kv.fog_color ? kv.fog_color.split(" ").map(parseFloat) : [0, 0, 0];
-    entAny.fog_sky_factor = parseFloat(kv.fog_sky_factor) || 0;
-    entAny.fog_density_off = parseFloat(kv.fog_density_off) || 0;
-    entAny.fog_color_off = kv.fog_color_off ? kv.fog_color_off.split(" ").map(parseFloat) : [0, 0, 0];
-    entAny.fog_sky_factor_off = parseFloat(kv.fog_sky_factor_off) || 0;
-    if (entity.target) {
-      entity.movetype = 0 /* None */;
-      entity.movetarget = null;
-    }
-    if (!entity.delay) entity.delay = 0.5;
-    entity.touch = (self, other) => trigger_fog_touch(self, other, context.entities);
-  });
-}
-
-// src/entities/triggers/flashlight.ts
-var registerTriggerFlashlight = (registry) => {
-  registry.register("trigger_flashlight", (self, context) => {
-    self.solid = 1 /* Trigger */;
-    self.movetype = 0;
-    self.svflags |= 1 /* NoClient */;
-    self.touch = (self2, other, plane, surf) => {
-      if (!other || !other.client) return;
-      const style = self2.style || 0;
-      let sound = "";
-      if (style === 0) {
-        if (other.flags & 4194304 /* Flashlight */) {
-          other.flags &= ~4194304 /* Flashlight */;
-          sound = "items/flashlight_off.wav";
-        } else {
-          other.flags |= 4194304 /* Flashlight */;
-          sound = "items/flashlight_on.wav";
-        }
-      } else if (style === 1) {
-        if (!(other.flags & 4194304 /* Flashlight */)) {
-          other.flags |= 4194304 /* Flashlight */;
-          sound = "items/flashlight_on.wav";
-        }
-      } else if (style === 2) {
-        if (other.flags & 4194304 /* Flashlight */) {
-          other.flags &= ~4194304 /* Flashlight */;
-          sound = "items/flashlight_off.wav";
-        }
-      }
-      if (other.flags & 4194304 /* Flashlight */) {
-        other.renderfx |= RenderFx.Flashlight;
-      } else {
-        other.renderfx &= ~RenderFx.Flashlight;
-      }
-      if (sound) {
-        context.entities.sound(other, 0, sound, 1, 3, 0);
-      }
-    };
-    context.entities.linkentity(self);
-  });
-};
-
-// src/entities/triggers.ts
-var FRAME_TIME_SECONDS = 1 / 40;
-var THINK_INTERVAL = 0.1;
-var HURT_INTERVAL = 0.1;
+// src/entities/triggers/common.ts
 var TRIGGER_SPAWNFLAGS = {
   Monster: 1 << 0,
   NotPlayer: 1 << 1,
@@ -8104,50 +7957,7 @@ var TRIGGER_SPAWNFLAGS = {
   Latched: 1 << 4,
   Clip: 1 << 5
 };
-var RELAY_SPAWNFLAGS = {
-  NoSound: 1 << 0
-};
-var COUNTER_SPAWNFLAGS = {
-  NoMessage: 1 << 0
-};
-var PUSH_SPAWNFLAGS = {
-  Once: 1 << 0,
-  Plus: 1 << 1,
-  Silent: 1 << 2,
-  StartOff: 1 << 3,
-  Clip: 1 << 4
-};
-var HURT_SPAWNFLAGS = {
-  StartOff: 1 << 0,
-  Toggle: 1 << 1,
-  Silent: 1 << 2,
-  NoProtection: 1 << 3,
-  Slow: 1 << 4,
-  NoPlayers: 1 << 5,
-  NoMonsters: 1 << 6,
-  Clip: 1 << 7
-};
-var TELEPORT_SPAWNFLAGS = {
-  StartOn: 1 << 3
-};
-var GRAVITY_SPAWNFLAGS = {
-  Toggle: 1 << 0,
-  StartOff: 1 << 1,
-  Clip: 1 << 2
-};
-var MONSTERJUMP_SPAWNFLAGS = {
-  Toggle: 1 << 0,
-  StartOff: 1 << 1,
-  Clip: 1 << 2
-};
-function trainResume(train, entities) {
-  if (!train.think) {
-    train.think = (self) => {
-      self.nextthink = 0;
-    };
-  }
-  entities.scheduleThink(train, entities.timeSeconds + FRAME_TIME_SECONDS);
-}
+var FRAME_TIME_SECONDS = 1 / 40;
 function initTrigger(entity) {
   entity.movetype = 0 /* None */;
   entity.solid = 1 /* Trigger */;
@@ -8155,10 +7965,6 @@ function initTrigger(entity) {
   entity.movedir = setMovedir(entity.angles);
   entity.angles = { x: 0, y: 0, z: 0 };
 }
-function multiWait(self) {
-  self.nextthink = 0;
-  self.think = void 0;
-}
 function canActivate(trigger, other) {
   if (trigger.solid === 0 /* Not */) {
     return false;
@@ -8183,6 +7989,15 @@ function canActivate(trigger, other) {
   }
   return true;
 }
+function triggerEnable(self) {
+  self.solid = 1 /* Trigger */;
+}
+
+// src/entities/triggers/multiple.ts
+function multiWait(self) {
+  self.nextthink = 0;
+  self.think = void 0;
+}
 function multiTrigger(self, entities) {
   if (self.nextthink > entities.timeSeconds) {
     return;
@@ -8241,9 +8056,6 @@ function useMulti(self, _other, activator, entities) {
   self.activator = activator;
   multiTrigger(self, entities);
 }
-function triggerEnable(self) {
-  self.solid = 1 /* Trigger */;
-}
 function registerTriggerMultiple(registry) {
   registry.register("trigger_multiple", (entity, context) => {
     initTrigger(entity);
@@ -8269,12 +8081,23 @@ function registerTriggerMultiple(registry) {
     entity.touch = (self, other) => touchMulti(self, other, context.entities);
   });
 }
+
+// src/entities/triggers/once.ts
 function registerTriggerOnce(registry) {
   registry.register("trigger_once", (entity, context) => {
     entity.wait = -1;
-    registry.get("trigger_multiple")?.(entity, context);
+    const multipleSpawn = registry.get("trigger_multiple");
+    if (multipleSpawn) {
+      multipleSpawn(entity, context);
+    } else {
+    }
   });
 }
+
+// src/entities/triggers/relay.ts
+var RELAY_SPAWNFLAGS = {
+  NoSound: 1 << 0
+};
 function registerTriggerRelay(registry) {
   registry.register("trigger_relay", (entity, context) => {
     if (entity.spawnflags & RELAY_SPAWNFLAGS.NoSound) {
@@ -8291,6 +8114,8 @@ function registerTriggerRelay(registry) {
     };
   });
 }
+
+// src/entities/triggers/always.ts
 function registerTriggerAlways(registry) {
   registry.register("trigger_always", (entity, context) => {
     if (entity.delay === 0) {
@@ -8299,14 +8124,27 @@ function registerTriggerAlways(registry) {
     context.entities.useTargets(entity, entity);
   });
 }
+
+// src/entities/triggers/counter.ts
+var COUNTER_SPAWNFLAGS = {
+  NoMessage: 1 << 0
+};
 function counterUse(self, _other, activator, entities) {
   if (self.count === 0) {
     return;
   }
   self.count -= 1;
   if (self.count > 0) {
+    if (!(self.spawnflags & COUNTER_SPAWNFLAGS.NoMessage) && activator && activator.client) {
+      entities.engine.centerprintf?.(activator, `${self.count} more to go...`);
+      entities.sound(activator, 0, "misc/talk1.wav", 1, 1, 0);
+    }
     return;
   }
+  if (!(self.spawnflags & COUNTER_SPAWNFLAGS.NoMessage) && activator && activator.client) {
+    entities.engine.centerprintf?.(activator, "Sequence completed!");
+    entities.sound(activator, 0, "misc/talk1.wav", 1, 1, 0);
+  }
   self.activator = activator;
   multiTrigger(self, entities);
 }
@@ -8322,6 +8160,8 @@ function registerTriggerCounter(registry) {
     }
   });
 }
+
+// src/entities/triggers/key.ts
 function triggerKeyUse(self, activator, entities, warn) {
   if (!self.item || !activator) {
     return;
@@ -8332,13 +8172,17 @@ function triggerKeyUse(self, activator, entities, warn) {
       return;
     }
     self.timestamp = entities.timeSeconds + 5;
-    warn(`Missing required key item: ${self.item}`);
+    if (activator.client) {
+      entities.engine.centerprintf?.(activator, `You need the ${self.item}`);
+      entities.sound(activator, 0, "misc/keytry.wav", 1, 1, 0);
+    }
     return;
   }
   activator.inventory[self.item] = available - 1;
   if (activator.inventory[self.item] <= 0) {
     delete activator.inventory[self.item];
   }
+  entities.sound(activator, 0, "misc/keyuse.wav", 1, 1, 0);
   entities.useTargets(self, activator);
   self.use = void 0;
 }
@@ -8354,6 +8198,16 @@ function registerTriggerKey(registry) {
     entity.use = (self, other, activator) => triggerKeyUse(self, activator ?? other, context.entities, context.warn);
   });
 }
+
+// src/entities/triggers/push.ts
+var PUSH_SPAWNFLAGS = {
+  Once: 1 << 0,
+  Plus: 1 << 1,
+  Silent: 1 << 2,
+  StartOff: 1 << 3,
+  Clip: 1 << 4
+};
+var THINK_INTERVAL = 0.1;
 function triggerPushTouch(self, other, entities) {
   if (!other) {
     return;
@@ -8365,6 +8219,12 @@ function triggerPushTouch(self, other, entities) {
       y: self.movedir.y * scale,
       z: self.movedir.z * scale
     };
+    if (!(self.spawnflags & PUSH_SPAWNFLAGS.Silent)) {
+      if (!other.fly_sound_debounce_time || other.fly_sound_debounce_time < entities.timeSeconds) {
+        other.fly_sound_debounce_time = entities.timeSeconds + 1.5;
+        entities.sound(other, 0, "misc/windfly.wav", 1, 1, 0);
+      }
+    }
   }
   if (self.spawnflags & PUSH_SPAWNFLAGS.Once) {
     entities.free(self);
@@ -8426,10 +8286,23 @@ function registerTriggerPush(registry) {
     }
   });
 }
-function hurtTouch(self, other, entities) {
-  if (!other) {
-    return;
-  }
+
+// src/entities/triggers/hurt.ts
+var HURT_SPAWNFLAGS = {
+  StartOff: 1 << 0,
+  Toggle: 1 << 1,
+  Silent: 1 << 2,
+  NoProtection: 1 << 3,
+  Slow: 1 << 4,
+  NoPlayers: 1 << 5,
+  NoMonsters: 1 << 6,
+  Clip: 1 << 7
+};
+var HURT_INTERVAL = 0.1;
+function hurtTouch(self, other, entities) {
+  if (!other) {
+    return;
+  }
   if (!other.takedamage && other.classname !== "grenade") {
     return;
   }
@@ -8446,6 +8319,9 @@ function hurtTouch(self, other, entities) {
   const damage = self.dmg || 5;
   other.health -= damage;
 }
+function toggleSolid2(self) {
+  self.solid = self.solid === 0 /* Not */ ? 1 /* Trigger */ : 0 /* Not */;
+}
 function registerTriggerHurt(registry) {
   registry.register("trigger_hurt", (entity, context) => {
     initTrigger(entity);
@@ -8458,178 +8334,475 @@ function registerTriggerHurt(registry) {
     }
     if (entity.spawnflags & HURT_SPAWNFLAGS.Toggle) {
       entity.use = (self) => {
-        toggleSolid(self);
+        toggleSolid2(self);
+        self.touch = self.solid === 1 /* Trigger */ ? touchHandler : void 0;
+      };
+    }
+  });
+}
+
+// src/entities/triggers/teleport.ts
+var TELEPORT_SPAWNFLAGS = {
+  StartOn: 1 << 3
+};
+function teleportTouch(self, other, entities, warn) {
+  if (!other) {
+    return;
+  }
+  if (self.delay > 0) {
+    return;
+  }
+  const destination = entities.pickTarget(self.target);
+  if (!destination) {
+    warn("trigger_teleport target not found");
+    return;
+  }
+  const destOrigin = {
+    x: destination.origin.x,
+    y: destination.origin.y,
+    z: destination.origin.z + 10
+  };
+  other.origin = { ...destOrigin };
+  other.old_origin = { ...destOrigin };
+  other.velocity = { x: 0, y: 0, z: 0 };
+  other.groundentity = null;
+  other.angles = { ...destination.angles };
+  entities.killBox(other);
+}
+function registerTriggerTeleport(registry) {
+  registry.register("trigger_teleport", (entity, context) => {
+    if (!entity.wait) {
+      entity.wait = 0.2;
+    }
+    initTrigger(entity);
+    if (entity.targetname) {
+      entity.use = (self) => {
+        self.delay = self.delay > 0 ? 0 : 1;
+      };
+      if ((entity.spawnflags & TELEPORT_SPAWNFLAGS.StartOn) === 0) {
+        entity.delay = 1;
+      }
+    }
+    entity.touch = (self, other) => teleportTouch(self, other, context.entities, context.warn);
+  });
+}
+
+// src/entities/triggers/gravity.ts
+var GRAVITY_SPAWNFLAGS = {
+  Toggle: 1 << 0,
+  StartOff: 1 << 1,
+  Clip: 1 << 2
+};
+function gravityTouch(self, other) {
+  if (!other) {
+    return;
+  }
+  if (self.spawnflags & GRAVITY_SPAWNFLAGS.Clip) {
+  }
+  other.gravity = self.gravity;
+}
+function toggleSolid3(self) {
+  self.solid = self.solid === 0 /* Not */ ? 1 /* Trigger */ : 0 /* Not */;
+}
+function registerTriggerGravity(registry) {
+  registry.register("trigger_gravity", (entity, context) => {
+    const gravityText = context.keyValues.gravity;
+    if (!gravityText) {
+      context.warn("trigger_gravity requires a gravity value");
+      context.free(entity);
+      return;
+    }
+    initTrigger(entity);
+    entity.gravity = Number.parseFloat(gravityText) || 0;
+    const touchHandler = (self, other) => gravityTouch(self, other);
+    entity.touch = touchHandler;
+    if (entity.spawnflags & GRAVITY_SPAWNFLAGS.StartOff) {
+      entity.solid = 0 /* Not */;
+      entity.touch = void 0;
+    }
+    if (entity.spawnflags & GRAVITY_SPAWNFLAGS.Toggle) {
+      entity.use = (self) => {
+        toggleSolid3(self);
         self.touch = self.solid === 1 /* Trigger */ ? touchHandler : void 0;
       };
     }
   });
-}
-function teleportTouch(self, other, entities, warn) {
-  if (!other) {
+}
+
+// src/entities/triggers/elevator.ts
+function trainResume(train, entities) {
+  if (!train.think) {
+    train.think = (self) => {
+      self.nextthink = 0;
+    };
+  }
+  entities.scheduleThink(train, entities.timeSeconds + FRAME_TIME_SECONDS);
+}
+function triggerElevatorUse(self, other, entities, warn) {
+  if (!self.movetarget) {
+    return;
+  }
+  if (self.movetarget.nextthink > 0) {
+    return;
+  }
+  if (!other?.pathtarget) {
+    warn("trigger_elevator used with no pathtarget");
+    return;
+  }
+  const target = entities.pickTarget(other.pathtarget);
+  if (!target) {
+    warn(`trigger_elevator used with bad pathtarget: ${other.pathtarget}`);
+    return;
+  }
+  self.movetarget.target_ent = target;
+  trainResume(self.movetarget, entities);
+}
+function triggerElevatorInit(self, entities, warn) {
+  if (!self.target) {
+    warn("trigger_elevator has no target");
+    return;
+  }
+  const target = entities.pickTarget(self.target);
+  if (!target) {
+    warn(`trigger_elevator unable to find target ${self.target}`);
+    return;
+  }
+  self.movetarget = target;
+  if (target.classname !== "func_train") {
+    warn(`trigger_elevator target ${self.target} is not a train`);
+    return;
+  }
+  self.use = (entity, other, activator) => triggerElevatorUse(entity, other ?? activator ?? null, entities, warn);
+  self.svflags |= 1 /* NoClient */;
+}
+function registerTriggerElevator(registry) {
+  registry.register("trigger_elevator", (entity, context) => {
+    entity.think = (self) => triggerElevatorInit(self, context.entities, context.warn);
+    context.entities.scheduleThink(entity, context.entities.timeSeconds + FRAME_TIME_SECONDS);
+  });
+}
+
+// src/entities/triggers/monsterjump.ts
+var MONSTERJUMP_SPAWNFLAGS = {
+  Toggle: 1 << 0,
+  StartOff: 1 << 1,
+  Clip: 1 << 2
+};
+function monsterJumpTouch(self, other) {
+  if (!other) {
+    return;
+  }
+  if ((other.flags & (1 /* Fly */ | 2 /* Swim */)) !== 0) {
+    return;
+  }
+  if (other.svflags & 2 /* DeadMonster */) {
+    return;
+  }
+  if ((other.svflags & 4 /* Monster */) === 0) {
+    return;
+  }
+  other.velocity = {
+    x: self.movedir.x * self.speed,
+    y: self.movedir.y * self.speed,
+    z: other.velocity.z
+  };
+  if (!other.groundentity) {
+    return;
+  }
+  other.groundentity = null;
+  other.velocity = { x: other.velocity.x, y: other.velocity.y, z: self.movedir.z };
+}
+function toggleSolid4(self) {
+  self.solid = self.solid === 0 /* Not */ ? 1 /* Trigger */ : 0 /* Not */;
+}
+function registerTriggerMonsterJump(registry) {
+  registry.register("trigger_monsterjump", (entity, context) => {
+    const heightText = context.keyValues.height;
+    const height = heightText ? Number.parseFloat(heightText) || 0 : 200;
+    if (entity.angles.y === 0) {
+      entity.angles = { ...entity.angles, y: 360 };
+    }
+    if (!entity.speed) {
+      entity.speed = 200;
+    }
+    initTrigger(entity);
+    entity.movedir = { ...entity.movedir, z: height };
+    const touchHandler = (self, other) => monsterJumpTouch(self, other);
+    entity.touch = touchHandler;
+    if (entity.spawnflags & MONSTERJUMP_SPAWNFLAGS.StartOff) {
+      entity.solid = 0 /* Not */;
+      entity.touch = void 0;
+    }
+    if (entity.spawnflags & MONSTERJUMP_SPAWNFLAGS.Toggle) {
+      entity.use = (self) => {
+        toggleSolid4(self);
+        self.touch = self.solid === 1 /* Trigger */ ? touchHandler : void 0;
+      };
+    }
+  });
+}
+
+// src/entities/triggers/fog.ts
+function clamp2(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function lerp(start, end, t) {
+  return start + (end - start) * t;
+}
+var SPAWNFLAG_FOG_AFFECT_FOG = 1;
+var SPAWNFLAG_FOG_INSTANTANEOUS = 4;
+var SPAWNFLAG_FOG_FORCE = 8;
+var SPAWNFLAG_FOG_BLEND = 16;
+function trigger_fog_touch(self, other, context) {
+  if (!other || !other.client) return;
+  if (self.timestamp > context.timeSeconds) return;
+  self.timestamp = context.timeSeconds + (self.wait || 0);
+  let fog_value_storage = self;
+  if (self.movetarget) {
+    fog_value_storage = self.movetarget;
+  }
+  if (self.spawnflags & SPAWNFLAG_FOG_INSTANTANEOUS) {
+    if (other.client.pers) other.client.pers.fog_transition_time = 0;
+  } else {
+    if (other.client.pers) other.client.pers.fog_transition_time = fog_value_storage.delay || 0.5;
+  }
+  if (self.spawnflags & SPAWNFLAG_FOG_BLEND) {
+    const center = scaleVec3(addVec3(self.absmin, self.absmax), 0.5);
+    const half_size = addVec3(scaleVec3(self.size, 0.5), scaleVec3(other.size, 0.5));
+    const start = {
+      x: -self.movedir.x * half_size.x,
+      y: -self.movedir.y * half_size.y,
+      z: -self.movedir.z * half_size.z
+    };
+    const end = {
+      x: self.movedir.x * half_size.x,
+      y: self.movedir.y * half_size.y,
+      z: self.movedir.z * half_size.z
+    };
+    const delta = subtractVec3(other.origin, center);
+    const absMovedir = {
+      x: Math.abs(self.movedir.x),
+      y: Math.abs(self.movedir.y),
+      z: Math.abs(self.movedir.z)
+    };
+    const player_dist = {
+      x: delta.x * absMovedir.x,
+      y: delta.y * absMovedir.y,
+      z: delta.z * absMovedir.z
+    };
+    let dist = lengthVec3(subtractVec3(player_dist, start));
+    dist /= lengthVec3(subtractVec3(start, end));
+    dist = clamp2(dist, 0, 1);
+    if (self.spawnflags & SPAWNFLAG_FOG_AFFECT_FOG) {
+      const storage2 = fog_value_storage;
+      if (other.client.pers) {
+        other.client.pers.wanted_fog = {
+          density: lerp(storage2.fog_density_off || 0, storage2.fog_density || 0, dist),
+          r: lerp(storage2.fog_color_off?.[0] || 0, storage2.fog_color?.[0] || 0, dist),
+          g: lerp(storage2.fog_color_off?.[1] || 0, storage2.fog_color?.[1] || 0, dist),
+          b: lerp(storage2.fog_color_off?.[2] || 0, storage2.fog_color?.[2] || 0, dist),
+          sky_factor: lerp(storage2.fog_sky_factor_off || 0, storage2.fog_sky_factor || 0, dist)
+        };
+      }
+    }
+    return;
+  }
+  let use_on = true;
+  if (!(self.spawnflags & SPAWNFLAG_FOG_FORCE)) {
+    const len = lengthVec3(other.velocity);
+    if (len <= 1e-4) return;
+    const forward = normalizeVec3(other.velocity);
+    const dot = forward.x * self.movedir.x + forward.y * self.movedir.y + forward.z * self.movedir.z;
+    use_on = dot > 0;
+  }
+  const storage = fog_value_storage;
+  if (self.spawnflags & SPAWNFLAG_FOG_AFFECT_FOG) {
+    if (other.client.pers) {
+      if (use_on) {
+        other.client.pers.wanted_fog = {
+          density: storage.fog_density || 0,
+          r: storage.fog_color?.[0] || 0,
+          g: storage.fog_color?.[1] || 0,
+          b: storage.fog_color?.[2] || 0,
+          sky_factor: storage.fog_sky_factor || 0
+        };
+      } else {
+        other.client.pers.wanted_fog = {
+          density: storage.fog_density_off || 0,
+          r: storage.fog_color_off?.[0] || 0,
+          g: storage.fog_color_off?.[1] || 0,
+          b: storage.fog_color_off?.[2] || 0,
+          sky_factor: storage.fog_sky_factor_off || 0
+        };
+      }
+    }
+  }
+}
+function registerTriggerFog(registry) {
+  registry.register("trigger_fog", (entity, context) => {
+    entity.solid = 1 /* Trigger */;
+    entity.movetype = 0 /* None */;
+    entity.svflags |= 1 /* NoClient */;
+    const entAny = entity;
+    const kv = context.keyValues;
+    entAny.fog_density = parseFloat(kv.fog_density) || 0;
+    entAny.fog_color = kv.fog_color ? kv.fog_color.split(" ").map(parseFloat) : [0, 0, 0];
+    entAny.fog_sky_factor = parseFloat(kv.fog_sky_factor) || 0;
+    entAny.fog_density_off = parseFloat(kv.fog_density_off) || 0;
+    entAny.fog_color_off = kv.fog_color_off ? kv.fog_color_off.split(" ").map(parseFloat) : [0, 0, 0];
+    entAny.fog_sky_factor_off = parseFloat(kv.fog_sky_factor_off) || 0;
+    if (entity.target) {
+      entity.movetype = 0 /* None */;
+      entity.movetarget = null;
+    }
+    if (!entity.delay) entity.delay = 0.5;
+    entity.touch = (self, other) => trigger_fog_touch(self, other, context.entities);
+  });
+}
+
+// src/entities/triggers/flashlight.ts
+var registerTriggerFlashlight = (registry) => {
+  registry.register("trigger_flashlight", (self, context) => {
+    self.solid = 1 /* Trigger */;
+    self.movetype = 0;
+    self.svflags |= 1 /* NoClient */;
+    self.touch = (self2, other, plane, surf) => {
+      if (!other || !other.client) return;
+      const style = self2.style || 0;
+      let sound = "";
+      if (style === 0) {
+        if (other.flags & 4194304 /* Flashlight */) {
+          other.flags &= ~4194304 /* Flashlight */;
+          sound = "items/flashlight_off.wav";
+        } else {
+          other.flags |= 4194304 /* Flashlight */;
+          sound = "items/flashlight_on.wav";
+        }
+      } else if (style === 1) {
+        if (!(other.flags & 4194304 /* Flashlight */)) {
+          other.flags |= 4194304 /* Flashlight */;
+          sound = "items/flashlight_on.wav";
+        }
+      } else if (style === 2) {
+        if (other.flags & 4194304 /* Flashlight */) {
+          other.flags &= ~4194304 /* Flashlight */;
+          sound = "items/flashlight_off.wav";
+        }
+      }
+      if (other.flags & 4194304 /* Flashlight */) {
+        other.renderfx |= RenderFx.Flashlight;
+      } else {
+        other.renderfx &= ~RenderFx.Flashlight;
+      }
+      if (sound) {
+        context.entities.sound(other, 0, sound, 1, 3, 0);
+      }
+    };
+    context.entities.linkentity(self);
+  });
+};
+
+// src/entities/triggers/secret.ts
+var SECRET_SPAWNFLAGS = {
+  Once: 1 << 0
+};
+function triggerSecretTouch(self, other, entities) {
+  if (!other || !other.client) {
     return;
   }
-  if (self.delay > 0) {
+  if (self.timestamp > entities.timeSeconds) {
     return;
   }
-  const destination = entities.pickTarget(self.target);
-  if (!destination) {
-    warn("trigger_teleport target not found");
-    return;
+  self.timestamp = entities.timeSeconds + 1;
+  if (!self.message) {
+    self.message = "You found a secret area!";
   }
-  const destOrigin = {
-    x: destination.origin.x,
-    y: destination.origin.y,
-    z: destination.origin.z + 10
-  };
-  other.origin = { ...destOrigin };
-  other.old_origin = { ...destOrigin };
-  other.velocity = { x: 0, y: 0, z: 0 };
-  other.groundentity = null;
-  other.angles = { ...destination.angles };
-  entities.killBox(other);
-}
-function registerTriggerTeleport(registry) {
-  registry.register("trigger_teleport", (entity, context) => {
-    if (!entity.wait) {
-      entity.wait = 0.2;
-    }
-    initTrigger(entity);
-    if (entity.targetname) {
-      entity.use = (self) => {
-        self.delay = self.delay > 0 ? 0 : 1;
-      };
-      if ((entity.spawnflags & TELEPORT_SPAWNFLAGS.StartOn) === 0) {
-        entity.delay = 1;
-      }
-    }
-    entity.touch = (self, other) => teleportTouch(self, other, context.entities, context.warn);
-  });
-}
-function gravityTouch(self, other) {
-  if (!other) {
-    return;
+  if (other.client) {
+    entities.engine.centerprintf?.(other, self.message);
+    entities.sound(other, 0, "misc/secret.wav", 1, 1, 0);
   }
-  if (self.spawnflags & GRAVITY_SPAWNFLAGS.Clip) {
+  if (self.spawnflags & SECRET_SPAWNFLAGS.Once) {
+    entities.free(self);
   }
-  other.gravity = self.gravity;
 }
-function registerTriggerGravity(registry) {
-  registry.register("trigger_gravity", (entity, context) => {
-    const gravityText = context.keyValues.gravity;
-    if (!gravityText) {
-      context.warn("trigger_gravity requires a gravity value");
-      context.free(entity);
-      return;
-    }
-    initTrigger(entity);
-    entity.gravity = Number.parseFloat(gravityText) || 0;
-    const touchHandler = (self, other) => gravityTouch(self, other);
-    entity.touch = touchHandler;
-    if (entity.spawnflags & GRAVITY_SPAWNFLAGS.StartOff) {
+function registerTriggerSecret(registry) {
+  registry.register("trigger_secret", (entity, context) => {
+    entity.movetype = 0 /* None */;
+    entity.solid = 1 /* Trigger */;
+    entity.svflags |= 1 /* NoClient */;
+    entity.movedir = setMovedir(entity.angles);
+    entity.angles = { x: 0, y: 0, z: 0 };
+    if (entity.targetname) {
       entity.solid = 0 /* Not */;
-      entity.touch = void 0;
-    }
-    if (entity.spawnflags & GRAVITY_SPAWNFLAGS.Toggle) {
       entity.use = (self) => {
-        toggleSolid(self);
-        self.touch = self.solid === 1 /* Trigger */ ? touchHandler : void 0;
+        self.solid = 1 /* Trigger */;
+        self.use = void 0;
       };
     }
+    entity.touch = (self, other) => triggerSecretTouch(self, other, context.entities);
   });
 }
-function monsterJumpTouch(self, other) {
-  if (!other) {
-    return;
-  }
-  if ((other.flags & (1 /* Fly */ | 2 /* Swim */)) !== 0) {
-    return;
-  }
-  if (other.svflags & 2 /* DeadMonster */) {
-    return;
-  }
-  if ((other.svflags & 4 /* Monster */) === 0) {
-    return;
+
+// src/entities/triggers/look.ts
+var LOOK_SPAWNFLAGS = {
+  LookAway: 1 << 0
+};
+function triggerLookThink(self, entities) {
+  let fired = false;
+  const players = entities.findByClassname("player");
+  for (const player of players) {
+    if (player.health <= 0) continue;
+    const vec = subtractVec3(self.origin, player.origin);
+    const dist = Math.sqrt(dotVec3(vec, vec));
+    const dir = normalizeVec3(vec);
+    const forward = angleVectors(player.angles).forward;
+    const dot = dotVec3(forward, dir);
+    const fov = self.fov || 0.9;
+    if (dot >= fov) {
+      fired = true;
+      self.activator = player;
+      entities.useTargets(self, player);
+      break;
+    }
   }
-  other.velocity = {
-    x: self.movedir.x * self.speed,
-    y: self.movedir.y * self.speed,
-    z: other.velocity.z
-  };
-  if (!other.groundentity) {
-    return;
+  if (fired) {
+    entities.free(self);
+  } else {
+    entities.scheduleThink(self, entities.timeSeconds + 0.1);
   }
-  other.groundentity = null;
-  other.velocity = { x: other.velocity.x, y: other.velocity.y, z: self.movedir.z };
 }
-function triggerElevatorUse(self, other, entities, warn) {
-  if (!self.movetarget) {
-    return;
-  }
-  if (self.movetarget.nextthink > 0) {
-    return;
-  }
-  if (!other?.pathtarget) {
-    warn("trigger_elevator used with no pathtarget");
-    return;
-  }
-  const target = entities.pickTarget(other.pathtarget);
-  if (!target) {
-    warn(`trigger_elevator used with bad pathtarget: ${other.pathtarget}`);
-    return;
-  }
-  self.movetarget.target_ent = target;
-  trainResume(self.movetarget, entities);
+function registerTriggerLook(registry) {
+  registry.register("trigger_look", (entity, context) => {
+    entity.movetype = 0 /* None */;
+    entity.solid = 0 /* Not */;
+    entity.svflags |= 1 /* NoClient */;
+    entity.movedir = setMovedir(entity.angles);
+    if (!entity.fov) entity.fov = 0.9;
+    entity.think = (self) => triggerLookThink(self, context.entities);
+    context.entities.scheduleThink(entity, context.entities.timeSeconds + 0.1);
+  });
 }
-function triggerElevatorInit(self, entities, warn) {
-  if (!self.target) {
-    warn("trigger_elevator has no target");
-    return;
-  }
-  const target = entities.pickTarget(self.target);
-  if (!target) {
-    warn(`trigger_elevator unable to find target ${self.target}`);
-    return;
-  }
-  self.movetarget = target;
-  if (target.classname !== "func_train") {
-    warn(`trigger_elevator target ${self.target} is not a train`);
-    return;
+
+// src/entities/triggers/bad_area.ts
+function badAreaTouch(self, other) {
+  if (!other) return;
+  if (other.takedamage) {
   }
-  self.use = (entity, other, activator) => triggerElevatorUse(entity, other ?? activator ?? null, entities, warn);
-  self.svflags |= 1 /* NoClient */;
-}
-function registerTriggerElevator(registry) {
-  registry.register("trigger_elevator", (entity, context) => {
-    entity.think = (self) => triggerElevatorInit(self, context.entities, context.warn);
-    context.entities.scheduleThink(entity, context.entities.timeSeconds + FRAME_TIME_SECONDS);
-  });
 }
-function registerTriggerMonsterJump(registry) {
-  registry.register("trigger_monsterjump", (entity, context) => {
-    const heightText = context.keyValues.height;
-    const height = heightText ? Number.parseFloat(heightText) || 0 : 200;
-    if (entity.angles.y === 0) {
-      entity.angles = { ...entity.angles, y: 360 };
-    }
-    if (!entity.speed) {
-      entity.speed = 200;
-    }
-    initTrigger(entity);
-    entity.movedir = { ...entity.movedir, z: height };
-    const touchHandler = (self, other) => monsterJumpTouch(self, other);
-    entity.touch = touchHandler;
-    if (entity.spawnflags & MONSTERJUMP_SPAWNFLAGS.StartOff) {
-      entity.solid = 0 /* Not */;
-      entity.touch = void 0;
-    }
-    if (entity.spawnflags & MONSTERJUMP_SPAWNFLAGS.Toggle) {
-      entity.use = (self) => {
-        toggleSolid(self);
-        self.touch = self.solid === 1 /* Trigger */ ? touchHandler : void 0;
+function registerBadArea(registry) {
+  registry.register("bad_area", (entity, context) => {
+    entity.movetype = 0 /* None */;
+    entity.solid = 1 /* Trigger */;
+    entity.touch = badAreaTouch;
+    if (entity.nextthink) {
+      entity.think = (self) => {
+        context.entities.free(self);
       };
     }
   });
 }
+
+// src/entities/triggers/index.ts
 function registerTriggerSpawns(registry) {
   registerTriggerMultiple(registry);
   registerTriggerOnce(registry);
@@ -8645,25 +8818,10 @@ function registerTriggerSpawns(registry) {
   registerTriggerMonsterJump(registry);
   registerTriggerFog(registry);
   registerTriggerFlashlight(registry);
+  registerTriggerSecret(registry);
+  registerTriggerLook(registry);
   registerBadArea(registry);
 }
-function badAreaTouch(self, other) {
-  if (!other) return;
-  if (other.takedamage) {
-  }
-}
-function registerBadArea(registry) {
-  registry.register("bad_area", (entity, context) => {
-    entity.movetype = 0 /* None */;
-    entity.solid = 1 /* Trigger */;
-    entity.touch = badAreaTouch;
-    if (entity.nextthink) {
-      entity.think = (self) => {
-        context.entities.free(self);
-      };
-    }
-  });
-}
 
 // src/combat/weapons/state.ts
 var WeaponStateEnum = /* @__PURE__ */ ((WeaponStateEnum2) => {
@@ -9978,6 +10136,95 @@ function Trap_Think(player, sys) {
   );
 }
 
+// src/modes/ctf/grapple.ts
+var GRAPPLE_SPEED = 1200;
+var GRAPPLE_PULL_SPEED = 800;
+var GRAPPLE_DAMAGE = 20;
+function Grapple_Think(player, sys) {
+  if (player.client?.inventory.currentWeapon !== WeaponId.Grapple) {
+    ResetGrapple(player, sys);
+  }
+  Weapon_Generic(
+    player,
+    0,
+    10,
+    // ready
+    11,
+    20,
+    // fire
+    [],
+    // pause frames
+    [11],
+    // fire frames
+    (ent) => fire_grapple(ent, sys),
+    sys
+  );
+  if (player.client && !(player.client.buttons & 1)) {
+    ResetGrapple(player, sys);
+  }
+  if (player.grapple && player.grapple.grappleState === "attached") {
+    Grapple_Pull(player, player.grapple, sys);
+  }
+}
+function fire_grapple(player, sys) {
+  if (player.grapple) return;
+  const angles = player.client.v_angle || player.angles;
+  const vectors = angleVectors(angles);
+  const forward = vectors.forward;
+  const right = vectors.right;
+  const up = vectors.up;
+  const game = sys.game;
+  const start = P_ProjectSource(game, player, { x: 8, y: 8, z: 8 }, forward, right, up);
+  const dir = { ...forward };
+  const grapple = createProjectile(sys, start, dir, GRAPPLE_SPEED, 57 /* GRAPPLE */, 0);
+  grapple.classname = "grapple";
+  grapple.owner = player;
+  grapple.movetype = 8 /* FlyMissile */;
+  grapple.solid = 2 /* BoundingBox */;
+  grapple.mins = { x: -4, y: -4, z: -4 };
+  grapple.maxs = { x: 4, y: 4, z: 4 };
+  grapple.model = "models/weapons/grapple/hook/tris.md2";
+  grapple.grappleState = "fly";
+  grapple.touch = (self, other, plane, surface) => {
+    if (!other) return;
+    Grapple_Touch(self, other, plane, surface, sys);
+  };
+  player.grapple = grapple;
+  sys.sound(player, 0, "weapons/grapple/throw.wav", 1, 1, 0);
+}
+function Grapple_Touch(self, other, plane, surface, sys) {
+  if (other === self.owner) return;
+  if (self.grappleState === "attached") return;
+  if (other.takedamage) {
+    T_Damage(other, self, self.owner, self.velocity, self.origin, ZERO_VEC3, GRAPPLE_DAMAGE, 0, 0, 57 /* GRAPPLE */, sys.timeSeconds, sys.multicast.bind(sys));
+    sys.free(self);
+    if (self.owner) self.owner.grapple = void 0;
+    return;
+  }
+  if (other.solid === 3 /* Bsp */ || other.solid === 2 /* BoundingBox */) {
+    self.velocity = { x: 0, y: 0, z: 0 };
+    self.movetype = 0 /* None */;
+    self.grappleState = "attached";
+    sys.sound(self, 0, "weapons/grapple/hit.wav", 1, 1, 0);
+    if (plane) {
+    }
+  }
+}
+function Grapple_Pull(player, grapple, sys) {
+  const dir = subtractVec3(grapple.origin, player.origin);
+  const dist = lengthVec3(dir);
+  if (dist < 32) return;
+  const normalizedDir = normalizeVec3(dir);
+  const pull = scaleVec3(normalizedDir, GRAPPLE_PULL_SPEED);
+  player.velocity = pull;
+}
+function ResetGrapple(player, sys) {
+  if (player.grapple) {
+    sys.free(player.grapple);
+    player.grapple = void 0;
+  }
+}
+
 // src/inventory/items.ts
 var WEAPON_ITEMS = {
   "weapon_blaster": {
@@ -10175,6 +10422,18 @@ var WEAPON_ITEMS = {
     pickupAmmo: 5,
     fireRate: 1,
     think: Trap_Think
+  },
+  "weapon_grapple": {
+    type: "weapon",
+    id: "weapon_grapple",
+    name: "Grapple",
+    weaponId: WeaponId.Grapple,
+    ammoType: null,
+    // Grapple uses no ammo in standard Q2 CTF? Or maybe just internal timer.
+    initialAmmo: 0,
+    pickupAmmo: 0,
+    fireRate: 0.5,
+    think: Grapple_Think
   }
 };
 var HEALTH_ITEMS = {
@@ -10576,6 +10835,34 @@ function setFlagState(flag, newState, context) {
   flag.flagState = newState;
 }
 
+// src/modes/ctf/scoreboard.ts
+var teamScores = {
+  [1 /* RED */]: 0,
+  [2 /* BLUE */]: 0
+};
+function addTeamScore(team, points) {
+  if (team === 1 /* RED */ || team === 2 /* BLUE */) {
+    teamScores[team] += points;
+  }
+}
+function updateCtfScoreboard(ent, sys) {
+  if (!ent.client || !ent.client.stats) return;
+  const stats = ent.client.stats;
+  stats[PlayerStat.STAT_CTF_TEAM1_PIC] = sys.configStringIndex ? sys.configStringIndex("pics/ctf_r.pcx") : 0;
+  stats[PlayerStat.STAT_CTF_TEAM1_CAPS] = teamScores[1 /* RED */];
+  stats[PlayerStat.STAT_CTF_TEAM2_PIC] = sys.configStringIndex ? sys.configStringIndex("pics/ctf_b.pcx") : 0;
+  stats[PlayerStat.STAT_CTF_TEAM2_CAPS] = teamScores[2 /* BLUE */];
+  const clientTeam = ent.client.ctfTeam;
+  stats[PlayerStat.STAT_CTF_JOINED_TEAM1_PIC] = 0;
+  stats[PlayerStat.STAT_CTF_JOINED_TEAM2_PIC] = 0;
+  if (clientTeam === 1 /* RED */) {
+    stats[PlayerStat.STAT_CTF_JOINED_TEAM1_PIC] = sys.configStringIndex ? sys.configStringIndex("pics/ctf_r.pcx") : 0;
+  } else if (clientTeam === 2 /* BLUE */) {
+    stats[PlayerStat.STAT_CTF_JOINED_TEAM2_PIC] = sys.configStringIndex ? sys.configStringIndex("pics/ctf_b.pcx") : 0;
+  }
+  stats[PlayerStat.STAT_CTF_TEAMINFO] = 1;
+}
+
 // src/modes/ctf/capture.ts
 function checkCapture(flag, player, game, context) {
   if (!player.client) return false;
@@ -10596,11 +10883,17 @@ function captureFlag(ownFlag, player, game, context) {
   if (!player.client) return false;
   const playerTeam = player.client.team || "red";
   const enemyTeam = playerTeam === "red" ? "blue" : "red";
+  const ctfStats = player.client.ctfStats;
+  if (ctfStats) {
+    ctfStats.captures++;
+  }
   if (player.client.score !== void 0) {
     player.client.score += 5;
   } else {
     player.client.score = 5;
   }
+  const teamEnum = playerTeam === "red" ? 1 /* RED */ : 2 /* BLUE */;
+  addTeamScore(teamEnum, 1);
   game.sound?.(player, 0, "ctf/flagcap.wav", 1, 1, 0);
   game.centerprintf?.(player, "You captured the flag!");
   const enemyFlagKey = playerTeam === "red" ? "key_blue_flag" /* BlueFlag */ : "key_red_flag" /* RedFlag */;
@@ -26230,6 +26523,9 @@ function player_think(self, sys) {
     }
   }
   P_PlayerThink(self, sys);
+  if (sys.deathmatch && (sys.configStringIndex ? sys.configStringIndex("pics/ctf_r.pcx") > 0 : true)) {
+    updateCtfScoreboard(self, sys);
+  }
   self.nextthink = sys.timeSeconds + 0.1;
   sys.scheduleThink(self, self.nextthink);
 }
@@ -26297,6 +26593,16 @@ function populatePlayerStats(player, timeSeconds) {
     const remainingSeconds = Math.ceil((bestTime - nowMs) / 1e3);
     statArray[PlayerStat.STAT_TIMER] = remainingSeconds;
   }
+  if (player.client.score !== void 0) {
+    statArray[PlayerStat.STAT_FRAGS] = player.client.score;
+  }
+  if (player.client.stats) {
+    for (let i = 0; i < player.client.stats.length; i++) {
+      if (player.client.stats[i] !== 0) {
+        statArray[i] = player.client.stats[i];
+      }
+    }
+  }
   return statArray;
 }