@vaitosoi/minejs 0.4.3 → 0.5.0

package/src/base/bitset.ts

@@ -1,42 +1,323 @@
-import BitSet_ from "bitset";
+import assert from "node:assert";
+import { UnexpectedValue } from "./error";
+import { numberOfLeadingZeros, numberOfTrailingZeros } from "./math";
+
 
 /**
- * Custom implementation of BitSet to implement missing method
+ * Simplified implementation of the Java's BitSet class
+ * 
+ * @see https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/BitSet.java
+ * @hidden
  */
-export class BitSet extends BitSet_ {
-    public nextClearBit(fromIndex: number) {
-        fromIndex = fromIndex || 0;
-        const data = (this as any)['data'];
-        let wordIndex = fromIndex >>> 5;
+export class BitSet {
+    public static readonly ADDRESS_BITS_PER_WORD = 6;
+    public static readonly BITS_PER_WORD = 1 << this.ADDRESS_BITS_PER_WORD;
+    public static readonly WORD_MASK = 0xffffffffffffffffn;
+
+    public words: BigUint64Array;
+    public wordsInUse: number = 0;
+
+    private static wordIndex(bitIndex: number) {
+        return bitIndex >> this.ADDRESS_BITS_PER_WORD;
+    }
+
+    private static bitIndexInWord(bitIndex: number) {
+        return bitIndex & (this.BITS_PER_WORD - 1); // should be bitIndex & 63
+    }
+
+    /**
+     * Create a mask with lowest `n` bits set to 1
+     * 
+     * For example:
+     * * n = 0 -> `0b0n`
+     * * n = 3 -> `0b111n`
+     * * n = 5 -> `0b11111n`
+     * 
+     * @param nBits 
+     * @returns 
+     */
+    private static lowBits(nBits: number) {
+        return (1n << BigInt(nBits)) - 1n;
+    }
+
+    private initWords(nBits: number) {
+        return new BigUint64Array(BitSet.wordIndex(nBits - 1) + 1);
+    }
+
+    private static checkRange(fromIndex: number, toIndex: number) {
+        if (fromIndex < 0)
+            throw new UnexpectedValue("value of fromIndex", fromIndex.toString(), "non-negative number");
+        if (toIndex < 0)
+            throw new UnexpectedValue("value of toIndex", toIndex.toString(), "non-negative number");
+        if (fromIndex > toIndex)
+            throw new UnexpectedValue("fromIndex and toIndex", `fromIndex ${fromIndex}; toIndex ${toIndex}`, "fromIndex has to be smaller than toIndex");
+    }
+
+
+    constructor(nBits?: number) {
+        if (nBits && nBits < 0)
+            throw new UnexpectedValue("length of bitset", nBits.toString(), "non-negative number");
+        this.words = this.initWords(nBits ?? BitSet.BITS_PER_WORD);
+    }
+
+    public clone() {
+        const bitset = new BitSet(0);
+        bitset.words = structuredClone(this.words);
+        bitset.wordsInUse = this.wordsInUse;
+        bitset.checkInvariants();
+        return bitset;
+    }
 
-        if (wordIndex >= data.length) {
-            // Past the stored words — depends on the infinite tail bit
-            return (this as any)['_'] === 0 ? fromIndex : Infinity;
+    private expandTo(wordIndex: number) {
+        const wordsRequired = wordIndex + 1;
+        if (this.wordsInUse < wordsRequired) {
+            this.ensureCapacity(wordsRequired);
+            this.wordsInUse = wordsRequired;
         }
+    }
 
-        // ~word marks clear bits; mask off anything before fromIndex.
-        // JS's << only uses the low 5 bits of the shift amount, so
-        // `-1 << fromIndex` masks correctly even when fromIndex > 31.
-        let word = ~data[wordIndex] & (-1 << fromIndex);
+    private ensureCapacity(wordsRequired: number) {
+        if (wordsRequired > this.words.length) {
+            // Allocate larger of doubled size or required size
+            const request = Math.max(2 * this.words.length, wordsRequired);
+            const newWords = new BigUint64Array(request);
+            newWords.set(this.words);
+            this.words = newWords;
+        }
+    }
 
-        while (true) {
-            if (word !== 0) {
-                const lowestSet = word & -word;   // isolate lowest set bit
-                let c = 0;
-                for (let v = lowestSet; (v >>>= 1); c++) {
-                    //
-                }
-                return wordIndex * 32 + c;
-            }
-            wordIndex++;
-            if (wordIndex >= data.length) {
-                return (this as any)['_'] === 0 ? wordIndex * 32 : Infinity;
+    private recalculateWordsInUse() {
+        let i = this.wordsInUse - 1;
+        while (i >= 0 && this.words[i] === 0n) i--;
+        this.wordsInUse = i + 1; // The new logical size
+    }
+
+    private checkInvariants() {
+        assert(this.wordsInUse === 0 || this.words[this.wordsInUse - 1] !== 0n);
+        assert(this.wordsInUse >= 0 && this.wordsInUse <= this.words.length);
+        assert(this.wordsInUse === this.words.length || this.words[this.wordsInUse] === 0n);
+    }
+
+
+    public toByteArray() {
+        const n = this.wordsInUse;
+        if (n == 0)
+            return [];
+
+        const bytes: number[] = [];
+        for (const word of this.words) {
+            let coppiedWord = structuredClone(word);
+            // Slice a 64-bit (or 8-byte word) into 8 8-bit (or 1-byte) slices
+            for (let i = 0; i < 8; i++) {
+                bytes.push(Number(coppiedWord & 0xffn));
+                coppiedWord >>= 8n;
             }
-            word = ~data[wordIndex];
         }
-    };
 
-    public override clone(): BitSet {
-        return new BitSet(this.toString());
+        while (bytes.length > 0 && bytes.at(-1) === 0) bytes.pop();
+        return bytes;
+    }
+
+    public flip(bitIndex: number) {
+        if (bitIndex < 0)
+            throw new UnexpectedValue("value of bitIndex", bitIndex.toString(), "non-negative number");
+
+        const wordIndex = BitSet.wordIndex(bitIndex);
+        this.expandTo(wordIndex);
+
+        this.words[wordIndex]! ^= BigInt(BitSet.bitIndexInWord(bitIndex));
+
+        this.recalculateWordsInUse();
+        this.checkInvariants();
     }
-}
+
+    public set(bitIndex: number) {
+        if (bitIndex < 0)
+            throw new UnexpectedValue("value of bitIndex", bitIndex.toString(), "non-negative number");
+
+        const wordIndex = BitSet.wordIndex(bitIndex);
+        this.expandTo(wordIndex);
+
+        this.words[wordIndex]! |= 1n << BigInt(BitSet.bitIndexInWord(bitIndex)); // Restores invariants
+
+        this.checkInvariants();
+    }
+    public setRange(fromIndex: number, toIndex: number) {
+        BitSet.checkRange(fromIndex, toIndex);
+
+        if (fromIndex == toIndex)
+            return;
+
+        // Increase capacity if necessary
+        const startWordIndex = BitSet.wordIndex(fromIndex);
+        const endWordIndex = BitSet.wordIndex(toIndex - 1);
+        this.expandTo(endWordIndex);
+
+        const fromBit = BitSet.bitIndexInWord(fromIndex),
+            toBitInclusive = BitSet.bitIndexInWord(toIndex - 1) + 1,
+
+            /**
+             * The NOT (~) bitwise meaning:
+             * 
+             * Let say we want to set 2 to 6:
+             * ```
+             * 110010100
+             *    ^   ^
+             *    |   +-- this is the 2nd bit
+             *  and this is the 6th bit
+             * ```
+             * 
+             * So we call lowBits(2) and it return `...0011`
+             * 
+             * Then we have to flip it to `...1100` to access the '2nd bit and the bits after it'
+             */
+            firstWordMask = ~BitSet.lowBits(fromBit),
+            lastWordMask = BitSet.lowBits(toBitInclusive);
+        if (startWordIndex == endWordIndex) {
+            // Case 1: One word
+            this.words[startWordIndex]! |= (firstWordMask & lastWordMask);
+        } else {
+            // Case 2: Multiple words
+            // Handle first word
+            this.words[startWordIndex]! |= firstWordMask;
+
+            // Handle intermediate words, if any
+            for (let i = startWordIndex + 1; i < endWordIndex; i++)
+                this.words[i] = BitSet.WORD_MASK;
+
+            // Handle last word (restores invariants)
+            this.words[endWordIndex]! |= lastWordMask;
+        }
+
+        this.checkInvariants();
+    }
+
+
+    public clear(bitIndex: number) {
+        if (bitIndex < 0)
+            throw new UnexpectedValue("value of bitIndex", bitIndex.toString(), "non-negative number");
+
+        const wordIndex = BitSet.wordIndex(bitIndex);
+        if (wordIndex >= this.wordsInUse)
+            return;
+
+        this.words[wordIndex]! &= ~(1n << BigInt(bitIndex));
+
+        this.recalculateWordsInUse();
+        this.checkInvariants();
+    }
+    public clearRange(fromIndex: number, toIndex: number) {
+        BitSet.checkRange(fromIndex, toIndex);
+
+        if (fromIndex == toIndex)
+            return;
+
+        const startWordIndex = BitSet.wordIndex(fromIndex);
+        if (startWordIndex >= this.wordsInUse)
+            return;
+
+        let endWordIndex = BitSet.wordIndex(toIndex - 1);
+        if (endWordIndex >= this.wordsInUse) {
+            toIndex = this.length();
+            endWordIndex = this.wordsInUse - 1;
+        }
+
+        const fromBit = BitSet.bitIndexInWord(fromIndex),
+            toBitInclusive = BitSet.bitIndexInWord(toIndex - 1) + 1,
+            /**
+             * See the explaination in the setRange function
+             */
+            firstWordMask = ~BitSet.lowBits(fromBit),
+            lastWordMask = BitSet.lowBits(toBitInclusive);
+        if (startWordIndex == endWordIndex) {
+            // Case 1: One word
+            this.words[startWordIndex]! &= ~(firstWordMask & lastWordMask);
+        } else {
+            // Case 2: Multiple words
+            // Handle first word
+            this.words[startWordIndex]! &= ~firstWordMask;
+
+            // Handle intermediate words, if any
+            for (let i = startWordIndex + 1; i < endWordIndex; i++)
+                this.words[i]! = 0n;
+
+            // Handle last word
+            this.words[endWordIndex]! &= ~lastWordMask;
+        }
+
+        this.recalculateWordsInUse();
+        this.checkInvariants();
+    }
+
+
+    public get(bitIndex: number) {
+        if (bitIndex < 0)
+            throw new UnexpectedValue("value of bitIndex", bitIndex.toString(), "non-negative number");
+
+        this.checkInvariants();
+
+        const wordIndex = BitSet.wordIndex(bitIndex);
+        if (wordIndex >= this.wordsInUse) return false;
+
+        const bit = 1n << BigInt(BitSet.bitIndexInWord(bitIndex));
+        return (Number(this.words[wordIndex]! & bit) != 0);
+    }
+
+    public nextSetBit(fromIndex: number) {
+        if (fromIndex < 0)
+            throw new UnexpectedValue("value of fromIndex", fromIndex.toString(), "non-negative number");
+
+        this.checkInvariants();
+
+        let u = BitSet.wordIndex(fromIndex);
+        if (u >= this.wordsInUse)
+            return -1;
+
+        let word = this.words[u]! & (~0n << BigInt(BitSet.bitIndexInWord(fromIndex)));
+
+        while (true) {
+            if (word != 0n)
+                return (u * BitSet.BITS_PER_WORD) + numberOfTrailingZeros(word);
+            if (++u == this.wordsInUse)
+                return -1;
+            word = this.words[u]!;
+        }
+    }
+
+    public nextClearBit(fromIndex: number) {
+        // Neither spec nor implementation handle bitsets of maximal length.
+        // See 4816253.
+        if (fromIndex < 0)
+            throw new UnexpectedValue("value of fromIndex", fromIndex.toString(), "non-negative number");
+
+        this.checkInvariants();
+
+        let u = BitSet.wordIndex(fromIndex);
+        if (u >= this.wordsInUse)
+            return fromIndex;
+
+        let word = ~this.words[u]! & (BitSet.WORD_MASK << BigInt(fromIndex));
+
+        while (true) {
+            if (word != 0n)
+                return (u * BitSet.BITS_PER_WORD) + numberOfTrailingZeros(word);
+            if (++u == this.wordsInUse)
+                return this.wordsInUse * BitSet.BITS_PER_WORD;
+            word = ~this.words[u]!;
+        }
+    }
+
+    public length() {
+        if (this.wordsInUse == 0)
+            return 0;
+
+        return BitSet.BITS_PER_WORD * (this.wordsInUse - 1) +
+            (BitSet.BITS_PER_WORD - numberOfLeadingZeros(this.words[this.wordsInUse - 1]!));
+    }
+
+    public isEmpty() {
+        return this.wordsInUse == 0;
+    }
+}
+
+export default BitSet;

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/math.ts

@@ -112,4 +112,46 @@ 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 
+ */
+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 
+ */
+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,8 @@ 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>;
+
+export interface RegistryData {
+    registry_id: string,
+    entries: { entry_id: string, data: Record<string, any> | null }[]
+}

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

@@ -62,9 +62,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