teeworlds 2.1.5 → 2.1.7

package/lib/client.ts

@@ -1,15 +1,13 @@
 import { randomBytes } from "crypto";
 
 import net from 'dgram';
-import fs, { stat } from 'fs';
 import { EventEmitter } from 'stream';
-import { spawn } from 'child_process';
 
 import { unpackInt, unpackString, MsgUnpacker } from "./MsgUnpacker";
 
 import Movement from './movement';
 
-import MsgPacker from './MsgPacker';
+import { MsgPacker } from './MsgPacker';
 import { Snapshot } from './snapshot';
 import Huffman from "./huffman";
 
@@ -174,7 +172,13 @@ declare interface iKillMsg {
 	special_mode: number
 }
 
-declare interface Client {
+declare interface iOptions {
+	identity?: ClientInfo,
+	password?: string,
+	ddnet_version?: {version: number, release_version: string},
+}
+
+export declare interface Client {
 	host: string;
 	port: number;
 	name: string;
@@ -201,6 +205,7 @@ declare interface Client {
 
 	lastSendTime: number;
 
+	options?: iOptions;
 
 	on(event: 'connected', listener: () => void): this;
 	on(event: 'disconnect', listener: (reason: string) => void): this;
@@ -209,17 +214,23 @@ declare interface Client {
 	on(event: 'kill', listener: (kill: iKillMsg) => void): this;
 
 }
-class Client extends EventEmitter {
 
 
 
-	constructor(ip: string, port: number, nickname: string) {
+export class Client extends EventEmitter {
+
+
+
+	constructor(ip: string, port: number, nickname: string, options?: iOptions) {
 		super();
 		this.host = ip;
 		this.port = port;
 		this.name = nickname;
 		this.AckGameTick = 0;
 		this.PredGameTick = 0;
+		
+		if (options) 			
+			this.options = options;
 
 		this.timer = 0;
 
@@ -304,39 +315,43 @@ class Client extends EventEmitter {
 		*/
 		})
 	}
-	SendMsgEx(Msg: MsgPacker, Flags: number) {
-		if (this.State == States.STATE_OFFLINE)
-			throw new Error("Client is not connected");
-		if (!this.socket)
-			return;
-		this.lastSendTime = new Date().getTime();
-		var header = []
-		header[0] = ((Flags & 3) << 6) | ((Msg.size >> 4) & 0x3f);
-		header[1] = (Msg.size & 0xf);
-		if (Flags & 1) {
-			this.clientAck = (this.clientAck + 1) % (1 << 10);
-			header[1] |= (this.clientAck >> 2) & 0xf0;
-			header[2] = this.clientAck & 0xff;
-
-			this.sentChunkQueue.push(Buffer.concat([Buffer.from(header), Msg.buffer]));
-		}
-
-		let latestBuf = Buffer.from([0x0 + (((16 << 4) & 0xf0) | ((this.ack >> 8) & 0xf)), this.ack & 0xff, 0x1, header[0], header[1]]);
-		if (Flags & 1)
-			latestBuf = Buffer.concat([latestBuf, Buffer.from([this.clientAck])]);
-		latestBuf = Buffer.concat([latestBuf, Msg.buffer, this.TKEN]);
-		this.socket.send(latestBuf, 0, latestBuf.length, this.port, this.host);
-
-	}
-	SendMsgExWithChunks(Msgs: MsgPacker[], Flags: number) {
+	// SendMsgEx(Msg: MsgPacker, Flags: number) {
+	// 	if (this.State == States.STATE_OFFLINE)
+	// 		throw new Error("Client is not connected");
+	// 	if (!this.socket)
+	// 		return;
+	// 	this.lastSendTime = new Date().getTime();
+	// 	var header = []
+	// 	header[0] = ((Flags & 3) << 6) | ((Msg.size >> 4) & 0x3f);
+	// 	header[1] = (Msg.size & 0xf);
+	// 	if (Flags & 1) {
+	// 		this.clientAck = (this.clientAck + 1) % (1 << 10);
+	// 		header[1] |= (this.clientAck >> 2) & 0xf0;
+	// 		header[2] = this.clientAck & 0xff;
+
+	// 		this.sentChunkQueue.push(Buffer.concat([Buffer.from(header), Msg.buffer]));
+	// 	}
+
+	// 	let latestBuf = Buffer.from([0x0 + (((16 << 4) & 0xf0) | ((this.ack >> 8) & 0xf)), this.ack & 0xff, 0x1, header[0], header[1]]);
+	// 	if (Flags & 1)
+	// 		latestBuf = Buffer.concat([latestBuf, Buffer.from([this.clientAck])]);
+	// 	latestBuf = Buffer.concat([latestBuf, Msg.buffer, this.TKEN]);
+	// 	this.socket.send(latestBuf, 0, latestBuf.length, this.port, this.host);
+
+	// }
+	SendMsgEx(Msgs: MsgPacker[] | MsgPacker, Flags: number) {
 		if (this.State == States.STATE_OFFLINE)
-			throw new Error("Client is not connected");
+			return; //throw new Error("Client is not connected");
 		if (!this.socket)
 			return;
+		let _Msgs: MsgPacker[];
+		if (Msgs instanceof Array)
+			_Msgs = Msgs;
+		else
+			_Msgs = [Msgs];
 		this.lastSendTime = new Date().getTime();
 		var header: Buffer[] = [];
-
-		Msgs.forEach((Msg: MsgPacker, index) => {
+		_Msgs.forEach((Msg: MsgPacker, index) => {
 			header[index] = Buffer.alloc((Flags & 1 ? 3 : 2));
 			header[index][0] = ((Flags & 3) << 6) | ((Msg.size >> 4) & 0x3f);
 			header[index][1] = (Msg.size & 0xf);
@@ -344,19 +359,15 @@ class Client extends EventEmitter {
 				this.clientAck = (this.clientAck + 1) % (1 << 10);
 				header[index][1] |= (this.clientAck >> 2) & 0xf0;
 				header[index][2] = this.clientAck & 0xff;
-
 				header[index][0] = (((Flags | 2)&3)<<6)|((Msg.size>>4)&0x3f); // 2 is resend flag (ugly hack for queue)
 				
 				this.sentChunkQueue.push(Buffer.concat([header[index], Msg.buffer]));
-
 				header[index][0] = (((Flags)&3)<<6)|((Msg.size>>4)&0x3f);
-
-
 			}
 		})
-		var packetHeader = Buffer.from([0x0 + (((16 << 4) & 0xf0) | ((this.ack >> 8) & 0xf)), this.ack & 0xff, Msgs.length]);
+		var packetHeader = Buffer.from([0x0 + (((16 << 4) & 0xf0) | ((this.ack >> 8) & 0xf)), this.ack & 0xff, _Msgs.length]);
 		var chunks = Buffer.from([]);
-		Msgs.forEach((Msg: MsgPacker, index) => {
+		_Msgs.forEach((Msg: MsgPacker, index) => {
 			chunks = Buffer.concat([chunks, Buffer.from(header[index]), Msg.buffer]);
 		})
 		var packet = Buffer.concat([(packetHeader), chunks, this.TKEN]);
@@ -365,7 +376,7 @@ class Client extends EventEmitter {
 	}
 	SendMsgRaw(chunks: Buffer[]) {
 		if (this.State == States.STATE_OFFLINE)
-			throw new Error("Client is not connected");
+			return console.log(chunks, "client not connected"); //throw new Error("Client is not connected");
 		if (!this.socket)
 			return;
 
@@ -411,10 +422,13 @@ class Client extends EventEmitter {
 		this.State = States.STATE_CONNECTING;
 
 		let predTimer = setInterval(() => {
-			if (this.State == States.STATE_ONLINE && this.AckGameTick > 0) {
-				this.PredGameTick++;
+			if (this.State == States.STATE_ONLINE) {
+				if (this.AckGameTick > 0)
+					this.PredGameTick++;
 				// console.log(this.PredGameTick, this.AckGameTick)
-			}
+			} else if (this.State == States.STATE_OFFLINE) 
+				clearInterval(predTimer);
+			
 		}, 20);
 
 		this.SendControlMsg(1, "TKEN")
@@ -425,8 +439,10 @@ class Client extends EventEmitter {
 				clearInterval(connectInterval)
 		}, 500);
 
-		setInterval(() => {
+		let inputInterval = setInterval(() => {
 			// if (new Date().getTime() - this.time >= 1000) {
+			if (this.State == States.STATE_OFFLINE)
+				clearInterval(inputInterval)
 			if (this.State != States.STATE_ONLINE)
 				return;
 			this.time = new Date().getTime();
@@ -440,12 +456,13 @@ class Client extends EventEmitter {
 			// this.sentChunkQueue.forEach((chunk) => {
 			// if (this.State == 0) // disconnected
 				// return;
-			if (this.State != 0) {
-				if (((new Date().getTime()) - this.lastSendTime) > 900) {
+			if (this.State != States.STATE_OFFLINE) {
+				if (((new Date().getTime()) - this.lastSendTime) > 900 && this.sentChunkQueue.length > 0) {
 					this.SendMsgRaw([this.sentChunkQueue[0]]);
-					console.log(this.sentChunkQueue);
+					console.log(this.sentChunkQueue, this.State);
 				}
-			}
+			} else
+				clearInterval(resendTimeout)
 			// })
 		}, 1000)
 	
@@ -453,7 +470,9 @@ class Client extends EventEmitter {
 		this.time = new Date().getTime() + 2000; // start sending keepalives after 2s
 
 		if (this.socket)
-			this.socket.on("message", (a) => {
+			this.socket.on("message", (a, rinfo) => {
+				if (this.State == 0 || rinfo.address != this.host || rinfo.port != this.port)
+					return;
 				clearInterval(connectInterval)
 				if (a.toJSON().data[0] == 0x10) {
 					if (a.toString().includes("TKEN") || a.toJSON().data[3] == 0x2) {
@@ -461,9 +480,11 @@ class Client extends EventEmitter {
 						this.TKEN = Buffer.from(a.toJSON().data.slice(a.toJSON().data.length - 4, a.toJSON().data.length))
 						this.SendControlMsg(3);
 						this.State = States.STATE_LOADING; // loading state
+						this.receivedSnaps = 0;
+						
 						var info = new MsgPacker(1, true);
 						info.AddString("0.6 626fce9a778df4d4");
-						info.AddString(""); // password
+						info.AddString(this.options?.password === undefined ? "" : this.options?.password); // password
 
 						var client_version = new MsgPacker(0, true);
 						client_version.AddBuffer(Buffer.from("8c00130484613e478787f672b3835bd4", 'hex'));
@@ -472,10 +493,15 @@ class Client extends EventEmitter {
 						randomBytes(16).copy(randomUuid);
 
 						client_version.AddBuffer(randomUuid);
-						client_version.AddInt(16003);
-						client_version.AddString("DDNet 16.0.3");
+						if (this.options?.ddnet_version !== undefined) {
+							client_version.AddInt(this.options?.ddnet_version.version);
+							client_version.AddString("DDNet " + this.options?.ddnet_version.release_version);
+						} else {
+							client_version.AddInt(16003);
+							client_version.AddString("DDNet 16.0.3");
+						}
 		
-						this.SendMsgExWithChunks([client_version, info], 1)
+						this.SendMsgEx([client_version, info], 1)
 					} else if (a.toJSON().data[3] == 0x4) {
 						// disconnected
 						this.State = States.STATE_OFFLINE;
@@ -610,13 +636,24 @@ class Client extends EventEmitter {
 					this.SendMsgEx(Msg, 1);
 				} else if ((unpacked.chunks[0] && chunkMessages.includes("CON_READY") || unpacked.chunks[0] && chunkMessages.includes("SV_MOTD"))) {
 					var info = new MsgPacker(20, false);
-					info.AddString(this.name); /* name */
-					info.AddString(""); /* clan */
-					info.AddInt(-1); /* country */
-					info.AddString("greyfox"); /* skin */
-					info.AddInt(1); /* use custom color */
-					info.AddInt(10346103); /* color body */
-					info.AddInt(65535); /* color feet */
+					if (this.options?.identity) {
+						info.AddString(this.options.identity.name); 
+						info.AddString(this.options.identity.clan); 
+						info.AddInt(this.options.identity.country); 
+						info.AddString(this.options.identity.skin); 
+						info.AddInt(this.options.identity.use_custom_color);
+						info.AddInt(this.options.identity.color_body); 
+						info.AddInt(this.options.identity.color_feet); 
+					} else {
+						info.AddString(this.name); /* name */
+						info.AddString(""); /* clan */
+						info.AddInt(-1); /* country */
+						info.AddString("greyfox"); /* skin */
+						info.AddInt(1); /* use custom color */
+						info.AddInt(10346103); /* color body */
+						info.AddInt(65535); /* color feet */
+
+					}
 					this.SendMsgEx(info, 1);
 
 
@@ -772,5 +809,6 @@ class Client extends EventEmitter {
 
 
 }
-export = Client;
+
+// export = Client;
 // module.exports = Client;

package/lib/huffman.js

@@ -0,0 +1,190 @@
+"use strict";
+var FREQ_TABLE = [
+    1 << 30, 4545, 2657, 431, 1950, 919, 444, 482, 2244, 617, 838, 542, 715, 1814, 304, 240, 754, 212, 647, 186,
+    283, 131, 146, 166, 543, 164, 167, 136, 179, 859, 363, 113, 157, 154, 204, 108, 137, 180, 202, 176,
+    872, 404, 168, 134, 151, 111, 113, 109, 120, 126, 129, 100, 41, 20, 16, 22, 18, 18, 17, 19,
+    16, 37, 13, 21, 362, 166, 99, 78, 95, 88, 81, 70, 83, 284, 91, 187, 77, 68, 52, 68,
+    59, 66, 61, 638, 71, 157, 50, 46, 69, 43, 11, 24, 13, 19, 10, 12, 12, 20, 14, 9,
+    20, 20, 10, 10, 15, 15, 12, 12, 7, 19, 15, 14, 13, 18, 35, 19, 17, 14, 8, 5,
+    15, 17, 9, 15, 14, 18, 8, 10, 2173, 134, 157, 68, 188, 60, 170, 60, 194, 62, 175, 71,
+    148, 67, 167, 78, 211, 67, 156, 69, 1674, 90, 174, 53, 147, 89, 181, 51, 174, 63, 163, 80,
+    167, 94, 128, 122, 223, 153, 218, 77, 200, 110, 190, 73, 174, 69, 145, 66, 277, 143, 141, 60,
+    136, 53, 180, 57, 142, 57, 158, 61, 166, 112, 152, 92, 26, 22, 21, 28, 20, 26, 30, 21,
+    32, 27, 20, 17, 23, 21, 30, 22, 22, 21, 27, 25, 17, 27, 23, 18, 39, 26, 15, 21,
+    12, 18, 18, 27, 20, 18, 15, 19, 11, 17, 33, 12, 18, 15, 19, 18, 16, 26, 17, 18,
+    9, 10, 25, 22, 22, 17, 20, 16, 6, 16, 15, 20, 14, 18, 24, 335, 1517
+], HUFFMAN_EOF_SYMBOL = 256, HUFFMAN_MAX_SYMBOLS = HUFFMAN_EOF_SYMBOL + 1, HUFFMAN_MAX_NODES = HUFFMAN_MAX_SYMBOLS * 2 - 1, HUFFMAN_LUTBITS = 10, HUFFMAN_LUTSIZE = 1 << HUFFMAN_LUTBITS, HUFFMAN_LUTMASK = HUFFMAN_LUTSIZE - 1;
+var Huffman = /** @class */ (function () {
+    function Huffman(frequencies) {
+        if (frequencies === void 0) { frequencies = FREQ_TABLE; }
+        this.nodes = new Array(HUFFMAN_MAX_NODES);
+        for (var i = 0; i < HUFFMAN_MAX_NODES; i++) {
+            this.nodes[i] = {};
+        }
+        this.decode_lut = new Array(HUFFMAN_LUTSIZE);
+        this.num_nodes = 0;
+        this.start_node_index = 0;
+        this.construct_tree(frequencies);
+        for (var i = 0; i < HUFFMAN_LUTSIZE; i++) {
+            var bits = i;
+            var broke = false;
+            var index = this.start_node_index;
+            for (var x = 0; x < HUFFMAN_LUTBITS; x++) {
+                if (bits & 1)
+                    index = this.nodes[index].right;
+                else
+                    index = this.nodes[index].left;
+                bits >>= 1;
+                if (this.nodes[index].numbits) {
+                    this.decode_lut[i] = index;
+                    broke = true;
+                    break;
+                }
+            }
+            if (!broke) {
+                this.decode_lut[i] = index;
+            }
+        }
+    }
+    Huffman.prototype.set_bits_r = function (node_index, bits, depth) {
+        if (this.nodes[node_index].right != 0xffff)
+            this.set_bits_r(this.nodes[node_index].right, bits | (1 << depth), depth + 1);
+        if (this.nodes[node_index].left != 0xffff)
+            this.set_bits_r(this.nodes[node_index].left, bits, depth + 1);
+        if (this.nodes[node_index].numbits) {
+            this.nodes[node_index].bits = bits;
+            this.nodes[node_index].numbits = depth;
+        }
+    };
+    Huffman.prototype.bubble_sort = function (index_list, node_list, size) {
+        var changed = true;
+        while (changed) {
+            changed = false;
+            for (var i = 0; i < size - 1; i++) {
+                if (node_list[index_list[i]].frequency < node_list[index_list[i + 1]].frequency) {
+                    var temp = index_list[i];
+                    index_list[i] = index_list[i + 1];
+                    index_list[i + 1] = temp;
+                    changed = true;
+                }
+            }
+            size--;
+        }
+        return index_list;
+    };
+    Huffman.prototype.construct_tree = function (frequencies) {
+        if (frequencies === void 0) { frequencies = FREQ_TABLE; }
+        var nodes_left_storage = new Array(HUFFMAN_MAX_SYMBOLS);
+        for (var i = 0; i < HUFFMAN_MAX_SYMBOLS; i++) {
+            nodes_left_storage[i] = {};
+        }
+        var nodes_left = new Array(HUFFMAN_MAX_SYMBOLS);
+        var num_nodes_left = HUFFMAN_MAX_SYMBOLS;
+        for (var i = 0; i < HUFFMAN_MAX_SYMBOLS; i++) {
+            this.nodes[i].numbits = 0xFFFFFFFF;
+            this.nodes[i].symbol = i;
+            this.nodes[i].left = 0xFFFF;
+            this.nodes[i].right = 0xFFFF;
+            if (i == HUFFMAN_EOF_SYMBOL) {
+                nodes_left_storage[i].frequency = 1;
+            }
+            else
+                nodes_left_storage[i].frequency = frequencies[i];
+            nodes_left_storage[i].node_id = i;
+            nodes_left[i] = i;
+        }
+        this.num_nodes = HUFFMAN_MAX_SYMBOLS;
+        while (num_nodes_left > 1) {
+            nodes_left = this.bubble_sort(nodes_left, nodes_left_storage, num_nodes_left);
+            this.nodes[this.num_nodes].numbits = 0;
+            this.nodes[this.num_nodes].left = nodes_left_storage[nodes_left[num_nodes_left - 1]].node_id;
+            this.nodes[this.num_nodes].right = nodes_left_storage[nodes_left[num_nodes_left - 2]].node_id;
+            nodes_left_storage[nodes_left[num_nodes_left - 2]].node_id = this.num_nodes;
+            nodes_left_storage[nodes_left[num_nodes_left - 2]].frequency = nodes_left_storage[nodes_left[num_nodes_left - 1]].frequency
+                + nodes_left_storage[nodes_left[num_nodes_left - 2]].frequency;
+            this.num_nodes++;
+            num_nodes_left--;
+        }
+        this.start_node_index = this.num_nodes - 1;
+        this.set_bits_r(this.start_node_index, 0, 0);
+    };
+    Huffman.prototype.compress = function (inp_buffer, start_index, size) {
+        if (start_index === void 0) { start_index = 0; }
+        if (size === void 0) { size = 0; }
+        var output = [];
+        var bits = 0;
+        var bitcount = 0;
+        if (size == 0)
+            size = inp_buffer.byteLength;
+        inp_buffer = inp_buffer.slice(start_index, start_index + size);
+        for (var i = 0; i < size; i++) {
+            var x = inp_buffer[i];
+            bits |= this.nodes[x].bits << bitcount;
+            bitcount += this.nodes[x].numbits;
+            while (bitcount >= 8) {
+                output.push(bits & 0xff);
+                bits >>= 8;
+                bitcount -= 8;
+            }
+        }
+        bits |= this.nodes[HUFFMAN_EOF_SYMBOL].bits << bitcount;
+        bitcount += this.nodes[HUFFMAN_EOF_SYMBOL].numbits;
+        while (bitcount >= 8) {
+            output.push(bits & 0xff);
+            bits >>= 8;
+            bitcount -= 8;
+        }
+        output.push(bits);
+        return Buffer.from(output);
+    };
+    Huffman.prototype.decompress = function (inp_buffer, size) {
+        if (size === void 0) { size = 0; }
+        var bits = 0;
+        var bitcount = 0;
+        var eof = this.nodes[HUFFMAN_EOF_SYMBOL];
+        var output = [];
+        if (size == 0)
+            size = inp_buffer.byteLength;
+        inp_buffer = inp_buffer.slice(0, size);
+        var src_index = 0;
+        while (true) {
+            var node_i = -1;
+            if (bitcount >= HUFFMAN_LUTBITS)
+                node_i = this.decode_lut[bits & HUFFMAN_LUTMASK];
+            while (bitcount < 24 && src_index != size) {
+                bits |= inp_buffer[src_index] << bitcount;
+                bitcount += 8;
+                src_index++;
+            }
+            if (node_i == -1)
+                node_i = this.decode_lut[bits & HUFFMAN_LUTMASK];
+            if (this.nodes[node_i].numbits) {
+                bits >>= this.nodes[node_i].numbits;
+                bitcount -= this.nodes[node_i].numbits;
+            }
+            else {
+                bits >>= HUFFMAN_LUTBITS;
+                bitcount -= HUFFMAN_LUTBITS;
+                while (true) {
+                    if (bits & 1) {
+                        node_i = this.nodes[node_i].right;
+                    }
+                    else
+                        node_i = this.nodes[node_i].left;
+                    bitcount -= 1;
+                    bits >>= 1;
+                    if (this.nodes[node_i].numbits)
+                        break;
+                    if (bitcount == 0)
+                        throw new Error("No more bits, decoding error");
+                }
+            }
+            if (this.nodes[node_i] == eof)
+                break;
+            output.push(this.nodes[node_i].symbol);
+        }
+        return Buffer.from(output);
+    };
+    return Huffman;
+}());
+module.exports = Huffman;

package/lib/movement.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+var Movement = /** @class */ (function () {
+    function Movement() {
+        this.input = { m_Direction: 0, m_Fire: 0, m_Hook: 0, m_Jump: 0, m_NextWeapon: 0, m_PlayerFlags: 1, m_PrevWeapon: 0, m_TargetX: 0, m_TargetY: 0, m_WantedWeapon: 1 };
+    }
+    Movement.prototype.RunLeft = function () {
+        this.input.m_Direction = -1;
+    };
+    Movement.prototype.RunRight = function () {
+        this.input.m_Direction = 1;
+    };
+    Movement.prototype.RunStop = function () {
+        this.input.m_Direction = 0;
+    };
+    Movement.prototype.Jump = function (state) {
+        if (state === void 0) { state = true; }
+        this.input.m_Jump = state ? 1 : 0;
+    };
+    Movement.prototype.Fire = function () {
+        this.input.m_Fire = 1;
+    };
+    Movement.prototype.Hook = function (state) {
+        if (state === void 0) { state = true; }
+        this.input.m_Hook = state ? 1 : 0;
+    };
+    Movement.prototype.NextWeapon = function () {
+        this.input.m_NextWeapon = 1;
+        this.WantedWeapon(0);
+    };
+    Movement.prototype.PrevWeapon = function () {
+        this.input.m_PrevWeapon = 1;
+        this.WantedWeapon(0);
+    };
+    Movement.prototype.WantedWeapon = function (weapon) {
+        this.input.m_WantedWeapon = weapon;
+    };
+    Movement.prototype.SetAim = function (x, y) {
+        this.input.m_TargetX = x;
+        this.input.m_TargetY = y;
+    };
+    Movement.prototype.Reset = function () {
+        this.input.m_Direction = 0;
+        this.input.m_Jump = 0;
+        this.input.m_Fire = 0;
+        this.input.m_Hook = 0;
+        this.input.m_PlayerFlags = 0;
+        this.input.m_NextWeapon = 0;
+        this.input.m_PrevWeapon = 0;
+    };
+    return Movement;
+}());
+exports.default = Movement;