teeworlds 2.1.3 → 2.1.8

package/lib/client.ts

@@ -1,20 +1,42 @@
 import { randomBytes } from "crypto";
 
 import net from 'dgram';
-import fs from 'fs';
 import { EventEmitter } from 'stream';
-import { spawn } from 'child_process';
 
-import { unpackInt, unpackString, MsgUnpacker } from "./MsgUnpacker";
+import { unpackString, MsgUnpacker } from "./MsgUnpacker";
 
+import Movement from './movement';
 
-import MsgPacker from './MsgPacker';
+import { MsgPacker } from './MsgPacker';
 import { Snapshot } from './snapshot';
 import Huffman from "./huffman";
 
 const huff = new Huffman();
 const SnapUnpacker = new Snapshot();
 
+enum States {
+	STATE_OFFLINE = 0,
+	STATE_CONNECTING,
+	STATE_LOADING,
+	STATE_ONLINE,
+	STATE_DEMOPLAYBACK,
+	STATE_QUITTING,
+	STATE_RESTARTING
+}
+
+interface NetObj_PlayerInput {
+	m_Direction: number,
+	m_TargetX: number,
+	m_TargetY: number,
+	m_Jump: number,
+	m_Fire: number,
+	m_Hook: number,
+	m_PlayerFlags: number,
+	m_WantedWeapon: number,
+	m_NextWeapon: number,
+	m_PrevWeapon: number
+};
+
 enum NETMSGTYPE {
 	EX,
 	SV_MOTD,
@@ -118,21 +140,21 @@ function arrStartsWith(arr: number[], arrStart: number[], start = 0) {
 	return true;
 }
 declare interface PlayerInfo {
-    local: number,
-    client_id: number,
-    team: number,
-    score: number,
-    latency: number,
+	local: number,
+	client_id: number,
+	team: number,
+	score: number,
+	latency: number,
 }
 
 declare interface ClientInfo {
-    name: string,
-    clan: string,
-    country: number,
-    skin: string,
-    use_custom_color: number,
-    color_body: number,
-    color_feet: number,
+	name: string,
+	clan: string,
+	country: number,
+	skin: string,
+	use_custom_color: number,
+	color_body: number,
+	color_feet: number,
 }
 declare interface iMessage {
 	team: number,
@@ -150,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;
@@ -159,15 +187,25 @@ declare interface Client {
 	clientAck: number;
 	receivedSnaps: number; /* wait for 2 ss before seeing self as connected */
 	lastMsg: string;
-	_port: number;
 	socket: net.Socket | undefined;
 	TKEN: Buffer;
 	time: number;
 
+	timer: number;
+	PredGameTick: number;
+	AckGameTick: number;
+
+	movement: Movement;
+
 	snaps: Buffer[];
 	client_infos: ClientInfo[];
 	player_infos: PlayerInfo[];
 
+	sentChunkQueue: Buffer[];
+
+	lastSendTime: number;
+
+	options?: iOptions;
 
 	on(event: 'connected', listener: () => void): this;
 	on(event: 'disconnect', listener: (reason: string) => void): this;
@@ -176,34 +214,49 @@ 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;
+
+		this.movement = new Movement();
 
 		this.snaps = [];
 		this.client_infos = [];
 		this.player_infos = [];
 
-		this.State = 0; // 0 = offline; 1 = STATE_CONNECTING = 1, STATE_LOADING = 2, STATE_ONLINE = 3
+		this.sentChunkQueue = [];
+
+		this.State = States.STATE_OFFLINE; // 0 = offline; 1 = STATE_CONNECTING = 1, STATE_LOADING = 2, STATE_ONLINE = 3
 		this.ack = 0; // ack of messages the client has received
 		this.clientAck = 0; // ack of messages the client has sent
 		this.receivedSnaps = 0; /* wait for 2 snaps before seeing self as connected */
 		this.lastMsg = "";
-		this._port = Math.floor(Math.random() * 65535)
 		this.socket = net.createSocket("udp4")
 		this.socket.bind();
 
 		this.TKEN = Buffer.from([255, 255, 255, 255])
 		this.time = new Date().getTime() + 2000; // time (used for keepalives, start to send keepalives after 2 seconds)
-		this.State = 0;
+
+		this.lastSendTime = new Date().getTime();
+
 	}
-	async Unpack(packet: Buffer): Promise<_packet> {
+	Unpack(packet: Buffer): _packet {
 		var unpacked: _packet = { twprotocol: { flags: packet[0], ack: packet[1], chunkAmount: packet[2], size: packet.byteLength - 3 }, chunks: [] }
 
 
@@ -215,10 +268,10 @@ class Client extends EventEmitter {
 			if (packet.length == 1 && packet[0] == -1)
 				return unpacked
 		}
-		// return unpacked;
+
 		for (let i = 0; i < unpacked.twprotocol.chunkAmount; i++) {
 			var chunk: chunk = {} as chunk;
-			chunk.bytes = ((packet[0] & 0x3f) << 4) | (packet[1] & ((1 << 4) - 1)); // idk what this shit is but it works
+			chunk.bytes = ((packet[0] & 0x3f) << 4) | (packet[1] & ((1 << 4) - 1));
 			chunk.flags = (packet[0] >> 6) & 3;
 			chunk.sequence = -1;
 
@@ -234,17 +287,17 @@ class Client extends EventEmitter {
 			Object.values(messageUUIDs).forEach((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
+			packet = packet.slice(chunk.bytes) 
 			unpacked.chunks.push(chunk)
 		}
 		return unpacked
 	}
 	SendControlMsg(msg: number, ExtraMsg: string = "") {
+		this.lastSendTime = new Date().getTime();
 		return new Promise((resolve, reject) => {
 			if (this.socket) {
 				var latestBuf = Buffer.from([0x10 + (((16 << 4) & 0xf0) | ((this.ack >> 8) & 0xf)), this.ack & 0xff, 0x00, msg])
@@ -261,227 +314,356 @@ class Client extends EventEmitter {
 		*/
 		})
 	}
-	SendMsgEx(Msg: MsgPacker, Flags: number) {
-		if (this.State == -1)
-			throw new Error("Client is not connected");
-		if (!this.socket)
-			return;
-		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;
-		}
-		var latestBuf = Buffer.from([0x0 + (((16 << 4) & 0xf0) | ((this.ack >> 8) & 0xf)), this.ack & 0xff, 0x1, header[0], header[1], this.clientAck]);
-		var latestBuf = Buffer.concat([latestBuf, Msg.buffer, this.TKEN]);
 
-		this.socket.send(latestBuf, 0, latestBuf.length, this.port, this.host)
-	}
-	SendMsgExWithChunks(Msgs: MsgPacker[], Flags: number) {
-		if (this.State == -1)
-			throw new Error("Client is not connected");
+	SendMsgEx(Msgs: MsgPacker[] | MsgPacker, Flags: number) {
+		if (this.State == States.STATE_OFFLINE)
+			return; 
 		if (!this.socket)
 			return;
-		var header: any[][] = [];
-
-		Msgs.forEach((Msg: MsgPacker, index) => {
-			header[index] = new Array(2);
+		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) => {
+			header[index] = Buffer.alloc((Flags & 1 ? 3 : 2));
 			header[index][0] = ((Flags & 3) << 6) | ((Msg.size >> 4) & 0x3f);
 			header[index][1] = (Msg.size & 0xf);
 			if (Flags & 1) {
 				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]);
 
 		this.socket.send(packet, 0, packet.length, this.port, this.host)
 	}
+	SendMsgRaw(chunks: Buffer[]) {
+		if (this.State == States.STATE_OFFLINE)
+			return;
+		if (!this.socket)
+			return;
+
+		this.lastSendTime = new Date().getTime();
+
+		var packetHeader = Buffer.from([0x0+(((16<<4)&0xf0)|((this.ack>>8)&0xf)), this.ack&0xff, chunks.length]);
+
+		var packet = Buffer.concat([(packetHeader), Buffer.concat(chunks), this.TKEN]);
+		
+		this.socket.send(packet, 0, packet.length, this.port, this.host)
+	}
+
+	MsgToChunk(packet: Buffer) {
+		var chunk: chunk = {} as chunk;
+		chunk.bytes = ((packet[0] & 0x3f) << 4) | (packet[1] & ((1 << 4) - 1));
+		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((a, i) => {
+			if (a.compare(packet.slice(0, 16)) === 0) {
+				chunk.extended_msgid = a;
+				chunk.msg = Object.keys(messageUUIDs)[i];
+			}
+		})
+		return chunk;
+	}
+
 	connect() {
+		
+		this.State = States.STATE_CONNECTING;
+
+		let predTimer = setInterval(() => {
+			if (this.State == States.STATE_ONLINE) {
+				if (this.AckGameTick > 0)
+					this.PredGameTick++;
+			} else if (this.State == States.STATE_OFFLINE) 
+				clearInterval(predTimer);
+			
+		}, 20);
+
 		this.SendControlMsg(1, "TKEN")
 		let connectInterval = setInterval(() => {
-			if (this.State == 0)
+			if (this.State == States.STATE_CONNECTING)
 				this.SendControlMsg(1, "TKEN")
 			else
 				clearInterval(connectInterval)
+		}, 500);
+
+		let inputInterval = setInterval(() => {
+			if (this.State == States.STATE_OFFLINE)
+				clearInterval(inputInterval)
+			if (this.State != States.STATE_ONLINE)
+				return;
+			this.time = new Date().getTime();
+			this.sendInput();
 		}, 500)
+
+		let resendTimeout = setInterval(() => {
+			if (this.State != States.STATE_OFFLINE) {
+				if (((new Date().getTime()) - this.lastSendTime) > 900 && this.sentChunkQueue.length > 0) {
+					this.SendMsgRaw([this.sentChunkQueue[0]]);
+				}
+			} else
+				clearInterval(resendTimeout)
+		}, 1000)
+	
+
 		this.time = new Date().getTime() + 2000; // start sending keepalives after 2s
+
 		if (this.socket)
-		this.socket.on("message", async (a) => {
-			var unpacked: _packet = await this.Unpack(a)
-			if (unpacked.twprotocol.flags != 128 && unpacked.twprotocol.ack) {
+			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) {
+						clearInterval(connectInterval);
+						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(this.options?.password === undefined ? "" : this.options?.password); // password
+
+						var client_version = new MsgPacker(0, true);
+						client_version.AddBuffer(Buffer.from("8c00130484613e478787f672b3835bd4", 'hex'));
+						let randomUuid = Buffer.alloc(16);
+
+						randomBytes(16).copy(randomUuid);
+
+						client_version.AddBuffer(randomUuid);
+						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.SendMsgEx([client_version, info], 1)
+					} else if (a.toJSON().data[3] == 0x4) {
+						// disconnected
+						this.State = States.STATE_OFFLINE;
+						let reason: string = (unpackString(a.toJSON().data.slice(4)).result);
+						this.emit("disconnect", reason);
+					}
+
+				}
+				
+				var unpacked: _packet = this.Unpack(a)
 				unpacked.chunks.forEach(a => {
-					if (a.msg && !a.msg.startsWith("SNAP")) {
+					if (a.flags & 1) { // vital
 						if (a.seq != undefined && a.seq != -1)
 							this.ack = a.seq
-
-					}
-				})
-			}
-			var chunkMessages = unpacked.chunks.map(a => a.msg)
-			if (chunkMessages.includes("SV_CHAT")) {
-				var chat = unpacked.chunks.filter(a => a.msg == "SV_CHAT");
-				chat.forEach(a => {
-					if (a.msg == "SV_CHAT") {
-						var unpacked: iMessage = {} as iMessage;
-						unpacked.team = unpackInt(a.raw.toJSON().data).result;
-						var remaining: number[] = unpackInt(a.raw.toJSON().data).remaining;
-						unpacked.client_id = unpackInt(remaining).result;
-						remaining = unpackInt(remaining).remaining;
-						unpacked.message = unpackString(remaining).result;
-						if (unpacked.client_id != -1)
-							unpacked.author = { ClientInfo: this.client_infos[unpacked.client_id], PlayerInfo: this.player_infos[unpacked.client_id] }
-						// console.log(unpacked)
-						this.emit("message", unpacked)
 					}
 				})
-			}
-			if (chunkMessages.includes("SV_KILL_MSG")) {
-				var chat = unpacked.chunks.filter(a => a.msg == "SV_KILL_MSG");
-				chat.forEach(a => {
-					if (a.msg == "SV_KILL_MSG") {
-						var unpacked: iKillMsg = {} as iKillMsg;
-						let unpacker = new MsgUnpacker(a.raw.toJSON().data);
-						unpacked.killer_id = unpacker.unpackInt();
-						unpacked.victim_id = unpacker.unpackInt();
-						unpacked.weapon = unpacker.unpackInt();
-						unpacked.special_mode = unpacker.unpackInt();
-						if (unpacked.victim_id != -1)
-							unpacked.victim = { ClientInfo: this.client_infos[unpacked.victim_id], PlayerInfo: this.player_infos[unpacked.victim_id] }
-						if (unpacked.killer_id != -1)
-							unpacked.killer = { ClientInfo: this.client_infos[unpacked.killer_id], PlayerInfo: this.player_infos[unpacked.killer_id] }
-						// console.log(unpacked)
-						this.emit("kill", unpacked)
-					}
+				this.sentChunkQueue.forEach((buff, i) => {
+					let chunk = this.MsgToChunk(buff);
+					if (chunk.flags & 1) {
+						if (chunk.seq && chunk.seq < this.ack) {
+							this.sentChunkQueue.splice(i, 1);
+						} 
+					} 
 				})
-			}
-			if (a.toJSON().data[0] == 0x10) {
-				if (a.toString().includes("TKEN") || arrStartsWith(a.toJSON().data, [0x10, 0x0, 0x0, 0x0])) {
-					clearInterval(connectInterval);
-					this.TKEN = Buffer.from(a.toJSON().data.slice(a.toJSON().data.length - 4, a.toJSON().data.length))
-					this.SendControlMsg(3);
-					this.State = 2; // loading state
-					var info = new MsgPacker(1, true);
-					info.AddString("0.6 626fce9a778df4d4");
-					info.AddString(""); // password
-
-					var client_version = new MsgPacker(0, true);
-					client_version.AddBuffer(Buffer.from("8c00130484613e478787f672b3835bd4", 'hex'));
-					let randomUuid = new Uint8Array(16);
-
-					randomBytes(16).copy(randomUuid);
-
-					client_version.AddBuffer(Buffer.from(randomUuid));
-					client_version.AddInt(15091);
-					client_version.AddString("DDNet 15.9.1");
-
-					this.SendMsgExWithChunks([client_version, info], 1)
-				} else if (a.toJSON().data[3] == 0x4) {
-					// disconnected
-					this.State = 0;
-					let reason: string = (unpackString(a.toJSON().data.slice(4)).result);
-					this.State = -1;
-					this.emit("disconnect", reason);
-				}
-
-			}
-			if (unpacked.chunks[0] && chunkMessages.includes("SV_READY_TO_ENTER")) {
-				var Msg = new MsgPacker(15, true); /* entergame */
-				this.SendMsgEx(Msg, 1);
-			} else if ((unpacked.chunks[0] && chunkMessages.includes("CAPABILITIES") || unpacked.chunks[0] && chunkMessages.includes("MAP_CHANGE"))) {
-				// send ready
-				var Msg = new MsgPacker(14, true); /* ready */
-				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 */
-				this.SendMsgEx(info, 1);
-
-
-			} else if (unpacked.chunks[0] && chunkMessages.includes("SV_READY_TO_ENTER")) {
-
-				if (this.State != 3) {
-					this.emit('connected');
-				}
-				this.State = 3
-			} else if (unpacked.chunks[0] && chunkMessages.includes("PING")) {
-				var info = new MsgPacker(23, true);
-				this.SendMsgEx(info, 1)
-			}
-			if (chunkMessages.includes("SNAP") || chunkMessages.includes("SNAP_EMPTY") || chunkMessages.includes("SNAP_SINGLE")) {
-				this.receivedSnaps++; /* wait for 2 ss before seeing self as connected */
-				if (this.receivedSnaps >= 2) {
-					if (this.State != 3)
-						this.emit('connected')
-					this.State = 3
-				}
-
-				var chunks = unpacked.chunks.filter(a => a.msg == "SNAP" || a.msg == "SNAP_SINGLE" || a.msg == "SNAP_EMPTY");
-				if (chunks.length > 0) {
+				var snapChunks = unpacked.chunks.filter(a => a.msg === "SNAP" || a.msg === "SNAP_SINGLE" || a.msg === "SNAP_EMPTY");
+				if (snapChunks.length > 0) {
 					let part = 0;
 					let num_parts = 1;
-					chunks.forEach(chunk => {
-						let AckGameTick = (unpackInt(chunk.raw.toJSON().data).result);
-						chunk.raw = Buffer.from(unpackInt(chunk?.raw?.toJSON().data).remaining);
-						let DeltaTick = unpackInt(chunk?.raw?.toJSON().data).result
-						if (chunk.msg == "SNAP") {
-							chunk.raw = Buffer.from(unpackInt(chunk?.raw?.toJSON().data).remaining); // delta tick
-							num_parts = (unpackInt(chunk?.raw?.toJSON().data).result)
-							chunk.raw = Buffer.from(unpackInt(chunk?.raw?.toJSON().data).remaining); // num parts
-							part = (unpackInt(chunk?.raw?.toJSON().data).result)
+					snapChunks.forEach(chunk => {
+						let unpacker = new MsgUnpacker(chunk.raw.toJSON().data);
+			
+						let AckGameTick = unpacker.unpackInt();
+						if (AckGameTick > this.AckGameTick) {
+							this.AckGameTick = AckGameTick;
+							if (Math.abs(this.PredGameTick - this.AckGameTick) > 10)
+								this.PredGameTick = AckGameTick + 1;
+						}
+
+						// chunk.raw = Buffer.from(unpackInt(chunk?.raw?.toJSON().data).remaining);
+						let DeltaTick = AckGameTick - unpacker.unpackInt();
+						let num_parts = 1;
+						let part = 0;
+
+						if (chunk.msg === "SNAP") {
+							// chunk.raw = Buffer.from(unpackInt(chunk?.raw?.toJSON().data).remaining); // delta tick
+							num_parts = unpacker.unpackInt();
+							// chunk.raw = Buffer.from(unpackInt(chunk?.raw?.toJSON().data).remaining); // num parts
+							part = unpacker.unpackInt();
 						}
-						chunk.raw = Buffer.from(unpackInt(chunk?.raw?.toJSON().data).remaining); // part
-						if (chunk.msg != "SNAP_EMPTY")
-							chunk.raw = Buffer.from(unpackInt(chunk?.raw?.toJSON().data).remaining); // crc
-						chunk.raw = Buffer.from(unpackInt(chunk?.raw?.toJSON().data).remaining); // crc
-						if (part == 0 || this.snaps.length > 30) {
+						
+						let crc = 0;
+						let part_size = 0;
+						if (chunk.msg != "SNAP_EMPTY") {
+							crc = unpacker.unpackInt(); // crc
+							part_size = unpacker.unpackInt();
+						}
+						if (part === 0 || this.snaps.length > 30) {
 							this.snaps = [];
 						}
+						chunk.raw = Buffer.from(unpacker.remaining);
 						this.snaps.push(chunk.raw)
 
-						if ((num_parts - 1) == part && this.snaps.length == num_parts) {
+						if ((num_parts - 1) === part && this.snaps.length === num_parts) {
 							let mergedSnaps = Buffer.concat(this.snaps);
+							// mergedSnaps = Buffer.from(unpackInt(mergedSnaps.toJSON().data).remaining);
 							let snapUnpacked = SnapUnpacker.unpackSnapshot(mergedSnaps.toJSON().data, 1)
-
+							// console.log(snapUnpacked.items, toHexStream(mergedSnaps));
 							snapUnpacked.items.forEach((a, i) => {
-								if (a.type_id == items.OBJ_CLIENT_INFO) {
+								if (a.type_id === items.OBJ_CLIENT_INFO) {
 									this.client_infos[a.id] = a.parsed as ClientInfo;
-									// console.log(a.parsed, i)
-									// console.log(this.client_infos[a.id])
-								} else if (a.type_id == items.OBJ_PLAYER_INFO) {
-									this.player_infos[i] = a.parsed as PlayerInfo;
-								} else if (a.type_id == items.OBJ_EX || a.type_id > 0x4000) {
-									if (a.data.length == 5 && ((a.parsed as DdnetCharacter).freeze_end > 0 || (a.parsed as DdnetCharacter).freeze_end == -1)) {
-										// var packer = new MsgPacker(22, false)
-										// this.SendMsgEx(packer, 1)
+									if (this.client_infos[a.id].name.includes("�") || this.client_infos[a.id].clan.includes("�")) {
+										console.log("bad name", this.client_infos[a.id], toHexStream(mergedSnaps), chunk, AckGameTick, DeltaTick, crc, part_size);
 									}
+									console.log(this.client_infos[a.id])
 								}
 							})
 						}
 
+
+					})
+				}
+				var chunkMessages = unpacked.chunks.map(a => a.msg)
+				if (chunkMessages.includes("SV_CHAT")) {
+					var chat = unpacked.chunks.filter(a => a.msg == "SV_CHAT");
+					chat.forEach(a => {
+						if (a.msg == "SV_CHAT") {
+							let unpacker = new MsgUnpacker(a.raw.toJSON().data);
+							var unpacked: iMessage = {
+								team: unpacker.unpackInt(),
+								client_id: unpacker.unpackInt(),
+								message: unpacker.unpackString()
+							} as iMessage;
+
+							if (unpacked.client_id != -1)
+								unpacked.author = { 
+									ClientInfo: this.client_infos[unpacked.client_id], 
+									PlayerInfo: this.player_infos[unpacked.client_id] 
+								}
+							this.emit("message", unpacked)
+						}
+					})
+				}
+				if (chunkMessages.includes("SV_KILL_MSG")) {
+					var chat = unpacked.chunks.filter(a => a.msg == "SV_KILL_MSG");
+					chat.forEach(a => {
+						if (a.msg == "SV_KILL_MSG") {
+							var unpacked: iKillMsg = {} as iKillMsg;
+							let unpacker = new MsgUnpacker(a.raw.toJSON().data);
+							unpacked.killer_id = unpacker.unpackInt();
+							unpacked.victim_id = unpacker.unpackInt();
+							unpacked.weapon = unpacker.unpackInt();
+							unpacked.special_mode = unpacker.unpackInt();
+							if (unpacked.victim_id != -1)
+								unpacked.victim = { ClientInfo: this.client_infos[unpacked.victim_id], PlayerInfo: this.player_infos[unpacked.victim_id] }
+							if (unpacked.killer_id != -1)
+								unpacked.killer = { ClientInfo: this.client_infos[unpacked.killer_id], PlayerInfo: this.player_infos[unpacked.killer_id] }
+							this.emit("kill", unpacked)
+						}
 					})
 				}
 
-			}
-			if (new Date().getTime() - this.time >= 1000) {
-				this.time = new Date().getTime();
-				this.SendControlMsg(0);
-			}
-		})
+				if (unpacked.chunks[0] && chunkMessages.includes("SV_READY_TO_ENTER")) {
+					var Msg = new MsgPacker(15, true); /* entergame */
+					this.SendMsgEx(Msg, 1);
+				} else if ((unpacked.chunks[0] && chunkMessages.includes("CAPABILITIES") || unpacked.chunks[0] && chunkMessages.includes("MAP_CHANGE"))) {
+					// send ready
+					var Msg = new MsgPacker(14, true); /* ready */
+					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);
+					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);
+
+
+				} else if (unpacked.chunks[0] && chunkMessages.includes("PING")) {
+					var info = new MsgPacker(23, true);
+					this.SendMsgEx(info, 1)
+				}
+				if (chunkMessages.includes("SNAP") || chunkMessages.includes("SNAP_EMPTY") || chunkMessages.includes("SNAP_SINGLE")) {
+					this.receivedSnaps++; /* wait for 2 ss before seeing self as connected */
+					if (this.receivedSnaps == 2) {
+						if (this.State != States.STATE_ONLINE)
+							this.emit('connected')
+						this.State = States.STATE_ONLINE;
+					}
+
+				}
+				if (new Date().getTime() - this.time >= 1000 && this.State == States.STATE_ONLINE) {
+					this.time = new Date().getTime();
+					this.SendControlMsg(0);
+				}
+			})
+	}
+
+	sendInput(input = this.movement.input) {
+		if (this.State != States.STATE_ONLINE)
+			return;
+
+		let inputMsg = new MsgPacker(16, true);
+		inputMsg.AddInt(this.AckGameTick);
+		inputMsg.AddInt(this.PredGameTick);
+		inputMsg.AddInt(40);
+
+		let input_data = [
+
+			input.m_Direction,
+			input.m_TargetX,
+			input.m_TargetY,
+			input.m_Jump,
+			input.m_Fire,
+			input.m_Hook,
+			input.m_PlayerFlags,
+			input.m_WantedWeapon,
+			input.m_NextWeapon,
+			input.m_PrevWeapon
+		]
+		input_data.forEach(a => {
+			inputMsg.AddInt(a);
+		});
+		this.SendMsgEx(inputMsg, 0);
+	}
+	get input() {
+		return this.movement.input;
 	}
 
 	Disconnect() {
@@ -491,7 +673,7 @@ class Client extends EventEmitter {
 				if (this.socket)
 					this.socket.close();
 				this.socket = undefined
-				this.State = -1;
+				this.State = States.STATE_OFFLINE;
 			})
 		})
 	}
@@ -533,6 +715,5 @@ class Client extends EventEmitter {
 		this.SendMsgEx(packer, 1);
 	}
 
+
 }
-export = Client;
-// module.exports = Client;