@vaitosoi/minejs 0.4.3 → 0.5.1

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

@@ -1,61 +1,70 @@
 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 {
+/**
+ * Packet listener
+ */
+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 +108,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 +145,10 @@ export class Dispatcher {
             angle: {
                 yaw: 0,
                 pitch: 0,
-            }
+            },
+            effects: {}
         } satisfies ClientPlayer as any;
-        this.sendLoginAck();
+        this.sender.sendLoginAck();
     }
 
     // Configure
@@ -152,8 +162,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 +181,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 +236,7 @@ export class Dispatcher {
         this.state.status = ClientStatus.Ready;
 
         if (this.state.useEncryption)
-            this.sendPlayerSession();
+            this.sender.sendPlayerSession();
 
         this.emit("ready");
     }
@@ -291,8 +302,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 +319,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) {
@@ -602,6 +613,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 {
@@ -677,6 +735,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 +776,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 +834,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)
-        });
-    }
 }

package/src/packet/sender.ts

@@ -0,0 +1,179 @@
+import { createPublicKey, publicEncrypt, constants as crypto_constants, randomBytes } from "node:crypto";
+import { TypedEmmiter } from "../base/event";
+import { ClientEvents } from "../client/client";
+import { ProtocolVersionMapping } from "../version/registry";
+import { ClientStatus, ConnectionState, ServerKnownPack, SharedState } from "../world/state";
+import { sliceBuffer } from "../base/buffer";
+import { randomUUIDBytes } from "../base/math";
+import { Angle, BaseVec3 } from "../physics/direction";
+import { MessageTooLong, NotImplemented } from "../base/error";
+import BitSet from "../base/bitset";
+import { makeMovementFlag } from "../binary/encoder";
+
+/**
+ * Packet sender
+ */
+export class Sender {
+    constructor(
+        private state: SharedState,
+        private emit: TypedEmmiter<ClientEvents>["emit"]
+    ) { }
+
+    public sendPacket: (packetId: string, data: object) => void = () => { throw new NotImplemented(); };
+
+    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")
+        });
+    }
+
+    public 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 }
+        });
+    }
+
+    public sendLoginAck() {
+        this.sendPacket("login_acknowledged", {});
+        this.state.state = ConnectionState.Configure;
+        this.state.server = {};
+    }
+
+    // Configuring
+
+    public sendKnownPack(knownPacks: ServerKnownPack[]) {
+        this.sendPacket("select_known_packs", {
+            known_packs: {
+                value: knownPacks,
+                length: knownPacks.length
+            }
+        });
+    }
+
+    public sendConfigureAck() {
+        this.sendPacket("finish_configuration", {});
+        this.state.state = ConnectionState.Play;
+    }
+
+    // Play
+
+    public 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
+        });
+    }
+
+    public sendConfirmTeleportation(teleportId: number) {
+        this.sendPacket("accept_teleportation", {
+            teleport_id: teleportId
+        });
+    }
+
+    public 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)
+        });
+    }
+
+    public sendMessage(
+        content: string
+    ) {
+        if (content.length > 256)
+            throw new MessageTooLong(content);
+        const bitset = new BitSet(20);
+        const timestamp = Date.now();
+        const salt = randomBytes(8).readBigInt64BE();
+        this.sendPacket("chat", {
+            message: content,
+            timestamp,
+            salt,
+            signature: null, // skip for now
+            message_count: this.state.messageCount,
+            acknowledged: bitset,
+            checksum: 0
+        });
+        this.state.messageCount = 0;
+    }
+}

package/src/physics/aabb.ts

@@ -14,6 +14,9 @@ export interface BaseAABB {
     maxZ: number;
 }
 
+/**
+ * Represent an axis-aligned bounding box
+ */
 export class AABB implements BaseAABB {
     public minX: number;
     public minY: number;
@@ -348,7 +351,7 @@ export class VoxelShape {
             mergeY.forMergedIndex((y1, y2, yr) => {
                 mergeZ.forMergedIndex((z1, z2, zr) => {
                     if (a.isFullWide(x1, y1, z1) || b.isFullWide(x2, y2, z2))
-                        storage.set(getCoords(xr, yr, zr), 1);
+                        storage.set(getCoords(xr, yr, zr));
                 });
             });
         });
@@ -377,12 +380,13 @@ export class VoxelShape {
             this.storage = cells;
         else {
             this.storage = new BitSet();
-            this.storage.setRange(0, (((xs.length - 1) * ys.length) + (ys.length - 1)) * zs.length + (zs.length - 1), 0);
+            if ((((xs.length - 1) * ys.length) + (ys.length - 1)) * zs.length + (zs.length - 1) > 0)
+                this.storage.clearRange(0, (((xs.length - 1) * ys.length) + (ys.length - 1)) * zs.length + (zs.length - 1));
             for (let x = 0; x < cells.length; x++)
                 for (let y = 0; y < cells[x]!.length; y++)
                     for (let z = 0; z < cells[x]![y]!.length; z++)
                         if (cells[x]![y]![z] === true)
-                            this.storage.set(this.getIndex(x, y, z), 1);
+                            this.storage.set(this.getIndex(x, y, z));
         }
     }
 
@@ -432,7 +436,7 @@ export class VoxelShape {
         if (x < 0 || x >= this.xs.length - 1) return false;
         if (y < 0 || y >= this.ys.length - 1) return false;
         if (z < 0 || z >= this.zs.length - 1) return false;
-        return this.storage.get(this.getIndex(x, y, z)) === 1;
+        return this.storage.get(this.getIndex(x, y, z));
     }
 
     /**
@@ -637,7 +641,7 @@ export class VoxelShape {
         return true;
     }
     private clearZStrip(startZ: number, endZ: number, x: number, y: number) {
-        this.storage.clear(this.getIndex(x, y, startZ), this.getIndex(x, y, endZ));
+        this.storage.clearRange(this.getIndex(x, y, startZ), this.getIndex(x, y, endZ));
     }
 }
 
@@ -679,10 +683,10 @@ class NoneOverlappingMerger extends IndexMerger {
     }
 
     private forMergedIndexNotSwapped(consumer: IndexMergerConsumer) {
-        for (const i of this.lower)
+        for (let i = 0; i < this.lower.length; i++)
             consumer(i, -1, i);
 
-        for (const i of this.upper)
+        for (let i = 0; i < this.upper.length; i++)
             consumer(this.lower.length - 1, i, this.lower.length + i);
     }
 
@@ -702,7 +706,7 @@ class IdenticalMerger extends IndexMerger {
     }
 
     public forMergedIndex(consumer: IndexMergerConsumer): void {
-        for (const i of this.coords)
+        for (let i = 0; i < this.coords.length; i++)
             consumer(i, i, i);
     }
 

package/src/physics/direction.ts

@@ -4,6 +4,9 @@ export interface BaseVec3 {
     z: number
 }
 
+/**
+ * Represent a vector which has 3 coords
+ */
 export class Vec3 implements BaseVec3 {
     public static readonly Zero = new Vec3(0, 0, 0);
     public static readonly XAxis = new Vec3(1, 0, 0);