teeworlds 2.0.4 → 2.0.5

package/lib/client.js

@@ -54,10 +54,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var crypto_1 = require("crypto");
 var dgram_1 = __importDefault(require("dgram"));
 var stream_1 = require("stream");
-var child_process_1 = require("child_process");
 var MsgUnpacker_1 = __importDefault(require("./MsgUnpacker"));
 var MsgPacker_1 = __importDefault(require("./MsgPacker"));
 var snapshot_1 = require("./snapshot");
+var huffman_1 = __importDefault(require("./huffman"));
+var huff = new huffman_1.default();
 var SnapUnpacker = new snapshot_1.Snapshot();
 var NETMSGTYPE;
 (function (NETMSGTYPE) {
@@ -122,26 +123,6 @@ var items;
 function toHexStream(buff) {
     return buff.toJSON().data.map(function (a) { return ('0' + (a & 0xff).toString(16)).slice(-2); }).join("");
 }
-function decompress(buff) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, new Promise(function (resolve) {
-                    // get hex stream
-                    var hexStream = toHexStream(buff);
-                    var ls = child_process_1.spawn('python', [__dirname + '\\huffman.py', hexStream, "-decompress"]);
-                    ls.stdout.on('data', function (data) {
-                        resolve(Buffer.from(eval(data.toString()))); // convert stdout array to actual array, then convert the array to Buffer & return it
-                    });
-                    setTimeout(function () {
-                        ls.stdin.end();
-                        ls.stdout.destroy();
-                        ls.stderr.destroy();
-                        resolve(Buffer.from([]));
-                    }, 750);
-                })];
-        });
-    });
-}
 var messageTypes = [
     ["none, starts at 1", "SV_MOTD", "SV_BROADCAST", "SV_CHAT", "SV_KILL_MSG", "SV_SOUND_GLOBAL", "SV_TUNE_PARAMS", "SV_EXTRA_PROJECTILE", "SV_READY_TO_ENTER", "SV_WEAPON_PICKUP", "SV_EMOTICON", "SV_VOTE_CLEAR_OPTIONS", "SV_VOTE_OPTION_LIST_ADD", "SV_VOTE_OPTION_ADD", "SV_VOTE_OPTION_REMOVE", "SV_VOTE_SET", "SV_VOTE_STATUS", "CL_SAY", "CL_SET_TEAM", "CL_SET_SPECTATOR_MODE", "CL_START_INFO", "CL_CHANGE_INFO", "CL_KILL", "CL_EMOTICON", "CL_VOTE", "CL_CALL_VOTE", "CL_IS_DDNET", "SV_DDRACE_TIME", "SV_RECORD", "UNUSED", "SV_TEAMS_STATE", "CL_SHOW_OTHERS_LEGACY"],
     ["none, starts at 1", "INFO", "MAP_CHANGE", "MAP_DATA", "CON_READY", "SNAP", "SNAP_EMPTY", "SNAP_SINGLE", "INPUT_TIMING", "RCON_AUTH_STATUS", "RCON_LINE", "READY", "ENTER_GAME", "INPUT", "RCON_CMD", "RCON_AUTH", "REQUEST_MAP_DATA", "PING", "PING_REPLY", "RCON_CMD_ADD", "RCON_CMD_REMOVE"]
@@ -193,48 +174,42 @@ var Client = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             var unpacked, i, chunk;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        unpacked = { twprotocol: { flags: packet[0], ack: packet[1], chunkAmount: packet[2], size: packet.byteLength - 3 }, chunks: [] };
-                        if (packet.indexOf(Buffer.from([0xff, 0xff, 0xff, 0xff])) == 0 && !(unpacked.twprotocol.flags & 8) || unpacked.twprotocol.flags == 255) // flags == 255 is connectionless (used for sending usernames)
-                            return [2 /*return*/, unpacked];
-                        packet = packet.slice(3);
-                        if (!(unpacked.twprotocol.flags & 128)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, decompress(packet)];
-                    case 1:
-                        packet = _a.sent();
-                        if (packet.length == 1 && packet[0] == -1)
-                            return [2 /*return*/, unpacked];
-                        _a.label = 2;
-                    case 2:
-                        // return unpacked;
-                        for (i = 0; i < unpacked.twprotocol.chunkAmount; i++) {
-                            chunk = {};
-                            chunk.bytes = ((packet[0] & 0x3f) << 4) | (packet[1] & ((1 << 4) - 1)); // idk what this shit is but it works
-                            chunk.flags = (packet[0] >> 6) & 3;
-                            chunk.sequence = -1;
-                            if (chunk.flags & 1) {
-                                chunk.seq = ((packet[1] & 0xf0) << 2) | packet[2];
-                                packet = packet.slice(3); // remove flags & size
-                            }
-                            else
-                                packet = packet.slice(2);
-                            chunk.type = packet[0] & 1 ? "sys" : "game"; // & 1 = binary, ****_***1. e.g 0001_0111 sys, 0001_0110 game
-                            chunk.msgid = (packet[0] - (packet[0] & 1)) / 2;
-                            chunk.msg = messageTypes[packet[0] & 1][chunk.msgid];
-                            chunk.raw = packet.slice(1, chunk.bytes);
-                            Object.values(messageUUIDs).forEach(function (a, i) {
-                                if (a.compare(packet.slice(0, 16)) == 0) {
-                                    chunk.extended_msgid = a;
-                                    // chunk.type = 'sys';
-                                    chunk.msg = Object.keys(messageUUIDs)[i];
-                                }
-                            });
-                            packet = packet.slice(chunk.bytes); // +1 cuz it adds an extra \x00 for easier parsing i guess
-                            unpacked.chunks.push(chunk);
-                        }
+                unpacked = { twprotocol: { flags: packet[0], ack: packet[1], chunkAmount: packet[2], size: packet.byteLength - 3 }, chunks: [] };
+                if (packet.indexOf(Buffer.from([0xff, 0xff, 0xff, 0xff])) == 0 && !(unpacked.twprotocol.flags & 8) || unpacked.twprotocol.flags == 255) // flags == 255 is connectionless (used for sending usernames)
+                    return [2 /*return*/, unpacked];
+                packet = packet.slice(3);
+                if (unpacked.twprotocol.flags & 128) {
+                    packet = huff.decompress(packet);
+                    if (packet.length == 1 && packet[0] == -1)
                         return [2 /*return*/, unpacked];
                 }
+                // return unpacked;
+                for (i = 0; i < unpacked.twprotocol.chunkAmount; i++) {
+                    chunk = {};
+                    chunk.bytes = ((packet[0] & 0x3f) << 4) | (packet[1] & ((1 << 4) - 1)); // idk what this shit is but it works
+                    chunk.flags = (packet[0] >> 6) & 3;
+                    chunk.sequence = -1;
+                    if (chunk.flags & 1) {
+                        chunk.seq = ((packet[1] & 0xf0) << 2) | packet[2];
+                        packet = packet.slice(3); // remove flags & size
+                    }
+                    else
+                        packet = packet.slice(2);
+                    chunk.type = packet[0] & 1 ? "sys" : "game"; // & 1 = binary, ****_***1. e.g 0001_0111 sys, 0001_0110 game
+                    chunk.msgid = (packet[0] - (packet[0] & 1)) / 2;
+                    chunk.msg = messageTypes[packet[0] & 1][chunk.msgid];
+                    chunk.raw = packet.slice(1, chunk.bytes);
+                    Object.values(messageUUIDs).forEach(function (a, i) {
+                        if (a.compare(packet.slice(0, 16)) == 0) {
+                            chunk.extended_msgid = a;
+                            // chunk.type = 'sys';
+                            chunk.msg = Object.keys(messageUUIDs)[i];
+                        }
+                    });
+                    packet = packet.slice(chunk.bytes); // +1 cuz it adds an extra \x00 for easier parsing i guess
+                    unpacked.chunks.push(chunk);
+                }
+                return [2 /*return*/, unpacked];
             });
         });
     };

package/lib/client.ts

@@ -7,7 +7,9 @@ import { spawn } from 'child_process';
 import MsgUnpacker from './MsgUnpacker';
 import MsgPacker from './MsgPacker';
 import { Snapshot } from './snapshot';
+import Huffman from "./huffman";
 
+const huff = new Huffman();
 const SnapUnpacker = new Snapshot();
 
 enum NETMSGTYPE {
@@ -83,24 +85,6 @@ interface chunk {
 function toHexStream(buff: Buffer): string {
 	return buff.toJSON().data.map(a => ('0' + (a & 0xff).toString(16)).slice(-2)).join("");
 }
-async function decompress(buff: Buffer): Promise<Buffer> {
-	return new Promise((resolve) => {
-		// get hex stream
-		var hexStream = toHexStream(buff)
-		var ls = spawn('python', [__dirname + '\\huffman.py', hexStream, "-decompress"])
-		ls.stdout.on('data', (data) => {
-			resolve(Buffer.from(eval(data.toString()))); // convert stdout array to actual array, then convert the array to Buffer & return it
-		});
-		setTimeout(() => {
-			ls.stdin.end();
-			ls.stdout.destroy();
-			ls.stderr.destroy();
-
-			resolve(Buffer.from([]));
-		}, 750)
-
-	})
-}
 interface _packet {
 	twprotocol: { flags: number, ack: number, chunkAmount: number, size: number },
 	chunks: chunk[]
@@ -207,7 +191,7 @@ class Client extends EventEmitter {
 			return unpacked;
 		packet = packet.slice(3)
 		if (unpacked.twprotocol.flags & 128) {
-			packet = await decompress(packet)
+			packet = huff.decompress(packet)
 			if (packet.length == 1 && packet[0] == -1)
 				return unpacked
 		}

package/lib/huffman.js

@@ -0,0 +1,236 @@
+"use strict";
+// from Ryozuki, found on ddnet discord ( 11.10.2018 )
+// from typing import List
+// from sys import argv
+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;
+// class HuffmanConstructNode {
+// 	node_id: number;
+// 	frequency: number;
+// 	constructor(node_id: number, frequency: number) {
+// 		this.node_id = node_id;
+// 		this.frequency = frequency;
+// 	}
+// }
+// class HuffmanConstructNode:
+//     def __init__(self):
+//         self.node_id: int = None
+//         self.frequency: int = None
+var Huffman = /** @class */ (function () {
+    function Huffman(frequencies) {
+        if (frequencies === void 0) { frequencies = FREQ_TABLE; }
+        // this.frequencies = frequencies;
+        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);
+        var xx = 0;
+        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);
+        /*        output = bytearray()
+        bits = 0
+        bitcount = 0
+
+        if size is None:
+            size = len(inp_buffer)
+
+        for x in inp_buffer[start_index:size:]:
+            bits |= self.nodes[x].bits << bitcount
+            bitcount += self.nodes[x].numbits
+
+            while bitcount >= 8:
+                output.append(bits & 0xff)
+                bits >>= 8
+                bitcount -= 8
+
+        bits |= self.nodes[HUFFMAN_EOF_SYMBOL].bits << bitcount
+        bitcount += self.nodes[HUFFMAN_EOF_SYMBOL].numbits
+
+        while bitcount >= 8:
+            output.append(bits & 0xff)
+            bits >>= 8
+            bitcount -= 8
+
+        # write out last bits
+        output.append(bits)
+        return 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];
+            // console.log(node_i, bits & HUFFMAN_LUTMASK, this.decode_lut)
+            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/huffman.ts

@@ -0,0 +1,342 @@
+// from Ryozuki, found on ddnet discord ( 11.10.2018 )
+// from typing import List
+// from sys import argv
+let 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;
+
+interface HuffmanNode {
+	bits: number;
+	numbits: number;
+	left: number;
+	right: number;
+	symbol: number;
+}
+
+// class HuffmanNode {
+// 	bits: number;
+// 	numbits: number;
+// 	left: number;
+// 	right: number;
+// 	symbol: number;
+// 	constructor(/*bits: number, numbits: number, left: number, right: number, symbol: number*/) {
+// 		this.bits = -1;
+// 		this.numbits = -1;
+// 		this.left = -1;
+// 		this.right = -1;
+// 		this.symbol = -1;
+// 	}
+
+// 	equal(node: HuffmanNode) {
+// 		return this.bits == node.bits && this.numbits == node.numbits && this.left == node.left && this.right == node.right && this.symbol == node.symbol;
+// 	}
+	
+// }
+
+interface HuffmanConstructNode {
+	node_id: number;
+	frequency: number;
+}
+
+// class HuffmanConstructNode {
+// 	node_id: number;
+// 	frequency: number;
+// 	constructor(node_id: number, frequency: number) {
+// 		this.node_id = node_id;
+// 		this.frequency = frequency;
+// 	}
+// }
+// class HuffmanConstructNode:
+//     def __init__(self):
+//         self.node_id: int = None
+//         self.frequency: int = None
+
+class Huffman {
+	nodes: HuffmanNode[];
+	decode_lut: number[];
+	num_nodes: number;
+	start_node_index: number;
+
+	constructor(frequencies = FREQ_TABLE) {
+		// this.frequencies = frequencies;
+		this.nodes = new Array<HuffmanNode>(HUFFMAN_MAX_NODES);
+		for (let i = 0; i < HUFFMAN_MAX_NODES; i++) {
+			this.nodes[i] = {} as HuffmanNode;
+		}
+		this.decode_lut = new Array<number>(HUFFMAN_LUTSIZE);
+		this.num_nodes = 0;
+		this.start_node_index = 0;
+
+		this.construct_tree(frequencies);
+
+		let xx = 0;
+		
+		for (let i = 0; i < HUFFMAN_LUTSIZE; i++) {
+			let bits = i;
+			let broke = false;
+			let index = this.start_node_index;
+			for (let 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;
+			}
+		}
+	}
+	set_bits_r(node_index: number, bits: number, depth: number) {
+		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;
+		}
+	}
+	
+	bubble_sort(index_list: number[], node_list: HuffmanConstructNode[], size: number) {
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (let i = 0; i < size-1; i++) {
+				if (node_list[index_list[i]].frequency < node_list[index_list[i + 1]].frequency) {
+					let temp = index_list[i];
+					index_list[i] = index_list[i + 1];
+					index_list[i + 1] = temp;
+					changed = true;
+				}
+			}
+			size--;
+		}
+		return index_list;
+	}
+
+	construct_tree(frequencies = FREQ_TABLE) {
+		let nodes_left_storage: HuffmanConstructNode[] = new Array<HuffmanConstructNode>(HUFFMAN_MAX_SYMBOLS);
+		for (let i = 0; i < HUFFMAN_MAX_SYMBOLS; i++) {
+			nodes_left_storage[i] = {} as HuffmanConstructNode;
+		}
+		let nodes_left: number[] = new Array<number>(HUFFMAN_MAX_SYMBOLS);
+		let num_nodes_left = HUFFMAN_MAX_SYMBOLS;
+
+		for (let 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);
+	}
+
+	compress(inp_buffer: Buffer, start_index = 0, size: number = 0): Buffer {
+		let output = [];
+		let bits = 0;
+		let bitcount = 0;
+
+		if (size == 0)
+			size = inp_buffer.byteLength;
+		inp_buffer = inp_buffer.slice(start_index, start_index + size);
+		for (let i = 0; i < size; i++) {
+			let 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);
+		
+		/*        output = bytearray()
+        bits = 0
+        bitcount = 0
+
+        if size is None:
+            size = len(inp_buffer)
+
+        for x in inp_buffer[start_index:size:]:
+            bits |= self.nodes[x].bits << bitcount
+            bitcount += self.nodes[x].numbits
+
+            while bitcount >= 8:
+                output.append(bits & 0xff)
+                bits >>= 8
+                bitcount -= 8
+
+        bits |= self.nodes[HUFFMAN_EOF_SYMBOL].bits << bitcount
+        bitcount += self.nodes[HUFFMAN_EOF_SYMBOL].numbits
+
+        while bitcount >= 8:
+            output.append(bits & 0xff)
+            bits >>= 8
+            bitcount -= 8
+
+        # write out last bits
+        output.append(bits)
+        return output
+*/
+	}
+	decompress(inp_buffer: Buffer, size = 0): Buffer {
+
+		let bits = 0;
+		let bitcount = 0;
+		let eof = this.nodes[HUFFMAN_EOF_SYMBOL];
+		let output = [];
+		
+		if (size == 0)
+			size = inp_buffer.byteLength;
+		inp_buffer = inp_buffer.slice(0, size);
+		let src_index = 0;
+		while (true) {
+			let 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];
+			// console.log(node_i, bits & HUFFMAN_LUTMASK, this.decode_lut)
+			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);
+		}
+
+		/*bits = 0
+        bitcount = 0
+        eof = self.nodes[HUFFMAN_EOF_SYMBOL]
+        output = bytearray()
+
+        if size is None:
+            size = len(inp_buffer)
+
+        src_index = 0
+        while True:
+            node_i = None
+            if bitcount >= HUFFMAN_LUTBITS:
+                node_i = self.decode_lut[bits & HUFFMAN_LUTMASK]
+
+            while bitcount < 24 and src_index != size:
+                bits |= inp_buffer[src_index] << bitcount
+                src_index += 1
+                bitcount += 8
+
+            if node_i is None:
+                node_i = self.decode_lut[bits & HUFFMAN_LUTMASK]
+            if self.nodes[node_i].numbits:
+                bits >>= self.nodes[node_i].numbits
+                bitcount -= self.nodes[node_i].numbits
+            else:
+                bits >>= HUFFMAN_LUTBITS
+                bitcount -= HUFFMAN_LUTBITS
+
+                while True:
+                    if bits & 1:
+                        node_i = self.nodes[node_i].right
+                    else:
+                        node_i = self.nodes[node_i].left
+
+                    bitcount -= 1
+                    bits >>= 1
+
+                    if self.nodes[node_i].numbits:
+                        break
+
+                    if bitcount === 0:
+                        raise ValueError("No more bits, decoding error")
+
+            if self.nodes[node_i] === eof:
+                break
+            output.append(self.nodes[node_i].symbol)
+
+        return output */
+	}
+
+export = Huffman;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "teeworlds",
-	"version": "2.0.4",
+	"version": "2.0.5",
 	"description": "Library for (ingame) teeworlds bots.",
 	"license": "MIT",
 	"main": "index.js",

package/lib/huffman.py

@@ -1,224 +0,0 @@
-# from Ryozuki, found on ddnet discord ( 11.10.2018 )
-from typing import List
-from sys import argv
-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
-
-
-class Node:
-    def __init__(self):
-        self.bits: int = None
-        self.numbits: int = None
-        # Leafs
-        self.left: int = None
-        self.right: int = None
-
-        self.symbol: int = None
-
-    def __eq__(self, other):
-        return self.symbol == other.symbol
-
-
-class HuffmanConstructNode:
-    def __init__(self):
-        self.node_id: int = None
-        self.frequency: int = None
-
-
-class Huffman:
-    def __init__(self, frequencies: List[int]):
-        self.nodes: List[Node] = [Node() for _ in range(HUFFMAN_MAX_NODES)]
-        # list of index of nodes
-        self.decode_lut: List[int] = [None for _ in range(HUFFMAN_LUTSIZE)]
-        self.num_nodes: int = None
-        self.start_node_index: int = None
-
-        self.construct_tree(frequencies)
-        # print(self.num_nodes, "numnodes")
-        # print(self.start_node_index, "nodeindex")
-        # print(len(self.decode_lut), "dcodelut")
-        xx = 0
-        for i in range(HUFFMAN_LUTSIZE):
-            bits = i
-            broke = False
-            index = self.start_node_index
-            for x in range(HUFFMAN_LUTBITS):
-                if bits & 1:
-                    index = self.nodes[index].right
-                else:
-                    index = self.nodes[index].left
-                # print(index)
-                bits >>= 1
-
-                if self.nodes[index].numbits:
-                    # print(i, bits)
-                    self.decode_lut[i] = index
-                    xx += 1
-                    broke = True
-                    break		
-            if not broke:
-                self.decode_lut[i] = index
-        # print(xx, HUFFMAN_LUTSIZE, HUFFMAN_LUTBITS)
-    def set_bits_r(self, node_index: int, bits: int, depth: int):
-        if self.nodes[node_index].right != 0xffff:
-            self.set_bits_r(self.nodes[node_index].right, bits | (1 << depth), depth + 1)
-        if self.nodes[node_index].left != 0xffff:
-            self.set_bits_r(self.nodes[node_index].left, bits, depth + 1)
-
-        if self.nodes[node_index].numbits:
-            self.nodes[node_index].bits = bits
-            self.nodes[node_index].numbits = depth
-
-    @staticmethod
-    def bubble_sort(index_list: List[int], node_list: List[HuffmanConstructNode], size: int):
-        changed = True
-        while changed:
-            changed = False
-            for i in range(size - 1):
-                if node_list[index_list[i]].frequency < node_list[index_list[i + 1]].frequency:
-                    index_list[i], index_list[i + 1] = index_list[i + 1], index_list[i]
-                    changed = True
-            size -= 1
-        return index_list
-
-    def construct_tree(self, frequencies: List[int]):
-        nodes_left_storage: List[HuffmanConstructNode] = [HuffmanConstructNode() for _ in range(HUFFMAN_MAX_SYMBOLS)]
-        nodes_left: List[int] = [None for _ in range(HUFFMAN_MAX_SYMBOLS)]
-        num_nodes_left = HUFFMAN_MAX_SYMBOLS
-
-        for i in range(HUFFMAN_MAX_SYMBOLS):
-            self.nodes[i].numbits = 0xFFFFFFFF
-            self.nodes[i].symbol = i
-            self.nodes[i].left = 0xffff
-            self.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
-
-        self.num_nodes = HUFFMAN_MAX_SYMBOLS
-
-        while num_nodes_left > 1:
-            nodes_left = Huffman.bubble_sort(nodes_left, nodes_left_storage, num_nodes_left)
-
-            self.nodes[self.num_nodes].numbits = 0
-            self.nodes[self.num_nodes].left = nodes_left_storage[nodes_left[num_nodes_left - 1]].node_id
-            self.nodes[self.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 = self.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
-            self.num_nodes += 1
-            num_nodes_left -= 1
-        self.start_node_index = self.num_nodes - 1
-        self.set_bits_r(self.start_node_index, 0, 0)
-
-    def compress(self, inp_buffer: bytearray, start_index: int = 0, size: int = None):
-        output = bytearray()
-        bits = 0
-        bitcount = 0
-
-        if size is None:
-            size = len(inp_buffer)
-
-        for x in inp_buffer[start_index:size:]:
-            # print(x)
-            bits |= self.nodes[x].bits << bitcount
-            bitcount += self.nodes[x].numbits
-
-            while bitcount >= 8:
-                output.append(bits & 0xff)
-                bits >>= 8
-                bitcount -= 8
-
-        bits |= self.nodes[HUFFMAN_EOF_SYMBOL].bits << bitcount
-        bitcount += self.nodes[HUFFMAN_EOF_SYMBOL].numbits
-
-        while bitcount >= 8:
-            output.append(bits & 0xff)
-            bits >>= 8
-            bitcount -= 8
-
-        # write out last bits
-        output.append(bits)
-        return output
-
-    def decompress(self, inp_buffer: bytearray, size: int = None):
-        bits = 0
-        bitcount = 0
-        eof = self.nodes[HUFFMAN_EOF_SYMBOL]
-        output = bytearray()
-
-        if size is None:
-            size = len(inp_buffer)
-
-        src_index = 0
-        while True:
-            node_i = None
-            if bitcount >= HUFFMAN_LUTBITS:
-                node_i = self.decode_lut[bits & HUFFMAN_LUTMASK]
-                # print("yes im here!", output, node_i, bits & HUFFMAN_LUTMASK)
-
-            while bitcount < 24 and src_index != size:
-                bits |= inp_buffer[src_index] << bitcount
-                src_index += 1
-                bitcount += 8
-
-            # print(self.decode_lut)
-            if node_i is None:
-                node_i = self.decode_lut[bits & HUFFMAN_LUTMASK]
-            if self.nodes[node_i].numbits:
-                bits >>= self.nodes[node_i].numbits
-                bitcount -= self.nodes[node_i].numbits
-            else:
-                bits >>= HUFFMAN_LUTBITS
-                bitcount -= HUFFMAN_LUTBITS
-                # print("yes im here!", output)
-
-                while True:
-                    if bits & 1:
-                        node_i = self.nodes[node_i].right
-                    else:
-                        node_i = self.nodes[node_i].left
-
-                    bitcount -= 1
-                    bits >>= 1
-
-                    if self.nodes[node_i].numbits:
-                        break
-
-                    if bitcount == 0:
-                        raise ValueError("No more bits, decoding error")
-
-            if self.nodes[node_i] == eof:
-                break
-            output.append(self.nodes[node_i].symbol)
-
-        return output
-huff = Huffman(frequencies=FREQ_TABLE)
-if (argv[1] and argv[2] == "-decompress"):
-	print(list(huff.decompress(bytearray.fromhex(argv[1]))))
-elif (argv[1] and argv[2] == "-compress"):
-    print(list(huff.compress(bytearray.fromhex(argv[1]))))