@vaitosoi/minejs 0.2.1 → 0.2.2

package/dist/client/tcp.js

@@ -0,0 +1,838 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCPClient = exports.ClientState = exports.ClientStatus = exports.GameMode = void 0;
+const node_net_1 = require("node:net");
+const node_events_1 = require("node:events");
+const node_crypto_1 = require("node:crypto");
+const node_zlib_1 = require("node:zlib");
+const decoder_1 = require("../translator/decoder");
+const encoder_1 = require("../translator/encoder");
+const error_1 = require("../base/error");
+const math_1 = require("../base/math");
+const static_1 = require("./static");
+const auth_1 = require("./auth");
+var GameMode;
+(function (GameMode) {
+    GameMode[GameMode["Survival"] = 0] = "Survival";
+    GameMode[GameMode["Creative"] = 1] = "Creative";
+    GameMode[GameMode["Adventure"] = 2] = "Adventure";
+    GameMode[GameMode["Spectator"] = 3] = "Spectator";
+})(GameMode || (exports.GameMode = GameMode = {}));
+var ClientStatus;
+(function (ClientStatus) {
+    ClientStatus[ClientStatus["Disconnected"] = 0] = "Disconnected";
+    ClientStatus[ClientStatus["Connecting"] = 1] = "Connecting";
+    ClientStatus[ClientStatus["Logining"] = 2] = "Logining";
+    ClientStatus[ClientStatus["Ready"] = 3] = "Ready";
+})(ClientStatus || (exports.ClientStatus = ClientStatus = {}));
+var ClientState;
+(function (ClientState) {
+    ClientState[ClientState["Disconnected"] = 0] = "Disconnected";
+    ClientState[ClientState["Handshake"] = 1] = "Handshake";
+    ClientState[ClientState["Login"] = 2] = "Login";
+    ClientState[ClientState["Configure"] = 3] = "Configure";
+    ClientState[ClientState["Play"] = 4] = "Play";
+})(ClientState || (exports.ClientState = ClientState = {}));
+// export enum TCPServerIntent {
+//     Status = 1,
+//     Login = 2,
+//     Transfer = 3,
+// }
+/**
+ * Low-level client. You SHOULD NOT use this client unless you know what are you doing
+ *
+ * @see https://minecraft.wiki/w/Java_Edition_protocol/Packets?oldid=3445844
+ */
+class TCPClient extends node_events_1.EventEmitter {
+    option;
+    socket;
+    server = undefined;
+    // Internal var
+    /**
+     * | Value | Meaning |
+     * |-------|---------|
+     * | 0     |  not set yet |
+     * | -1    | dont compress |
+     * | > 0   | compression threshold |
+     */
+    compressionThreshold = 0;
+    bufferPool = Buffer.alloc(0);
+    status = ClientStatus.Disconnected;
+    state = ClientState.Disconnected;
+    // Encryption
+    sharedSecret = undefined;
+    cipher = undefined;
+    decipher = undefined;
+    // Play data
+    world;
+    player;
+    registry;
+    // Initial data
+    playerUUID;
+    constructor(option, socketOption) {
+        super();
+        this.option = option;
+        this.socket = new node_net_1.Socket(socketOption);
+        this.wipePlayData();
+        if (!option.isOffline && !option.auth)
+            throw new error_1.MissingAuthOption();
+    }
+    wipePlayData() {
+        this.world = null;
+        this.player = null;
+        this.registry = null;
+    }
+    /**
+     * Connect to server
+     */
+    async connect() {
+        if (!this.playerUUID) {
+            if (this.option.auth) {
+                const authClient = new auth_1.AuthClient(this.option.auth);
+                const { uuid } = await authClient.auth();
+                this.playerUUID = Buffer.from(uuid);
+            }
+            else
+                this.playerUUID = (0, math_1.computeUUID)(this.option.playerName);
+        }
+        this.status = ClientStatus.Connecting;
+        const connection = this.socket.connect({
+            host: this.option.host,
+            port: this.option.port
+        });
+        connection.on("connect", () => {
+            this.emit("connect");
+            this.wipePlayData();
+            this.sendHandshake();
+            this.sendLoginStart();
+        });
+        connection.on("data", (data) => {
+            let buf = Buffer.from(data);
+            if (this.decipher) {
+                buf = this.decipher.update(buf);
+            }
+            this.emit("raw", Buffer.from(buf));
+            this.bufferPool = Buffer.concat([this.bufferPool, buf]);
+            this.handlePacket();
+        });
+        connection.once("end", () => {
+            if (this.status === ClientStatus.Disconnected)
+                return;
+            this.status = ClientStatus.Disconnected;
+            this.state = ClientState.Disconnected;
+            this.emit("disconnect", "socket close");
+        });
+        connection.once("close", () => {
+            if (this.status === ClientStatus.Disconnected)
+                return;
+            this.status = ClientStatus.Disconnected;
+            this.state = ClientState.Disconnected;
+            this.emit("disconnect", "socket close");
+        });
+    }
+    disconnect() {
+        if (!this.socket.closed)
+            this.socket.destroy();
+    }
+    isReady() {
+        return this.status === ClientStatus.Ready;
+    }
+    checkReady() {
+        if (!this.isReady())
+            throw new error_1.ClientNotReady();
+        return true;
+    }
+    /*
+    * Read packet
+    */
+    handlePacket() {
+        while (true) {
+            if (this.bufferPool.length === 0)
+                break;
+            let decoder = new decoder_1.BinaryDecoder(this.bufferPool);
+            let packetLength;
+            try {
+                packetLength = decoder.readVarInt();
+            }
+            catch (e) {
+                break; // Not enough data to read VarInt
+            }
+            if (this.bufferPool.length - decoder.offset < packetLength)
+                break;
+            const expectedPacketEnd = decoder.offset + packetLength;
+            let packetID;
+            if (this.compressionThreshold === 0)
+                packetID = decoder.readVarInt();
+            else if (this.compressionThreshold === -1) {
+                decoder.readVarInt();
+                packetID = decoder.readVarInt();
+            }
+            else {
+                const dataLength = decoder.readVarInt();
+                if (dataLength === 0) {
+                    packetID = decoder.readVarInt();
+                }
+                else {
+                    const dataBuffer = this.bufferPool.subarray(decoder.offset, expectedPacketEnd);
+                    const decompressed = (0, node_zlib_1.inflateSync)(dataBuffer);
+                    decoder = new decoder_1.BinaryDecoder(decompressed);
+                    packetID = decoder.readVarInt();
+                }
+            }
+            // Debug
+            if (this.option.debug?.packetLogger)
+                console.dir({
+                    state: ClientState[this.state],
+                    packetID: "0x" + packetID.toString(16),
+                    length: decoder.buffer.length
+                });
+            switch (packetID) {
+                case 0x00:
+                    if (this.state === ClientState.Login)
+                        this.handleLoginDisconnect(decoder);
+                    break;
+                case 0x01:
+                    if (this.state === ClientState.Login)
+                        this.handleEncryption(decoder);
+                    if (this.state === ClientState.Play)
+                        this.handleSpawnEntity(decoder);
+                    break;
+                case 0x02:
+                    if (this.state === ClientState.Configure)
+                        this.handleConfiguarionPlayDisconnect(decoder);
+                    if (this.state === ClientState.Login)
+                        this.handleLoginSucess(decoder);
+                    break;
+                case 0x03:
+                    if (this.state === ClientState.Login)
+                        this.handleSetCompression(decoder);
+                    if (this.state === ClientState.Configure)
+                        this.sendConfigureAck();
+                    break;
+                case 0x06:
+                    if (this.state === ClientState.Play)
+                        this.handleBlockEntityData(decoder);
+                    break;
+                case 0x07:
+                    if (this.state === ClientState.Configure)
+                        this.handleRegistryData(decoder);
+                    break;
+                case 0x0A:
+                    if (this.state === ClientState.Play)
+                        this.handleChangeGameMode(decoder);
+                    break;
+                case 0x0E:
+                    if (this.state === ClientState.Configure)
+                        this.handleKnownPack(decoder);
+                    break;
+                case 0x20:
+                    if (this.state === ClientState.Play)
+                        this.handleConfiguarionPlayDisconnect(decoder);
+                    break;
+                case 0x21:
+                    if (this.state === ClientState.Play)
+                        this.handleDisguisedChatMessage(decoder);
+                    break;
+                case 0x23:
+                    if (this.state === ClientState.Play)
+                        this.handleTeleportEntity(decoder);
+                    break;
+                case 0x25:
+                    if (this.state === ClientState.Play)
+                        this.handleUnloadChunk(decoder);
+                    break;
+                case 0x2D:
+                    if (this.state === ClientState.Play)
+                        this.handleChunkData(decoder);
+                    break;
+                case 0x2C:
+                    if (this.state === ClientState.Play)
+                        this.handleKeepAlive(decoder);
+                    break;
+                case 0x31:
+                    if (this.state === ClientState.Play)
+                        this.handlePlayLogin(decoder);
+                    break;
+                case 0x35:
+                    if (this.state === ClientState.Play)
+                        this.handleUpdateEntityPosition(decoder);
+                    break;
+                case 0x36:
+                    if (this.state === ClientState.Play)
+                        this.handleUpdateEntityPositionRotation(decoder);
+                    break;
+                case 0x41:
+                    if (this.state === ClientState.Play)
+                        this.handlePlayerChat(decoder);
+                    break;
+                case 0x48:
+                    if (this.state === ClientState.Play)
+                        this.handleSynchronizePlayerPosition(decoder);
+                    break;
+                case 0x4D:
+                    if (this.state === ClientState.Play)
+                        this.handleRemoveEntity(decoder);
+                    break;
+                case 0x57:
+                    if (this.state === ClientState.Play)
+                        this.handleSetActionBar(decoder);
+                    break;
+                case 0x65:
+                    if (this.state === ClientState.Play)
+                        this.handleSetEntityVelocity(decoder);
+                    break;
+                case 0x79:
+                    if (this.state === ClientState.Play)
+                        this.handleSystemMessage(decoder);
+                    break;
+            }
+            this.bufferPool = this.bufferPool.subarray(expectedPacketEnd);
+        }
+    }
+    // Login
+    handleLoginDisconnect(decoder) {
+        const reason = JSON.parse(decoder.readString());
+        const text = (0, decoder_1.getTextFromTextComponent)(reason);
+        this.status = ClientStatus.Disconnected;
+        this.state = ClientState.Disconnected;
+        this.wipePlayData();
+        this.emit("disconnect", text.toString());
+        this.emit("disconnectRaw", reason);
+        this.disconnect();
+    }
+    handleEncryption(decoder) {
+        const serverId = decoder.readString(); // Should be ignored in 1.7+ server
+        const publicKey = decoder.readRawPrefixedArray(8);
+        const verifyToken = decoder.readRawPrefixedArray(8);
+        const shoudlCallMojang = decoder.readBoolean(); // I'm too lazy to do this D:
+        const sharedSecret = (0, node_crypto_1.randomBytes)(16);
+        this.sharedSecret = sharedSecret;
+        this.cipher = (0, node_crypto_1.createCipheriv)("aes-128-cfb8", this.sharedSecret, this.sharedSecret);
+        this.decipher = (0, node_crypto_1.createDecipheriv)("aes-128-cfb8", this.sharedSecret, this.sharedSecret);
+        this.sendEncryptionResponse(publicKey, verifyToken);
+    }
+    handleSetCompression(decoder) {
+        const threshold = decoder.readVarInt();
+        if (threshold < 0)
+            this.compressionThreshold = -1;
+        else
+            this.compressionThreshold = threshold;
+    }
+    handleLoginSucess(decoder) {
+        const uuid = decoder.readUUID();
+        const username = decoder.readString();
+        this.player = {
+            uuid,
+            username,
+            entityId: 0,
+            dimension: "",
+            gameMode: GameMode.Survival,
+            position: {
+                x: 0,
+                y: 0,
+                z: 0,
+            },
+            velocity: {
+                x: 0,
+                y: 0,
+                z: 0,
+            },
+            angle: {
+                yaw: 0,
+                pitch: 0,
+            }
+        };
+        this.sendLoginAck();
+    }
+    // Configure
+    handleKnownPack(decoder) {
+        const packs = decoder.readPrefixedArray((decoder) => ({
+            namespace: decoder.readString(),
+            id: decoder.readString(),
+            version: decoder.readString()
+        }));
+        this.server.knownPacks = packs;
+        // this.sendKnownPack(this.option.loadRegistry === true ? [] : packs);
+        this.sendKnownPack([]);
+    }
+    handleRegistryData(decoder) {
+        const id = decoder.readString();
+        const entries = decoder.readPrefixedArray((decoder) => ({
+            id: decoder.readString(),
+            data: decoder.readPrefixedOptional((decoder) => decoder.readNBT())
+        }));
+        if (!this.registry)
+            this.registry = {};
+        const registry = this.registry;
+        if (!(id in registry))
+            registry[id] = [];
+        registry[id].push(...entries);
+    }
+    handleConfiguarionPlayDisconnect(decoder) {
+        const reason = decoder.readNBT();
+        const text = (0, decoder_1.getTextFromTextComponent)(reason);
+        this.status = ClientStatus.Disconnected;
+        this.state = ClientState.Disconnected;
+        this.wipePlayData();
+        this.emit("disconnect", text.toString());
+        this.emit("disconnectRaw", reason);
+        this.disconnect();
+    }
+    // Play
+    handlePlayLogin(decoder) {
+        const entityId = decoder.readInt(), isHardcore = decoder.readBoolean(), dimensions = decoder.readPrefixedArray((decoder) => decoder.readString()), maxPlayers = decoder.readVarInt(), viewDistance = decoder.readVarInt(), simulationDistance = decoder.readVarInt();
+        decoder.readBoolean(); // Reduced Debug Info
+        decoder.readBoolean(); // Enable respawn screen 
+        decoder.readBoolean(); // Do limited crafting
+        decoder.readVarInt(); // Dimension Type
+        const dimensionName = decoder.readString();
+        decoder.readLong(); // Hashed seed
+        const gameMode = decoder.readUByte();
+        this.world = {
+            hardcore: isHardcore,
+            dimensions,
+            maxPlayers,
+            viewDistance,
+            simulationDistance,
+            chunks: {},
+            entities: {}
+        }; // To avoid type conflict
+        this.player.dimension = dimensionName;
+        this.player.entityId = entityId;
+        this.player.gameMode = gameMode;
+        this.status = ClientStatus.Ready;
+        this.emit("ready", this);
+    }
+    handleSynchronizePlayerPosition(decoder) {
+        const teleportId = decoder.readVarInt();
+        const x = decoder.readDouble(), y = decoder.readDouble(), z = decoder.readDouble(), velX = decoder.readDouble(), velY = decoder.readDouble(), velZ = decoder.readDouble(), yaw = decoder.readFloat() % 360, pitch = decoder.readFloat() % 360;
+        const flag = decoder.readTeleportFlag();
+        const { position, velocity, angle } = this.player;
+        let { x: newPosX, y: newPosY, z: newPosZ } = position;
+        let { x: newVelX, y: newVelY, z: newVelZ } = velocity;
+        let { yaw: newYaw, pitch: newPitch } = angle;
+        if (flag.x)
+            newPosX += x;
+        else
+            newPosX = x;
+        if (flag.y)
+            newPosY += y;
+        else
+            newPosY = y;
+        if (flag.z)
+            newPosZ += z;
+        else
+            newPosZ = z;
+        if (flag.velX)
+            newVelX += velX;
+        else
+            newVelX = velX;
+        if (flag.velY)
+            newVelY += velY;
+        else
+            newVelY = velY;
+        if (flag.velZ)
+            newVelZ += velZ;
+        else
+            newVelZ = velZ;
+        if (flag.yaw)
+            newYaw += yaw;
+        else
+            newYaw = yaw;
+        if (flag.pitch)
+            newPitch += pitch;
+        else
+            newPitch = pitch;
+        const newPosition = { x: newPosX, y: newPosY, z: newPosZ }, newVelocity = { x: newVelX, y: newVelY, z: newVelZ }, newAngle = { yaw: newYaw, pitch: newPitch };
+        this.player = {
+            ...this.player,
+            position: newPosition,
+            velocity: newVelocity,
+            angle: newAngle,
+        };
+        this.emit("playerPosition", { x: newPosX, y: newPosY, z: newPosZ });
+        this.sendConfirmTeleportation(teleportId);
+        this.sendPlayerPosRot(newPosition, newAngle, true, false);
+    }
+    handleKeepAlive(decoder) {
+        const aliveID = decoder.readLong();
+        this.sendKeepAlive(aliveID);
+    }
+    handleChangeGameMode(decoder) {
+        const gameMode = decoder.readUByte();
+        this.player.gameMode = gameMode;
+    }
+    // Chunk
+    handleChunkData(decoder) {
+        const chunkX = decoder.readInt(), chunkZ = decoder.readInt(), heightMaps = decoder.readPrefixedArray(decoder => ({
+            type: decoder.readVarInt(),
+            data: decoder.readPrefixedArray(decoder => decoder.readLong())
+        })), // Not used yet
+        chunkData = decoder.readPrefixedArray(decoder => decoder.readByte()), blockEntities = decoder.readPrefixedArray(decoder => {
+            const packedXZ = decoder.readByte(), y = decoder.readShort(), type = decoder.readVarInt(), nbt = decoder.readNBT();
+            const x = (packedXZ >> 4) & 15, z = packedXZ & 15;
+            const packedPosition = (0, static_1.packBlockPos)(x, y, z);
+            return { packedPosition, type, nbt };
+        });
+        // this.world!.chunks[`${this.player!.dimension}:${chunkX}:${chunkZ}`] = [];
+        const chunkSections = {};
+        const chunkDataDecoder = new decoder_1.BinaryDecoder(Buffer.from(chunkData));
+        for (let height = 0; height < (static_1.SectionsPerChunk[this.player.dimension] || 0); height++) {
+            const blockCount = chunkDataDecoder.readShort();
+            const fluidCount = chunkDataDecoder.readShort();
+            // Blocks
+            let blockStateBPE = chunkDataDecoder.readUByte();
+            let blockStatePalettes = [];
+            if (blockStateBPE === 0) {
+                blockStatePalettes = [chunkDataDecoder.readVarInt()];
+            }
+            else if (blockStateBPE <= 8) {
+                // Indirect palette
+                if (blockStateBPE < 4)
+                    blockStateBPE = 4; // BPE smaller than 4 will be rounđe up to 4
+                blockStatePalettes = chunkDataDecoder.readPrefixedArray(decoder => decoder.readVarInt());
+            }
+            else {
+                // Direct palette (no palette array)
+            }
+            const blockEntriesPerSection = 4096;
+            const blockEntriesPerLong = Math.floor(64 / blockStateBPE);
+            let blockDataArray = null;
+            if (blockStateBPE !== 0) {
+                const blockDataArrayLength = Math.floor((blockEntriesPerSection + blockEntriesPerLong - 1) / blockEntriesPerLong);
+                blockDataArray = new BigInt64Array(chunkDataDecoder.readArray(blockDataArrayLength, (decoder) => decoder.readLong()));
+            }
+            // Biomes - Not used yet, but need to be read to advance decoder
+            const biomeBPE = chunkDataDecoder.readUByte();
+            let biomePalettes = [];
+            if (biomeBPE === 0) {
+                biomePalettes = [chunkDataDecoder.readVarInt()]; // Palette value
+            }
+            else if (biomeBPE <= 3) {
+                // Indirect palette
+                biomePalettes = chunkDataDecoder.readPrefixedArray(decoder => decoder.readVarInt());
+            }
+            else {
+                // Direct palette (no palette array)
+            }
+            const biomeEntriesPerSection = 64;
+            const biomeEntriesPerLong = Math.floor(64 / biomeBPE);
+            let biomeDataArray = null;
+            if (biomeBPE !== 0) {
+                const biomeDataArrayLength = Math.floor((biomeEntriesPerSection + biomeEntriesPerLong - 1) / biomeEntriesPerLong);
+                biomeDataArray = new BigInt64Array(chunkDataDecoder.readArray(biomeDataArrayLength, (decoder) => decoder.readLong()));
+            }
+            chunkSections[height] = {
+                block: {
+                    bpe: blockStateBPE,
+                    palette: blockStatePalettes,
+                    data: blockDataArray
+                },
+                biome: {
+                    bpe: biomeBPE,
+                    palette: biomePalettes,
+                    data: biomeDataArray
+                }
+            };
+            this.emit("loadChunk", chunkX, height, chunkZ);
+        }
+        const blockEntitiesObj = Object.fromEntries(blockEntities.map(val => [val.packedPosition, { type: val.type, data: val.nbt }]));
+        this.world.chunks[`${this.player.dimension}:${chunkX}:${chunkZ}`] = {
+            sections: chunkSections,
+            blockEntities: blockEntitiesObj
+        };
+    }
+    handleUnloadChunk(decoder) {
+        const chunkZ = decoder.readInt(), chunkX = decoder.readInt();
+        delete this.world.chunks[`${this.player.dimension}:${chunkX}:${chunkZ}`];
+        this.emit("unloadChunk", chunkX, chunkZ);
+    }
+    handleBlockEntityData(decoder) {
+        const location = decoder.readPosition(), type = decoder.readVarInt(), data = decoder.readNBT();
+        const chunkX = Math.floor(location.x / 16), chunkZ = Math.floor(location.z / 16);
+        const xWitinChunk = location.x % 16, zWitinChunk = location.z % 16;
+        const packedPosition = (0, static_1.packBlockPos)(xWitinChunk, location.y, zWitinChunk);
+        if (`${this.player.dimension}:${chunkX}:${chunkZ}` in this.world.chunks)
+            this.world.chunks[`${this.player.dimension}:${chunkX}:${chunkZ}`].blockEntities[packedPosition] = {
+                type,
+                data
+            };
+    }
+    // Entity
+    handleSpawnEntity(decoder) {
+        const id = decoder.readVarInt(), UUID = decoder.readUUID(), type = decoder.readVarInt(), x = decoder.readDouble(), y = decoder.readDouble(), z = decoder.readDouble(), velocity = decoder.readLpVec3(), pitch = decoder.readAngle(), yaw = decoder.readAngle(), headYaw = decoder.readAngle(), data = decoder.readVarInt();
+        this.world.entities[id] = {
+            id,
+            type,
+            position: { x, y, z },
+            velocity,
+            angle: {
+                pitch,
+                yaw
+            },
+            data
+        };
+        this.emit("spawnEntity", this.world.entities[id]);
+    }
+    handleTeleportEntity(decoder) {
+        const id = decoder.readVarInt(), x = decoder.readDouble(), y = decoder.readDouble(), z = decoder.readDouble(), velX = decoder.readDouble(), velY = decoder.readDouble(), velZ = decoder.readDouble(), pitch = decoder.readAngle(), yaw = decoder.readAngle();
+        if (id in this.world.entities) {
+            this.world.entities[id].position = { x, y, z };
+            this.world.entities[id].velocity = { x: velX, y: velY, z: velZ };
+            this.world.entities[id].angle = { pitch, yaw };
+            this.emit("updateEntity", this.world.entities[id]);
+        }
+    }
+    handleUpdateEntityPosition(decoder) {
+        const id = decoder.readVarInt(), delX = decoder.readFixedPoint(decoder.readShort(), 12), delY = decoder.readFixedPoint(decoder.readShort(), 12), delZ = decoder.readFixedPoint(decoder.readShort(), 12);
+        if (id in this.world.entities) {
+            let { x, y, z } = this.world.entities[id].position;
+            x += delX;
+            y += delY;
+            z += delZ;
+            this.world.entities[id].position = { x, y, z };
+            this.emit("updateEntity", this.world.entities[id]);
+        }
+    }
+    handleUpdateEntityPositionRotation(decoder) {
+        const id = decoder.readVarInt(), delX = decoder.readFixedPoint(decoder.readShort(), 12), delY = decoder.readFixedPoint(decoder.readShort(), 12), delZ = decoder.readFixedPoint(decoder.readShort(), 12), pitch = decoder.readAngle(), yaw = decoder.readAngle();
+        if (id in this.world.entities) {
+            let { x, y, z } = this.world.entities[id].position;
+            x += delX;
+            y += delY;
+            z += delZ;
+            this.world.entities[id].position = { x, y, z };
+            this.world.entities[id].angle = { yaw, pitch };
+            this.emit("updateEntity", this.world.entities[id]);
+        }
+    }
+    handleSetEntityVelocity(decoder) {
+        const entityId = decoder.readVarInt(), velocity = decoder.readLpVec3();
+        if (entityId in this.world.entities)
+            this.world.entities[entityId].velocity = velocity;
+    }
+    handleRemoveEntity(decoder) {
+        const entities = decoder.readPrefixedArray((decoder) => decoder.readVarInt());
+        for (const entityId of entities) {
+            delete this.world.entities[entityId];
+            this.emit("removeEntity", entityId);
+        }
+    }
+    // Chat
+    handlePlayerChat(decoder) {
+        const globalIndex = decoder.readVarInt(), senderUUID = decoder.readUUID(), index = decoder.readVarInt(), messageSignature = decoder.readPrefixedOptional(decoder => decoder.readArray(256, decoder => decoder.readByte())), message = decoder.readString(), timestamp = decoder.readLong(), salt = decoder.readLong(), previousMessages = decoder.readPrefixedArray(decoder => {
+            const id = decoder.readVarInt();
+            let signature;
+            if (id === 0)
+                signature = decoder.readArray(256, decoder => decoder.readByte());
+            return { id, signature };
+        }), unsignedContent = decoder.readPrefixedOptional(decoder => decoder.readNBT()), // Text component
+        filterType = decoder.readVarInt(), filterTypeBits = filterType === 1 ? decoder.readPrefixedArray(decoder => decoder.readLong()) : undefined, chatType = decoder.readIdOrX(decoder => decoder.readChatType()), senderName = decoder.readNBT(), targetName = decoder.readPrefixedOptional(decoder => decoder.readNBT());
+        const senderNameText = (0, decoder_1.getTextFromTextComponent)(senderName).toString(), targetNameText = targetName ?? (0, decoder_1.getTextFromTextComponent)(targetName).toString();
+        this.emit("message", {
+            sender: senderNameText,
+            target: targetNameText,
+            content: message,
+            raw: {
+                sender: senderName,
+                target: targetName,
+                content: unsignedContent,
+            }
+        });
+    }
+    handleSystemMessage(decoder) {
+        const content = decoder.readNBT(), isActionbar = decoder.readBoolean();
+        const text = (0, decoder_1.getTextFromTextComponent)(content);
+        if (isActionbar) {
+            this.emit("actionBar", text.toString());
+            this.emit("actionBarRaw", content);
+        }
+        else {
+            this.emit("systemMessage", text.toString());
+            this.emit("systemMessageRaw", content);
+        }
+    }
+    handleSetActionBar(decoder) {
+        const content = decoder.readNBT();
+        const text = (0, decoder_1.getTextFromTextComponent)(content);
+        this.emit("actionBar", text.toString());
+        this.emit("actionBarRaw", content);
+    }
+    handleDisguisedChatMessage(decoder) {
+        const message = decoder.readNBT(), chatType = decoder.readChatType(), senderName = decoder.readNBT(), targetName = decoder.readPrefixedOptional(decoder => decoder.readNBT());
+        const messageText = (0, decoder_1.getTextFromTextComponent)(message).toString(), senderNameText = (0, decoder_1.getTextFromTextComponent)(senderName).toString(), targetNameText = targetName ?? (0, decoder_1.getTextFromTextComponent)(targetName).toString();
+        this.emit("message", {
+            sender: senderNameText,
+            target: targetNameText,
+            content: messageText,
+            raw: {
+                sender: senderName,
+                target: targetName,
+                content: message,
+            }
+        });
+    }
+    /*
+    * Send packet
+    */
+    write(buf) {
+        if (this.status == ClientStatus.Disconnected || !this.socket.writable)
+            throw new error_1.SockerIsNotWritable();
+        let sendBuffer = buf;
+        if (this.cipher)
+            sendBuffer = this.cipher.update(sendBuffer);
+        this.socket.write(sendBuffer);
+    }
+    sendPacket(packetId, content) {
+        const encodePacketId = new encoder_1.BinaryEncoder();
+        encodePacketId.writeVarInt(packetId);
+        const sendData = Buffer.concat([encodePacketId.getBuffer(), content]);
+        let packet;
+        if (this.compressionThreshold !== 0) {
+            let data;
+            let uncompressedLength;
+            if (this.compressionThreshold > 0 && sendData.length > this.compressionThreshold) {
+                uncompressedLength = sendData.length;
+                data = (0, node_zlib_1.deflateSync)(sendData);
+            }
+            else {
+                uncompressedLength = 0;
+                data = sendData;
+            }
+            const dataLengthEncoder = new encoder_1.BinaryEncoder();
+            dataLengthEncoder.writeVarInt(uncompressedLength);
+            const dataLengthBuf = dataLengthEncoder.getBuffer();
+            const packetLengthEncoder = new encoder_1.BinaryEncoder();
+            packetLengthEncoder.writeVarInt(dataLengthBuf.length + data.length);
+            packet = Buffer.concat([packetLengthEncoder.getBuffer(), dataLengthBuf, data]);
+        }
+        else {
+            const packetLengthEncoder = new encoder_1.BinaryEncoder();
+            packetLengthEncoder.writeVarInt(sendData.length);
+            packet = Buffer.concat([packetLengthEncoder.getBuffer(), sendData]);
+        }
+        this.write(packet);
+    }
+    // Login
+    sendHandshake() {
+        this.state = ClientState.Handshake;
+        const encoder = new encoder_1.BinaryEncoder();
+        encoder.writeVarInt(this.option.protocolVersion);
+        encoder.writeString(this.option.host);
+        encoder.writeUShort(this.option.port);
+        encoder.writeVarInt(2);
+        this.sendPacket(0x00, encoder.getBuffer());
+    }
+    sendLoginStart() {
+        this.state = ClientState.Login;
+        this.status = ClientStatus.Logining;
+        const encoder = new encoder_1.BinaryEncoder();
+        const playerName = this.option.playerName;
+        const playerUUID = this.playerUUID;
+        encoder.writeString(playerName);
+        encoder.concat(playerUUID);
+        this.sendPacket(0x00, encoder.getBuffer());
+    }
+    sendEncryptionResponse(publicKey, verifyToken) {
+        const encryptedSecret = (0, node_crypto_1.publicEncrypt)({
+            key: (0, node_crypto_1.createPublicKey)({ key: publicKey, format: 'der', type: 'spki' }),
+            padding: node_crypto_1.constants.RSA_PKCS1_PADDING
+        }, this.sharedSecret);
+        const encryptedVerifyToken = (0, node_crypto_1.publicEncrypt)({
+            key: (0, node_crypto_1.createPublicKey)({ key: publicKey, format: 'der', type: 'spki' }),
+            padding: node_crypto_1.constants.RSA_PKCS1_PADDING
+        }, verifyToken);
+        const encoder = new encoder_1.BinaryEncoder();
+        encoder.writeRawPrefixedArray(encryptedSecret, 8);
+        encoder.writeRawPrefixedArray(encryptedVerifyToken, 8);
+        this.sendPacket(0x01, encoder.getBuffer());
+    }
+    sendLoginAck() {
+        this.state = ClientState.Configure;
+        this.server = {};
+        this.sendPacket(0x03, Buffer.alloc(0));
+    }
+    // Configuring
+    sendKnownPack(knownPacks) {
+        const encoder = new encoder_1.BinaryEncoder();
+        encoder.writePrefixedArray(knownPacks.length, (encoder, ind) => {
+            const pack = knownPacks[ind];
+            return encoder
+                .writeString(pack.namespace)
+                .writeString(pack.id)
+                .writeString(pack.version);
+        });
+        this.sendPacket(0x07, encoder.getBuffer());
+    }
+    sendConfigureAck() {
+        this.state = ClientState.Play;
+        this.sendPacket(0x3, Buffer.alloc(0));
+    }
+    // Play
+    sendConfirmTeleportation(teleportId) {
+        const encoder = new encoder_1.BinaryEncoder();
+        encoder.writeVarInt(teleportId);
+        this.sendPacket(0, encoder.getBuffer());
+    }
+    sendKeepAlive(id) {
+        const encoder = new encoder_1.BinaryEncoder();
+        encoder.writeLong(id);
+        this.sendPacket(0x1C, encoder.getBuffer());
+    }
+    sendPlayerPosRot(pos, rot, onGround, pushingWall) {
+        let flag = 0;
+        if (onGround)
+            flag |= 1;
+        if (pushingWall)
+            flag |= 1 << 2;
+        // // console.log({ pos, rot, flag });
+        const encoder = new encoder_1.BinaryEncoder();
+        encoder.writeDouble(pos.x);
+        encoder.writeDouble(pos.y);
+        encoder.writeDouble(pos.z);
+        encoder.writeFloat(rot.yaw);
+        encoder.writeFloat(rot.pitch);
+        encoder.writeByte(flag);
+        this.sendPacket(0x1F, encoder.getBuffer());
+    }
+    sendPlayerPos(pos, onGround, pushingWall) {
+        let flag = 0;
+        if (onGround)
+            flag &= 1;
+        if (pushingWall)
+            flag |= 1 << 2;
+        // // console.log({ pos, flag });
+        const encoder = new encoder_1.BinaryEncoder();
+        encoder.writeDouble(pos.x);
+        encoder.writeDouble(pos.y);
+        encoder.writeDouble(pos.z);
+        encoder.writeByte(flag);
+        this.sendPacket(0x1E, encoder.getBuffer());
+    }
+    sendPlayerRot(rot, onGround, pushingWall) {
+        let flag = 0;
+        if (onGround)
+            flag &= 1;
+        if (pushingWall)
+            flag |= 1 << 2;
+        // // console.log({ rot, flag });
+        const encoder = new encoder_1.BinaryEncoder();
+        encoder.writeFloat(rot.yaw);
+        encoder.writeFloat(rot.pitch);
+        encoder.writeByte(flag);
+        this.sendPacket(0x20, encoder.getBuffer());
+    }
+    sendPlayerStatus(onGround, pushingWall) {
+        let flag = 0;
+        if (onGround)
+            flag &= 1;
+        if (pushingWall)
+            flag |= 1 << 2;
+        // // console.log({ flag });
+        const encoder = new encoder_1.BinaryEncoder();
+        encoder.writeByte(flag);
+        this.sendPacket(0x21, encoder.getBuffer());
+    }
+}
+exports.TCPClient = TCPClient;
+//# sourceMappingURL=tcp.js.map