@sanctumterra/raknet 1.0.10 → 1.0.11

package/dist/src/client/FrameHandler.d.ts

@@ -16,8 +16,10 @@ export declare class FrameHandler {
     private handleFrame;
     private processFrame;
     private handleFragment;
+    private reassembleAndProcessFragment;
     private handleSequenced;
     private handleOrdered;
+    private processOrderedFrames;
     private handleConnectedPing;
     private handleConnectionRequestAccepted;
 }

package/dist/src/client/FrameHandler.js

@@ -59,10 +59,16 @@ class FrameHandler {
         }
     }
     handleFrame(frame) {
-        if (frame.isSplit()) return this.handleFragment(frame);
-        else if (frame.isSequenced()) return this.handleSequenced(frame);
-        else if (frame.isOrdered()) this.handleOrdered(frame);
-        else this.processFrame(frame);
+        _Logger.Logger.debug(`Handling frame: reliability=${frame.reliability}, orderIndex=${frame.orderIndex}, sequenceIndex=${frame.sequenceIndex}`);
+        if (frame.isSplit()) {
+            this.handleFragment(frame);
+        } else if (frame.isSequenced()) {
+            this.handleSequenced(frame);
+        } else if (frame.isOrdered()) {
+            this.handleOrdered(frame);
+        } else {
+            this.processFrame(frame);
+        }
     }
     processFrame(frame) {
         const header = frame.payload[0];
@@ -79,63 +85,75 @@ class FrameHandler {
         }
     }
     handleFragment(frame) {
-        if (this.fragmentsQueue.has(frame.splitId)) {
-            const fragment = this.fragmentsQueue.get(frame.splitId);
-            if (!fragment) return;
-            fragment.set(frame.splitIndex, frame);
-            if (fragment.size === frame.splitSize) {
-                const stream = new _binarystream.BinaryStream();
-                for(let index = 0; index < fragment.size; index++){
-                    const sframe = fragment.get(index);
-                    stream.writeBuffer(sframe.payload);
-                }
-                const nframe = new _raknet.Frame();
-                nframe.reliability = frame.reliability;
-                nframe.reliableIndex = frame.reliableIndex;
-                nframe.sequenceIndex = frame.sequenceIndex;
-                nframe.orderIndex = frame.orderIndex;
-                nframe.orderChannel = frame.orderChannel;
-                nframe.payload = stream.getBuffer();
-                this.fragmentsQueue.delete(frame.splitId);
-                return this.handleFrame(nframe);
+        _Logger.Logger.debug(`Handling fragment: splitId=${frame.splitId}, splitIndex=${frame.splitIndex}, splitSize=${frame.splitSize}`);
+        if (!this.fragmentsQueue.has(frame.splitId)) {
+            this.fragmentsQueue.set(frame.splitId, new Map());
+        }
+        const fragment = this.fragmentsQueue.get(frame.splitId);
+        if (!fragment) return;
+        fragment.set(frame.splitIndex, frame);
+        if (fragment.size === frame.splitSize) {
+            _Logger.Logger.debug(`Reassembling complete frame from fragments: splitId=${frame.splitId}`);
+            this.reassembleAndProcessFragment(frame, fragment);
+        }
+    }
+    reassembleAndProcessFragment(frame, fragment) {
+        const stream = new _binarystream.BinaryStream();
+        for(let index = 0; index < fragment.size; index++){
+            const sframe = fragment.get(index);
+            if (sframe) {
+                stream.writeBuffer(sframe.payload);
+            } else {
+                _Logger.Logger.error(`Missing fragment at index ${index} for splitId=${frame.splitId}`);
+                return;
             }
-        } else {
-            this.fragmentsQueue.set(frame.splitId, new Map([
-                [
-                    frame.splitIndex,
-                    frame
-                ]
-            ]));
         }
+        const reassembledFrame = new _raknet.Frame();
+        reassembledFrame.reliability = frame.reliability;
+        reassembledFrame.reliableIndex = frame.reliableIndex;
+        reassembledFrame.sequenceIndex = frame.sequenceIndex;
+        reassembledFrame.orderIndex = frame.orderIndex;
+        reassembledFrame.orderChannel = frame.orderChannel;
+        reassembledFrame.payload = stream.getBuffer();
+        this.fragmentsQueue.delete(frame.splitId);
+        this.handleFrame(reassembledFrame);
     }
     handleSequenced(frame) {
-        if (frame.sequenceIndex < this.inputHighestSequenceIndex[frame.orderChannel] || frame.orderIndex < this.inputOrderIndex[frame.orderChannel]) {
-            return _Logger.Logger.debug(`Recieved out of order frame ${frame.sequenceIndex}!`);
+        const currentHighestSequence = this.inputHighestSequenceIndex[frame.orderChannel];
+        _Logger.Logger.debug(`Handling sequenced frame: sequenceIndex=${frame.sequenceIndex}, currentHighest=${currentHighestSequence}`);
+        if (frame.sequenceIndex > currentHighestSequence) {
+            this.inputHighestSequenceIndex[frame.orderChannel] = frame.sequenceIndex;
+            this.processFrame(frame);
+        } else {
+            _Logger.Logger.debug(`Discarding old sequenced frame: ${frame.sequenceIndex}`);
         }
-        this.inputHighestSequenceIndex[frame.orderChannel] = frame.sequenceIndex + 1;
-        return this.processFrame(frame);
     }
     handleOrdered(frame) {
-        if (frame.orderIndex === this.inputOrderIndex[frame.orderChannel]) {
-            this.inputHighestSequenceIndex[frame.orderChannel] = 0;
-            this.inputOrderIndex[frame.orderChannel] = frame.orderIndex + 1;
-            this.processFrame(frame);
-            let index = this.inputOrderIndex[frame.orderChannel];
-            const outOfOrderQueue = this.inputOrderingQueue.get(frame.orderChannel);
-            for(; outOfOrderQueue.has(index); index++){
-                const frame = outOfOrderQueue.get(index);
-                if (!frame) break;
-                this.processFrame(frame);
-                outOfOrderQueue.delete(index);
-            }
-            this.inputOrderingQueue.set(frame.orderChannel, outOfOrderQueue);
-            this.inputOrderIndex[frame.orderChannel] = index;
-        } else if (frame.orderIndex > this.inputOrderIndex[frame.orderChannel]) {
-            const unordered = this.inputOrderingQueue.get(frame.orderChannel);
-            if (!unordered) return;
-            unordered.set(frame.orderIndex, frame);
+        _Logger.Logger.debug(`Handling ordered frame: orderIndex=${frame.orderIndex}, channel=${frame.orderChannel}`);
+        const expectedOrderIndex = this.inputOrderIndex[frame.orderChannel];
+        const outOfOrderQueue = this.inputOrderingQueue.get(frame.orderChannel);
+        if (frame.orderIndex === expectedOrderIndex) {
+            this.processOrderedFrames(frame, outOfOrderQueue);
+        } else if (frame.orderIndex > expectedOrderIndex) {
+            _Logger.Logger.debug(`Queuing out-of-order frame: ${frame.orderIndex}`);
+            outOfOrderQueue.set(frame.orderIndex, frame);
         } else {
-            return this.processFrame(frame);
+            _Logger.Logger.debug(`Discarding old frame: ${frame.orderIndex}`);
+        }
+    }
+    processOrderedFrames(frame, outOfOrderQueue) {
+        this.processFrame(frame);
+        this.inputOrderIndex[frame.orderChannel]++;
+        let nextOrderIndex = this.inputOrderIndex[frame.orderChannel];
+        while(outOfOrderQueue.has(nextOrderIndex)){
+            const nextFrame = outOfOrderQueue.get(nextOrderIndex);
+            if (nextFrame) {
+                _Logger.Logger.debug(`Processing queued frame: ${nextOrderIndex}`);
+                this.processFrame(nextFrame);
+                outOfOrderQueue.delete(nextOrderIndex);
+                this.inputOrderIndex[frame.orderChannel]++;
+                nextOrderIndex++;
+            }
         }
     }
     handleConnectedPing(buffer) {
@@ -181,12 +199,12 @@ class FrameHandler {
         this.lastInputSequence = -1;
         this.receivedFrameSequences = new Set();
         this.lostFrameSequences = new Set();
-        this.inputHighestSequenceIndex = new Array(32).fill(0);
-        this.inputOrderIndex = new Array(32).fill(0);
+        this.inputHighestSequenceIndex = new Array(64).fill(0);
+        this.inputOrderIndex = new Array(64).fill(0);
         this.inputOrderingQueue = new Map();
         this.fragmentsQueue = new Map();
         this.raknet = raknet;
-        for(let index = 0; index < 32; index++){
+        for(let index = 0; index < 64; index++){
             this.inputOrderingQueue.set(index, new Map());
         }
         this.raknet.on("tick", ()=>{

package/dist/src/client/PacketHandler.d.ts

@@ -5,6 +5,7 @@ export declare class PacketHandler {
     framehandler: FrameHandler;
     constructor(client: RakNetClient);
     handleIncoming(buffer: Buffer): void;
+    otherPackets(buffer: Buffer): void;
     handleOpenConnectionRequest2(buffer: Buffer): void;
     handleOpenConnectionRequest(): void;
     sendConnectionPacket(): void;

package/dist/src/client/PacketHandler.js

@@ -23,8 +23,8 @@ class PacketHandler {
         ];
         if (!ignore.includes(packetId)) _Logger.Logger.debug("Received Packet ID " + packetId);
         switch(packetId){
-            case 254:
-                process.exit(0);
+            case _raknet.Bitflags.Valid + 44:
+                this.framehandler.handleFrameSet(buffer);
                 break;
             case _raknet.Packet.OpenConnectionReply1:
                 this.handleOpenConnectionRequest2(buffer);
@@ -32,35 +32,29 @@ class PacketHandler {
             case _raknet.Packet.OpenConnectionReply2:
                 this.handleOpenConnectionRequest();
                 break;
+            default:
+                this.otherPackets(buffer);
+                _Logger.Logger.debug('Received unknown packet ' + packetId);
+        }
+    }
+    otherPackets(buffer) {
+        const packetId = buffer.readUint8() & 0xf0;
+        switch(packetId){
+            case _raknet.Bitflags.Valid:
+                this.framehandler.handleFrameSet(buffer);
+                break;
             case _raknet.Packet.Ack:
-                _Logger.Logger.debug(new _raknet.Ack(buffer).deserialize());
                 break;
             case _raknet.Packet.Nack:
-                _Logger.Logger.debug(new _raknet.Nack(buffer).deserialize());
-                break;
-            case 128:
-            case 129:
-            case 130:
-            case 131:
-            case 132:
-            case 134:
-            case 135:
-            case 136:
-            case 137:
-            case 138:
-            case 139:
-            case 140:
-            case 141:
-                this.framehandler.handleFrameSet(buffer);
                 break;
             default:
-                _Logger.Logger.debug('Received unknown packet ' + packetId);
+                break;
         }
     }
     handleOpenConnectionRequest2(buffer) {
         const reply2 = new _raknet.OpenConnectionReply1(buffer).deserialize();
         const pak = new _raknet.OpenConnectionRequest2();
-        pak.mtu = 1492;
+        pak.mtu = 1024;
         pak.client = this.client.id;
         pak.magic = reply2.magic;
         pak.address = new _raknet.Address(this.client.socket.address().address, this.client.socket.address().port, 4);
@@ -81,7 +75,7 @@ class PacketHandler {
         const packet = new _raknet.OpenConnectionRequest1();
         packet.magic = Buffer.from("\0\xFF\xFF\0\xFE\xFE\xFE\xFE\xFD\xFD\xFD\xFD4Vx", "binary");
         packet.protocol = this.client.protocol;
-        packet.mtu = 1464;
+        packet.mtu = 1024 - _raknet.DGRAM_MTU_OVERHEAD;
         const serializedPacket = packet.serialize();
         this.client.send(serializedPacket);
     }

package/dist/src/client/Queue.d.ts

@@ -1,7 +1,6 @@
 import { Frame, FrameSet, Priority } from '@serenityjs/raknet';
 import { RakNetClient } from './RaknetClient';
 export declare class Queue {
-    outputBackupQueue: Map<number, Frame[]>;
     outputOrderIndex: Array<number>;
     outputSequenceIndex: Array<number>;
     outputFrameQueue: FrameSet;
@@ -10,7 +9,7 @@ export declare class Queue {
     protected outputsplitIndex: number;
     protected outputReliableIndex: number;
     protected outputFrames: Set<Frame>;
-    protected outputBackup: Map<number, Frame[]>;
+    outputBackup: Map<number, Frame[]>;
     protected client: RakNetClient;
     constructor(client: RakNetClient);
     onTick(): void;

package/dist/src/client/Queue.js

@@ -68,8 +68,7 @@ class Queue {
         return this.client.send(frameset.serialize());
     }
     constructor(client){
-        this.outputBackupQueue = new Map();
-        this.mtu = 1492;
+        this.mtu = 1024;
         this.outputSequence = 0;
         this.outputsplitIndex = 0;
         this.outputReliableIndex = 0;

package/dist/src/client/RaknetClient.js

@@ -87,7 +87,7 @@ class RakNetClient extends _events.EventEmitter {
         this.id = BigInt(Array.from({
             length: 20
         }, ()=>Math.floor(Math.random() * 10)).join(''));
-        this.status = _raknet.Status.Disconnected;
+        this.status = _raknet.Status.Connecting;
         this.packetHandler = new _PacketHandler.PacketHandler(this);
         this.queue = new _Queue.Queue(this);
         setInterval(()=>{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanctumterra/raknet",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "",
   "main": "dist/index.js",
   "emitDeclarationOnly": true,