@vaitosoi/minejs 0.2.2 → 0.4.0

package/dist/packet/dispatcher.js

@@ -0,0 +1,738 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dispatcher = void 0;
+const zod_1 = __importDefault(require("zod"));
+const node_crypto_1 = require("node:crypto");
+const state_1 = require("../world/state");
+const decoder_1 = require("./decoder");
+const static_1 = require("../client/static");
+const direction_1 = require("../physics/direction");
+const registry_1 = require("../version/registry");
+const encoder_1 = require("./encoder");
+const error_1 = require("../base/error");
+const math_1 = require("../base/math");
+const link_1 = require("../message/link");
+const buffer_1 = require("../base/buffer");
+function zodParse(data, zod) {
+    return zod.parse(data);
+}
+class Dispatcher {
+    state;
+    emit;
+    mapping;
+    constructor(state, emit) {
+        this.state = state;
+        this.emit = 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,
+        };
+    }
+    sendPacket = () => { throw new error_1.NotImplemented(); };
+    disconnect = () => { throw new error_1.NotImplemented(); };
+    handlePacket(packetId, data) {
+        if (packetId in this.mapping)
+            this.mapping[packetId].bind(this)(data);
+    }
+    // Login
+    handleLoginDisconnect(data) {
+        const { reason } = zodParse(data, zod_1.default.object({ reason: zod_1.default.record(zod_1.default.string(), zod_1.default.any()) }));
+        const text = (0, decoder_1.getTextFromTextComponent)(reason);
+        this.disconnect(text, reason);
+    }
+    handleEncryption(data) {
+        const { server_id, public_key, verify_token, should_authenticate } = zodParse(data, zod_1.default.object({
+            server_id: zod_1.default.string(),
+            public_key: zod_1.default.array(zod_1.default.number()),
+            verify_token: zod_1.default.array(zod_1.default.number()),
+            should_authenticate: zod_1.default.boolean()
+        }));
+        const sharedSecret = (0, node_crypto_1.randomBytes)(16);
+        this.state.sharedSecret = sharedSecret;
+        this.state.cipher = (0, node_crypto_1.createCipheriv)("aes-128-cfb8", sharedSecret, sharedSecret);
+        this.state.decipher = (0, node_crypto_1.createDecipheriv)("aes-128-cfb8", sharedSecret, sharedSecret);
+        this.state.useEncryption = true;
+        const publicKey = Buffer.from(public_key), verifyToken = Buffer.from(verify_token);
+        if (should_authenticate)
+            if (!this.state.authClient)
+                throw new error_1.AuthRelatedNotFound("auth client");
+            else
+                this.state.authClient.sendAuth(server_id, sharedSecret, publicKey)
+                    .then(() => this.sendEncryptionResponse(publicKey, verifyToken));
+        else
+            this.sendEncryptionResponse(publicKey, verifyToken);
+    }
+    handleSetCompression(data) {
+        const { threshold } = zodParse(data, zod_1.default.object({ threshold: zod_1.default.number() }));
+        if (threshold < 0)
+            this.state.compressionThreshold = -1;
+        else
+            this.state.compressionThreshold = threshold;
+    }
+    handleLoginSucess(data) {
+        const { profile: { uuid, username } } = zodParse(data, zod_1.default.object({
+            profile: zod_1.default.object({ uuid: zod_1.default.string(), username: zod_1.default.string() }),
+            session_id: zod_1.default.string()
+        }));
+        this.state.player = {
+            uuid,
+            username,
+            entityId: 0,
+            dimension: "",
+            gameMode: state_1.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(data) {
+        const { known_packs } = zodParse(data, zod_1.default.object({
+            known_packs: zod_1.default.array(zod_1.default.object({
+                namespace: zod_1.default.string(),
+                id: zod_1.default.string(),
+                version: zod_1.default.string(),
+            }))
+        }));
+        this.state.server.knownPacks = known_packs;
+        this.sendKnownPack(this.state.clientOptions.loadRegistry === true ? [] : known_packs);
+        // this.sendKnownPack([]);
+    }
+    handleRegistryData(data) {
+        const { registry_id, entries } = zodParse(data, zod_1.default.object({
+            registry_id: zod_1.default.string(),
+            entries: zod_1.default.array(zod_1.default.object({
+                entry_id: zod_1.default.string(),
+                data: zod_1.default.record(zod_1.default.string(), zod_1.default.any()).nullable()
+            }))
+        }));
+        if (!this.state.registry)
+            this.state.registry = {};
+        const registry = this.state.registry;
+        if (!(registry_id in registry))
+            registry[registry_id] = [];
+        registry[registry_id].push(...entries);
+    }
+    handleFinishConfiguration(data) {
+        this.sendConfigureAck();
+    }
+    handleConfiguarionPlayDisconnect(data) {
+        const { reason } = zodParse(data, zod_1.default.object({ reason: zod_1.default.record(zod_1.default.string(), zod_1.default.any()) }));
+        const text = (0, decoder_1.getTextFromTextComponent)(reason);
+        this.disconnect(text, reason);
+    }
+    // Play
+    handlePlayLogin(data) {
+        const { entity_id, is_hardcore, dimension_names, max_players, view_distance, simulation_distance, dimension_name, game_mode } = zodParse(data, zod_1.default.object({
+            entity_id: zod_1.default.int(),
+            is_hardcore: zod_1.default.boolean(),
+            dimension_names: zod_1.default.array(zod_1.default.string()),
+            max_players: zod_1.default.int(),
+            view_distance: zod_1.default.int(),
+            simulation_distance: zod_1.default.int(),
+            dimension_name: zod_1.default.string(),
+            game_mode: zod_1.default.int()
+        }));
+        this.state.world = {
+            hardcore: is_hardcore,
+            dimensions: dimension_names,
+            maxPlayers: max_players,
+            viewDistance: view_distance,
+            simulationDistance: simulation_distance,
+            chunks: {},
+            entities: {}
+        }; // 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 = state_1.ClientStatus.Ready;
+        if (this.state.useEncryption)
+            this.sendPlayerSession();
+        this.emit("ready");
+    }
+    handleSynchronizePlayerPosition(data) {
+        const { teleport_id, x, y, z, velocity_x, velocity_y, velocity_z, yaw, pitch, flags } = zodParse(data, zod_1.default.object({
+            teleport_id: zod_1.default.int(),
+            x: zod_1.default.number(),
+            y: zod_1.default.number(),
+            z: zod_1.default.number(),
+            velocity_x: zod_1.default.number(),
+            velocity_y: zod_1.default.number(),
+            velocity_z: zod_1.default.number(),
+            yaw: zod_1.default.number(),
+            pitch: zod_1.default.number(),
+            flags: zod_1.default.object({
+                x: zod_1.default.boolean(),
+                y: zod_1.default.boolean(),
+                z: zod_1.default.boolean(),
+                yaw: zod_1.default.boolean(),
+                pitch: zod_1.default.boolean(),
+                velX: zod_1.default.boolean(),
+                velY: zod_1.default.boolean(),
+                velZ: zod_1.default.boolean(),
+                rotateVelocity: zod_1.default.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,
+        });
+        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: (0, encoder_1.makeMovementFlag)(true, false)
+        });
+    }
+    handleKeepAlive(data) {
+        const { keep_alive_id } = zodParse(data, zod_1.default.object({
+            keep_alive_id: zod_1.default.bigint().or(zod_1.default.number())
+        }));
+        this.sendKeepAlive(BigInt(keep_alive_id));
+    }
+    handleChangeGameMode(data) {
+        const { gameMode } = zodParse(data, zod_1.default.object({ gameMode: zod_1.default.number() }));
+        this.state.enqueueMutation(state => state.player.gameMode = gameMode);
+    }
+    // Chunk
+    handleChunkData(data_) {
+        const { chunk_x, chunk_z, heightmaps, data, block_entities, light, } = zodParse(data_, zod_1.default.object({
+            chunk_x: zod_1.default.int(),
+            chunk_z: zod_1.default.int(),
+            heightmaps: zod_1.default.array(zod_1.default.any()),
+            data: zod_1.default.array(zod_1.default.int()),
+            block_entities: zod_1.default.array(zod_1.default.object({
+                packed_xz: zod_1.default.int(),
+                y: zod_1.default.int(),
+                type: zod_1.default.int(),
+                data: zod_1.default.record(zod_1.default.string(), zod_1.default.any())
+            })),
+            light: zod_1.default.any(),
+        }));
+        const chunkSections = {};
+        const chunkDataDecoder = new decoder_1.BinaryDecoder(Buffer.from(data));
+        for (let height = 0; height < (static_1.SectionsPerChunk[this.state.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.state.enqueueEvent("loadChunk", chunk_x, height, chunk_z);
+        }
+        const blockEntitiesObj = 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
+        });
+    }
+    handleUnloadChunk(data) {
+        const { chunk_x, chunk_z } = zodParse(data, zod_1.default.object({
+            chunk_x: zod_1.default.number(),
+            chunk_z: zod_1.default.number()
+        }));
+        this.state.enqueueMutation(state => delete state.world.chunks[`${state.player.dimension}:${chunk_x}:${chunk_z}`]);
+        this.state.enqueueEvent("unloadChunk", chunk_x, chunk_z);
+    }
+    handleBlockEntityData(data_) {
+        const { location, type, data } = zodParse(data_, zod_1.default.object({
+            location: zod_1.default.object({ x: zod_1.default.number(), y: zod_1.default.number(), z: zod_1.default.number() }),
+            type: zod_1.default.int(),
+            data: zod_1.default.record(zod_1.default.string(), zod_1.default.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 = (0, static_1.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
+    handleSpawnEntity(data_) {
+        const { entity_id, entity_uuid, type, x, y, z, velocity, pitch, yaw, head_yaw, data } = zodParse(data_, zod_1.default.object({
+            entity_id: zod_1.default.int(),
+            entity_uuid: zod_1.default.string(),
+            type: zod_1.default.int(),
+            x: zod_1.default.number(),
+            y: zod_1.default.number(),
+            z: zod_1.default.number(),
+            velocity: zod_1.default.instanceof(direction_1.Vec3),
+            pitch: zod_1.default.number(),
+            yaw: zod_1.default.number(),
+            head_yaw: zod_1.default.number(),
+            data: zod_1.default.int(),
+        }));
+        const 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);
+    }
+    handleTeleportEntity(data) {
+        const { entity_id, x, y, z, velocity_x, velocity_y, velocity_z, pitch, yaw } = zodParse(data, zod_1.default.object({
+            entity_id: zod_1.default.int(),
+            x: zod_1.default.number(),
+            y: zod_1.default.number(),
+            z: zod_1.default.number(),
+            velocity_x: zod_1.default.number(),
+            velocity_y: zod_1.default.number(),
+            velocity_z: zod_1.default.number(),
+            pitch: zod_1.default.number(),
+            yaw: zod_1.default.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);
+    }
+    handleUpdateEntityPosition(data) {
+        const { entity_id, delta_x, delta_y, delta_z } = zodParse(data, zod_1.default.object({
+            entity_id: zod_1.default.number(),
+            delta_x: zod_1.default.number(),
+            delta_y: zod_1.default.number(),
+            delta_z: zod_1.default.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);
+    }
+    handleUpdateEntityPositionRotation(data) {
+        const { entity_id, delta_x, delta_y, delta_z, pitch, yaw } = zodParse(data, zod_1.default.object({
+            entity_id: zod_1.default.number(),
+            delta_x: zod_1.default.number(),
+            delta_y: zod_1.default.number(),
+            delta_z: zod_1.default.number(),
+            pitch: zod_1.default.number(),
+            yaw: zod_1.default.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);
+        }
+    }
+    handleSetEntityVelocity(data) {
+        const { entity_id, velocity } = zodParse(data, zod_1.default.object({
+            entity_id: zod_1.default.number(),
+            velocity: zod_1.default.instanceof(direction_1.Vec3)
+        }));
+        if (entity_id in this.state.world.entities)
+            this.state.enqueueMutation(state => state.world.entities[entity_id].velocity = velocity);
+    }
+    handleRemoveEntity(data) {
+        const { entity_ids } = zodParse(data, zod_1.default.object({ entity_ids: zod_1.default.array(zod_1.default.number()) }));
+        this.state.enqueueMutation(state => {
+            for (const entityId of entity_ids) {
+                delete state.world.entities[entityId];
+                this.state.enqueueEvent("removeEntity", entityId);
+            }
+        });
+    }
+    // Chat
+    handlePlayerChat(data) {
+        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_1.default.object({
+            global_index: zod_1.default.int(),
+            sender: zod_1.default.string(),
+            index: zod_1.default.int(),
+            message_signature_bytes: zod_1.default.array(zod_1.default.number()).nullable(),
+            message: zod_1.default.string(),
+            timestamp: zod_1.default.bigint(),
+            salt: zod_1.default.bigint(),
+            previous_messages: zod_1.default.array(zod_1.default.object({
+                message_id: zod_1.default.number(),
+                signature: zod_1.default.array(zod_1.default.number()).optional()
+            })),
+            unsigned_content: zod_1.default.record(zod_1.default.string(), zod_1.default.any()).nullable(),
+            filter_type: zod_1.default.int(),
+            filter_type_bits: zod_1.default.array(zod_1.default.bigint()).nullable(),
+            chat_type: zod_1.default.int().or(zod_1.default.record(zod_1.default.string(), zod_1.default.any())),
+            sender_name: zod_1.default.record(zod_1.default.string(), zod_1.default.any()),
+            target_name: zod_1.default.record(zod_1.default.string(), zod_1.default.any()).nullable()
+        }));
+        const senderNameText = (0, decoder_1.getTextFromTextComponent)(sender_name).toString(), targetNameText = target_name ? (0, decoder_1.getTextFromTextComponent)(target_name).toString() : undefined;
+        const emitObject = {
+            sender: senderNameText,
+            target: targetNameText,
+            content: (0, decoder_1.getTextFromTextComponent)(unsigned_content),
+            raw: {
+                sender: sender_name,
+                target: target_name || undefined,
+                content: unsigned_content || undefined,
+            }
+        };
+        let link = undefined;
+        if (this.state.clientOptions.shouldVerifyMessageOrder && this.state.messageLinks) {
+            if (index === 0) {
+                if (this.state.sessionID)
+                    link = link_1.MessageLink.root(sender, this.state.sessionID.toString("hex"));
+                else
+                    link = link_1.MessageLink.unsinged(sender);
+                this.state.messageLinks[sender] = link;
+            }
+            else {
+                const oldLink = this.state.messageLinks[sender];
+                if (!oldLink)
+                    throw new error_1.MessageLinkNotFound(sender);
+                let newLink;
+                if (this.state.sessionID)
+                    newLink = new link_1.MessageLink(global_index, sender, this.state.sessionID.toString("hex"));
+                else
+                    newLink = link_1.MessageLink.unsinged(sender);
+                if (!newLink.isDescendantOf(oldLink))
+                    throw new error_1.UnexpectedValue("message order", newLink.index.toString(), (oldLink.index + 1).toString());
+                this.state.messageLinks[sender] = newLink;
+                link = newLink;
+            }
+        }
+        if (this.state.clientOptions.shouldVerifyMessageSignature === true && message_signature_bytes) {
+            if (!this.state.sessionID)
+                throw new error_1.AuthRelatedNotFound("session uuid");
+            if (!this.state.messageSignatureCache)
+                throw new error_1.AuthRelatedNotFound("signature cache");
+            if (!link)
+                throw new error_1.HaveSignatureButNotIndex();
+            const { publicKey } = this.state.getSignature();
+            const formatVersion = Buffer.alloc(4);
+            formatVersion.writeInt32BE(1);
+            const senderUUIDBuf = (0, math_1.uuidToBuffer)(sender);
+            const sessionUUIDBuf = this.state.sessionID;
+            const indexBuf = Buffer.alloc(4);
+            indexBuf.writeInt32BE(link.index);
+            const saltBuf = Buffer.alloc(8);
+            saltBuf.writeBigInt64BE(salt);
+            const timestampBuf = Buffer.alloc(8);
+            timestampBuf.writeBigInt64BE(timestamp);
+            const _messageBuf = Buffer.from(message, "utf-8");
+            const lengthBuf = Buffer.alloc(4);
+            lengthBuf.writeInt32BE(_messageBuf.length);
+            const messageBuf = _messageBuf;
+            const previousMessagesLenghtBuf = Buffer.alloc(4);
+            previousMessagesLenghtBuf.writeInt32BE(previous_messages.length);
+            const previousMessagesBuf = Buffer.concat(this.state.messageSignatureCache.unpack(previous_messages));
+            const signaturePayload = Buffer.concat([
+                formatVersion,
+                senderUUIDBuf,
+                sessionUUIDBuf,
+                indexBuf,
+                saltBuf,
+                timestampBuf,
+                lengthBuf,
+                messageBuf,
+                previousMessagesLenghtBuf,
+                previousMessagesBuf
+            ]);
+            const verify = (0, node_crypto_1.createVerify)("RSA-SHA256");
+            verify.update(signaturePayload);
+            verify.end();
+            const signature = Buffer.from(message_signature_bytes);
+            if (!verify.verify(publicKey, signature))
+                this.emit("failedMessage", emitObject);
+        }
+        this.emit("message", emitObject);
+    }
+    handleSystemMessage(data) {
+        const { content, overlay: isActionbar } = zodParse(data, zod_1.default.object({
+            content: zod_1.default.record(zod_1.default.string(), zod_1.default.any()),
+            overlay: zod_1.default.boolean()
+        }));
+        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(data) {
+        const { action_bar_text: content } = zodParse(data, zod_1.default.object({ action_bar_text: zod_1.default.record(zod_1.default.string(), zod_1.default.any()) }));
+        const text = (0, decoder_1.getTextFromTextComponent)(content);
+        this.emit("actionBar", text.toString());
+        this.emit("actionBarRaw", content);
+    }
+    handleDisguisedChatMessage(data) {
+        const { message, chatType, senderName, targetName } = zodParse(data, zod_1.default.object({
+            message: zod_1.default.record(zod_1.default.string(), zod_1.default.any()),
+            chatType: zod_1.default.string().or(zod_1.default.record(zod_1.default.string(), zod_1.default.any())),
+            senderName: zod_1.default.record(zod_1.default.string(), zod_1.default.any()),
+            targetName: zod_1.default.record(zod_1.default.string(), zod_1.default.any()).nullable(),
+        }));
+        const messageText = (0, decoder_1.getTextFromTextComponent)(message).toString(), senderNameText = (0, decoder_1.getTextFromTextComponent)(senderName).toString(), targetNameText = targetName ? (0, decoder_1.getTextFromTextComponent)(targetName).toString() : undefined;
+        this.emit("message", {
+            sender: senderNameText,
+            target: targetNameText,
+            content: messageText,
+            raw: {
+                sender: senderName,
+                target: targetName || undefined,
+                content: message,
+            }
+        });
+    }
+    /*
+    * Send packet
+    */
+    // Login
+    sendHandshake() {
+        this.state.state = state_1.ConnectionState.Handshake;
+        this.sendPacket("intention", {
+            protocol_version: registry_1.ProtocolVersionMapping[this.state.clientOptions.version],
+            server_address: this.state.clientOptions.host,
+            server_port: this.state.clientOptions.port,
+            intent: 2
+        });
+    }
+    sendLoginStart() {
+        this.state.state = state_1.ConnectionState.Login;
+        this.state.status = state_1.ClientStatus.Logining;
+        this.sendPacket("hello", {
+            name: this.state.clientOptions.playerName,
+            player_uuid: Buffer.from(this.state.playerUUID, "hex")
+        });
+    }
+    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.state.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 secretBuf = (0, buffer_1.sliceBuffer)(encryptedSecret, 1, (buf) => buf.readInt8());
+        const token = (0, buffer_1.sliceBuffer)(encryptedVerifyToken, 1, (buf) => buf.readInt8());
+        this.sendPacket("key", {
+            shared_secret: { value: secretBuf, length: secretBuf.length },
+            verify_token: { value: token, length: token.length }
+        });
+    }
+    sendLoginAck() {
+        this.sendPacket("login_acknowledged", {});
+        this.state.state = state_1.ConnectionState.Configure;
+        this.state.server = {};
+    }
+    // Configuring
+    sendKnownPack(knownPacks) {
+        this.sendPacket("select_known_packs", {
+            known_packs: {
+                value: knownPacks,
+                length: knownPacks.length
+            }
+        });
+    }
+    sendConfigureAck() {
+        this.sendPacket("finish_configuration", {});
+        this.state.state = state_1.ConnectionState.Play;
+    }
+    // Play
+    sendPlayerSession() {
+        const sessionUUID = (0, math_1.randomUUIDBytes)();
+        const expireTime = 15 * 60 * 1000; // 15min in ms
+        const expiredAt = Date.now() + expireTime;
+        const { publicKey, signature } = this.state.getSignature();
+        this.state.sessionID = sessionUUID;
+        this.sendPacket("chat_session_update", {
+            session_id: sessionUUID,
+            expire_at: expiredAt,
+            public_key: publicKey,
+            signature
+        });
+    }
+    sendConfirmTeleportation(teleportId) {
+        this.sendPacket("accept_teleportation", {
+            teleport_id: teleportId
+        });
+    }
+    sendKeepAlive(id) {
+        this.sendPacket("keep_alive", {
+            keep_alive_id: id
+        });
+    }
+    sendPlayerPos(position, onGround, horizontalCollision) {
+        const { x, y, z } = position;
+        this.state.enqueuePacket("move_player_pos", {
+            x, feet_y: y, z,
+            flags: (0, encoder_1.makeMovementFlag)(onGround, horizontalCollision)
+        });
+    }
+    sendPlayerPosRot(position, angle, onGround, horizontalCollision) {
+        const { x, y, z } = position, { yaw, pitch } = angle;
+        this.state.enqueuePacket("move_player_pos_rot", {
+            x, feet_y: y, z,
+            yaw, pitch,
+            flags: (0, encoder_1.makeMovementFlag)(onGround, horizontalCollision)
+        });
+    }
+    sendPlayerRot(angle, onGround, horizontalCollision) {
+        const { yaw, pitch } = angle;
+        this.state.enqueuePacket("move_player_rot", {
+            yaw, pitch,
+            flags: (0, encoder_1.makeMovementFlag)(onGround, horizontalCollision)
+        });
+    }
+    sendPlayerStatus(onGround, horizontalCollision) {
+        this.state.enqueuePacket("move_player_status_only", {
+            flags: (0, encoder_1.makeMovementFlag)(onGround, horizontalCollision)
+        });
+    }
+}
+exports.Dispatcher = Dispatcher;
+//# sourceMappingURL=dispatcher.js.map