@sanctumterra/raknet 1.0.8 → 1.0.10

package/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "files.exclude": {
+        "**/.git": true,
+        "**/.svn": true,
+        "**/.hg": true,
+        "**/CVS": true,
+        "**/.DS_Store": true,
+        "**/Thumbs.db": true
+    },
+    "hide-files.files": []
+}

package/dist/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "files.exclude": {
+        "**/.git": true,
+        "**/.svn": true,
+        "**/.hg": true,
+        "**/CVS": true,
+        "**/.DS_Store": true,
+        "**/Thumbs.db": true
+    },
+    "hide-files.files": []
+}

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

@@ -1,23 +1,13 @@
+import { Frame } from "@serenityjs/raknet";
 import { RakNetClient } from "./RaknetClient";
-export declare class Queue<T> {
-    private elements;
-    enqueue(element: T): void;
-    dequeue(): T | undefined;
-    peek(): T | undefined;
-    isEmpty(): boolean;
-    size(): number;
-}
 export declare class FrameHandler {
-    private fragmentedPackets;
-    private reliablePackets;
-    private orderedPackets;
-    private highestSequence;
     private lastInputSequence;
     private receivedFrameSequences;
     private lostFrameSequences;
     private inputHighestSequenceIndex;
     private inputOrderIndex;
-    private frameQueue;
+    protected inputOrderingQueue: Map<number, Map<number, Frame>>;
+    protected readonly fragmentsQueue: Map<number, Map<number, Frame>>;
     private raknet;
     constructor(raknet: RakNetClient);
     tick(): void;
@@ -25,12 +15,9 @@ export declare class FrameHandler {
     handleFrameSet(buffer: Buffer): void;
     private handleFrame;
     private processFrame;
-    private processQueuedFrames;
-    private handleFragmentedFrame;
-    private handleSequencedFrame;
-    private handleOrderedFrame;
-    private handleReliableFrame;
-    private processReliableFrames;
+    private handleFragment;
+    private handleSequenced;
+    private handleOrdered;
     private handleConnectedPing;
     private handleConnectionRequestAccepted;
 }

package/dist/src/client/FrameHandler.js

@@ -2,65 +2,33 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    FrameHandler: function() {
+Object.defineProperty(exports, "FrameHandler", {
+    enumerable: true,
+    get: function() {
         return FrameHandler;
-    },
-    Queue: function() {
-        return Queue;
     }
 });
 const _raknet = require("@serenityjs/raknet");
 const _OhMyNewIncommingConnection = require("../packets/raknet/OhMyNewIncommingConnection");
 const _binarystream = require("@serenityjs/binarystream");
 const _Logger = require("../utils/Logger");
-class Queue {
-    enqueue(element) {
-        this.elements.push(element);
-    }
-    dequeue() {
-        return this.elements.shift();
-    }
-    peek() {
-        return this.elements[0];
-    }
-    isEmpty() {
-        return this.elements.length === 0;
-    }
-    size() {
-        return this.elements.length;
-    }
-    constructor(){
-        this.elements = [];
-    }
-}
 class FrameHandler {
     tick() {
         if (this.receivedFrameSequences.size > 0) {
             const ack = new _raknet.Ack();
             ack.sequences = [
                 ...this.receivedFrameSequences
-            ].map((x)=>{
-                this.receivedFrameSequences.delete(x);
-                return x;
-            });
+            ];
+            for (const sequence of this.receivedFrameSequences)this.receivedFrameSequences.delete(sequence);
             this.send(ack.serialize());
         }
         if (this.lostFrameSequences.size > 0) {
-            const pk = new _raknet.Nack();
-            pk.sequences = [
+            const nack = new _raknet.Nack();
+            nack.sequences = [
                 ...this.lostFrameSequences
-            ].map((x)=>{
-                this.lostFrameSequences.delete(x);
-                return x;
-            });
-            this.send(pk.serialize());
+            ];
+            for (const sequence of this.lostFrameSequences)this.lostFrameSequences.delete(sequence);
+            this.send(nack.serialize());
         }
     }
     send(buffer) {
@@ -68,9 +36,12 @@ class FrameHandler {
     }
     handleFrameSet(buffer) {
         const frameSet = new _raknet.FrameSet(buffer).deserialize();
-        if (frameSet.sequence <= this.highestSequence) {
-            _Logger.Logger.debug(`Ignoring old or duplicate FrameSet: ${frameSet.sequence}`);
-            return;
+        if (this.receivedFrameSequences.has(frameSet.sequence)) {
+            return _Logger.Logger.debug(`Received duplicate frameset ${frameSet.sequence}`);
+        }
+        this.lostFrameSequences.delete(frameSet.sequence);
+        if (frameSet.sequence < this.lastInputSequence || frameSet.sequence === this.lastInputSequence) {
+            _Logger.Logger.debug(`Received out of order frameset ${frameSet.sequence}!`);
         }
         this.receivedFrameSequences.add(frameSet.sequence);
         const diff = frameSet.sequence - this.lastInputSequence;
@@ -82,24 +53,16 @@ class FrameHandler {
             }
         }
         this.lastInputSequence = frameSet.sequence;
-        this.highestSequence = frameSet.sequence;
+        this.lastInputSequence = frameSet.sequence;
         for (const frame of frameSet.frames){
-            this.frameQueue.enqueue(frame);
+            this.handleFrame(frame);
         }
-        this.processQueuedFrames();
     }
     handleFrame(frame) {
-        if (frame.isFragmented()) {
-            this.handleFragmentedFrame(frame);
-        } else if (frame.isSequenced()) {
-            this.handleSequencedFrame(frame);
-        } else if (frame.isOrdered()) {
-            this.handleOrderedFrame(frame);
-        } else if (frame.isReliable()) {
-            this.handleReliableFrame(frame);
-        } else {
-            this.processFrame(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);
     }
     processFrame(frame) {
         const header = frame.payload[0];
@@ -115,78 +78,64 @@ class FrameHandler {
                 break;
         }
     }
-    processQueuedFrames() {
-        while(!this.frameQueue.isEmpty()){
-            const frame = this.frameQueue.dequeue();
-            if (frame) {
-                try {
-                    this.handleFrame(frame);
-                } catch (error) {
-                    _Logger.Logger.error(`Error processing frame: ${error}`);
+    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);
             }
+        } else {
+            this.fragmentsQueue.set(frame.splitId, new Map([
+                [
+                    frame.splitIndex,
+                    frame
+                ]
+            ]));
         }
     }
-    handleFragmentedFrame(frame) {
-        if (!this.fragmentedPackets.has(frame.fragmentId)) {
-            this.fragmentedPackets.set(frame.fragmentId, new Map());
-        }
-        const fragments = this.fragmentedPackets.get(frame.fragmentId);
-        fragments.set(frame.fragmentIndex, frame);
-        if (fragments.size === frame.fragmentSize) {
-            const stream = new _binarystream.BinaryStream();
-            for(let index = 0; index < fragments.size; index++){
-                const fragment = fragments.get(index);
-                stream.writeBuffer(fragment.payload);
-            }
-            const reassembledFrame = new _raknet.Frame();
-            Object.assign(reassembledFrame, frame);
-            reassembledFrame.payload = stream.getBuffer();
-            reassembledFrame.fragmentSize = 0;
-            this.fragmentedPackets.delete(frame.fragmentId);
-            this.handleFrame(reassembledFrame);
-        }
-    }
-    handleSequencedFrame(frame) {
+    handleSequenced(frame) {
         if (frame.sequenceIndex < this.inputHighestSequenceIndex[frame.orderChannel] || frame.orderIndex < this.inputOrderIndex[frame.orderChannel]) {
-            return _Logger.Logger.debug(`Received out of order frame ${frame.sequenceIndex}`);
+            return _Logger.Logger.debug(`Recieved out of order frame ${frame.sequenceIndex}!`);
         }
         this.inputHighestSequenceIndex[frame.orderChannel] = frame.sequenceIndex + 1;
-        this.processFrame(frame);
+        return this.processFrame(frame);
     }
-    handleOrderedFrame(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.orderedPackets.get(frame.orderChannel) || new Map();
-            while(outOfOrderQueue.has(index)){
-                const nextFrame = outOfOrderQueue.get(index);
-                this.processFrame(nextFrame);
+            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);
-                index++;
             }
-            this.orderedPackets.set(frame.orderChannel, outOfOrderQueue);
+            this.inputOrderingQueue.set(frame.orderChannel, outOfOrderQueue);
             this.inputOrderIndex[frame.orderChannel] = index;
         } else if (frame.orderIndex > this.inputOrderIndex[frame.orderChannel]) {
-            const outOfOrderQueue = this.orderedPackets.get(frame.orderChannel) || new Map();
-            outOfOrderQueue.set(frame.orderIndex, frame);
-            this.orderedPackets.set(frame.orderChannel, outOfOrderQueue);
-        }
-    }
-    handleReliableFrame(frame) {
-        if (frame.reliableIndex > (this.reliablePackets.size > 0 ? Math.max(...this.reliablePackets.keys()) : -1)) {
-            this.reliablePackets.set(frame.reliableIndex, frame);
-            this.processReliableFrames();
-        }
-    }
-    processReliableFrames() {
-        const sortedReliableIndexes = Array.from(this.reliablePackets.keys()).sort((a, b)=>a - b);
-        for (const index of sortedReliableIndexes){
-            const frame = this.reliablePackets.get(index);
-            this.processFrame(frame);
-            this.reliablePackets.delete(index);
+            const unordered = this.inputOrderingQueue.get(frame.orderChannel);
+            if (!unordered) return;
+            unordered.set(frame.orderIndex, frame);
+        } else {
+            return this.processFrame(frame);
         }
     }
     handleConnectedPing(buffer) {
@@ -229,17 +178,17 @@ class FrameHandler {
         void this.raknet.emit("connect", {});
     }
     constructor(raknet){
-        this.fragmentedPackets = new Map();
-        this.reliablePackets = new Map();
-        this.orderedPackets = new Map();
-        this.highestSequence = -1;
         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.frameQueue = new Queue();
+        this.inputOrderingQueue = new Map();
+        this.fragmentsQueue = new Map();
         this.raknet = raknet;
+        for(let index = 0; index < 32; index++){
+            this.inputOrderingQueue.set(index, new Map());
+        }
         this.raknet.on("tick", ()=>{
             this.tick();
         });

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

@@ -1,16 +1,19 @@
 import { Frame, FrameSet, Priority } from '@serenityjs/raknet';
 import { RakNetClient } from './RaknetClient';
 export declare class Queue {
-    private client;
     outputBackupQueue: Map<number, Frame[]>;
     outputOrderIndex: Array<number>;
     outputSequenceIndex: Array<number>;
     outputFrameQueue: FrameSet;
-    outputSequence: number;
-    outputReliableIndex: number;
-    outputFragmentIndex: number;
     mtu: number;
+    protected outputSequence: number;
+    protected outputsplitIndex: number;
+    protected outputReliableIndex: number;
+    protected outputFrames: Set<Frame>;
+    protected outputBackup: Map<number, Frame[]>;
+    protected client: RakNetClient;
     constructor(client: RakNetClient);
+    onTick(): void;
     /**
      * Sends a frame to the connection.
      *
@@ -18,14 +21,6 @@ export declare class Queue {
      * @param priority - The priority of the frame
      */
     sendFrame(frame: Frame, priority: Priority): void;
-    private addFrameToQueue;
-    /**
-     * Sends the output frame queue
-     */
-    sendFrameQueue(): void;
-    /**
-     * Sends a frame set to the connection
-     * @param frameset The frame set
-     */
-    private sendFrameSet;
+    private queueFrame;
+    sendQueue(amount: number): void;
 }

package/dist/src/client/Queue.js

@@ -10,6 +10,10 @@ Object.defineProperty(exports, "Queue", {
 });
 const _raknet = require("@serenityjs/raknet");
 class Queue {
+    onTick() {
+        if (this.client.status === _raknet.Status.Disconnecting || this.client.status === _raknet.Status.Disconnected) return;
+        return this.sendQueue(this.outputFrames.size);
+    }
     /**
 	 * Sends a frame to the connection.
 	 *
@@ -19,64 +23,59 @@ class Queue {
         if (frame.isSequenced()) {
             frame.orderIndex = this.outputOrderIndex[frame.orderChannel];
             frame.sequenceIndex = this.outputSequenceIndex[frame.orderChannel]++;
-        } else if (frame.isOrderExclusive()) {
+        } else if (frame.isOrdered()) {
             frame.orderIndex = this.outputOrderIndex[frame.orderChannel]++;
             this.outputSequenceIndex[frame.orderChannel] = 0;
         }
-        frame.reliableIndex = this.outputReliableIndex++;
-        const maxSize = this.mtu - 6 - 23;
+        const maxSize = this.mtu - 36;
+        const splitSize = Math.ceil(frame.payload.byteLength / maxSize);
         if (frame.payload.byteLength > maxSize) {
-            const buffer = Buffer.from(frame.payload);
-            const fragmentId = this.outputFragmentIndex++ % 65_536;
-            for(let index = 0; index < buffer.byteLength; index += maxSize){
-                if (index !== 0) frame.reliableIndex = this.outputReliableIndex++;
-                frame.payload = buffer.subarray(index, index + maxSize);
-                frame.fragmentIndex = index / maxSize;
-                frame.fragmentId = fragmentId;
-                frame.fragmentSize = Math.ceil(buffer.byteLength / maxSize);
-                this.addFrameToQueue(frame, priority || _raknet.Priority.Normal);
+            const splitId = this.outputsplitIndex++ % 65_536;
+            for(let index = 0; index < frame.payload.byteLength; index += maxSize){
+                const nframe = new _raknet.Frame();
+                if (frame.isReliable()) nframe.reliableIndex = this.outputReliableIndex++;
+                nframe.sequenceIndex = frame.sequenceIndex;
+                nframe.orderIndex = frame.orderIndex;
+                nframe.orderChannel = frame.orderChannel;
+                nframe.reliability = frame.reliability;
+                nframe.payload = frame.payload.subarray(index, index + maxSize);
+                nframe.splitIndex = index / maxSize;
+                nframe.splitId = splitId;
+                nframe.splitSize = splitSize;
+                this.queueFrame(nframe, priority);
             }
         } else {
-            this.addFrameToQueue(frame, priority);
-        }
-    }
-    addFrameToQueue(frame, priority) {
-        let length = 4;
-        for (const queuedFrame of this.outputFrameQueue.frames){
-            length += queuedFrame.getByteLength();
-        }
-        if (length + frame.getByteLength() > this.mtu - 36) {
-            this.sendFrameQueue();
-        }
-        this.outputFrameQueue.frames.push(frame);
-        if (priority === _raknet.Priority.Immediate) {
-            this.sendFrameQueue();
+            if (frame.isReliable()) frame.reliableIndex = this.outputReliableIndex++;
+            return this.queueFrame(frame, priority);
         }
     }
-    /**
-	 * Sends the output frame queue
-	 */ sendFrameQueue() {
-        if (this.outputFrameQueue.frames.length > 0) {
-            this.outputFrameQueue.sequence = this.outputSequence++;
-            this.sendFrameSet(this.outputFrameQueue);
-            this.outputFrameQueue = new _raknet.FrameSet();
-            this.outputFrameQueue.frames = [];
-        }
+    queueFrame(frame, priority) {
+        let length = _raknet.DGRAM_HEADER_SIZE;
+        for (const frame of this.outputFrames)length += frame.getByteLength();
+        if (length + frame.getByteLength() > this.mtu - _raknet.DGRAM_MTU_OVERHEAD) this.sendQueue(this.outputFrames.size);
+        this.outputFrames.add(frame);
+        if (priority === _raknet.Priority.Immediate) return this.sendQueue(1);
     }
-    /**
-	 * Sends a frame set to the connection
-	 * @param frameset The frame set
-	 */ sendFrameSet(frameset) {
-        this.client.send(frameset.serialize());
-        this.outputBackupQueue.set(frameset.sequence, frameset.frames.filter((frame)=>frame.isReliable()));
+    sendQueue(amount) {
+        if (this.outputFrames.size === 0) return;
+        const frameset = new _raknet.FrameSet();
+        frameset.sequence = this.outputSequence++;
+        frameset.frames = [
+            ...this.outputFrames
+        ].slice(0, amount);
+        this.outputBackup.set(frameset.sequence, frameset.frames);
+        for (const frame of frameset.frames)this.outputFrames.delete(frame);
+        return this.client.send(frameset.serialize());
     }
     constructor(client){
-        this.client = client;
         this.outputBackupQueue = new Map();
+        this.mtu = 1492;
         this.outputSequence = 0;
+        this.outputsplitIndex = 0;
         this.outputReliableIndex = 0;
-        this.outputFragmentIndex = 0;
-        this.mtu = 1492;
+        this.outputFrames = new Set();
+        this.outputBackup = new Map();
+        this.client = client;
         this.outputFrameQueue = new _raknet.FrameSet();
         this.outputFrameQueue.frames = [];
         this.outputOrderIndex = Array.from({
@@ -85,5 +84,8 @@ class Queue {
         this.outputSequenceIndex = Array.from({
             length: 32
         }).fill(0);
+        this.client.on("tick", ()=>{
+            this.onTick();
+        });
     }
 }

package/dist/src/client/RaknetClient.js

@@ -79,7 +79,6 @@ class RakNetClient extends _events.EventEmitter {
         this.connected = false;
         this.protocol = 11;
         this.isBusy = false;
-        this.status = _raknet.Status.Disconnected;
         this.clientAdress = new _raknet.Address('0.0.0.0', 0, 4);
         this.serverAddress = serverAddress;
         this.serverPort = serverPort;
@@ -88,6 +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.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.8",
+  "version": "1.0.10",
   "description": "",
   "main": "dist/index.js",
   "emitDeclarationOnly": true,
@@ -18,13 +18,16 @@
   "devDependencies": {
     "@swc/core": "^1.6.13",
     "@swc/helpers": "^0.5.11",
+    "@types/bun": "^1.1.6",
     "@types/node": "^20.14.10",
     "typescript": "^5.5.3"
   },
   "dependencies": {
     "@serenityjs/binarystream": "^2.6.6",
-    "@serenityjs/raknet": "^0.3.6",
+    "@serenityjs/raknet": "0.4.0-beta-20240715032912",
     "chalk": "^4.1.2",
+    "i": "^0.3.7",
+    "npm": "^10.8.2",
     "path": "^0.12.7"
   }
 }

package/tsconfig.json

@@ -8,11 +8,16 @@
     "moduleResolution": "node",
     "outDir": "dist",
     "baseUrl": ".", 
+    "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,    
     "paths": {
       "*": ["./*"]
     }
   },
+  "exclude": [
+    "*/node_modules/",
+    "dist"
+  ],
   "ts-node": {
     "swc": true, 
     "transpileOnly": true