@vaitosoi/minejs 0.2.2 → 0.4.0

package/dist/client/tcp.js

@@ -1,38 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TCPClient = exports.ClientState = exports.ClientStatus = exports.GameMode = void 0;
+exports.TCPClient = 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 decoder_1 = require("../packet/decoder");
+const encoder_1 = require("../packet/encoder");
+const state_1 = require("../world/state");
 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,
@@ -44,9 +19,9 @@ var ClientState;
  * @see https://minecraft.wiki/w/Java_Edition_protocol/Packets?oldid=3445844
  */
 class TCPClient extends node_events_1.EventEmitter {
+    state;
     option;
     socket;
-    server = undefined;
     // Internal var
     /**
      * | Value | Meaning |
@@ -55,100 +30,53 @@ class TCPClient extends node_events_1.EventEmitter {
      * | -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) {
+    constructor(state, option, socketOption) {
         super();
+        this.state = state;
         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;
     }
+    sendInitPacket = () => { throw new error_1.NotImplemented(); };
+    forwardPacket = () => { throw new error_1.NotImplemented(); };
+    parsePacket = () => { throw new error_1.NotImplemented(); };
     /**
      * 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;
+    connect() {
+        this.state.status = state_1.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();
+            this.sendInitPacket();
         });
         connection.on("data", (data) => {
             let buf = Buffer.from(data);
-            if (this.decipher) {
-                buf = this.decipher.update(buf);
-            }
+            if (this.state.decipher)
+                buf = this.state.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");
+            this.emit("destroy");
         });
         connection.once("close", () => {
-            if (this.status === ClientStatus.Disconnected)
-                return;
-            this.status = ClientStatus.Disconnected;
-            this.state = ClientState.Disconnected;
-            this.emit("disconnect", "socket close");
+            this.emit("destroy");
         });
     }
     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;
+        while (this.bufferPool.length > 0) {
             let decoder = new decoder_1.BinaryDecoder(this.bufferPool);
             let packetLength;
             try {
@@ -161,9 +89,9 @@ class TCPClient extends node_events_1.EventEmitter {
                 break;
             const expectedPacketEnd = decoder.offset + packetLength;
             let packetID;
-            if (this.compressionThreshold === 0)
+            if (this.state.compressionThreshold === 0)
                 packetID = decoder.readVarInt();
-            else if (this.compressionThreshold === -1) {
+            else if (this.state.compressionThreshold === -1) {
                 decoder.readVarInt();
                 packetID = decoder.readVarInt();
             }
@@ -175,523 +103,37 @@ class TCPClient extends node_events_1.EventEmitter {
                 else {
                     const dataBuffer = this.bufferPool.subarray(decoder.offset, expectedPacketEnd);
                     const decompressed = (0, node_zlib_1.inflateSync)(dataBuffer);
+                    if (decompressed.length !== dataLength)
+                        throw new error_1.UnexpectedValue("decompressed packet data", decompressed.length.toString(), dataLength.toString());
                     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.forwardPacket(packetID, decoder);
             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
-    */
+     * Send packet
+     */
     write(buf) {
-        if (this.status == ClientStatus.Disconnected || !this.socket.writable)
+        if (!this.socket.writable)
             throw new error_1.SockerIsNotWritable();
         let sendBuffer = buf;
-        if (this.cipher)
-            sendBuffer = this.cipher.update(sendBuffer);
+        if (this.state.cipher)
+            sendBuffer = this.state.cipher.update(sendBuffer);
         this.socket.write(sendBuffer);
     }
-    sendPacket(packetId, content) {
+    sendPacket(packetId, data) {
+        const { buffer: content, packet } = this.parsePacket(packetId, data);
         const encodePacketId = new encoder_1.BinaryEncoder();
-        encodePacketId.writeVarInt(packetId);
+        encodePacketId.writeVarInt(packet.id);
         const sendData = Buffer.concat([encodePacketId.getBuffer(), content]);
-        let packet;
-        if (this.compressionThreshold !== 0) {
+        let sendingPacket;
+        if (this.state.compressionThreshold !== 0) {
             let data;
             let uncompressedLength;
-            if (this.compressionThreshold > 0 && sendData.length > this.compressionThreshold) {
+            if (this.state.compressionThreshold > 0 && sendData.length > this.state.compressionThreshold) {
                 uncompressedLength = sendData.length;
                 data = (0, node_zlib_1.deflateSync)(sendData);
             }
@@ -704,134 +146,14 @@ class TCPClient extends node_events_1.EventEmitter {
             const dataLengthBuf = dataLengthEncoder.getBuffer();
             const packetLengthEncoder = new encoder_1.BinaryEncoder();
             packetLengthEncoder.writeVarInt(dataLengthBuf.length + data.length);
-            packet = Buffer.concat([packetLengthEncoder.getBuffer(), dataLengthBuf, data]);
+            sendingPacket = Buffer.concat([packetLengthEncoder.getBuffer(), dataLengthBuf, data]);
         }
         else {
             const packetLengthEncoder = new encoder_1.BinaryEncoder();
             packetLengthEncoder.writeVarInt(sendData.length);
-            packet = Buffer.concat([packetLengthEncoder.getBuffer(), sendData]);
+            sendingPacket = 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());
+        this.write(sendingPacket);
     }
 }
 exports.TCPClient = TCPClient;