@vaitosoi/minejs 0.4.2 → 0.5.0

package/src/client/client.ts

@@ -3,17 +3,19 @@ import { BlockManager, BlockState } from "../world/block";
 import { EntitiesManager } from "../world/entity";
 import { Input, Player } from "../physics/player";
 import { TickLoop } from "../world/tick";
-import { Message, TCPClient, TCPClientOption } from "./tcp";
+import { Message, TCPClient, TCPClientOption } from "../net/tcp";
 import { TypedEmmiter as TypedEmitter } from "../base/event";
-import { BlockRegistry, EntityRegistry, PacketRegistry, ProtocolVersionMapping } from "../version/registry";
+import { BlockRegistry, EffectRegistry, EntityRegistry, PacketRegistry, ProtocolVersionMapping } from "../version/registry";
 import { BaseVec3, Vec3 } from "../physics/direction";
-import { TextComponent } from "../base/typing";
+import { RegistryData, TextComponent } from "../base/typing";
 import { ClientStatus, ConnectionState, EmittedEvent as EmittedEvent, Entity, SharedState } from "../world/state";
-import { Dispatcher } from "../packet/dispatcher";
+import { Listener } from "../packet/listener";
 import { VersionCodec } from "../version/codec";
 import { AuthClient } from "./auth";
 import { computeUUID } from "../base/math";
 import { HaveSignatureButNotIndex } from "../base/error";
+import { Sender } from "../packet/sender";
+import { CacheImplementation } from "../base/cache";
 
 export type ClientOption = Omit<TCPClientOption, "protocolVersion"> & {
     version: string,
@@ -23,12 +25,26 @@ export type ClientOption = Omit<TCPClientOption, "protocolVersion"> & {
      * 
      * When set this option to true, you HAVE TO set `shouldVerifyMessageOrder` to true
      */
-    shouldVerifyMessageSignature?: boolean
+    shouldVerifyMessageSignature?: boolean,
 
     /**
      * Should verify the message orders to keep the sync with server.
      */
-    shouldVerifyMessageOrder?: boolean
+    shouldVerifyMessageOrder?: boolean,
+
+    /**
+     * Whether to load the whole chunk section (16x16x16) and keep them in the cache or just load the needed block.
+     * 
+     * Please consider this carefully since this can consume a lot of resource to calculate the whole chunk section and store it while you may not need that much.
+     * 
+     * This option is useful when you have to constantly access to the world chunk, e.g pathfinding.
+     */
+    loadAndCacheChunk?: boolean,
+
+    /**
+     * Custom cache class. Default to `LRUCache`
+     */
+    cacheImplementation?: new () => CacheImplementation<Uint16Array>,
 }
 
 export interface ClientEvents {
@@ -71,6 +87,8 @@ export interface ClientEvents {
     updateEntity: [entityId: number],
     /** When an entity go out of client view distance or despawned */
     removeEntity: [entityId: number],
+    /** The registry_data packet */
+    registryData: [data: RegistryData],
 
     // Chat
     /** When a chat message got broadcasted */
@@ -101,6 +119,8 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
 
     private tcp: TCPClient;
     private state: SharedState<IsReady>;
+    private packetListener: Listener;
+    private packetSender: Sender;
 
     constructor(private options: ClientOption) {
         if (options.shouldVerifyMessageSignature === true && options.shouldVerifyMessageOrder !== true)
@@ -111,7 +131,8 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
         // For managing shared data
         this.state = new SharedState(options);
         // For handling packet
-        const dispatcher = new Dispatcher(this.state, this.emit.bind(this));
+        this.packetSender = new Sender(this.state, this.emit.bind(this));
+        this.packetListener = new Listener(this.state, this.emit.bind(this), this.packetSender);
         // For reading packet
         const versionCodec = new VersionCodec(this.state);
         // For throwing packet through internet
@@ -126,12 +147,12 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
         this.tcp.forwardPacket = versionCodec.handlePacket.bind(versionCodec);
         this.tcp.parsePacket = versionCodec.encodePacket.bind(versionCodec);
         this.tcp.sendInitPacket = () => {
-            dispatcher.sendHandshake();
-            dispatcher.sendLoginStart();
+            this.packetSender.sendHandshake();
+            this.packetSender.sendLoginStart();
         };
-        dispatcher.sendPacket = this.tcp.sendPacket.bind(this.tcp);
-        dispatcher.disconnect = this.disconnect.bind(this);
-        versionCodec.consumePacket = dispatcher.handlePacket.bind(dispatcher);
+        this.packetSender.sendPacket = this.tcp.sendPacket.bind(this.tcp);
+        this.packetListener.disconnect = this.disconnect.bind(this);
+        versionCodec.consumePacket = this.packetListener.handlePacket.bind(this.packetListener);
 
         // For querying data
         this.blocks = new BlockManager(this.state);
@@ -143,24 +164,27 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
             this.entities,
             this.blocks,
         );
-        this.player.sendPlayerPos = dispatcher.sendPlayerPos;
-        this.player.sendPlayerPosRot = dispatcher.sendPlayerPosRot;
-        this.player.sendPlayerRot = dispatcher.sendPlayerRot;
-        this.player.sendPlayerStatus = dispatcher.sendPlayerStatus;
+        this.player.sendPlayerPos = this.packetSender.sendPlayerPos;
+        this.player.sendPlayerPosRot = this.packetSender.sendPlayerPosRot;
+        this.player.sendPlayerRot = this.packetSender.sendPlayerRot;
+        this.player.sendPlayerStatus = this.packetSender.sendPlayerStatus;
 
         // For tick-tock tick-tock
         this.tickLoop = new TickLoop(() => {
             this.state.drainMutation();
-            this.state.drainEvent()
-                .forEach(event => this.emitEvent(event));
-            this.state.drainPacket()
-                .forEach((packet) => this.tcp.sendPacket(packet.id, packet.data));
+            this.state.drainEvent(event => this.emitEvent(event));
+            this.state.drainPacket((packet) => this.tcp.sendPacket(packet.id, packet.data));
             this.player.tick();
         });
 
         // Forward TCP events
         this.tcp.on("connect", () => this.emit("connect"));
         this.tcp.on("destroy", () => this.emit("destroy"));
+        this.on("loadChunk", (sx, sy, sz) => this.blocks.deleteChunkCache(sx, sy, sz));
+        this.on("unloadChunk", (sx, sz) => {
+            for (let sy = 0; sy < 16; sy++) 
+                this.blocks.deleteChunkCache(sx, sy, sz);
+        });
     }
 
     private emitEvent(event: EmittedEvent) {
@@ -170,9 +194,11 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
     private async loadRegistries() {
         if (Client.loadRegistry) return;
         Client.loadRegistry = true;
-        await BlockRegistry.load(this.options.version);
-        await EntityRegistry.load(this.options.version);
-        await PacketRegistry.load(this.options.version);
+        const { version } = this.options;
+        await BlockRegistry.load(version);
+        await EntityRegistry.load(version);
+        await PacketRegistry.load(version);
+        await EffectRegistry.load(version);
     }
 
     // Start / stop
@@ -241,6 +267,13 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
         this.player.releaseAllInputs();
     }
 
+    /**
+     * Send a message
+     */
+    public chat(message: string) {
+        this.packetSender.sendMessage(message);
+    }
+
     // World
     /**
      * Get the block state at position

package/src/index.ts

@@ -1,14 +1,22 @@
 export * from "./base/bitset";
+export * from "./base/buffer";
+export * from "./base/cache";
 export * from "./base/error";
 export * from "./base/event";
+export * from "./base/http";
 export * from "./base/math";
 export * from "./base/typing";
+export * from "./binary/decoder";
+export * from "./binary/encoder";
+export * from "./binary/static";
 export * from "./client/auth";
 export * from "./client/client";
-export * from "./client/tcp";
-export * from "./packet/decoder";
-export * from "./packet/encoder";
-export * from "./packet/dispatcher";
+export * from "./client/static";
+export * from "./message/link";
+export * from "./message/sigCache";
+export * from "./net/tcp";
+export * from "./packet/listener";
+export * from "./packet/sender";
 export * from "./physics/aabb";
 export * from "./physics/direction";
 export * from "./physics/player";

package/src/{client → net}/tcp.ts

@@ -3,9 +3,9 @@ import { EventEmitter } from "node:events";
 import { deflateSync, inflateSync } from "node:zlib";
 
 import { TypedEmmiter } from "../base/event";
-import { BinaryDecoder } from "../packet/decoder";
-import { BinaryEncoder } from "../packet/encoder";
-import { AuthOption } from "./auth";
+import { BinaryDecoder } from "../binary/decoder";
+import { BinaryEncoder } from "../binary/encoder";
+import { AuthOption } from "../client/auth";
 import { ClientStatus, SharedState } from "../world/state";
 import { EncodeResult } from "../version/codec";
 import { TextComponent } from "../base/typing";
@@ -171,6 +171,8 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
                     packetID = decoder.readVarInt();
                 }
             }
+            if (this.state.clientOptions.debug?.packetLogger == true)
+                console.log("packet", packetID, "length", decoder.buffer.length);
             this.forwardPacket(packetID, decoder);
 
             this.bufferPool = this.bufferPool.subarray(expectedPacketEnd);

package/src/packet/{dispatcher.ts → listener.ts}

@@ -1,61 +1,67 @@
 import zod from "zod";
-import { createCipheriv, createDecipheriv, createPublicKey, publicEncrypt, randomBytes, constants as crypto_constants, createVerify } from "node:crypto";
-import { BlockEntity, ChunkSection, ClientPlayer, ClientStatus, ConnectionState, Entity, GameMode, PaletteContainer, ServerKnownPack, ServerWorld, SharedState } from "../world/state";
-import { BinaryDecoder, getTextFromTextComponent } from "./decoder";
+import { createCipheriv, createDecipheriv, randomBytes, createVerify } from "node:crypto";
+import { BlockEntity, ChunkSection, ClientPlayer, ClientStatus, Entity, GameMode, ServerKnownPack, ServerWorld, SharedState } from "../world/state";
+import { BinaryDecoder, getTextFromTextComponent } from "../binary/decoder";
 import { packBlockPos, SectionsPerChunk } from "../client/static";
-import { Angle, BaseVec3, Vec3 } from "../physics/direction";
-import { ProtocolVersionMapping } from "../version/registry";
+import { Vec3 } from "../physics/direction";
 import { TypedEmmiter } from "../base/event";
 import { ClientEvents } from "../client/client";
-import { makeMovementFlag } from "./encoder";
+import { makeMovementFlag } from "../binary/encoder";
 import { TextComponent } from "../base/typing";
-import { AuthRelatedNotFound, HaveSignatureButNotIndex, MessageLinkNotFound, MissingAuthOption, NotImplemented, UnexpectedValue } from "../base/error";
-import { randomUUIDBytes, uuidToBuffer } from "../base/math";
+import { AuthRelatedNotFound, HaveSignatureButNotIndex, MessageLinkNotFound, NotImplemented, UnexpectedValue } from "../base/error";
+import { uuidToBuffer } from "../base/math";
 import { MessageLink } from "../message/link";
-import { sliceBuffer } from "../base/buffer";
+import { Sender } from "./sender";
 
 function zodParse<Type extends zod.ZodType>(data: object, zod: Type): zod.infer<Type> {
     return zod.parse(data);
 }
 
-export class Dispatcher {
+export class Listener {
     private readonly mapping: Record<string, (data: object) => void>;
 
     constructor(
         private state: SharedState,
-        private emit: TypedEmmiter<ClientEvents>["emit"]
+        private emit: TypedEmmiter<ClientEvents>["emit"],
+        private sender: Sender,
     ) {
         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:login": this.handlePlayLogin,
             "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:player_chat": this.handlePlayerChat,
+            "play:disguised_chat": this.handleDisguisedChatMessage,
+            "play:system_chat": this.handleSystemMessage,
+            "play:set_action_bar_text": this.handleSetActionBar,
+
             "play:level_chunk_with_light": this.handleChunkData,
-            "play:login": this.handlePlayLogin,
+            "play:forget_level_chunk": this.handleUnloadChunk,
+
+            "play:add_entity": this.handleSpawnEntity,
             "play:move_entity_pos": this.handleUpdateEntityPosition,
             "play:move_entity_pos_rot": this.handleUpdateEntityPositionRotation,
-            "play:player_chat": this.handlePlayerChat,
+            "play:entity_position_sync": this.handleTeleportEntity,
             "play:player_position": this.handleSynchronizePlayerPosition,
+            "play:update_mob_effect": this.handleUpdateMobEffect,
             "play:remove_entities": this.handleRemoveEntity,
-            // "play:rotate_head": 
-            "play:set_action_bar_text": this.handleSetActionBar,
+            "play:remove_mob_effect": this.handleRemoveMobEffect,
+            // "play:rotate_head": ,
             "play:set_entity_motion": this.handleSetEntityVelocity,
-            "play:system_chat": this.handleSystemMessage,
         };
     }
 
-    public sendPacket: (packetId: string, data: object) => void = () => { throw new NotImplemented(); };
     public disconnect: (reason: string, reasonRaw?: TextComponent) => void = () => { throw new NotImplemented(); };
 
 
@@ -99,9 +105,9 @@ export class Dispatcher {
                 throw new AuthRelatedNotFound("auth client");
             else
                 this.state.authClient.sendAuth(server_id, sharedSecret, publicKey)
-                    .then(() => this.sendEncryptionResponse(publicKey, verifyToken));
+                    .then(() => this.sender.sendEncryptionResponse(publicKey, verifyToken));
         else
-            this.sendEncryptionResponse(publicKey, verifyToken);
+            this.sender.sendEncryptionResponse(publicKey, verifyToken);
     }
 
     private handleSetCompression(data: object) {
@@ -136,9 +142,10 @@ export class Dispatcher {
             angle: {
                 yaw: 0,
                 pitch: 0,
-            }
+            },
+            effects: {}
         } satisfies ClientPlayer as any;
-        this.sendLoginAck();
+        this.sender.sendLoginAck();
     }
 
     // Configure
@@ -152,8 +159,8 @@ export class Dispatcher {
             }))
         }));
         this.state.server!.knownPacks = known_packs satisfies ServerKnownPack[] as any;
-        this.sendKnownPack(this.state.clientOptions.loadRegistry === true ? [] : known_packs);
-        // this.sendKnownPack([]);
+        this.sender.sendKnownPack(this.state.clientOptions.loadRegistry === true ? [] : known_packs);
+        // this.sender.sendKnownPack([]);
     }
 
     private handleRegistryData(data: object) {
@@ -171,10 +178,11 @@ export class Dispatcher {
         const registry = this.state.registry as Record<string, any[]>;
         if (!(registry_id in registry)) registry[registry_id] = [];
         registry[registry_id]!.push(...entries);
+        this.emit("registryData", { registry_id, entries });
     }
 
     private handleFinishConfiguration(data: object) {
-        this.sendConfigureAck();
+        this.sender.sendConfigureAck();
     }
 
     private handleConfiguarionPlayDisconnect(data: object) {
@@ -225,7 +233,7 @@ export class Dispatcher {
         this.state.status = ClientStatus.Ready;
 
         if (this.state.useEncryption)
-            this.sendPlayerSession();
+            this.sender.sendPlayerSession();
 
         this.emit("ready");
     }
@@ -291,8 +299,8 @@ export class Dispatcher {
             } satisfies ClientPlayer as any
         );
         this.state.enqueueEvent("playerPosition", { x: newPosX, y: newPosY, z: newPosZ });
-        this.sendConfirmTeleportation(teleport_id);
-        this.sendPacket("move_player_pos_rot", {
+        this.sender.sendConfirmTeleportation(teleport_id);
+        this.sender.sendPacket("move_player_pos_rot", {
             x: newPosition.x,
             feet_y: newPosition.y,
             z: newPosition.z,
@@ -308,7 +316,7 @@ export class Dispatcher {
                 keep_alive_id: zod.bigint().or(zod.number())
             })
         );
-        this.sendKeepAlive(BigInt(keep_alive_id));
+        this.sender.sendKeepAlive(BigInt(keep_alive_id));
     }
 
     private handleChangeGameMode(data: object) {
@@ -337,7 +345,7 @@ export class Dispatcher {
                     type: zod.int(),
                     data: zod.record(zod.string(), zod.any())
                 })),
-                light: zod.any(),
+                light: zod.any().optional(),
             })
         );
 
@@ -602,6 +610,53 @@ export class Dispatcher {
         });
     }
 
+    private handleUpdateMobEffect(data: object) {
+        const {
+            entity_id,
+            effect_id,
+            amplifier,
+            duration,
+            flags
+        } = zodParse(data, zod.object({
+            entity_id: zod.number(),
+            effect_id: zod.number(),
+            amplifier: zod.number(),
+            duration: zod.number(),
+            flags: zod.number(),
+        }));
+        const isAmbient = (flags & 0x01) == 1,
+            showParticles = (flags & 0x02) == 1,
+            showIcon = (flags & 0x04) == 1,
+            blend = (flags & 0x08) == 1;
+        this.state.enqueueMutation((state) => {
+            if (state.player!.entityId === entity_id)
+                state.player!.effects[effect_id] = {
+                    amplifier,
+                    duration,
+                    id: effect_id,
+                    flag: {
+                        blend,
+                        isAmbient,
+                        showIcon,
+                        showParticles
+                    },
+                    date: Date.now()
+                };
+        });
+    }
+
+    private handleRemoveMobEffect(data: object) {
+        const { entity_id, effect_id } = zodParse(data, zod.object({
+            entity_id: zod.number(),
+            effect_id: zod.number(),
+        }));
+
+        this.state.enqueueMutation((state) => {
+            if (state.player!.entityId === entity_id)
+                delete state.player!.effects[effect_id];
+        });
+    }
+
     // Chat
     private handlePlayerChat(data: object) {
         const {
@@ -645,7 +700,7 @@ export class Dispatcher {
         const emitObject = {
             sender: senderNameText,
             target: targetNameText,
-            content: getTextFromTextComponent(unsigned_content),
+            content: message,
             raw: {
                 sender: sender_name,
                 target: target_name || undefined,
@@ -677,6 +732,8 @@ export class Dispatcher {
             }
         }
 
+        if (message_signature_bytes !== null)
+            this.state.messageCount += 1;
         if (this.state.clientOptions.shouldVerifyMessageSignature === true && message_signature_bytes) {
             if (!this.state.sessionID)
                 throw new AuthRelatedNotFound("session uuid");
@@ -716,7 +773,7 @@ export class Dispatcher {
             const signature = Buffer.from(message_signature_bytes);
 
             if (!verify.verify(publicKey!, signature))
-                this.emit("failedMessage", emitObject);
+                return this.emit("failedMessage", emitObject);
         }
 
         this.emit("message", emitObject);
@@ -774,146 +831,4 @@ export class Dispatcher {
             }
         });
     }
-
-    /*
-    * 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: Buffer.from(this.state.playerUUID!, "hex")
-        });
-    }
-
-    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);
-        const secretBuf = sliceBuffer(encryptedSecret, 1, (buf) => buf.readInt8());
-        const token = sliceBuffer(encryptedVerifyToken, 1, (buf) => buf.readInt8());
-        this.sendPacket("key", {
-            shared_secret: { value: secretBuf, length: secretBuf.length },
-            verify_token: { value: token, length: token.length }
-        });
-    }
-
-    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 sendPlayerSession() {
-        const sessionUUID = 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
-        });
-    }
-
-    private sendConfirmTeleportation(teleportId: number) {
-        this.sendPacket("accept_teleportation", {
-            teleport_id: teleportId
-        });
-    }
-
-    private sendKeepAlive(id: bigint) {
-        this.sendPacket("keep_alive", {
-            keep_alive_id: id
-        });
-    }
-
-    public sendPlayerPos(
-        position: BaseVec3,
-        onGround: boolean,
-        horizontalCollision: boolean
-    ) {
-        const { x, y, z } = position;
-        this.state.enqueuePacket("move_player_pos", {
-            x, feet_y: y, z,
-            flags: makeMovementFlag(onGround, horizontalCollision)
-        });
-    }
-
-    public sendPlayerPosRot(
-        position: BaseVec3,
-        angle: Angle,
-        onGround: boolean,
-        horizontalCollision: boolean
-    ) {
-        const { x, y, z } = position,
-            { yaw, pitch } = angle;
-        this.state.enqueuePacket("move_player_pos_rot", {
-            x, feet_y: y, z,
-            yaw, pitch,
-            flags: makeMovementFlag(onGround, horizontalCollision)
-        });
-    }
-
-    public sendPlayerRot(
-        angle: Angle,
-        onGround: boolean,
-        horizontalCollision: boolean
-    ) {
-        const { yaw, pitch } = angle;
-        this.state.enqueuePacket("move_player_rot", {
-            yaw, pitch,
-            flags: makeMovementFlag(onGround, horizontalCollision)
-        });
-    }
-
-    public sendPlayerStatus(
-        onGround: boolean,
-        horizontalCollision: boolean
-    ) {
-        this.state.enqueuePacket("move_player_status_only", {
-            flags: makeMovementFlag(onGround, horizontalCollision)
-        });
-    }
 }