quake2ts 0.0.301 → 0.0.302

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

@@ -5133,7 +5133,7 @@ var NetworkMessageBuilder = class {
 // src/net/netchan.ts
 var _NetChan = class _NetChan {
   constructor() {
-    // +2 for reliable length prefix
+    // 256KB
     // Public state
     this.qport = 0;
     // qport value to distinguish multiple clients from same IP
@@ -5148,11 +5148,17 @@ var _NetChan = class _NetChan {
     // last reliable message sequence received
     this.outgoingReliableSequence = 0;
     this.reliableLength = 0;
+    // Fragmentation State (Sending)
+    this.fragmentSendOffset = 0;
+    // Fragmentation State (Receiving)
+    this.fragmentBuffer = null;
+    this.fragmentLength = 0;
+    this.fragmentReceived = 0;
     // Timing
     this.lastReceived = 0;
     this.lastSent = 0;
     this.remoteAddress = null;
-    this.reliableMessage = new BinaryWriter(_NetChan.MAX_MSGLEN);
+    this.reliableMessage = new BinaryWriter(_NetChan.MAX_RELIABLE_BUFFER);
     const now = Date.now();
     this.lastReceived = now;
     this.lastSent = now;
@@ -5178,6 +5184,10 @@ var _NetChan = class _NetChan {
     this.outgoingReliableSequence = 0;
     this.reliableLength = 0;
     this.reliableMessage.reset();
+    this.fragmentSendOffset = 0;
+    this.fragmentBuffer = null;
+    this.fragmentLength = 0;
+    this.fragmentReceived = 0;
     this.lastReceived = Date.now();
     this.lastSent = Date.now();
   }
@@ -5187,18 +5197,38 @@ var _NetChan = class _NetChan {
   transmit(unreliableData) {
     this.outgoingSequence++;
     this.lastSent = Date.now();
+    let sendReliableLength = 0;
+    let isFragment = false;
+    let fragmentStart = 0;
+    if (this.reliableLength > 0) {
+      if (this.reliableLength > _NetChan.FRAGMENT_SIZE) {
+        isFragment = true;
+        if (this.fragmentSendOffset >= this.reliableLength) {
+          this.fragmentSendOffset = 0;
+        }
+        const remaining = this.reliableLength - this.fragmentSendOffset;
+        sendReliableLength = remaining;
+        if (sendReliableLength > _NetChan.FRAGMENT_SIZE) {
+          sendReliableLength = _NetChan.FRAGMENT_SIZE;
+        }
+        fragmentStart = this.fragmentSendOffset;
+        this.fragmentSendOffset += sendReliableLength;
+      } else {
+        sendReliableLength = this.reliableLength;
+      }
+    }
     const headerSize = _NetChan.PACKET_HEADER;
-    const reliableSize = this.reliableLength > 0 ? this.reliableLength + 2 : 0;
+    const reliableHeaderSize = sendReliableLength > 0 ? 2 + (isFragment ? 8 : 0) : 0;
     let unreliableSize = unreliableData ? unreliableData.length : 0;
-    if (headerSize + reliableSize + unreliableSize > _NetChan.MAX_MSGLEN) {
-      unreliableSize = _NetChan.MAX_MSGLEN - headerSize - reliableSize;
+    if (headerSize + reliableHeaderSize + sendReliableLength + unreliableSize > _NetChan.MAX_MSGLEN) {
+      unreliableSize = _NetChan.MAX_MSGLEN - headerSize - reliableHeaderSize - sendReliableLength;
       if (unreliableSize < 0) unreliableSize = 0;
     }
-    const buffer = new ArrayBuffer(headerSize + reliableSize + unreliableSize);
+    const buffer = new ArrayBuffer(headerSize + reliableHeaderSize + sendReliableLength + unreliableSize);
     const view = new DataView(buffer);
     const result = new Uint8Array(buffer);
     let sequence = this.outgoingSequence;
-    if (this.reliableLength > 0) {
+    if (sendReliableLength > 0) {
       sequence |= 2147483648;
       if ((this.outgoingReliableSequence & 1) !== 0) {
         sequence |= 1073741824;
@@ -5212,13 +5242,23 @@ var _NetChan = class _NetChan {
     view.setUint32(4, ack, true);
     view.setUint16(8, this.qport, true);
     let offset = headerSize;
-    if (this.reliableLength > 0) {
-      view.setUint16(offset, this.reliableLength, true);
+    if (sendReliableLength > 0) {
+      let lengthField = sendReliableLength;
+      if (isFragment) {
+        lengthField |= 32768;
+      }
+      view.setUint16(offset, lengthField, true);
       offset += 2;
+      if (isFragment) {
+        view.setUint32(offset, fragmentStart, true);
+        offset += 4;
+        view.setUint32(offset, this.reliableLength, true);
+        offset += 4;
+      }
       const reliableBuffer = this.reliableMessage.getBuffer();
-      const reliableBytes = reliableBuffer.subarray(0, this.reliableLength);
+      const reliableBytes = reliableBuffer.subarray(fragmentStart, fragmentStart + sendReliableLength);
       result.set(reliableBytes, offset);
-      offset += this.reliableLength;
+      offset += sendReliableLength;
     }
     if (unreliableData && unreliableSize > 0) {
       const chunk = unreliableData.slice(0, unreliableSize);
@@ -5259,6 +5299,7 @@ var _NetChan = class _NetChan {
         this.reliableLength = 0;
         this.reliableMessage.reset();
         this.outgoingReliableSequence ^= 1;
+        this.fragmentSendOffset = 0;
       }
     }
     const hasReliableData = (sequence & 2147483648) !== 0;
@@ -5267,13 +5308,45 @@ var _NetChan = class _NetChan {
     let reliableData = null;
     if (hasReliableData) {
       if (payloadOffset + 2 > packet.byteLength) return null;
-      const reliableLen = view.getUint16(payloadOffset, true);
+      let reliableLen = view.getUint16(payloadOffset, true);
       payloadOffset += 2;
+      const isFragment = (reliableLen & 32768) !== 0;
+      reliableLen &= 32767;
       const expectedBit = this.incomingReliableSequence & 1;
       if (reliableSeqBit === expectedBit) {
-        this.incomingReliableSequence++;
-        if (payloadOffset + reliableLen > packet.byteLength) return null;
-        reliableData = packet.slice(payloadOffset, payloadOffset + reliableLen);
+        if (isFragment) {
+          if (payloadOffset + 8 > packet.byteLength) return null;
+          const fragStart = view.getUint32(payloadOffset, true);
+          payloadOffset += 4;
+          const fragTotal = view.getUint32(payloadOffset, true);
+          payloadOffset += 4;
+          if (fragTotal > _NetChan.MAX_RELIABLE_BUFFER) {
+            console.warn(`NetChan: received invalid fragment total ${fragTotal} > ${_NetChan.MAX_RELIABLE_BUFFER}`);
+            return null;
+          }
+          if (!this.fragmentBuffer || this.fragmentBuffer.length !== fragTotal) {
+            this.fragmentBuffer = new Uint8Array(fragTotal);
+            this.fragmentLength = fragTotal;
+            this.fragmentReceived = 0;
+          }
+          if (payloadOffset + reliableLen > packet.byteLength) return null;
+          const data = packet.subarray(payloadOffset, payloadOffset + reliableLen);
+          if (fragStart === this.fragmentReceived && fragStart + reliableLen <= fragTotal) {
+            this.fragmentBuffer.set(data, fragStart);
+            this.fragmentReceived += reliableLen;
+            if (this.fragmentReceived >= fragTotal) {
+              reliableData = this.fragmentBuffer;
+              this.incomingReliableSequence++;
+              this.fragmentBuffer = null;
+              this.fragmentLength = 0;
+              this.fragmentReceived = 0;
+            }
+          }
+        } else {
+          this.incomingReliableSequence++;
+          if (payloadOffset + reliableLen > packet.byteLength) return null;
+          reliableData = packet.slice(payloadOffset, payloadOffset + reliableLen);
+        }
       }
       payloadOffset += reliableLen;
     }
@@ -5300,7 +5373,7 @@ var _NetChan = class _NetChan {
    * Writes a byte to the reliable message buffer
    */
   writeReliableByte(value) {
-    if (this.reliableLength + 1 > _NetChan.MAX_MSGLEN - _NetChan.HEADER_OVERHEAD) {
+    if (this.reliableLength + 1 > _NetChan.MAX_RELIABLE_BUFFER) {
       throw new Error("NetChan reliable buffer overflow");
     }
     this.reliableMessage.writeByte(value);
@@ -5310,7 +5383,7 @@ var _NetChan = class _NetChan {
    * Writes a short to the reliable message buffer
    */
   writeReliableShort(value) {
-    if (this.reliableLength + 2 > _NetChan.MAX_MSGLEN - _NetChan.HEADER_OVERHEAD) {
+    if (this.reliableLength + 2 > _NetChan.MAX_RELIABLE_BUFFER) {
       throw new Error("NetChan reliable buffer overflow");
     }
     this.reliableMessage.writeShort(value);
@@ -5320,7 +5393,7 @@ var _NetChan = class _NetChan {
    * Writes a long to the reliable message buffer
    */
   writeReliableLong(value) {
-    if (this.reliableLength + 4 > _NetChan.MAX_MSGLEN - _NetChan.HEADER_OVERHEAD) {
+    if (this.reliableLength + 4 > _NetChan.MAX_RELIABLE_BUFFER) {
       throw new Error("NetChan reliable buffer overflow");
     }
     this.reliableMessage.writeLong(value);
@@ -5331,7 +5404,7 @@ var _NetChan = class _NetChan {
    */
   writeReliableString(value) {
     const len = value.length + 1;
-    if (this.reliableLength + len > _NetChan.MAX_MSGLEN - _NetChan.HEADER_OVERHEAD) {
+    if (this.reliableLength + len > _NetChan.MAX_RELIABLE_BUFFER) {
       throw new Error("NetChan reliable buffer overflow");
     }
     this.reliableMessage.writeString(value);
@@ -5366,6 +5439,11 @@ _NetChan.FRAGMENT_SIZE = 1024;
 _NetChan.PACKET_HEADER = 10;
 // sequence(4) + ack(4) + qport(2)
 _NetChan.HEADER_OVERHEAD = _NetChan.PACKET_HEADER + 2;
+// +2 for reliable length prefix
+// Increase internal reliable buffer to support large messages (fragmentation)
+// Quake 2 uses MAX_MSGLEN for the reliable buffer, limiting single messages to ~1400 bytes.
+// We expand this to allow larger messages (e.g. snapshots, downloads) which are then fragmented.
+_NetChan.MAX_RELIABLE_BUFFER = 262144;
 var NetChan = _NetChan;
 
 // src/items/weapons.ts