@baltica/raknet 0.0.6 → 0.0.8

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,23 +45,21 @@ 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);
+        this.socket.ref();
         this.network.send = (data) => this.socket.send(data, this.options.port, this.options.address);
         return new Promise((resolve) => {
             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 +108,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,16 @@ export declare class NetworkSession extends Emitter<NetworkEvents> {
     private highestReliableIndex;
     private offlineRetry;
     private outputBackupTimestamps;
+    private ackTimer?;
+    private retransmitTimer?;
+    private cleanupTimer?;
+    private lastCleanup;
+    private keepaliveTimer?;
     constructor(mtu: number, client: boolean);
+    private startKeepalive;
     sendOfflineWithRetry(data: Buffer): void;
     private clearOfflineRetry;
+    destroy(): void;
     receive(buffer: Buffer): void;
     private handleClientOffline;
     private handleServerOffline;

package/dist/shared/network-session.js

@@ -42,19 +42,56 @@ class NetworkSession extends utils_1.Emitter {
     highestReliableIndex = -1;
     offlineRetry = null;
     outputBackupTimestamps = new Map();
+    ackTimer;
+    retransmitTimer;
+    cleanupTimer;
+    lastCleanup = 0;
+    keepaliveTimer;
     constructor(mtu, client) {
         super();
         this.mtu = mtu;
         this.client = client;
         for (let i = 0; i < 32; i++)
             this.inputOrderingQueue.set(i, new Map());
+        this.startKeepalive();
+    }
+    startKeepalive() {
+        if (this.keepaliveTimer)
+            clearTimeout(this.keepaliveTimer);
+        const interval = this.status === proto_1.Status.Connected ? 10 :
+            this.status === proto_1.Status.Connecting ? 10 : 100;
+        this.keepaliveTimer = setTimeout(() => {
+            this.tick();
+            this.startKeepalive();
+        }, interval);
+        this.keepaliveTimer.ref();
     }
     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);
+            this.retransmitTimer.ref();
+        }
     }
     clearOfflineRetry() {
         this.offlineRetry = null;
+        if (this.retransmitTimer) {
+            clearTimeout(this.retransmitTimer);
+            this.retransmitTimer = undefined;
+        }
+    }
+    destroy() {
+        this.status = proto_1.Status.Disconnected;
+        if (this.ackTimer)
+            clearTimeout(this.ackTimer);
+        if (this.retransmitTimer)
+            clearTimeout(this.retransmitTimer);
+        if (this.cleanupTimer)
+            clearTimeout(this.cleanupTimer);
+        if (this.keepaliveTimer)
+            clearTimeout(this.keepaliveTimer);
+        this.removeAllListeners();
     }
     receive(buffer) {
         const id = buffer[0];
@@ -221,7 +258,7 @@ class NetworkSession extends utils_1.Emitter {
         }
     }
     tick() {
-        if (this.status === proto_1.Status.Disconnected)
+        if (this.status === proto_1.Status.Disconnected || !this.send)
             return;
         const now = Date.now();
         if (this.offlineRetry) {
@@ -231,48 +268,58 @@ 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);
+                this.retransmitTimer.ref();
+                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 +327,34 @@ 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);
+            this.retransmitTimer.ref();
+        }
     }
     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) {
@@ -363,7 +424,7 @@ class NetworkSession extends utils_1.Emitter {
             this.flush();
     }
     flush() {
-        if (this.outputFrames.size === 0)
+        if (this.outputFrames.size === 0 || !this.send)
             return;
         const fs = new proto_1.FrameSet();
         fs.sequence = this.outputSequence++;
@@ -371,8 +432,11 @@ 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);
+            this.retransmitTimer.ref();
+        }
     }
     onFrameSet(fs) {
         if (this.receivedFrameSequences.has(fs.sequence))
@@ -389,6 +453,13 @@ 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);
+            this.ackTimer.ref();
+        }
     }
     handleFrame(frame) {
         if (frame.isReliable()) {

package/package.json

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