quake2ts 0.0.301 → 0.0.302

package/packages/game/dist/esm/index.js

@@ -1431,10 +1431,14 @@ var init_esm = __esm({
         this.incomingReliableSequence = 0;
         this.outgoingReliableSequence = 0;
         this.reliableLength = 0;
+        this.fragmentSendOffset = 0;
+        this.fragmentBuffer = null;
+        this.fragmentLength = 0;
+        this.fragmentReceived = 0;
         this.lastReceived = 0;
         this.lastSent = 0;
         this.remoteAddress = null;
-        this.reliableMessage = new BinaryWriter(_NetChan2.MAX_MSGLEN);
+        this.reliableMessage = new BinaryWriter(_NetChan2.MAX_RELIABLE_BUFFER);
         const now = Date.now();
         this.lastReceived = now;
         this.lastSent = now;
@@ -1460,6 +1464,10 @@ var init_esm = __esm({
         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();
       }
@@ -1469,18 +1477,38 @@ var init_esm = __esm({
       transmit(unreliableData) {
         this.outgoingSequence++;
         this.lastSent = Date.now();
+        let sendReliableLength = 0;
+        let isFragment = false;
+        let fragmentStart = 0;
+        if (this.reliableLength > 0) {
+          if (this.reliableLength > _NetChan2.FRAGMENT_SIZE) {
+            isFragment = true;
+            if (this.fragmentSendOffset >= this.reliableLength) {
+              this.fragmentSendOffset = 0;
+            }
+            const remaining = this.reliableLength - this.fragmentSendOffset;
+            sendReliableLength = remaining;
+            if (sendReliableLength > _NetChan2.FRAGMENT_SIZE) {
+              sendReliableLength = _NetChan2.FRAGMENT_SIZE;
+            }
+            fragmentStart = this.fragmentSendOffset;
+            this.fragmentSendOffset += sendReliableLength;
+          } else {
+            sendReliableLength = this.reliableLength;
+          }
+        }
         const headerSize = _NetChan2.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 > _NetChan2.MAX_MSGLEN) {
-          unreliableSize = _NetChan2.MAX_MSGLEN - headerSize - reliableSize;
+        if (headerSize + reliableHeaderSize + sendReliableLength + unreliableSize > _NetChan2.MAX_MSGLEN) {
+          unreliableSize = _NetChan2.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;
@@ -1494,13 +1522,23 @@ var init_esm = __esm({
         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);
@@ -1541,6 +1579,7 @@ var init_esm = __esm({
             this.reliableLength = 0;
             this.reliableMessage.reset();
             this.outgoingReliableSequence ^= 1;
+            this.fragmentSendOffset = 0;
           }
         }
         const hasReliableData = (sequence & 2147483648) !== 0;
@@ -1549,13 +1588,45 @@ var init_esm = __esm({
         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 > _NetChan2.MAX_RELIABLE_BUFFER) {
+                console.warn(`NetChan: received invalid fragment total ${fragTotal} > ${_NetChan2.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;
         }
@@ -1582,7 +1653,7 @@ var init_esm = __esm({
        * Writes a byte to the reliable message buffer
        */
       writeReliableByte(value) {
-        if (this.reliableLength + 1 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+        if (this.reliableLength + 1 > _NetChan2.MAX_RELIABLE_BUFFER) {
           throw new Error("NetChan reliable buffer overflow");
         }
         this.reliableMessage.writeByte(value);
@@ -1592,7 +1663,7 @@ var init_esm = __esm({
        * Writes a short to the reliable message buffer
        */
       writeReliableShort(value) {
-        if (this.reliableLength + 2 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+        if (this.reliableLength + 2 > _NetChan2.MAX_RELIABLE_BUFFER) {
           throw new Error("NetChan reliable buffer overflow");
         }
         this.reliableMessage.writeShort(value);
@@ -1602,7 +1673,7 @@ var init_esm = __esm({
        * Writes a long to the reliable message buffer
        */
       writeReliableLong(value) {
-        if (this.reliableLength + 4 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+        if (this.reliableLength + 4 > _NetChan2.MAX_RELIABLE_BUFFER) {
           throw new Error("NetChan reliable buffer overflow");
         }
         this.reliableMessage.writeLong(value);
@@ -1613,7 +1684,7 @@ var init_esm = __esm({
        */
       writeReliableString(value) {
         const len = value.length + 1;
-        if (this.reliableLength + len > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+        if (this.reliableLength + len > _NetChan2.MAX_RELIABLE_BUFFER) {
           throw new Error("NetChan reliable buffer overflow");
         }
         this.reliableMessage.writeString(value);
@@ -1646,6 +1717,7 @@ var init_esm = __esm({
     _NetChan.FRAGMENT_SIZE = 1024;
     _NetChan.PACKET_HEADER = 10;
     _NetChan.HEADER_OVERHEAD = _NetChan.PACKET_HEADER + 2;
+    _NetChan.MAX_RELIABLE_BUFFER = 262144;
     WeaponId = /* @__PURE__ */ ((WeaponId22) => {
       WeaponId22["Blaster"] = "blaster";
       WeaponId22["Shotgun"] = "shotgun";