@vaitosoi/minejs 0.4.3 → 0.5.1

package/src/base/cache.ts

@@ -0,0 +1,62 @@
+/**
+ * The base implementation for the Cache class
+ */
+export abstract class CacheImplementation<T = any> {
+    public abstract put(key: string, item: T): void;
+    public abstract get(key: string): T | undefined;
+    public abstract del(key: string): void;
+}
+
+/**
+ * The LRU cache implementation.
+ * 
+ * @see https://en.wikipedia.org/wiki/Cache_replacement_policies#Time-Aware,_Least_Recently_Used_(TLRU)
+ */
+export class LRUCache<T> extends CacheImplementation<T> {
+    private hash: Map<string, T> = new Map();
+    private list: string[] = [];
+
+    constructor(private capacity: number) {
+        super();
+    }
+
+    public put(key: string, item: T): void {
+        if (this.hash.has(key)) {
+            const oldIndex = this.list.indexOf(key);
+            if (oldIndex > -1)
+                this.list.splice(oldIndex, 1);
+        }
+
+        this.hash.set(key, item);
+        this.list.push(key);
+
+        this.truncateHash();
+    }
+
+    public get(key: string) {
+        if (!this.hash.has(key)) return undefined;
+
+        const item = this.hash.get(key);
+        const oldIndex = this.list.indexOf(key);
+        if (oldIndex > -1)
+            this.list.splice(oldIndex, 1);
+        this.list.push(key);
+        
+        return item;
+    }
+
+    public del(key: string): void {
+        const oldIndex = this.list.indexOf(key);
+        if (oldIndex > -1)
+            this.list.splice(oldIndex, 1);
+        this.hash.delete(key);
+    }
+
+    private truncateHash() {
+        while (this.list.length > this.capacity) {
+            const popping = this.list.pop();
+            if (popping)
+                this.hash.delete(popping);
+        }
+    }
+}

package/src/base/error.ts

@@ -211,4 +211,13 @@ export class HaveSignatureButNotIndex extends Error {
     constructor() {
         super (`expecting both shouldVerifyMessageOrder set to true when shouldVerifyMessageSignature set to true`);
     }
+}
+
+/**
+ * @hidden
+ */
+export class MessageTooLong extends Error {
+    constructor(public message: string) {
+        super(`your message is exceeding the 256 characters long limit, got ${message.length} characters`);
+    }
 }

package/src/base/http.ts

@@ -1,5 +1,6 @@
 import { AuthClientError } from "./error";
 
+/** @hidden */
 export async function getJson(res: Response, source: string) {
     const data = await res.text();
     try {

package/src/base/math.ts

@@ -112,4 +112,48 @@ export function minecraftSha1(
 function mcHexDigest(digest: Buffer | Uint8Array): string {
     const bigint = BigInt(`0x${digest.toString('hex')}`);
     return BigInt.asIntN(digest.length * 8, bigint).toString(16);
-}
+}
+
+/**
+ * Simplified implementation of Java's Long.numberOfTrailingZeros
+ * @param n 
+ * @returns 
+ * @hidden
+ */
+export function numberOfTrailingZeros(n: bigint): number {
+    if (n === 0n) {
+        return 64;
+    }
+
+    let count = 0;
+    while ((n & 1n) === 0n) {
+        count++;
+        n >>= 1n;
+    }
+
+    return count;
+}
+
+/**
+ * Simplified implementation of Java's Long.numberOfLeadingZeros
+ * @param n 
+ * @returns 
+ * @hidden
+ */
+export function numberOfLeadingZeros(n: bigint): number {
+    if (n === 0n) {
+        return 64;
+    }
+
+    let count = 0;
+    // Start checking from bit 63 (the most significant bit)
+    for (let i = 63; i >= 0; i--) {
+        if ((n & (1n << BigInt(i))) === 0n) {
+            count++;
+        } else {
+            break; // Stop at the first 1 bit
+        }
+    }
+
+    return count;
+}

package/src/base/typing.ts

@@ -8,3 +8,14 @@ export type If<Condition extends boolean, True, False = null> = Condition extend
  * @see https://minecraft.wiki/w/Text_component_format
  */
 export type TextComponent = Record<string, any>;
+
+
+/**
+ * Representing the data in Registry Data packet
+ * 
+ * @see https://minecraft.wiki/w/Java_Edition_protocol/Packets#Registry_Data
+ */
+export interface RegistryData {
+    registry_id: string,
+    entries: { entry_id: string, data: Record<string, any> | null }[]
+}

package/src/{packet → binary}/decoder.ts

@@ -6,6 +6,7 @@ import { unzipSync } from "zlib";
 import { minBigInt } from "../base/math";
 import { inspect } from "util";
 
+/** @hidden */
 export function getTextFromTextComponent(component: any): string {
     if (component === null || component === undefined) return "null";
     switch (typeof component) {
@@ -31,6 +32,9 @@ export function getTextFromTextComponent(component: any): string {
     }
 }
 
+/**
+ * Binary decoding helper class
+ */
 export class BinaryDecoder {
     public buffer: Buffer = Buffer.alloc(0);
     public offset: number = 0;

package/src/{packet → binary}/encoder.ts

@@ -3,6 +3,7 @@ import { CONTINUATION_FLAG, CONTINUE_BIT, isFixedSizeTag, isTag, MAX_QUANTIZED_V
 import { InvalidValue, NumberTooBig, UnexpectedValue } from "../base/error";
 import { FixedSizeTag, Tag } from "./static";
 
+/** @hidden */
 export function makeMovementFlag(onGround: boolean, pushingWall: boolean) {
     let flag = 0;
     if (onGround)
@@ -12,6 +13,9 @@ export function makeMovementFlag(onGround: boolean, pushingWall: boolean) {
     return flag;
 }
 
+/**
+ * Binary encoding helper
+ */
 export class BinaryEncoder {
     private buffer = Buffer.alloc(0);
 
@@ -62,9 +66,13 @@ export class BinaryEncoder {
      */
     public writeInt(val: number) { return this.write(4, val, (buf) => buf.writeInt32BE); }
     /**
-     * Write 6 bytes singed integer
+     * Write 8 bytes singed integer
      */
-    public writeLong(val: bigint) { return this.write(8, val, (buf) => buf.writeBigInt64BE); }
+    public writeLong(val: bigint | number) {
+        // Cast to BigInt 
+        const v = typeof val === "bigint" ? val : BigInt(val);
+        return this.write(8, v, (buf) => buf.writeBigInt64BE); 
+    }
     /**
      * Write 4 bytes float
      */

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,10 +164,10 @@ 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(() => {
@@ -159,6 +180,11 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
         // 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) {
@@ -168,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
@@ -239,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/message/link.ts

@@ -1,3 +1,6 @@
+/**
+ * Represent a node in the linked-list of messages
+ */
 export class MessageLink {
     constructor (
         public index: number,

package/src/message/sigCache.ts

@@ -1,3 +1,8 @@
+/**
+ * Used for caching the message signature
+ * 
+ * Not used for now
+ */
 export class SignatureCache {
     private entries: Buffer[];
 

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

@@ -3,18 +3,14 @@ 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";
 import { NotImplemented, SockerIsNotWritable, UnexpectedValue } from "../base/error";
 
-// Minecraft related typing
-
-
-
 // TCP related typing
 export interface TCPClientOption {
     /** Server host */
@@ -72,7 +68,7 @@ export interface Message {
 /**
  * Low-level client. You SHOULD NOT use this client unless you know what are you doing
  * 
- * @see https://minecraft.wiki/w/Java_Edition_protocol/Packets?oldid=3445844
+ * @see https://minecraft.wiki/w/Java_Edition_protocol/Packets
  */
 export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClientEvents>) {
     public readonly socket: Socket;