@vaitosoi/minejs 0.2.1 → 0.3.1

package/src/packet/dispatcher.ts

@@ -0,0 +1,785 @@
+import zod from "zod";
+import { createCipheriv, createDecipheriv, createPublicKey, publicEncrypt, randomBytes, constants as crypto_constants } from "node:crypto";
+import { BlockEntity, ChunkSection, ClientPlayer, ClientStatus, ConnectionState, Entity, GameMode, PaletteContainer, ServerKnownPack, ServerWorld, SharedState } from "../world/state";
+import { BinaryDecoder, getTextFromTextComponent } from "./decoder";
+import { packBlockPos, SectionsPerChunk } from "../client/static";
+import { Vec3 } from "../physics/direction";
+import { ProtocolVersionMapping } from "../version/registry";
+import { TypedEmmiter } from "../base/event";
+import { ClientEvents } from "../client/client";
+import { makeMovementFlag } from "./encoder";
+
+function zodParse<Type extends zod.ZodType>(data: object, zod: Type): zod.infer<Type> {
+    return zod.parse(data);
+}
+
+export class Dispatcher {
+    private readonly mapping: Record<string, (data: object) => void>;
+
+    constructor(
+        private state: SharedState,
+        private emit: TypedEmmiter<ClientEvents>["emit"]
+    ) {
+        this.mapping = {
+            "login:login_disconnect": this.handleLoginDisconnect,
+            "login:hello": this.handleEncryption,
+            "login:login_finished": this.handleLoginSucess,
+            "login:login_compression": this.handleSetCompression,
+            "configuration:disconnect": this.handleConfiguarionPlayDisconnect,
+            "configuration:keep_alive": this.handleKeepAlive,
+            "configuration:registry_data": this.handleRegistryData,
+            "configuration:select_known_packs": this.handleKnownPack,
+            "configuration:finish_configuration": this.handleFinishConfiguration,
+            "play:add_entity": this.handleSpawnEntity,
+            "play:disconnect": this.handleConfiguarionPlayDisconnect,
+            "play:disguised_chat": this.handleDisguisedChatMessage,
+            "play:entity_position_sync": this.handleTeleportEntity,
+            "play:forget_level_chunk": this.handleUnloadChunk,
+            "play:keep_alive": this.handleKeepAlive,
+            "play:level_chunk_with_light": this.handleChunkData,
+            "play:login": this.handlePlayLogin,
+            "play:move_entity_pos": this.handleUpdateEntityPosition,
+            "play:move_entity_pos_rot": this.handleUpdateEntityPositionRotation,
+            "play:player_chat": this.handlePlayerChat,
+            "play:player_position": this.handleSynchronizePlayerPosition,
+            "play:remove_entities": this.handleRemoveEntity,
+            // "play:rotate_head": 
+            "play:set_action_bar_text": this.handleSetActionBar,
+            "play:set_entity_motion": this.handleSetEntityVelocity,
+            "play:system_chat": this.handleSystemMessage,
+        };
+    }
+
+    public sendPacket: (packetId: string, data: object) => void = (...args) => { throw new Error("method not implemented"); };
+    public tcpDisconnect: () => void = () => { throw new Error("method not implemented"); };
+
+
+    public handlePacket(packetId: string, data: object) {
+        if (packetId in this.mapping)
+            this.mapping[packetId]!.bind(this)(data);
+    }
+
+    // Login
+
+    private handleLoginDisconnect(data: object) {
+        const { reason } = zodParse(data, zod.object({ reason: zod.record(zod.string(), zod.any()) }));
+        const text = getTextFromTextComponent(reason);
+
+        this.state.enqueueMutation((state) => {
+            state.status = ClientStatus.Disconnected;
+            state.state = ConnectionState.Disconnected;
+            state.pruneStates();
+        });
+
+        this.emit("disconnect", text.toString());
+        this.emit("disconnectRaw", reason);
+        this.tcpDisconnect();
+    }
+
+    private handleEncryption(data: object) {
+        const {
+            server_id,
+            public_key,
+            verify_token,
+            shoudl_call_mojang
+        } = zodParse(data, zod.object({
+            server_id: zod.string(),
+            public_key: zod.array(zod.number()),
+            verify_token: zod.array(zod.number()),
+            shoudl_call_mojang: zod.boolean()
+        }));
+
+        const sharedSecret = randomBytes(16);
+        this.state.enqueueMutation((state) => {
+            state.sharedSecret = sharedSecret;
+            state.cipher = createCipheriv("aes-128-cfb8", state.sharedSecret, state.sharedSecret);
+            state.decipher = createDecipheriv("aes-128-cfb8", state.sharedSecret, state.sharedSecret);
+        });
+
+        this.sendEncryptionResponse(Buffer.from(public_key), Buffer.from(verify_token));
+    }
+
+    private handleSetCompression(data: object) {
+        const { threshold } = zodParse(data, zod.object({ threshold: zod.number() }));
+        if (threshold < 0) this.state.compressionThreshold = -1;
+        else this.state.compressionThreshold = threshold;
+    }
+
+    private handleLoginSucess(data: object) {
+        const { profile: { uuid, username } } = zodParse(data,
+            zod.object({
+                profile: zod.object({ uuid: zod.string(), username: zod.string() }),
+                session_id: zod.string()
+            }));
+        this.state.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,
+            }
+        } satisfies ClientPlayer as any;
+        this.sendLoginAck();
+    }
+
+    // Configure
+
+    private handleKnownPack(data: object) {
+        const { known_packs } = zodParse(data, zod.object({
+            known_packs: zod.array(zod.object({
+                namespace: zod.string(),
+                id: zod.string(),
+                version: zod.string(),
+            }))
+        }));
+        this.state.server!.knownPacks = known_packs satisfies ServerKnownPack[] as any;
+        this.sendKnownPack(this.state.clientOptions.loadRegistry === true ? [] : known_packs);
+        // this.sendKnownPack([]);
+    }
+
+    private handleRegistryData(data: object) {
+        const { registry_id, entries } = zodParse(data,
+            zod.object({
+                registry_id: zod.string(),
+                entries: zod.array(zod.object({
+                    entry_id: zod.string(),
+                    data: zod.record(zod.string(), zod.any()).nullable()
+                }))
+            })
+        );
+
+        if (!this.state.registry) this.state.registry = {} as any;
+        const registry = this.state.registry as Record<string, any[]>;
+        if (!(registry_id in registry)) registry[registry_id] = [];
+        registry[registry_id]!.push(...entries);
+    }
+
+    private handleFinishConfiguration(data: object) {
+        this.sendConfigureAck();
+    }
+
+    private handleConfiguarionPlayDisconnect(data: object) {
+        const { reason } = zodParse(data, zod.object({ reason: zod.record(zod.string(), zod.any()) }));
+        const text = getTextFromTextComponent(reason);
+
+        this.state.status = ClientStatus.Disconnected;
+        this.state.state = ConnectionState.Disconnected;
+        this.state.pruneStates();
+
+        this.emit("disconnect", text.toString());
+        this.emit("disconnectRaw", reason);
+        this.tcpDisconnect();
+    }
+
+    // Play
+
+    private handlePlayLogin(data: object) {
+        const {
+            entity_id,
+            is_hardcore,
+            dimension_names,
+            max_players,
+            view_distance,
+            simulation_distance,
+            dimension_name,
+            game_mode
+        } = zodParse(data,
+            zod.object({
+                entity_id: zod.int(),
+                is_hardcore: zod.boolean(),
+                dimension_names: zod.array(zod.string()),
+                max_players: zod.int(),
+                view_distance: zod.int(),
+                simulation_distance: zod.int(),
+                dimension_name: zod.string(),
+                game_mode: zod.int()
+            })
+        );
+
+
+        this.state.world = {
+            hardcore: is_hardcore,
+            dimensions: dimension_names,
+            maxPlayers: max_players,
+            viewDistance: view_distance,
+            simulationDistance: simulation_distance,
+            chunks: {},
+            entities: {}
+        } satisfies ServerWorld as any; // To avoid type conflict
+        this.state.player!.dimension = dimension_name;
+        this.state.player!.entityId = entity_id;
+        this.state.player!.gameMode = game_mode;
+        this.state.status = ClientStatus.Ready;
+
+        this.emit("ready");
+    }
+
+    private handleSynchronizePlayerPosition(data: object) {
+        const {
+            teleport_id,
+            x,
+            y,
+            z,
+            velocity_x,
+            velocity_y,
+            velocity_z,
+            yaw,
+            pitch,
+            flags
+        } = zodParse(data,
+            zod.object({
+                teleport_id: zod.int(),
+                x: zod.number(),
+                y: zod.number(),
+                z: zod.number(),
+                velocity_x: zod.number(),
+                velocity_y: zod.number(),
+                velocity_z: zod.number(),
+                yaw: zod.number(),
+                pitch: zod.number(),
+                flags: zod.object({
+                    x: zod.boolean(),
+                    y: zod.boolean(),
+                    z: zod.boolean(),
+                    yaw: zod.boolean(),
+                    pitch: zod.boolean(),
+                    velX: zod.boolean(),
+                    velY: zod.boolean(),
+                    velZ: zod.boolean(),
+                    rotateVelocity: zod.boolean(),
+                }),
+            })
+        );
+
+        const { position, velocity, angle } = this.state.player!;
+        let { x: newPosX, y: newPosY, z: newPosZ } = position;
+        let { x: newVelX, y: newVelY, z: newVelZ } = velocity;
+        let { yaw: newYaw, pitch: newPitch } = angle;
+        if (flags.x) newPosX += x; else newPosX = x;
+        if (flags.y) newPosY += y; else newPosY = y;
+        if (flags.z) newPosZ += z; else newPosZ = z;
+        if (flags.velX) newVelX += velocity_x; else newVelX = velocity_x;
+        if (flags.velY) newVelY += velocity_y; else newVelY = velocity_y;
+        if (flags.velZ) newVelZ += velocity_z; else newVelZ = velocity_z;
+        if (flags.yaw) newYaw += yaw; else newYaw = yaw;
+        if (flags.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.state.enqueueMutation(state =>
+            state.player = {
+                ...state.player!,
+                position: newPosition,
+                velocity: newVelocity,
+                angle: newAngle,
+            } satisfies ClientPlayer as any
+        );
+        this.state.enqueueEvent("playerPosition", { x: newPosX, y: newPosY, z: newPosZ });
+        this.sendConfirmTeleportation(teleport_id);
+        this.sendPacket("move_player_pos_rot", {
+            x: newPosition.x,
+            feet_y: newPosition.y,
+            z: newPosition.z,
+            yaw: newAngle.yaw,
+            pitch: newAngle.pitch,
+            flags: makeMovementFlag(true, false)
+        });
+    }
+
+    private handleKeepAlive(data: object) {
+        const { keep_alive_id } = zodParse(data,
+            zod.object({
+                keep_alive_id: zod.bigint().or(zod.number())
+            })
+        );
+        this.sendKeepAlive(BigInt(keep_alive_id));
+    }
+
+    private handleChangeGameMode(data: object) {
+        const { gameMode } = zodParse(data, zod.object({ gameMode: zod.number() }));
+        this.state.enqueueMutation(state => state.player!.gameMode = gameMode);
+    }
+
+    // Chunk
+    private handleChunkData(data_: object) {
+        const {
+            chunk_x,
+            chunk_z,
+            heightmaps,
+            data,
+            block_entities,
+            light,
+        } = zodParse(data_,
+            zod.object({
+                chunk_x: zod.int(),
+                chunk_z: zod.int(),
+                heightmaps: zod.array(zod.any()),
+                data: zod.array(zod.int()),
+                block_entities: zod.array(zod.object({
+                    packed_xz: zod.int(),
+                    y: zod.int(),
+                    type: zod.int(),
+                    data: zod.record(zod.string(), zod.any())
+                })),
+                light: zod.any(),
+            })
+        );
+
+        const chunkSections: Record<number, ChunkSection> = {};
+
+        const chunkDataDecoder = new BinaryDecoder(Buffer.from(data));
+        for (let height = 0; height < (SectionsPerChunk[this.state.player!.dimension] || 0); height++) {
+            const blockCount = chunkDataDecoder.readShort();
+            const fluidCount = chunkDataDecoder.readShort();
+
+            // Blocks
+            let blockStateBPE = chunkDataDecoder.readUByte();
+            let blockStatePalettes: number[] = [];
+
+            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: BigInt64Array | null = 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: number[] = [];
+            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: BigInt64Array | null = 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.state.enqueueEvent("loadChunk", chunk_x, height, chunk_z);
+        }
+
+        const blockEntitiesObj: Record<number, BlockEntity> = Object.fromEntries(
+            block_entities.map(val => [val.packed_xz, { type: val.type, data: val.data }])
+        );
+
+
+        this.state.enqueueMutation(state =>
+            state.world!.chunks[`${state.player!.dimension}:${chunk_x}:${chunk_z}`] = {
+                sections: chunkSections,
+                blockEntities: blockEntitiesObj
+            });
+    }
+
+    private handleUnloadChunk(data: object) {
+        const {
+            chunk_x,
+            chunk_z
+        } = zodParse(data, zod.object({
+            chunk_x: zod.number(),
+            chunk_z: zod.number()
+        }));
+        this.state.enqueueMutation(state => delete state.world!.chunks[`${state.player!.dimension}:${chunk_x}:${chunk_z}`]);
+        this.state.enqueueEvent("unloadChunk", chunk_x, chunk_z);
+    }
+
+    private handleBlockEntityData(data_: object) {
+        const {
+            location,
+            type,
+            data
+        } = zodParse(data_, zod.object({
+            location: zod.object({ x: zod.number(), y: zod.number(), z: zod.number() }),
+            type: zod.int(),
+            data: zod.record(zod.string(), zod.any())
+        }));
+
+        const chunkX = Math.floor(location.x / 16),
+            chunkZ = Math.floor(location.z / 16);
+        const xWitinChunk = location.x % 16,
+            zWitinChunk = location.z % 16;
+        const packedPosition = packBlockPos(xWitinChunk, location.y, zWitinChunk);
+        if (`${this.state.player!.dimension}:${chunkX}:${chunkZ}` in this.state.world!.chunks)
+            this.state.enqueueMutation(state =>
+                state.world!.chunks[`${state.player!.dimension}:${chunkX}:${chunkZ}`]!.blockEntities[packedPosition] = {
+                    type,
+                    data
+                }
+            );
+    }
+
+    // Entity
+    private handleSpawnEntity(data_: object) {
+        const {
+            entity_id,
+            entity_uuid,
+            type,
+            x,
+            y,
+            z,
+            velocity,
+            pitch,
+            yaw,
+            head_yaw,
+            data
+        } = zodParse(data_, zod.object({
+            entity_id: zod.int(),
+            entity_uuid: zod.string(),
+            type: zod.int(),
+            x: zod.number(),
+            y: zod.number(),
+            z: zod.number(),
+            velocity: zod.instanceof(Vec3),
+            pitch: zod.number(),
+            yaw: zod.number(),
+            head_yaw: zod.number(),
+            data: zod.int(),
+        }));
+
+        const entity: Entity = {
+            id: entity_id,
+            type,
+            position: { x, y, z },
+            velocity,
+            angle: {
+                pitch,
+                yaw
+            },
+            data
+        };
+        this.state.enqueueMutation(state => state.world!.entities[entity_id] = entity);
+        this.state.enqueueEvent("spawnEntity", entity);
+    }
+
+    private handleTeleportEntity(data: object) {
+        const {
+            entity_id,
+            x,
+            y,
+            z,
+            velocity_x,
+            velocity_y,
+            velocity_z,
+            pitch,
+            yaw
+        } = zodParse(data, zod.object({
+            entity_id: zod.int(),
+            x: zod.number(),
+            y: zod.number(),
+            z: zod.number(),
+            velocity_x: zod.number(),
+            velocity_y: zod.number(),
+            velocity_z: zod.number(),
+            pitch: zod.number(),
+            yaw: zod.number(),
+        }));
+
+        if (entity_id in this.state.world!.entities) this.state.enqueueMutation(state => {
+            state.world!.entities[entity_id]!.position = { x, y, z };
+            state.world!.entities[entity_id]!.velocity = { x: velocity_x, y: velocity_y, z: velocity_z };
+            state.world!.entities[entity_id]!.angle = { pitch, yaw };
+        });
+        this.state.enqueueEvent("updateEntity", entity_id);
+    }
+
+    private handleUpdateEntityPosition(data: object) {
+        const {
+            entity_id,
+            delta_x,
+            delta_y,
+            delta_z
+        } = zodParse(data, zod.object({
+            entity_id: zod.number(),
+            delta_x: zod.number(),
+            delta_y: zod.number(),
+            delta_z: zod.number(),
+        }));
+
+        if (entity_id in this.state.world!.entities) this.state.enqueueMutation(state => {
+            let { x, y, z } = state.world!.entities[entity_id]!.position;
+            x += delta_x;
+            y += delta_y;
+            z += delta_z;
+            state.world!.entities[entity_id]!.position = { x, y, z };
+        });
+        this.state.enqueueEvent("updateEntity", entity_id);
+    }
+
+    private handleUpdateEntityPositionRotation(data: object) {
+        const {
+            entity_id,
+            delta_x,
+            delta_y,
+            delta_z,
+            pitch,
+            yaw
+        } = zodParse(data, zod.object({
+            entity_id: zod.number(),
+            delta_x: zod.number(),
+            delta_y: zod.number(),
+            delta_z: zod.number(),
+            pitch: zod.number(),
+            yaw: zod.number(),
+        }));
+        if (entity_id in this.state.world!.entities) {
+            this.state.enqueueMutation(state => {
+                let { x, y, z } = state.world!.entities[entity_id]!.position;
+                x += delta_x;
+                y += delta_y;
+                z += delta_z;
+                state.world!.entities[entity_id]!.position = { x, y, z };
+                state.world!.entities[entity_id]!.angle = { yaw, pitch };
+            });
+            this.state.enqueueEvent("updateEntity", entity_id);
+        }
+    }
+
+    private handleSetEntityVelocity(data: object) {
+        const { entity_id, velocity } = zodParse(data, zod.object({
+            entity_id: zod.number(),
+            velocity: zod.instanceof(Vec3)
+        }));
+
+        if (entity_id in this.state.world!.entities)
+            this.state.enqueueMutation(state => state.world!.entities[entity_id]!.velocity = velocity);
+    }
+
+    private handleRemoveEntity(data: object) {
+        const { entity_ids } = zodParse(data, zod.object({ entity_ids: zod.array(zod.number()) }));
+
+        this.state.enqueueMutation(state => {
+            for (const entityId of entity_ids) {
+                delete state.world!.entities[entityId];
+                this.state.enqueueEvent("removeEntity", entityId);
+            }
+        });
+    }
+
+    // Chat
+    private handlePlayerChat(data: object) {
+        const {
+            global_index,
+            sender,
+            index,
+            message_signature_bytes,
+            message,
+            timestamp,
+            salt,
+            previous_messages,
+            unsigned_content,
+            filter_type,
+            filter_type_bits,
+            chat_type,
+            sender_name,
+            target_name
+        } = zodParse(data, zod.object({
+            global_index: zod.int(),
+            sender: zod.string(),
+            index: zod.int(),
+            message_signature_bytes: zod.array(zod.number()).nullable(),
+            message: zod.string(),
+            timestamp: zod.bigint(),
+            salt: zod.bigint(),
+            previous_messages: zod.array(zod.object({
+                message_id: zod.number(),
+                signature: zod.array(zod.number()).optional()
+            })),
+            unsigned_content: zod.record(zod.string(), zod.any()).nullable(),
+            filter_type: zod.int(),
+            filter_type_bits: zod.array(zod.bigint()).nullable(),
+            chat_type: zod.int().or(zod.record(zod.string(), zod.any())),
+            sender_name: zod.record(zod.string(), zod.any()),
+            target_name: zod.record(zod.string(), zod.any()).nullable()
+        }));
+
+        const senderNameText = getTextFromTextComponent(sender_name).toString(),
+            targetNameText = target_name ? getTextFromTextComponent(target_name).toString() : undefined;
+
+        this.emit("message", {
+            sender: senderNameText,
+            target: targetNameText,
+            content: message,
+            raw: {
+                sender: sender_name,
+                target: target_name || undefined,
+                content: unsigned_content || undefined,
+            }
+        });
+    }
+
+    private handleSystemMessage(data: object) {
+        const {
+            content,
+            overlay: isActionbar
+        } = zodParse(data, zod.object({
+            content: zod.record(zod.string(), zod.any()),
+            overlay: zod.boolean()
+        }));
+        const text = getTextFromTextComponent(content);
+
+        if (isActionbar) {
+            this.emit("actionBar", text.toString());
+            this.emit("actionBarRaw", content);
+        } else {
+            this.emit("systemMessage", text.toString());
+            this.emit("systemMessageRaw", content);
+        }
+    }
+
+    private handleSetActionBar(data: object) {
+        const { action_bar_text: content } = zodParse(data, zod.object({ action_bar_text: zod.record(zod.string(), zod.any()) }));
+        const text = getTextFromTextComponent(content);
+        this.emit("actionBar", text.toString());
+        this.emit("actionBarRaw", content);
+    }
+
+    private handleDisguisedChatMessage(data: object) {
+        const {
+            message,
+            chatType,
+            senderName,
+            targetName
+        } = zodParse(data, zod.object({
+            message: zod.record(zod.string(), zod.any()),
+            chatType: zod.string().or(zod.record(zod.string(), zod.any())),
+            senderName: zod.record(zod.string(), zod.any()),
+            targetName: zod.record(zod.string(), zod.any()).nullable(),
+        }));
+        const messageText = getTextFromTextComponent(message).toString(),
+            senderNameText = getTextFromTextComponent(senderName).toString(),
+            targetNameText = targetName ? getTextFromTextComponent(targetName).toString() : undefined;
+        this.emit("message", {
+            sender: senderNameText,
+            target: targetNameText,
+            content: messageText,
+            raw: {
+                sender: senderName,
+                target: targetName || undefined,
+                content: message,
+            }
+        });
+    }
+
+    /*
+    * Send packet 
+    */
+
+    // Login
+
+    public sendHandshake() {
+        this.state.state = ConnectionState.Handshake;
+        this.sendPacket("intention",
+            {
+                protocol_version: ProtocolVersionMapping[this.state.clientOptions.version]!,
+                server_address: this.state.clientOptions.host,
+                server_port: this.state.clientOptions.port,
+                intent: 2
+            }
+        );
+    }
+
+    public sendLoginStart() {
+        this.state.state = ConnectionState.Login;
+        this.state.status = ClientStatus.Logining;
+        this.sendPacket("hello", {
+            name: this.state.clientOptions.playerName,
+            player_uuid: this.state.getUuid()
+        });
+    }
+
+    private sendEncryptionResponse(publicKey: Buffer, verifyToken: Buffer) {
+        const encryptedSecret = publicEncrypt({
+            key: createPublicKey({ key: publicKey, format: 'der', type: 'spki' }),
+            padding: crypto_constants.RSA_PKCS1_PADDING
+        }, this.state.sharedSecret!);
+        const encryptedVerifyToken = publicEncrypt({
+            key: createPublicKey({ key: publicKey, format: 'der', type: 'spki' }),
+            padding: crypto_constants.RSA_PKCS1_PADDING
+        }, verifyToken);
+        this.sendPacket("key", {
+            shared_secret: { value: encryptedSecret, length: 8 },
+            verify_token: { value: encryptedVerifyToken, length: 8 }
+        });
+    }
+
+    private sendLoginAck() {
+        this.sendPacket("login_acknowledged", {});
+        this.state.state = ConnectionState.Configure;
+        this.state.server = {};
+    }
+
+    // Configuring
+
+    private sendKnownPack(knownPacks: ServerKnownPack[]) {
+        this.sendPacket("select_known_packs", {
+            known_packs: {
+                value: knownPacks,
+                length: knownPacks.length
+            }
+        });
+    }
+
+    private sendConfigureAck() {
+        this.sendPacket("finish_configuration", {});
+        this.state.state = ConnectionState.Play;
+    }
+
+    // Play
+
+    private sendConfirmTeleportation(teleportId: number) {
+        this.sendPacket("accept_teleportation", {
+            teleport_id: teleportId
+        });
+    }
+
+    private sendKeepAlive(id: bigint) {
+        this.sendPacket("keep_alive", {
+            keep_alive_id: id
+        });
+    }
+}