bug fix

Author: AnyBananaGAME

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanctumterra/raknet",
-  "version": "1.3.66",
+  "version": "1.3.67",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

src/client/client.ts

@@ -81,45 +81,66 @@ export class Client extends Emitter<ClientEvents> {
 		this.status = Status.Connecting;
 		this.initSocket();
 
-		this.timer = setInterval(() => this.emit("tick"), 20);
+		this.timer = setInterval(() => this.emit("tick"), 50);
 
 		try {
 			const advertisement = await this.ping();
 			if (!advertisement) throw new Error("Failed to get server advertisement");
 
 			return new Promise((resolve, reject) => {
 				let isResolved = false;
+				let shouldContinueSending = true;
 
-				const connectionTimeout = setTimeout(() => {
+				const cleanup = () => {
+					clearTimeout(connectionTimeout);
+					clearInterval(requestInterval);
 					if (!isResolved) {
+						Logger.error("Could not resolve connection.");
 						this.cleanup();
-						reject(new Error("Connection timed out"));
 					}
+				};
+
+				const connectionTimeout = setTimeout(() => {
+					cleanup();
+					reject(new Error("Connection timed out"));
 				}, this.options.timeout);
 
 				const request = new OpenConnectionRequestOne();
 				request.mtu = this.options.mtuSize;
 				request.protocol = this.options.protocolVersion;
 
+				this.on("open-connection-reply-two", (packet) => {
+					const mtu = packet.mtu;
+					if (mtu > 400 && mtu < 1500) {
+						shouldContinueSending = false;
+					} else {
+						cleanup();
+						reject(new Error(`Invalid MTU size: ${mtu}`));
+					}
+				});
+
 				this.emit("open-connection-request-one", request);
 				this.send(request.serialize());
 
 				const requestInterval = setInterval(() => {
-					if (!isResolved) {
+					if (!isResolved && shouldContinueSending) {
 						this.send(request.serialize());
 					}
-				}, 20);
+				}, 50);
 
 				this.onceAfter("new-incoming-connection", () => {
 					if (!isResolved) {
-						clearTimeout(connectionTimeout);
-						clearInterval(requestInterval);
 						isResolved = true;
 						this.emit("connect");
 						this.status = Status.Connected;
 						resolve(advertisement);
 					}
 				});
+
+				this.once("error", (error) => {
+					cleanup();
+					reject(error);
+				});
 			});
 		} catch (error) {
 			this.status = Status.Disconnected;

src/client/framer.ts

@@ -135,40 +135,13 @@ export class Framer {
 				const packet = new OpenConnectionReplyTwo(payload).deserialize();
 				this.client.emit("open-connection-reply-two", packet);
 				this.client.options.mtuSize = packet.mtu;
-
 				const conReq = new ConnectionRequest();
 				conReq.clientGuid = this.client.options.clientId;
 				conReq.timestamp = BigInt(Date.now());
 				conReq.useSecurity = false;
 
 				this.client.emit("connection-request", conReq);
 				this.client.framer.frameAndSend(conReq.serialize(), Priority.Immediate);
-
-				let connectionAttempts = 1;
-				const maxAttempts = 3;
-
-				const connectionInterval = setInterval(() => {
-					if (connectionAttempts >= maxAttempts) {
-						clearInterval(connectionInterval);
-						this.client.cleanup();
-						this.client.emit(
-							"error",
-							new Error("Connection request timed out"),
-						);
-						return;
-					}
-
-					this.client.framer.frameAndSend(
-						conReq.serialize(),
-						Priority.Immediate,
-					);
-					connectionAttempts++;
-				}, 30);
-
-				this.client.once("new-incoming-connection", () => {
-					clearInterval(connectionInterval);
-				});
-
 				break;
 			}
 			case Packet.FrameSet: {