@vaitosoi/minejs 0.5.1 → 0.6.1

package/src/binary/encoder.ts

@@ -1,4 +1,4 @@
-import { Vec3 } from "../physics/direction";
+import { BaseVec3 } from "../physics/direction";
 import { CONTINUATION_FLAG, CONTINUE_BIT, isFixedSizeTag, isTag, MAX_QUANTIZED_VALUE, SCALE_BITS, SEGMENT_BITS } from "./static";
 import { InvalidValue, NumberTooBig, UnexpectedValue } from "../base/error";
 import { FixedSizeTag, Tag } from "./static";
@@ -71,7 +71,7 @@ export class BinaryEncoder {
     public writeLong(val: bigint | number) {
         // Cast to BigInt 
         const v = typeof val === "bigint" ? val : BigInt(val);
-        return this.write(8, v, (buf) => buf.writeBigInt64BE); 
+        return this.write(8, BigInt.asIntN(64, v), (buf) => buf.writeBigInt64BE);
     }
     /**
      * Write 4 bytes float
@@ -163,12 +163,11 @@ export class BinaryEncoder {
      * 
      * @returns a Position
      */
-    public writePosition(position: Vec3) {
-        const val = BigInt(
-            ((position.x & 0x3FFFFFF) << 38) |
-            ((position.z & 0x3FFFFFF) << 12) |
-            (position.y & 0xFFF)
-        );
+    public writePosition(position: BaseVec3) {
+        const val =
+            (BigInt(position.x & 0x3FFFFFF) << 38n) |
+            (BigInt(position.z & 0x3FFFFFF) << 12n) |
+            BigInt(position.y & 0xFFF);
         this.writeLong(val);
         return this;
     }
@@ -219,7 +218,7 @@ export class BinaryEncoder {
      * 
      * Read this article for more information: https://minecraft.wiki/w/Java_Edition_protocol/Data_types#LpVec3
      */
-    public writeLpVec3(vec3: Vec3) {
+    public writeLpVec3(vec3: BaseVec3) {
         const maxCoordinate = Math.max(Math.abs(vec3.x), Math.max(Math.abs(vec3.y), Math.abs(vec3.z)));
 
         // Checking for NaN values in our maxCoordinate

package/src/client/client.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import { BlockManager, BlockState } from "../world/block";
+import { BlockGetter, BlockManager, BlockState } from "../world/block";
 import { EntitiesManager } from "../world/entity";
 import { Input, Player } from "../physics/player";
 import { TickLoop } from "../world/tick";
@@ -16,14 +16,18 @@ import { computeUUID } from "../base/math";
 import { HaveSignatureButNotIndex } from "../base/error";
 import { Sender } from "../packet/sender";
 import { CacheImplementation } from "../base/cache";
+import { Container, Slot } from "../world/container";
 
 export type ClientOption = Omit<TCPClientOption, "protocolVersion"> & {
+    /**
+     * The client version. Supports 26.2 and 26.3
+     */
     version: string,
 
     /**
-     * Whenever should the client verify the message against the signature, if any
+     * Whenever should the client verify the message against the signature, if any.
      * 
-     * When set this option to true, you HAVE TO set `shouldVerifyMessageOrder` to true
+     * In order to set this option to true, you HAVE TO set `shouldVerifyMessageOrder` to true
      */
     shouldVerifyMessageSignature?: boolean,
 
@@ -57,28 +61,50 @@ export interface ClientEvents {
     /**
      * When the client is ready.
      * 
-     * Specifically, when the packet `Login (play)` is received
+     * Specifically, when the packet `Login (play)` is received.
+     * 
+     * Most of the client method require this event to be fired in order to work.
      */
     ready: [],
     /**
-     * When the client got disconnected from sevrer
+     * When the client got disconnected from server.
+     * 
+     * This event only provide the parsed string. To get the unparsed, or the raw one with decoration, use `disconnectRaw`.
+     * But, the `disconnectRaw` is only fired when the disconnection come from the server, or the server disconnect the client.
+     * Sometime, the disconnect will be fired within the client, meaning that there will be no `disconnectRaw` 
      */
     disconnect: [reason: string],
     /**
-     * When the disconection come with the raw Text Component
+     * When the disconnection come with the raw Text Component.
      */
     disconnectRaw: [textComponent: TextComponent],
 
+    /** The registry_data packet */
+    registryData: [data: RegistryData],
+
     /**
-     * When server send `Player Position Synchronization` packet
+     * When server send `Player Position Synchronization` packet.
+     * 
+     * **Note:** this event is not fired when the client is moved by holding the input.
      * 
-     * Note: this event is not fired when the client is moved by holding the input
+     * To get the player current position, use `getPosition` method
      */
     playerPosition: [position: BaseVec3],
 
-    /** When the chunk is loaded */
+    /** 
+     * When the chunk is loaded
+     * 
+     * Explaining the `chunkX`, `sectionY`, `chunkZ`: A chunk in Minecraft is a region which length and width is 16 and the height extends to the limit.
+     * But when sending the packet, the chunk is divided into smaller section which volume is 16x16x16. 
+     * So the `chunkX` and `chunkZ` is the chunk position and `sectionY` is the section within that chunk, 
+     * counting from the bedrock up to the sky
+     */
     loadChunk: [chunkX: number, sectionY: number, chunkZ: number],
-    /** When the chunk got deleted by the server */
+    /** 
+     * When the chunk got deleted by the server
+     * 
+     * See the `chunkX` and `chunkZ` explaination in `loadChunk` events 
+     */
     unloadChunk: [chunkX: number, chunkZ: number],
 
     /** When an entity is spawned or appeared in the client view distance */
@@ -87,28 +113,86 @@ 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 */
     message: [message: Message],
     /** When a message is failed to be verified against the signature sent with it */
     failedMessage: [message: Message],
-    /** The system message */
+    /** 
+     * The system message 
+     * 
+     * This event only provide the parsed string. To get the unparsed, or the raw one with decoration, use `systemMessageRaw`
+     */
     systemMessage: [message: string],
-    /** The raw system message */
+    /** 
+     * The system message with the Text Component for decorations
+     */
     systemMessageRaw: [textComponent: TextComponent],
-    /** The action bar */
+    /** 
+     * The action bar 
+     * 
+     * This event only provide the parsed string. To get the unparsed, or the raw one with decoration, use `actionBarRaw`
+     */
     actionBar: [message: string],
     /** The raw action bar */
     actionBarRaw: [textComponent: TextComponent],
+
+    // Container
+    /** 
+     * When a container is opened
+     * 
+     * This event will be fired when client click on a block (with `openBlock` method) that is a container 
+     * or when server believe that you just open a container (with open_screen packet).
+     */
+    openContainer: [container: Container],
+    /** When the opening container is closed */
+    closeContainer: [],
+    /** When the packet contain the content of the container is received */
+    containerContent: [container: Container, carryingItem: Slot],
+    /** When the packet contain the property of the container is received */
+    containerProperty: [container: Container],
+
+    /** 
+     * When tab list is updated
+     * 
+     * `{"text":""}` mean remove header or footer.
+     */
+    tablist: [newTablist: { header: { text: string, raw: TextComponent }, footer: { text: string, raw: TextComponent } }]
 }
 
 /**
  * High-level client.
+ * 
+ * @example
+ * ```ts
+ * const client = new Client({
+ *     playerName: "bot", // Put your name here
+ *     host: "localhost", // Put the server address
+ *     port: 25565, // 25565 is the default port, change to your server's port if needed
+ *     version: "26.2", // The client version 
+ *     loadRegistry: false, // 
+ *     // auth: { // This things is not working yet
+ *     //     client_id: "d86254d8-edf7-4640-90eb-643c99af188e",
+ *     //     method: "loopback",
+ *     //     openBrowser: true,
+ *     //     port: 12345
+ *     // },
+ *     // shouldVerifyMessageOrder: true,
+ *     // shouldVerifyMessageSignature: true
+ * });
+ * 
+ * // MineJs is a event driven library, the same way DiscordJS work (if you know them).
+ * // One thing to note is most of method in this client require client to be ready, 
+ * // meaning that unless the "ready" event is fired, you can't do, mostly, anything :D
+ * client.on("ready", () => console.log("Client is ready :yay:"));
+ * 
+ * // The init step before is just init the data and does not create the connection yet.
+ * // This method will create that connection.
+ * client.connect();
+ * ```
  */
-export class Client<IsReady extends boolean = boolean> extends (EventEmitter as new () => TypedEmitter<ClientEvents>) {
+export class Client extends (EventEmitter as new () => TypedEmitter<ClientEvents>) {
     private static loadRegistry: boolean = false;
 
     private tickLoop: TickLoop;
@@ -118,7 +202,7 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
     private player: Player;
 
     private tcp: TCPClient;
-    private state: SharedState<IsReady>;
+    private state: SharedState;
     private packetListener: Listener;
     private packetSender: Sender;
 
@@ -127,6 +211,7 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
             throw new HaveSignatureButNotIndex();
 
         super();
+        this.loadRegistries();
 
         // For managing shared data
         this.state = new SharedState(options);
@@ -182,7 +267,7 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
         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++) 
+            for (let sy = 0; sy < 16; sy++)
                 this.blocks.deleteChunkCache(sx, sy, sz);
         });
     }
@@ -191,14 +276,14 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
         this.emit(event.event, ...event.args);
     }
 
-    private async loadRegistries() {
+    private loadRegistries() {
         if (Client.loadRegistry) return;
         Client.loadRegistry = true;
         const { version } = this.options;
-        await BlockRegistry.load(version);
-        await EntityRegistry.load(version);
-        await PacketRegistry.load(version);
-        await EffectRegistry.load(version);
+        BlockRegistry.load(version);
+        EntityRegistry.load(version);
+        PacketRegistry.load(version);
+        EffectRegistry.load(version);
     }
 
     // Start / stop
@@ -207,7 +292,6 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
      * Create a connection to the server
      */
     public async connect() {
-        await this.loadRegistries();
         if (!this.state.playerUUID) {
             if (this.options.auth) {
                 this.state.authClient = new AuthClient(this.options.auth);
@@ -231,7 +315,9 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
         });
     }
     /**
-     * Destroy the connection
+     * Destroy the connection.
+     * 
+     * Calling this method will also fire the "disconnect" event.
      */
     public disconnect(reason: string = "Disconnect", raw?: TextComponent) {
         this.state.state = ConnectionState.Disconnected;
@@ -249,48 +335,162 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
 
     // Inputs
     /**
-     * Press and hold a key
+     * Press and hold a key.
+     * 
+     * This is pretty the same idea as when you play Minecraft.
+     * When you need to go forward, you have to hold the key `W`, `S` for backward, etc...
+     * 
+     * @throws {ClientNotReady} When the client is not ready
      */
-    public hold(inout: Input) {
-        this.player.input(inout);
+    public hold(input: Input) {
+        this.state.checkReady();
+        this.player.input(input);
     }
     /**
-     * Release a key
+     * Release a key.
+     * 
+     * This is also pretty the same idea as when you play Minecraft.
+     * Need to stop, stop holding `W`, `S` key, etc...
+     * 
+     * @throws {ClientNotReady} When the client is not ready
      */
     public release(input: Input) {
+        this.state.checkReady();
         this.player.releaseInput(input);
     }
     /**
-     * Release all key
+     * Release all key. 
+     * 
+     * This is the shortcut for release all keys. 
+     * Instead of calling `release` method for each keys, just call this
+     * 
+     * @throws {ClientNotReady} When the client is not ready
      */
     public stopMoving() {
+        this.state.checkReady();
         this.player.releaseAllInputs();
     }
 
     /**
      * Send a message
+     * 
+     * @throws {ClientNotReady} When the client is not ready
      */
     public chat(message: string) {
+        this.state.checkReady();
         this.packetSender.sendMessage(message);
     }
 
     // World
     /**
      * Get the block state at position
+     * 
+     * @throws {ClientNotReady} When the client is not ready
      */
-    public at(x: number, y: number, z: number): BlockState | null;
-    public at(position: BaseVec3): BlockState | null;
-    public at(a: BaseVec3 | number, b?: number, c?: number): BlockState | null {
+    public getBlock(x: number, y: number, z: number): BlockState | null;
+    public getBlock(position: BaseVec3): BlockState | null;
+    public getBlock(a: BaseVec3 | number, b?: number, c?: number): BlockState | null {
         const vec3 = Vec3.loadArgs(a, b, c);
         return this.blocks.at(vec3);
     }
 
+    /**
+     * Get player position
+     * 
+     * @throws {ClientNotReady} When the client is not ready
+     */
+    public getPosition() {
+        this.state.checkReady();
+        return structuredClone(this.state.player!.position);
+    }
+
     /**
      * Rotate your face
+     * 
+     * "Yaw is measured in degrees and does not follow classical trigonometry rules.
+     * The unit circle of yaw on the XZ-plane starts at (0, 1) and turns counterclockwise, with 90 at (-1, 0), 180 at (0, -1) and 270 at (1, 0).
+     *
+     * Pitch is measured in degrees, where 0 is looking straight ahead, -90 is looking straight up, and 90 is looking straight down."
+     *
+     * @see https://minecraft.wiki/w/Java_Edition_protocol/Packets#Synchronize_Player_Position For Yaw and Pitch definition
+     *
      * @param yaw In degree
      * @param pitch In degree
+     * 
+     * @throws {ClientNotReady} When the client is not ready
      */
     public lookAt(yaw: number, pitch: number) {
+        this.state.checkReady();
         this.player.setAngle(yaw, pitch);
     }
+
+    /**
+     * Get opening container.
+     * 
+     * Return `undefined` if nothing is opening
+     * 
+     * @throws {ClientNotReady} When the client is not ready
+     */
+    public getOpeningContainer() {
+        this.state.checkReady();
+        return this.state.openingContainer;
+    }
+    /**
+     * Get carrying item.
+     * 
+     * Return `undefined` if nothing is carried
+     * 
+     * @throws {ClientNotReady} When the client is not ready
+     */
+    public getCarryingItem() {
+        this.state.checkReady();
+        return this.state.player?.carryingItem;
+    }
+    /**
+     * Get player's inventory
+     * 
+     * @throws {ClientNotReady} When the client is not ready
+     */
+    public getInventory() {
+        this.state.checkReady();
+        return this.state.player?.inventory;
+    }
+
+    /**
+     * Open a block.
+     * 
+     * @throws {ClientNotReady} When the client is not ready
+     * @returns `true` if the target block is a solid block, or else, return `false`
+     */
+    public openBlock(x: number, y: number, z: number): boolean;
+    public openBlock(position: BaseVec3): boolean;
+    public openBlock(a: BaseVec3 | number, b?: number, c?: number): boolean {
+        this.state.checkReady();
+        const vec3 = Vec3.loadArgs(a, b, c);
+        const eyePos = new Vec3(this.state.player!.position).add(0, 1.62, 0);
+        const target = new Vec3(vec3).add(0.5, 0.5, 0.5); // aim at block center, or use look direction
+        const reach = 4.5; // survival reach, adjust as needed
+        const dir = target.subtract(eyePos).normalize();
+        const to = eyePos.add(dir.scale(reach));
+        const clipResult = BlockGetter.clip(
+            eyePos,
+            to,
+            (pos) => this.blocks.at(pos)!.shape
+        )!;
+        if (clipResult.miss) return false;
+        const cursorX = Math.abs(clipResult.location.x - clipResult.pos.x),
+            cursorY = Math.abs(clipResult.location.y - clipResult.pos.y),
+            cursorZ = Math.abs(clipResult.location.z - clipResult.pos.z);
+        if (cursorX > 1 || cursorY > 1 || cursorZ > 1)
+            return false;
+        this.packetSender.sendUseItemOn(
+            "main",
+            vec3,
+            clipResult.direction,
+            { x: cursorX, y: cursorY, z: cursorZ },
+            false,
+            false
+        );
+        return true;
+    }
 }

package/src/net/tcp.ts

@@ -34,7 +34,11 @@ export interface TCPClientOption {
 
     debug?: {
         /** Log the incoming packet */
-        packetLogger: boolean
+        packetLogger: boolean,
+        /** Packet to ignore */
+        ignorePackets?: string[],
+        /** Ignore logs from TCP client (`packet X length Y`) */
+        ignoreTCPPacketLogs?: number[] | true
     },
 
     // For premium account
@@ -52,8 +56,8 @@ export interface Message {
     target: string | undefined,
     content: string,
     raw: {
-        sender: TextComponent,
-        target: TextComponent | undefined,
+        sender: string | TextComponent,
+        target: string | TextComponent | undefined,
         content: TextComponent | undefined
     }
 }
@@ -74,13 +78,6 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
     public readonly socket: Socket;
 
     // Internal var
-    /**
-     * | Value | Meaning |
-     * |-------|---------|
-     * | 0     |  not set yet |
-     * | -1    | dont compress |
-     * | > 0   | compression threshold |
-     */
     private bufferPool: Buffer = Buffer.alloc(0);
 
     constructor(
@@ -137,7 +134,7 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
 
     private handlePacket() {
         while (this.bufferPool.length > 0) {
-            let decoder = new BinaryDecoder(this.bufferPool);
+            const decoder = new BinaryDecoder(this.bufferPool);
             let packetLength: number;
             try {
                 packetLength = decoder.readVarInt();
@@ -149,27 +146,35 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
             const expectedPacketEnd = decoder.offset + packetLength;
 
             let packetID: number;
+            let packetDecoder = new BinaryDecoder(decoder.buffer.subarray(decoder.offset, expectedPacketEnd));
             if (this.state.compressionThreshold === 0)
-                packetID = decoder.readVarInt();
+                packetID = packetDecoder.readVarInt();
             else if (this.state.compressionThreshold === -1) {
-                decoder.readVarInt();
-                packetID = decoder.readVarInt();
+                packetDecoder.readVarInt();
+                packetID = packetDecoder.readVarInt();
             } else {
-                const dataLength = decoder.readVarInt();
+                const dataLength = packetDecoder.readVarInt();
                 if (dataLength === 0) {
-                    packetID = decoder.readVarInt();
+                    packetID = packetDecoder.readVarInt();
                 } else {
-                    const dataBuffer = this.bufferPool.subarray(decoder.offset, expectedPacketEnd);
+                    const dataBuffer = packetDecoder.buffer.subarray(packetDecoder.offset);
                     const decompressed = inflateSync(dataBuffer);
                     if (decompressed.length !== dataLength)
                         throw new UnexpectedValue("decompressed packet data", decompressed.length.toString(), dataLength.toString());
-                    decoder = new BinaryDecoder(decompressed);
-                    packetID = decoder.readVarInt();
+                    packetDecoder = new BinaryDecoder(decompressed);
+                    packetID = packetDecoder.readVarInt();
                 }
             }
-            if (this.state.clientOptions.debug?.packetLogger == true)
-                console.log("packet", packetID, "length", decoder.buffer.length);
-            this.forwardPacket(packetID, decoder);
+            if (
+                this.state.clientOptions.debug &&
+                this.state.clientOptions.debug.packetLogger &&
+                (
+                    (Array.isArray(this.state.clientOptions.debug.ignoreTCPPacketLogs) && !this.state.clientOptions.debug.ignoreTCPPacketLogs.includes(packetID)) ||
+                    (!this.state.clientOptions.debug.ignoreTCPPacketLogs)
+                )
+            )
+                console.log("packet", packetID, "length", packetDecoder.buffer.length);
+            this.forwardPacket(packetID, packetDecoder);
 
             this.bufferPool = this.bufferPool.subarray(expectedPacketEnd);
         }