quake2ts 0.0.288 → 0.0.290

package/packages/shared/dist/cjs/index.cjs

@@ -23,6 +23,11 @@ __export(index_exports, {
   AMMO_MAX: () => AMMO_MAX,
   AMMO_TYPE_COUNT: () => AMMO_TYPE_COUNT,
   ANORMS: () => ANORMS,
+  ATTN_IDLE: () => ATTN_IDLE,
+  ATTN_LOOP_NONE: () => ATTN_LOOP_NONE,
+  ATTN_NONE: () => ATTN_NONE,
+  ATTN_NORM: () => ATTN_NORM,
+  ATTN_STATIC: () => ATTN_STATIC,
   AmmoItemId: () => AmmoItemId,
   AmmoType: () => AmmoType,
   BinaryStream: () => BinaryStream,
@@ -111,6 +116,7 @@ __export(index_exports, {
   MAX_QPATH: () => MAX_QPATH,
   MAX_SHADOW_LIGHTS: () => MAX_SHADOW_LIGHTS,
   MAX_SOUNDS: () => MAX_SOUNDS,
+  MAX_SOUND_CHANNELS: () => MAX_SOUND_CHANNELS,
   MAX_STRING_CHARS: () => MAX_STRING_CHARS,
   MAX_STRING_TOKENS: () => MAX_STRING_TOKENS,
   MAX_TOKEN_CHARS: () => MAX_TOKEN_CHARS,
@@ -134,6 +140,7 @@ __export(index_exports, {
   NUM_BITS_FOR_AMMO: () => NUM_BITS_FOR_AMMO,
   NUM_BITS_FOR_POWERUP: () => NUM_BITS_FOR_POWERUP,
   NUM_POWERUP_STATS: () => NUM_POWERUP_STATS,
+  NetChan: () => NetChan,
   NetworkMessageBuilder: () => NetworkMessageBuilder,
   PITCH: () => PITCH,
   POWERUP_MAX: () => POWERUP_MAX,
@@ -150,6 +157,8 @@ __export(index_exports, {
   Replay: () => replay_exports,
   SLIDEMOVE_BLOCKED_FLOOR: () => SLIDEMOVE_BLOCKED_FLOOR,
   SLIDEMOVE_BLOCKED_WALL: () => SLIDEMOVE_BLOCKED_WALL,
+  SOUND_FULLVOLUME: () => SOUND_FULLVOLUME,
+  SOUND_LOOP_ATTENUATE: () => SOUND_LOOP_ATTENUATE,
   STOP_EPSILON: () => STOP_EPSILON,
   SURF_ALPHATEST: () => SURF_ALPHATEST,
   SURF_FLOWING: () => SURF_FLOWING,
@@ -166,6 +175,7 @@ __export(index_exports, {
   SURF_TRANS66: () => SURF_TRANS66,
   SURF_WARP: () => SURF_WARP,
   ServerCommand: () => ServerCommand,
+  SoundChannel: () => SoundChannel,
   TempEntity: () => TempEntity,
   UPDATE_BACKUP: () => UPDATE_BACKUP,
   WEAPON_AMMO_MAP: () => WEAPON_AMMO_MAP,
@@ -191,12 +201,14 @@ __export(index_exports, {
   applyPmoveFriction: () => applyPmoveFriction,
   applyPmoveWaterMove: () => applyPmoveWaterMove,
   assertContract: () => assertContract,
+  attenuationToDistanceMultiplier: () => attenuationToDistanceMultiplier,
   boxContents: () => boxContents,
   boxOnPlaneSide: () => boxOnPlaneSide,
   boxesIntersect: () => boxesIntersect,
   buildAirGroundWish: () => buildAirGroundWish,
   buildCollisionModel: () => buildCollisionModel,
   buildWaterWish: () => buildWaterWish,
+  calculateMaxAudibleDistance: () => calculateMaxAudibleDistance,
   categorizePosition: () => categorizePosition,
   checkDuckState: () => checkDuckState,
   checkJump: () => checkJump,
@@ -212,6 +224,7 @@ __export(index_exports, {
   concatRotationMatrices: () => concatRotationMatrices,
   configStringSize: () => configStringSize,
   copyVec3: () => copyVec3,
+  crc8: () => crc8,
   createDefaultTrace: () => createDefaultTrace,
   createEmptyBounds3: () => createEmptyBounds3,
   createMat4Identity: () => createMat4Identity,
@@ -4094,6 +4107,273 @@ var RenderFx = /* @__PURE__ */ ((RenderFx2) => {
   return RenderFx2;
 })(RenderFx || {});
 
+// src/protocol/crc.ts
+var crc_table = [
+  0,
+  145,
+  227,
+  114,
+  7,
+  150,
+  228,
+  117,
+  14,
+  159,
+  237,
+  124,
+  9,
+  152,
+  234,
+  123,
+  28,
+  141,
+  255,
+  110,
+  27,
+  138,
+  248,
+  105,
+  18,
+  131,
+  241,
+  96,
+  21,
+  132,
+  246,
+  103,
+  56,
+  169,
+  219,
+  74,
+  63,
+  174,
+  220,
+  77,
+  54,
+  167,
+  213,
+  68,
+  49,
+  160,
+  210,
+  67,
+  36,
+  181,
+  199,
+  86,
+  35,
+  178,
+  192,
+  81,
+  42,
+  187,
+  201,
+  88,
+  45,
+  188,
+  206,
+  95,
+  112,
+  225,
+  147,
+  2,
+  119,
+  230,
+  148,
+  5,
+  126,
+  239,
+  157,
+  12,
+  121,
+  232,
+  154,
+  11,
+  108,
+  253,
+  143,
+  30,
+  107,
+  250,
+  136,
+  25,
+  98,
+  243,
+  129,
+  16,
+  101,
+  244,
+  134,
+  23,
+  72,
+  217,
+  171,
+  58,
+  79,
+  222,
+  172,
+  61,
+  70,
+  215,
+  165,
+  52,
+  65,
+  208,
+  162,
+  51,
+  84,
+  197,
+  183,
+  38,
+  83,
+  194,
+  176,
+  33,
+  90,
+  203,
+  185,
+  40,
+  93,
+  204,
+  190,
+  47,
+  224,
+  113,
+  3,
+  146,
+  231,
+  118,
+  4,
+  149,
+  238,
+  127,
+  13,
+  156,
+  233,
+  120,
+  10,
+  155,
+  252,
+  109,
+  31,
+  142,
+  251,
+  106,
+  24,
+  137,
+  242,
+  99,
+  17,
+  128,
+  245,
+  100,
+  22,
+  135,
+  216,
+  73,
+  59,
+  170,
+  223,
+  78,
+  60,
+  173,
+  214,
+  71,
+  53,
+  164,
+  209,
+  64,
+  50,
+  163,
+  196,
+  85,
+  39,
+  182,
+  195,
+  82,
+  32,
+  177,
+  202,
+  91,
+  41,
+  184,
+  205,
+  92,
+  46,
+  191,
+  144,
+  1,
+  115,
+  226,
+  151,
+  6,
+  116,
+  229,
+  158,
+  15,
+  125,
+  236,
+  153,
+  8,
+  122,
+  235,
+  140,
+  29,
+  111,
+  254,
+  139,
+  26,
+  104,
+  249,
+  130,
+  19,
+  97,
+  240,
+  133,
+  20,
+  102,
+  247,
+  168,
+  57,
+  75,
+  218,
+  175,
+  62,
+  76,
+  221,
+  166,
+  55,
+  69,
+  212,
+  161,
+  48,
+  66,
+  211,
+  180,
+  37,
+  86,
+  199,
+  179,
+  34,
+  80,
+  193,
+  186,
+  43,
+  89,
+  200,
+  189,
+  44,
+  94,
+  207
+];
+function crc8(data) {
+  let crc = 0;
+  for (let i = 0; i < data.length; i++) {
+    crc = crc_table[(crc ^ data[i]) & 255];
+  }
+  return crc;
+}
+
 // src/protocol/entityFlags.ts
 var entityFlags_exports = {};
 __export(entityFlags_exports, {
@@ -4547,6 +4827,244 @@ var NetworkMessageBuilder = class {
   }
 };
 
+// src/net/netchan.ts
+var _NetChan = class _NetChan {
+  constructor() {
+    // +2 for reliable length prefix
+    // Public state
+    this.qport = 0;
+    // qport value to distinguish multiple clients from same IP
+    // Sequencing
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    // Reliable messaging
+    this.incomingReliableAcknowledged = false;
+    // single bit
+    this.incomingReliableSequence = 0;
+    // last reliable message sequence received
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    // Timing
+    this.lastReceived = 0;
+    this.lastSent = 0;
+    this.remoteAddress = null;
+    this.reliableMessage = new BinaryWriter(_NetChan.MAX_MSGLEN);
+    const now = Date.now();
+    this.lastReceived = now;
+    this.lastSent = now;
+    this.qport = Math.floor(Math.random() * 65536);
+  }
+  /**
+   * Setup the netchan with specific settings
+   */
+  setup(qport, address = null) {
+    this.qport = qport;
+    this.remoteAddress = address;
+    this.reset();
+  }
+  /**
+   * Reset the netchan state
+   */
+  reset() {
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    this.incomingReliableAcknowledged = false;
+    this.incomingReliableSequence = 0;
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    this.reliableMessage.reset();
+    this.lastReceived = Date.now();
+    this.lastSent = Date.now();
+  }
+  /**
+   * Transmits a packet containing reliable and unreliable data
+   */
+  transmit(unreliableData) {
+    this.outgoingSequence++;
+    this.lastSent = Date.now();
+    const headerSize = _NetChan.PACKET_HEADER;
+    const reliableSize = this.reliableLength > 0 ? this.reliableLength + 2 : 0;
+    let unreliableSize = unreliableData ? unreliableData.length : 0;
+    if (headerSize + reliableSize + unreliableSize > _NetChan.MAX_MSGLEN) {
+      unreliableSize = _NetChan.MAX_MSGLEN - headerSize - reliableSize;
+      if (unreliableSize < 0) unreliableSize = 0;
+    }
+    const buffer = new ArrayBuffer(headerSize + reliableSize + unreliableSize);
+    const view = new DataView(buffer);
+    const result = new Uint8Array(buffer);
+    let sequence = this.outgoingSequence;
+    if (this.reliableLength > 0) {
+      sequence |= 2147483648;
+      if ((this.outgoingReliableSequence & 1) !== 0) {
+        sequence |= 1073741824;
+      }
+    }
+    view.setUint32(0, sequence, true);
+    let ack = this.incomingSequence;
+    if ((this.incomingReliableSequence & 1) !== 0) {
+      ack |= 2147483648;
+    }
+    view.setUint32(4, ack, true);
+    view.setUint16(8, this.qport, true);
+    let offset = headerSize;
+    if (this.reliableLength > 0) {
+      view.setUint16(offset, this.reliableLength, true);
+      offset += 2;
+      const reliableBuffer = this.reliableMessage.getBuffer();
+      const reliableBytes = reliableBuffer.subarray(0, this.reliableLength);
+      result.set(reliableBytes, offset);
+      offset += this.reliableLength;
+    }
+    if (unreliableData && unreliableSize > 0) {
+      const chunk = unreliableData.slice(0, unreliableSize);
+      result.set(chunk, offset);
+    }
+    return result;
+  }
+  /**
+   * Processes a received packet
+   * Returns the payload data (reliable + unreliable) to be processed, or null if discarded
+   */
+  process(packet) {
+    if (packet.length < _NetChan.PACKET_HEADER) {
+      return null;
+    }
+    this.lastReceived = Date.now();
+    const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const sequence = view.getUint32(0, true);
+    const ack = view.getUint32(4, true);
+    const qport = view.getUint16(8, true);
+    if (this.qport !== qport) {
+      return null;
+    }
+    const seqNumberClean = sequence & ~(2147483648 | 1073741824);
+    if ((seqNumberClean - this.incomingSequence | 0) <= 0) {
+      return null;
+    }
+    this.incomingSequence = seqNumberClean;
+    const ackNumber = ack & ~2147483648;
+    const ackReliable = (ack & 2147483648) !== 0;
+    if (ackNumber > this.incomingAcknowledged) {
+      this.incomingAcknowledged = ackNumber;
+    }
+    if (this.reliableLength > 0) {
+      const receivedAckBit = ackReliable ? 1 : 0;
+      const currentReliableBit = this.outgoingReliableSequence & 1;
+      if (receivedAckBit !== currentReliableBit) {
+        this.reliableLength = 0;
+        this.reliableMessage.reset();
+        this.outgoingReliableSequence ^= 1;
+      }
+    }
+    const hasReliableData = (sequence & 2147483648) !== 0;
+    const reliableSeqBit = (sequence & 1073741824) !== 0 ? 1 : 0;
+    let payloadOffset = _NetChan.PACKET_HEADER;
+    let reliableData = null;
+    if (hasReliableData) {
+      if (payloadOffset + 2 > packet.byteLength) return null;
+      const reliableLen = view.getUint16(payloadOffset, true);
+      payloadOffset += 2;
+      const expectedBit = this.incomingReliableSequence & 1;
+      if (reliableSeqBit === expectedBit) {
+        this.incomingReliableSequence++;
+        if (payloadOffset + reliableLen > packet.byteLength) return null;
+        reliableData = packet.slice(payloadOffset, payloadOffset + reliableLen);
+      }
+      payloadOffset += reliableLen;
+    }
+    const unreliableData = packet.slice(payloadOffset);
+    if (reliableData && reliableData.length > 0) {
+      const totalLen = reliableData.length + unreliableData.length;
+      const result = new Uint8Array(totalLen);
+      result.set(reliableData, 0);
+      result.set(unreliableData, reliableData.length);
+      return result;
+    }
+    if (unreliableData) {
+      return unreliableData;
+    }
+    return new Uint8Array(0);
+  }
+  /**
+   * Checks if reliable message buffer is empty and ready for new data
+   */
+  canSendReliable() {
+    return this.reliableLength === 0;
+  }
+  /**
+   * Writes a byte to the reliable message buffer
+   */
+  writeReliableByte(value) {
+    if (this.reliableLength + 1 > _NetChan.MAX_MSGLEN - _NetChan.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeByte(value);
+    this.reliableLength++;
+  }
+  /**
+   * Writes a short to the reliable message buffer
+   */
+  writeReliableShort(value) {
+    if (this.reliableLength + 2 > _NetChan.MAX_MSGLEN - _NetChan.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeShort(value);
+    this.reliableLength += 2;
+  }
+  /**
+   * Writes a long to the reliable message buffer
+   */
+  writeReliableLong(value) {
+    if (this.reliableLength + 4 > _NetChan.MAX_MSGLEN - _NetChan.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeLong(value);
+    this.reliableLength += 4;
+  }
+  /**
+   * Writes a string to the reliable message buffer
+   */
+  writeReliableString(value) {
+    const len = value.length + 1;
+    if (this.reliableLength + len > _NetChan.MAX_MSGLEN - _NetChan.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeString(value);
+    this.reliableLength += len;
+  }
+  /**
+   * Returns the current reliable data buffer
+   */
+  getReliableData() {
+    if (this.reliableLength === 0) {
+      return new Uint8Array(0);
+    }
+    const buffer = this.reliableMessage.getBuffer();
+    return buffer.subarray(0, this.reliableLength);
+  }
+  /**
+   * Checks if we need to send a keepalive packet
+   */
+  needsKeepalive(currentTime) {
+    return currentTime - this.lastSent > 1e3;
+  }
+  /**
+   * Checks if the connection has timed out
+   */
+  isTimedOut(currentTime, timeoutMs = 3e4) {
+    return currentTime - this.lastReceived > timeoutMs;
+  }
+};
+// Constants from net_chan.c
+_NetChan.MAX_MSGLEN = 1400;
+_NetChan.FRAGMENT_SIZE = 1024;
+_NetChan.PACKET_HEADER = 10;
+// sequence(4) + ack(4) + qport(2)
+_NetChan.HEADER_OVERHEAD = _NetChan.PACKET_HEADER + 2;
+var NetChan = _NetChan;
+
 // src/items/weapons.ts
 var WeaponId = /* @__PURE__ */ ((WeaponId2) => {
   WeaponId2["Blaster"] = "blaster";
@@ -4644,11 +5162,47 @@ var WEAPON_AMMO_MAP = {
   ["disruptor" /* Disruptor */]: 10 /* Disruptor */,
   ["trap" /* Trap */]: 7 /* Trap */
 };
+
+// src/audio/constants.ts
+var MAX_SOUND_CHANNELS = 32;
+var SoundChannel = /* @__PURE__ */ ((SoundChannel2) => {
+  SoundChannel2[SoundChannel2["Auto"] = 0] = "Auto";
+  SoundChannel2[SoundChannel2["Weapon"] = 1] = "Weapon";
+  SoundChannel2[SoundChannel2["Voice"] = 2] = "Voice";
+  SoundChannel2[SoundChannel2["Item"] = 3] = "Item";
+  SoundChannel2[SoundChannel2["Body"] = 4] = "Body";
+  SoundChannel2[SoundChannel2["Aux"] = 5] = "Aux";
+  SoundChannel2[SoundChannel2["Footstep"] = 6] = "Footstep";
+  SoundChannel2[SoundChannel2["Aux3"] = 7] = "Aux3";
+  SoundChannel2[SoundChannel2["NoPhsAdd"] = 8] = "NoPhsAdd";
+  SoundChannel2[SoundChannel2["Reliable"] = 16] = "Reliable";
+  SoundChannel2[SoundChannel2["ForcePos"] = 32] = "ForcePos";
+  return SoundChannel2;
+})(SoundChannel || {});
+var ATTN_LOOP_NONE = -1;
+var ATTN_NONE = 0;
+var ATTN_NORM = 1;
+var ATTN_IDLE = 2;
+var ATTN_STATIC = 3;
+var SOUND_FULLVOLUME = 80;
+var SOUND_LOOP_ATTENUATE = 3e-3;
+function attenuationToDistanceMultiplier(attenuation) {
+  return attenuation === ATTN_STATIC ? attenuation * 1e-3 : attenuation * 5e-4;
+}
+function calculateMaxAudibleDistance(attenuation) {
+  const distMult = attenuationToDistanceMultiplier(attenuation);
+  return distMult <= 0 ? Number.POSITIVE_INFINITY : SOUND_FULLVOLUME + 1 / distMult;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AMMO_MAX,
   AMMO_TYPE_COUNT,
   ANORMS,
+  ATTN_IDLE,
+  ATTN_LOOP_NONE,
+  ATTN_NONE,
+  ATTN_NORM,
+  ATTN_STATIC,
   AmmoItemId,
   AmmoType,
   BinaryStream,
@@ -4737,6 +5291,7 @@ var WEAPON_AMMO_MAP = {
   MAX_QPATH,
   MAX_SHADOW_LIGHTS,
   MAX_SOUNDS,
+  MAX_SOUND_CHANNELS,
   MAX_STRING_CHARS,
   MAX_STRING_TOKENS,
   MAX_TOKEN_CHARS,
@@ -4760,6 +5315,7 @@ var WEAPON_AMMO_MAP = {
   NUM_BITS_FOR_AMMO,
   NUM_BITS_FOR_POWERUP,
   NUM_POWERUP_STATS,
+  NetChan,
   NetworkMessageBuilder,
   PITCH,
   POWERUP_MAX,
@@ -4776,6 +5332,8 @@ var WEAPON_AMMO_MAP = {
   Replay,
   SLIDEMOVE_BLOCKED_FLOOR,
   SLIDEMOVE_BLOCKED_WALL,
+  SOUND_FULLVOLUME,
+  SOUND_LOOP_ATTENUATE,
   STOP_EPSILON,
   SURF_ALPHATEST,
   SURF_FLOWING,
@@ -4792,6 +5350,7 @@ var WEAPON_AMMO_MAP = {
   SURF_TRANS66,
   SURF_WARP,
   ServerCommand,
+  SoundChannel,
   TempEntity,
   UPDATE_BACKUP,
   WEAPON_AMMO_MAP,
@@ -4817,12 +5376,14 @@ var WEAPON_AMMO_MAP = {
   applyPmoveFriction,
   applyPmoveWaterMove,
   assertContract,
+  attenuationToDistanceMultiplier,
   boxContents,
   boxOnPlaneSide,
   boxesIntersect,
   buildAirGroundWish,
   buildCollisionModel,
   buildWaterWish,
+  calculateMaxAudibleDistance,
   categorizePosition,
   checkDuckState,
   checkJump,
@@ -4838,6 +5399,7 @@ var WEAPON_AMMO_MAP = {
   concatRotationMatrices,
   configStringSize,
   copyVec3,
+  crc8,
   createDefaultTrace,
   createEmptyBounds3,
   createMat4Identity,