quake2ts 0.0.286 → 0.0.289

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

@@ -134,6 +134,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,
@@ -212,6 +213,7 @@ __export(index_exports, {
   concatRotationMatrices: () => concatRotationMatrices,
   configStringSize: () => configStringSize,
   copyVec3: () => copyVec3,
+  crc8: () => crc8,
   createDefaultTrace: () => createDefaultTrace,
   createEmptyBounds3: () => createEmptyBounds3,
   createMat4Identity: () => createMat4Identity,
@@ -4094,6 +4096,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 +4816,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";
@@ -4760,6 +5267,7 @@ var WEAPON_AMMO_MAP = {
   NUM_BITS_FOR_AMMO,
   NUM_BITS_FOR_POWERUP,
   NUM_POWERUP_STATS,
+  NetChan,
   NetworkMessageBuilder,
   PITCH,
   POWERUP_MAX,
@@ -4838,6 +5346,7 @@ var WEAPON_AMMO_MAP = {
   concatRotationMatrices,
   configStringSize,
   copyVec3,
+  crc8,
   createDefaultTrace,
   createEmptyBounds3,
   createMat4Identity,