quake2ts 0.0.432 → 0.0.433

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

@@ -4652,6 +4652,8 @@ var EntitySystem = class {
       configstring: () => {
       },
       serverCommand: () => {
+      },
+      setLagCompensation: () => {
       }
     };
     this.imports = { ...defaultImports, ...imports };
@@ -8328,6 +8330,7 @@ var FRAME_CHAINGUN_ACTIVATE_LAST = 4;
 var FRAME_CHAINGUN_FIRE_LAST = 21;
 var FRAME_CHAINGUN_IDLE_LAST = 52;
 var FRAME_CHAINGUN_DEACTIVATE_LAST = 61;
+var FRAME_CHAINGUN_SPINUP = 5;
 var FRAME_RAILGUN_ACTIVATE_LAST = 3;
 var FRAME_RAILGUN_FIRE_LAST = 18;
 var FRAME_RAILGUN_IDLE_LAST = 51;
@@ -8381,6 +8384,14 @@ var ANIM_DEATH = 3;
 
 // src/combat/weapons/firing.ts
 var random3 = createRandomGenerator();
+var DEFAULT_SHOTGUN_HSPREAD = 500;
+var DEFAULT_SHOTGUN_VSPREAD = 500;
+var DEFAULT_SSHOTGUN_HSPREAD = 1e3;
+var DEFAULT_SSHOTGUN_VSPREAD = 500;
+var DEFAULT_DEATHMATCH_SHOTGUN_COUNT = 12;
+var DEFAULT_SHOTGUN_COUNT = 12;
+var DEFAULT_SSHOTGUN_COUNT = 20;
+var BUTTON_ATTACK2 = 32;
 function applyKick(player, pitch, yaw = 0, kickOrigin = 0) {
   if (player.client) {
     player.client.kick_angles = { x: pitch, y: yaw, z: 0 };
@@ -8401,14 +8412,24 @@ function setPlayerAttackAnim(player) {
 }
 function fireHitscan(game, player, start, forward, damage, knockback, mod) {
   const end = { x: start.x + forward.x * 8192, y: start.y + forward.y * 8192, z: start.z + forward.z * 8192 };
-  const trace = game.trace(
-    start,
-    null,
-    null,
-    end,
-    player,
-    0
-  );
+  if (game.setLagCompensation && player.client) {
+    game.setLagCompensation(true, player, player.client.ping);
+  }
+  let trace;
+  try {
+    trace = game.trace(
+      start,
+      null,
+      null,
+      end,
+      player,
+      0
+    );
+  } finally {
+    if (game.setLagCompensation) {
+      game.setLagCompensation(false);
+    }
+  }
   if (trace.ent && trace.ent.takedamage) {
     T_Damage(
       trace.ent,
@@ -8431,31 +8452,40 @@ function fireHitscan(game, player, start, forward, damage, knockback, mod) {
   }
 }
 function fireMultiplePellets(game, player, start, forward, right, up, count, damage, knockback, hspread, vspread, mod) {
-  for (let i = 0; i < count; i++) {
-    const spread = addVec3(scaleVec3(right, random3.crandom() * hspread), scaleVec3(up, random3.crandom() * vspread));
-    const dir = addVec3(forward, spread);
-    const end = { x: start.x + dir.x * 8192, y: start.y + dir.y * 8192, z: start.z + dir.z * 8192 };
-    const trace = game.trace(start, null, null, end, player, 0);
-    if (trace.ent && trace.ent.takedamage) {
-      T_Damage(
-        trace.ent,
-        player,
-        player,
-        ZERO_VEC3,
-        trace.endpos,
-        trace.plane ? trace.plane.normal : ZERO_VEC3,
-        damage,
-        knockback,
-        16 /* BULLET */,
-        mod,
-        game.time,
-        game.multicast
-      );
-    } else if (trace.plane) {
-      if (random3.frandom() > 0.9) {
-        game.multicast(trace.endpos, 1 /* Pvs */, ServerCommand.temp_entity, TempEntity.GUNSHOT, trace.endpos, trace.plane.normal);
+  if (game.setLagCompensation && player.client) {
+    game.setLagCompensation(true, player, player.client.ping);
+  }
+  try {
+    for (let i = 0; i < count; i++) {
+      const spread = addVec3(scaleVec3(right, random3.crandom() * hspread), scaleVec3(up, random3.crandom() * vspread));
+      const dir = addVec3(forward, spread);
+      const end = { x: start.x + dir.x * 8192, y: start.y + dir.y * 8192, z: start.z + dir.z * 8192 };
+      const trace = game.trace(start, null, null, end, player, 0);
+      if (trace.ent && trace.ent.takedamage) {
+        T_Damage(
+          trace.ent,
+          player,
+          player,
+          ZERO_VEC3,
+          trace.endpos,
+          trace.plane ? trace.plane.normal : ZERO_VEC3,
+          damage,
+          knockback,
+          16 /* BULLET */,
+          mod,
+          game.time,
+          game.multicast
+        );
+      } else if (trace.plane) {
+        if (random3.frandom() > 0.9) {
+          game.multicast(trace.endpos, 1 /* Pvs */, ServerCommand.temp_entity, TempEntity.GUNSHOT, trace.endpos, trace.plane.normal);
+        }
       }
     }
+  } finally {
+    if (game.setLagCompensation) {
+      game.setLagCompensation(false);
+    }
   }
 }
 function fireRailgun(game, player, start, forward, damage, knockback) {
@@ -8465,33 +8495,42 @@ function fireRailgun(game, player, start, forward, damage, knockback) {
   let ignore = player;
   let count = 0;
   let finalEnd = end;
-  while (count < 16) {
-    count++;
-    const trace = game.trace(currentStart, null, null, end, ignore, 0);
-    finalEnd = trace.endpos;
-    if (trace.fraction >= 1) {
-      break;
-    }
-    if (trace.ent && trace.ent.takedamage) {
-      T_Damage(
-        trace.ent,
-        player,
-        player,
-        ZERO_VEC3,
-        trace.endpos,
-        trace.plane ? trace.plane.normal : ZERO_VEC3,
-        damage,
-        knockback,
-        4 /* ENERGY */,
-        11 /* RAILGUN */,
-        game.time,
-        game.multicast
-      );
+  if (game.setLagCompensation && player.client) {
+    game.setLagCompensation(true, player, player.client.ping);
+  }
+  try {
+    while (count < 16) {
+      count++;
+      const trace = game.trace(currentStart, null, null, end, ignore, 0);
+      finalEnd = trace.endpos;
+      if (trace.fraction >= 1) {
+        break;
+      }
+      if (trace.ent && trace.ent.takedamage) {
+        T_Damage(
+          trace.ent,
+          player,
+          player,
+          ZERO_VEC3,
+          trace.endpos,
+          trace.plane ? trace.plane.normal : ZERO_VEC3,
+          damage,
+          knockback,
+          4 /* ENERGY */,
+          11 /* RAILGUN */,
+          game.time,
+          game.multicast
+        );
+      }
+      ignore = trace.ent;
+      currentStart = trace.endpos;
+      if (!trace.ent || trace.ent === game.entities.world) {
+        break;
+      }
     }
-    ignore = trace.ent;
-    currentStart = trace.endpos;
-    if (!trace.ent || trace.ent === game.entities.world) {
-      break;
+  } finally {
+    if (game.setLagCompensation) {
+      game.setLagCompensation(false);
     }
   }
   game.multicast(originalStart, 2 /* Phs */, ServerCommand.temp_entity, TempEntity.RAILTRAIL, originalStart, finalEnd);
@@ -8508,7 +8547,8 @@ function fireShotgun(game, player) {
   setPlayerAttackAnim(player);
   const { forward, right, up } = angleVectors(player.angles);
   const source = P_ProjectSource(game, player, { x: 8, y: 8, z: -8 }, forward, right, up);
-  fireMultiplePellets(game, player, source, forward, right, up, 12, 4, 1, 500, 500, 2 /* SHOTGUN */);
+  const count = game.deathmatch ? DEFAULT_DEATHMATCH_SHOTGUN_COUNT : DEFAULT_SHOTGUN_COUNT;
+  fireMultiplePellets(game, player, source, forward, right, up, count, 4, 1, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, 2 /* SHOTGUN */);
 }
 function fireSuperShotgun(game, player) {
   if (!player.client) return;
@@ -8516,16 +8556,26 @@ function fireSuperShotgun(game, player) {
   if (inventory.ammo.counts[AmmoType.Shells] < 2) {
     return;
   }
+  const isPrecision = (player.client.buttons & BUTTON_ATTACK2) !== 0;
   inventory.ammo.counts[AmmoType.Shells] -= 2;
   game.multicast(player.origin, 1 /* Pvs */, ServerCommand.muzzleflash, player.index, MZ_SSHOTGUN);
   applyKick(player, -4, 0, -4);
   setPlayerAttackAnim(player);
   const { forward, right, up } = angleVectors(player.angles);
   const source = P_ProjectSource(game, player, { x: 8, y: 8, z: -8 }, forward, right, up);
+  const count = DEFAULT_SSHOTGUN_COUNT / 2;
+  let hspread = DEFAULT_SSHOTGUN_HSPREAD;
+  let vspread = DEFAULT_SSHOTGUN_VSPREAD;
+  let damage = 6;
+  if (isPrecision) {
+    hspread = 300;
+    vspread = 150;
+    damage = 4;
+  }
   const { forward: forward1, right: right1, up: up1 } = angleVectors({ ...player.angles, y: player.angles.y - 5 });
-  fireMultiplePellets(game, player, source, forward1, right1, up1, 10, 6, 1, 700, 700, 3 /* SSHOTGUN */);
+  fireMultiplePellets(game, player, source, forward1, right1, up1, count, damage, 1, hspread, vspread, 3 /* SSHOTGUN */);
   const { forward: forward2, right: right2, up: up2 } = angleVectors({ ...player.angles, y: player.angles.y + 5 });
-  fireMultiplePellets(game, player, source, forward2, right2, up2, 10, 6, 1, 700, 700, 3 /* SSHOTGUN */);
+  fireMultiplePellets(game, player, source, forward2, right2, up2, count, damage, 1, hspread, vspread, 3 /* SSHOTGUN */);
 }
 function fireMachinegun(game, player) {
   if (!player.client) return;
@@ -8914,12 +8964,36 @@ function Throw_Generic(ent, FRAME_FIRE_LAST, FRAME_IDLE_LAST, FRAME_THROW_FIRST,
 
 // src/combat/weapons/chaingun.ts
 var CHAINGUN_PAUSE_FRAMES = [38, 43, 51, 61];
+var BUTTON_ATTACK22 = 32;
 function chaingunThink(player, sys) {
   const weaponState = getWeaponState(player.client.weaponStates, WeaponId.Chaingun);
-  if (!(player.client.buttons & BUTTON_ATTACK) && weaponState.spinupCount && weaponState.spinupCount > 0) {
+  const client = player.client;
+  if (!(client.buttons & BUTTON_ATTACK) && !(client.buttons & BUTTON_ATTACK22) && weaponState.spinupCount && weaponState.spinupCount > 0) {
     sys.sound(player, 0, "weapons/chngnd1a.wav", 1, 0, 0);
     weaponState.spinupCount = 0;
   }
+  if (client.buttons & BUTTON_ATTACK22 && !(client.buttons & BUTTON_ATTACK)) {
+    const spinupCount = (weaponState.spinupCount || 0) + 1;
+    weaponState.spinupCount = spinupCount;
+    const currentTime = sys.game ? sys.game.time : sys.timeSeconds * 1e3;
+    weaponState.lastFireTime = currentTime;
+    if (spinupCount > FRAME_CHAINGUN_SPINUP) {
+      sys.sound(player, 0, "weapons/chngnl1a.wav", 1, 0, 0);
+    } else {
+      if (spinupCount === 1) {
+        sys.sound(player, 0, "weapons/chngnu1a.wav", 1, 0, 0);
+      }
+    }
+    if (client.gun_frame < FRAME_CHAINGUN_SPINUP || client.gun_frame > FRAME_CHAINGUN_FIRE_LAST) {
+      client.gun_frame = FRAME_CHAINGUN_SPINUP;
+    } else {
+      client.gun_frame++;
+      if (client.gun_frame > FRAME_CHAINGUN_FIRE_LAST) {
+        client.gun_frame = FRAME_CHAINGUN_SPINUP;
+      }
+    }
+    return;
+  }
   Weapon_Repeating(
     player,
     FRAME_CHAINGUN_ACTIVATE_LAST,
@@ -8950,9 +9024,13 @@ function shotgunThink(player, sys) {
 }
 
 // src/combat/weapons/supershotgun.ts
+init_state();
+init_playerInventory();
 var SSHOTGUN_PAUSE_FRAMES = [29, 42, 57];
 var SSHOTGUN_FIRE_FRAMES = [22, 28];
 function superShotgunThink(player, sys) {
+  const client = player.client;
+  const weaponState = getWeaponState(client.weaponStates, WeaponId.SuperShotgun);
   Weapon_Generic(
     player,
     FRAME_SSHOTGUN_ACTIVATE_LAST,
@@ -9311,9 +9389,9 @@ function Weapon_ChainFist(player, sys) {
     fireChainfist(game, ent, inventory, weaponState, start, forward);
     if (ent.client) {
       const client = ent.client;
-      const BUTTON_ATTACK2 = 1;
+      const BUTTON_ATTACK3 = 1;
       const buttons = client.buttons;
-      if (buttons & BUTTON_ATTACK2) {
+      if (buttons & BUTTON_ATTACK3) {
         if (client.gun_frame === 12) client.gun_frame = 14;
         else if (client.gun_frame === 22) client.gun_frame = 24;
         else if (client.gun_frame >= 32) client.gun_frame = 7;
@@ -9932,32 +10010,68 @@ function createPowerArmorPickupEntity(game, item) {
 
 // src/modes/ctf/flag.ts
 init_playerInventory();
+
+// src/modes/ctf/state.ts
+function setFlagState(flag, newState, context) {
+  flag.flagState = newState;
+}
+
+// src/modes/ctf/flag.ts
 function createFlagPickupEntity(game, flagItem) {
-  const drop = (self, context) => {
-  };
+  const isRed = flagItem.team === "red";
   const respawn = (self) => {
+    setFlagState(self, 0 /* AT_BASE */, game.entities);
     self.solid = 1 /* Trigger */;
+    self.model = isRed ? "players/male/flag1.md2" : "players/male/flag2.md2";
+    self.origin = { ...self.baseOrigin };
+    self.svflags &= ~1;
   };
   return {
     classname: flagItem.id,
     solid: 1 /* Trigger */,
-    model: flagItem.team === "red" ? "players/male/flag1.md2" : "players/male/flag2.md2",
-    // Note: Models might need adjustment based on how Q2 handles skins for flags
-    // Original: "players/male/flag1.md2" (red) "players/male/flag2.md2" (blue)
-    // Usually it's just one model with skin change, but Q2 uses separate models for dropped flags often?
-    // Checking g_ctf.c: SP_item_flag_team1 sets ent->s.modelindex = gi.modelindex ("players/male/flag1.md2");
-    touch: (self, other) => {
+    model: isRed ? "players/male/flag1.md2" : "players/male/flag2.md2",
+    movetype: 0 /* None */,
+    // Base flag is stationary
+    // Initialize extended properties
+    // We cast this object to Partial<Entity> which includes FlagEntity props if we extend definition
+    // or we just assign them dynamically.
+    // For type safety, we might need to cast to any here or define these props on Entity.
+    // Since we can't easily modify Entity definition right now without a big refactor,
+    // we assume runtime extensions are allowed or these are custom fields.
+    flagState: 0 /* AT_BASE */,
+    flagTeam: flagItem.team,
+    baseOrigin: { x: 0, y: 0, z: 0 },
+    touch: (selfEntity, other) => {
+      const self = selfEntity;
       if (!other || !other.client) {
         return;
       }
-      if (pickupFlag(other.client, flagItem, game.time * 1e3)) {
-        game.sound?.(other, 0, "ctf/flagpk.wav", 1, 1, 0);
-        game.centerprintf?.(other, `You got the ${flagItem.name}`);
-        self.solid = 0 /* Not */;
-        self.model = void 0;
+      const playerTeam = other.client.team || "red";
+      const sameTeam = self.flagTeam === playerTeam;
+      if (sameTeam) {
+        if (self.flagState === 0 /* AT_BASE */) {
+          return;
+        }
+        if (self.flagState === 2 /* DROPPED */) {
+          game.sound?.(other, 0, "ctf/flagret.wav", 1, 1, 0);
+          game.centerprintf?.(other, `You returned the ${flagItem.name}!`);
+          respawn(self);
+        }
+      } else {
+        if (pickupFlag(other.client, flagItem, game.time * 1e3)) {
+          game.sound?.(other, 0, "ctf/flagpk.wav", 1, 1, 0);
+          game.centerprintf?.(other, `You got the ${flagItem.name}!`);
+          setFlagState(self, 1 /* CARRIED */, game.entities);
+          self.solid = 0 /* Not */;
+          self.model = void 0;
+          self.owner = other;
+        }
       }
     },
-    think: (self, context) => {
+    think: (selfEntity, context) => {
+      const self = selfEntity;
+      if (self.flagState === 2 /* DROPPED */) {
+      }
     }
   };
 }
@@ -24923,6 +25037,55 @@ function ClientObituary(self, inflictor, attacker, mod, sys) {
   }
 }
 
+// src/modes/ctf/integration.ts
+init_playerInventory();
+
+// src/modes/ctf/drop.ts
+function dropFlag(flag, origin, game, context) {
+  if (flag.flagState !== 1 /* CARRIED */) {
+    return;
+  }
+  setFlagState(flag, 2 /* DROPPED */, context);
+  flag.origin = { x: origin.x, y: origin.y, z: origin.z + 24 };
+  flag.owner = null;
+  flag.solid = 1 /* Trigger */;
+  flag.model = flag.flagTeam === "red" ? "players/male/flag1.md2" : "players/male/flag2.md2";
+  const time = context.timeSeconds ?? game.time;
+  flag.nextthink = time + 30;
+  game.centerprintf?.(flag, `The ${flag.flagTeam} flag was dropped!`);
+  flag.think = (selfEntity, ctx) => flagThink(selfEntity, ctx, game);
+}
+function flagThink(self, context, game) {
+  const flag = self;
+  if (flag.flagState === 2 /* DROPPED */) {
+    game.sound?.(flag, 0, "ctf/flagret.wav", 1, 1, 0);
+    game.centerprintf?.(flag, `The ${flag.flagTeam} flag returned to base!`);
+    setFlagState(flag, 0 /* AT_BASE */, context);
+    flag.origin = { ...flag.baseOrigin };
+    flag.solid = 1 /* Trigger */;
+    flag.nextthink = -1;
+  }
+}
+
+// src/modes/ctf/integration.ts
+function checkPlayerFlagDrop(player, sys) {
+  if (!player.client) return;
+  const hasRedFlag = hasKey(player.client.inventory, "key_red_flag" /* RedFlag */);
+  const hasBlueFlag = hasKey(player.client.inventory, "key_blue_flag" /* BlueFlag */);
+  if (!hasRedFlag && !hasBlueFlag) return;
+  sys.forEachEntity((ent) => {
+    const flag = ent;
+    if ((flag.classname === "item_flag_team1" || flag.classname === "item_flag_team2") && flag.owner === player) {
+      const game = sys._game;
+      if (game) {
+        dropFlag(flag, player.origin, game, sys);
+        player.client.inventory.keys.delete("key_red_flag" /* RedFlag */);
+        player.client.inventory.keys.delete("key_blue_flag" /* BlueFlag */);
+      }
+    }
+  });
+}
+
 // src/entities/player.ts
 function P_PlayerThink(ent, sys) {
   if (!ent.client) return;
@@ -25003,6 +25166,9 @@ function player_die(self, inflictor, attacker, damage, point, mod, sys) {
   self.solid = 0 /* Not */;
   self.movetype = 7 /* Toss */;
   self.takedamage = false;
+  if (sys) {
+    checkPlayerFlagDrop(self, sys);
+  }
   if (self.health < -40 && sys) {
     throwGibs(sys, self.origin, damage);
     return;
@@ -25769,6 +25935,11 @@ function createGame(imports, engine, options) {
     serverCommand(cmd) {
       serverCommand(cmd);
     },
+    setLagCompensation(active, client, lagMs) {
+      if (engine.setLagCompensation) {
+        engine.setLagCompensation(active, client, lagMs);
+      }
+    },
     get time() {
       return levelClock.current.timeSeconds;
     },