@baltica/raknet 0.0.6 → 0.0.7

package/dist/client/client.d.ts

@@ -4,7 +4,6 @@ import { ClientEvents, ClientOptions } from "./types";
 export declare class Client extends Emitter<ClientEvents> {
     private socket;
     private network;
-    private tickInterval?;
     private relay?;
     options: ClientOptions;
     constructor(options?: Partial<ClientOptions>);

package/dist/client/client.js

@@ -10,7 +10,6 @@ const types_1 = require("./types");
 class Client extends utils_1.Emitter {
     socket;
     network;
-    tickInterval;
     relay;
     options;
     constructor(options = {}) {
@@ -46,7 +45,6 @@ class Client extends utils_1.Emitter {
         const targetPort = this.network.address.port;
         this.network.send = (data) => this.relay.send(data, targetAddress, targetPort);
         this.relay.onMessage((data) => this.network.receive(data));
-        this.tickInterval = setInterval(() => this.network.tick(), 50);
     }
     initDirect() {
         this.socket = (0, node_dgram_1.createSocket)(this.options.family);
@@ -55,14 +53,12 @@ class Client extends utils_1.Emitter {
             try {
                 this.socket.address();
                 this.socket.on("message", (buf) => this.network.receive(buf));
-                this.tickInterval = setInterval(() => this.network.tick(), 50);
                 resolve();
             }
             catch {
                 this.socket.bind();
                 this.socket.on("listening", () => {
                     this.socket.on("message", (buf) => this.network.receive(buf));
-                    this.tickInterval = setInterval(() => this.network.tick(), 50);
                     resolve();
                 });
             }
@@ -111,10 +107,7 @@ class Client extends utils_1.Emitter {
         this.network.frameAndSend(data, priority);
     }
     close() {
-        if (this.tickInterval) {
-            clearInterval(this.tickInterval);
-            this.tickInterval = undefined;
-        }
+        this.network.destroy();
         this.network.status = shared_1.Status.Disconnected;
         this.network.send = () => { };
         this.network.removeAllListeners();

package/dist/server/server.d.ts

@@ -4,7 +4,6 @@ import { ServerEvents, ServerOptions } from "./types";
 import { Connection } from "./connection";
 export declare class Server extends Emitter<ServerEvents> {
     private socket;
-    private tickInterval?;
     private connections;
     options: ServerOptions;
     constructor(options?: Partial<ServerOptions>);

package/dist/server/server.js

@@ -10,7 +10,6 @@ const connection_1 = require("./connection");
 const RAKNET_PROTOCOL = 11;
 class Server extends utils_1.Emitter {
     socket;
-    tickInterval;
     connections = new Map();
     options;
     constructor(options = {}) {
@@ -26,14 +25,11 @@ class Server extends utils_1.Emitter {
             this.socket.bind(this.options.port, this.options.address);
             this.socket.on("listening", () => {
                 this.socket.on("message", (buffer, rinfo) => this.handleMessage(buffer, rinfo));
-                this.tickInterval = setInterval(() => this.tick(), 50);
                 resolve();
             });
         });
     }
     stop() {
-        if (this.tickInterval)
-            clearInterval(this.tickInterval);
         for (const conn of this.connections.values())
             conn.disconnect();
         this.connections.clear();

package/dist/shared/network-session.d.ts

@@ -40,9 +40,14 @@ export declare class NetworkSession extends Emitter<NetworkEvents> {
     private highestReliableIndex;
     private offlineRetry;
     private outputBackupTimestamps;
+    private ackTimer?;
+    private retransmitTimer?;
+    private cleanupTimer?;
+    private lastCleanup;
     constructor(mtu: number, client: boolean);
     sendOfflineWithRetry(data: Buffer): void;
     private clearOfflineRetry;
+    destroy(): void;
     receive(buffer: Buffer): void;
     private handleClientOffline;
     private handleServerOffline;

package/dist/shared/network-session.js

@@ -42,6 +42,10 @@ class NetworkSession extends utils_1.Emitter {
     highestReliableIndex = -1;
     offlineRetry = null;
     outputBackupTimestamps = new Map();
+    ackTimer;
+    retransmitTimer;
+    cleanupTimer;
+    lastCleanup = 0;
     constructor(mtu, client) {
         super();
         this.mtu = mtu;
@@ -52,9 +56,25 @@ class NetworkSession extends utils_1.Emitter {
     sendOfflineWithRetry(data) {
         this.offlineRetry = { data, attempts: 1, maxAttempts: this.maxRetransmit, lastSent: Date.now(), interval: this.retransmitInterval };
         this.send(data);
+        if (!this.retransmitTimer) {
+            this.retransmitTimer = setTimeout(() => this.tick(), this.retransmitInterval);
+        }
     }
     clearOfflineRetry() {
         this.offlineRetry = null;
+        if (this.retransmitTimer) {
+            clearTimeout(this.retransmitTimer);
+            this.retransmitTimer = undefined;
+        }
+    }
+    destroy() {
+        if (this.ackTimer)
+            clearTimeout(this.ackTimer);
+        if (this.retransmitTimer)
+            clearTimeout(this.retransmitTimer);
+        if (this.cleanupTimer)
+            clearTimeout(this.cleanupTimer);
+        this.removeAllListeners();
     }
     receive(buffer) {
         const id = buffer[0];
@@ -231,48 +251,57 @@ class NetworkSession extends utils_1.Emitter {
                     this.offlineRetry = null;
                     this.status = proto_1.Status.Disconnected;
                     this.emit("error", new Error("Connection timed out after " + r.maxAttempts + " attempts"));
+                    return;
                 }
-                else {
-                    r.attempts++;
-                    r.lastSent = now;
-                    this.send(r.data);
-                }
+                r.attempts++;
+                r.lastSent = now;
+                this.send(r.data);
+                if (this.retransmitTimer)
+                    clearTimeout(this.retransmitTimer);
+                this.retransmitTimer = setTimeout(() => this.tick(), r.interval);
+                return;
             }
         }
-        const windowStart = this.lastInputSequence - RECEIVE_WINDOW;
-        if (windowStart > 0) {
-            for (const s of this.receivedFrameSequences)
-                if (s < windowStart)
-                    this.receivedFrameSequences.delete(s);
-            for (const s of this.lostFrameSequences)
-                if (s < windowStart)
-                    this.lostFrameSequences.delete(s);
-        }
-        const relStart = this.highestReliableIndex - RELIABLE_WINDOW;
-        if (relStart > 0) {
-            for (const i of this.receivedReliableFrameIndices)
-                if (i < relStart)
-                    this.receivedReliableFrameIndices.delete(i);
-        }
-        for (const [id, entry] of this.fragmentsQueue) {
-            if (now - entry.timestamp > FRAGMENT_TIMEOUT)
-                this.fragmentsQueue.delete(id);
-        }
-        if (this.pendingAcks.size > 0) {
-            const ack = new proto_1.Ack();
-            ack.sequences = [...this.pendingAcks];
-            this.pendingAcks.clear();
-            this.send(ack.serialize());
+        if (now - this.lastCleanup > 5000) {
+            this.lastCleanup = now;
+            const windowStart = this.lastInputSequence - RECEIVE_WINDOW;
+            if (windowStart > 0) {
+                for (const s of this.receivedFrameSequences)
+                    if (s < windowStart)
+                        this.receivedFrameSequences.delete(s);
+                for (const s of this.lostFrameSequences)
+                    if (s < windowStart)
+                        this.lostFrameSequences.delete(s);
+            }
+            const relStart = this.highestReliableIndex - RELIABLE_WINDOW;
+            if (relStart > 0) {
+                for (const i of this.receivedReliableFrameIndices)
+                    if (i < relStart)
+                        this.receivedReliableFrameIndices.delete(i);
+            }
+            for (const [id, entry] of this.fragmentsQueue) {
+                if (now - entry.timestamp > FRAGMENT_TIMEOUT)
+                    this.fragmentsQueue.delete(id);
+            }
         }
-        if (this.lostFrameSequences.size > 0) {
-            const nack = new proto_1.Nack();
-            nack.sequences = [...this.lostFrameSequences];
-            this.lostFrameSequences.clear();
-            this.send(nack.serialize());
+        if (this.pendingAcks.size > 0 || this.lostFrameSequences.size > 0) {
+            if (this.pendingAcks.size > 0) {
+                const ack = new proto_1.Ack();
+                ack.sequences = [...this.pendingAcks];
+                this.pendingAcks.clear();
+                this.send(ack.serialize());
+            }
+            if (this.lostFrameSequences.size > 0) {
+                const nack = new proto_1.Nack();
+                nack.sequences = [...this.lostFrameSequences];
+                this.lostFrameSequences.clear();
+                this.send(nack.serialize());
+            }
         }
-        // Retransmit unacked frame sets that are older than the retry interval
+        let nextRetransmit = Infinity;
         for (const [seq, sentAt] of this.outputBackupTimestamps) {
-            if (now - sentAt >= this.retransmitInterval) {
+            const age = now - sentAt;
+            if (age >= this.retransmitInterval) {
                 const frames = this.outputBackup.get(seq);
                 if (frames) {
                     const fs = new proto_1.FrameSet();
@@ -280,20 +309,33 @@ class NetworkSession extends utils_1.Emitter {
                     fs.frames = frames;
                     this.send(fs.serialize());
                     this.outputBackupTimestamps.set(seq, now);
+                    nextRetransmit = Math.min(nextRetransmit, this.retransmitInterval);
                 }
                 else {
                     this.outputBackupTimestamps.delete(seq);
                 }
             }
+            else {
+                nextRetransmit = Math.min(nextRetransmit, this.retransmitInterval - age);
+            }
         }
         if (this.outputFrames.size > 0)
             this.flush();
+        if (nextRetransmit < Infinity) {
+            if (this.retransmitTimer)
+                clearTimeout(this.retransmitTimer);
+            this.retransmitTimer = setTimeout(() => this.tick(), nextRetransmit);
+        }
     }
     onAck(ack) {
         for (const seq of ack.sequences) {
             this.outputBackup.delete(seq);
             this.outputBackupTimestamps.delete(seq);
         }
+        if (this.outputBackupTimestamps.size === 0 && this.retransmitTimer) {
+            clearTimeout(this.retransmitTimer);
+            this.retransmitTimer = undefined;
+        }
     }
     onNack(nack) {
         for (const seq of nack.sequences) {
@@ -371,8 +413,10 @@ class NetworkSession extends utils_1.Emitter {
         this.outputBackup.set(fs.sequence, fs.frames);
         this.outputBackupTimestamps.set(fs.sequence, Date.now());
         this.outputFrames.clear();
-        const serialized = fs.serialize();
-        this.send(serialized);
+        this.send(fs.serialize());
+        if (!this.retransmitTimer) {
+            this.retransmitTimer = setTimeout(() => this.tick(), this.retransmitInterval);
+        }
     }
     onFrameSet(fs) {
         if (this.receivedFrameSequences.has(fs.sequence))
@@ -389,6 +433,12 @@ class NetworkSession extends utils_1.Emitter {
         }
         for (const frame of fs.frames)
             this.handleFrame(frame);
+        if (!this.ackTimer) {
+            this.ackTimer = setTimeout(() => {
+                this.ackTimer = undefined;
+                this.tick();
+            }, 10);
+        }
     }
     handleFrame(frame) {
         if (frame.isReliable()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baltica/raknet",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "RakNet implementation for Baltica",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",