teeworlds 2.0.4 → 2.0.7

package/README.md

@@ -1,10 +1,13 @@
 # tw-chatonly
 Library to connect a bot to a Teeworlds server.
 
+https://www.npmjs.com/package/teeworlds
+
+
 # Usage
 Example file:
-```const test = require('teeworlds');
-let client = new test.Client("127.0.0.1", 8303, "test");
+```const teeworlds = require('teeworlds');
+let client = new teeworlds.Client("127.0.0.1", 8303, "teest");
 
 client.connect();
 

package/index.ts

@@ -1,4 +1,4 @@
-import _Client = require("./lib/client")
+import _Client = require("./lib/client");
 import _MsgPacker = require("./lib/MsgPacker");
 
 export const Client = _Client;

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.ts

@@ -0,0 +1,228 @@
+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;
+}
+
+
+interface HuffmanConstructNode {
+	node_id: number;
+	frequency: number;
+}
+
+class Huffman {
+	nodes: HuffmanNode[];
+	decode_lut: number[];
+	num_nodes: number;
+	start_node_index: number;
+
+	constructor(frequencies = FREQ_TABLE) {
+		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);
+
+		
+		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);
+	}
+	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];
+			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);
+		}
+
+		
+	}
+
+export = Huffman;

package/lib/snapshot.ts

@@ -336,11 +336,15 @@ class Snapshot {
 
 			var data: number[] = []
 			for (let i = 0; i < _size; i++) {
-				snap = MsgUnpacker.unpackInt(snap).remaining;
-				data.push(MsgUnpacker.unpackInt(snap).result);
 				if (snap.length == 0) {
 					items.lost++;
 				}
+				if (snap[0]) {
+					snap = MsgUnpacker.unpackInt(snap).remaining;
+					data.push(MsgUnpacker.unpackInt(snap).result);
+				} else
+					break;
+
 			}
 			if (type_id > 0x4000 || type_id == 0) {
 				if (_size == 5 && id == 0)  {
@@ -354,9 +358,9 @@ class Snapshot {
 						// score: (!players[id] == undefined || typeof players[id].score == 'undefined') ? -1 : players[id].score
 					}
 					// console.log(Ddnet_Character)
-					// if (Ddnet_Character.freeze_end > 0 || Ddnet_Character.freeze_end == -1) {// freezed or deepfreezed 
+					if (Ddnet_Character.freeze_end > 0 || Ddnet_Character.freeze_end == -1) // freezed or deepfreezed 
 						
-					// }	// console.log(Ddnet_Character)
+						console.log(Ddnet_Character)
 				} // else
 					// console.log("lolol uuid??", _size, type_id, id, data)
 			}

package/package.json

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

package/lib/MsgPacker.js

@@ -1,53 +0,0 @@
-"use strict";
-var MsgPacker = /** @class */ (function () {
-    function MsgPacker(msg, sys) {
-        this.result = Buffer.from([2 * msg + (sys ? 1 : 0)]); // booleans turn into int automatically. 
-        this.sys = sys;
-    }
-    MsgPacker.prototype.AddString = function (str) {
-        this.result = Buffer.concat([this.result, Buffer.from(str), Buffer.from([0x00])]);
-    };
-    MsgPacker.prototype.AddBuffer = function (buffer) {
-        this.result = Buffer.concat([this.result, buffer]);
-    };
-    MsgPacker.prototype.AddInt = function (i) {
-        var result = [];
-        var pDst = (i >> 25) & 0x40;
-        var i = i ^ (i >> 31);
-        pDst |= i & 0x3f;
-        i >>= 6;
-        if (i) {
-            pDst |= 0x80;
-            result.push(pDst);
-            while (true) {
-                pDst++;
-                pDst = i & (0x7f);
-                i >>= 7;
-                pDst |= (Number(i != 0)) << 7;
-                result.push(pDst);
-                if (!i)
-                    break;
-            }
-        }
-        else
-            result.push(pDst);
-        // ... i'll just stop trying to understand.
-        this.result = Buffer.concat([this.result, Buffer.from(result)]);
-    };
-    Object.defineProperty(MsgPacker.prototype, "size", {
-        get: function () {
-            return this.result.byteLength;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(MsgPacker.prototype, "buffer", {
-        get: function () {
-            return this.result;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return MsgPacker;
-}());
-module.exports = MsgPacker;

package/lib/MsgUnpacker.js

@@ -1,37 +0,0 @@
-"use strict";
-var decoder = new TextDecoder('utf-8');
-function unpackInt(pSrc) {
-    var result = 0;
-    var len = 1;
-    var iter = pSrc[Symbol.iterator]();
-    var src = iter.next();
-    // if (src.done)
-    // console.warn("Unexpected end", src)
-    src = src.value;
-    var sign = ((src >> 6) & 1);
-    result |= (src & 63);
-    for (var i = 0; i < 4; i++) {
-        if ((src & 128) == 0)
-            break;
-        src = iter.next();
-        // console.log(src & 0b1000_0000)
-        // if (src.done)
-        // console.warn("Unexpected end", src);
-        src = src.value;
-        len += 1;
-        if (i == 3 && (src & 240) != 0)
-            console.warn("NonZeroIntPadding");
-        result |= ((src & 127)) << (6 + 7 * i);
-    }
-    if (len > 1 && src == 0) {
-        console.warn("OverlongIntEncoding");
-    }
-    result ^= -sign;
-    return { result: result, remaining: Array.from(iter) };
-}
-function unpackString(pSrc) {
-    var result = pSrc.slice(0, pSrc.indexOf(0));
-    pSrc = pSrc.slice(pSrc.indexOf(0), pSrc.length);
-    return { result: decoder.decode(new Uint8Array(result)), remaining: pSrc };
-}
-module.exports = { unpackInt: unpackInt, unpackString: unpackString };