@vaitosoi/minejs 0.5.1 → 0.6.1

package/src/packet/listener.ts

@@ -12,6 +12,7 @@ import { AuthRelatedNotFound, HaveSignatureButNotIndex, MessageLinkNotFound, Not
 import { uuidToBuffer } from "../base/math";
 import { MessageLink } from "../message/link";
 import { Sender } from "./sender";
+import { Container, Slot } from "../world/container";
 
 function zodParse<Type extends zod.ZodType>(data: object, zod: Type): zod.infer<Type> {
     return zod.parse(data);
@@ -55,13 +56,20 @@ export class Listener {
             "play:add_entity": this.handleSpawnEntity,
             "play:move_entity_pos": this.handleUpdateEntityPosition,
             "play:move_entity_pos_rot": this.handleUpdateEntityPositionRotation,
-            "play:entity_position_sync": this.handleTeleportEntity,
+            "play:entity_position_sync": this.handleEntityPositionSync,
             "play:player_position": this.handleSynchronizePlayerPosition,
             "play:update_mob_effect": this.handleUpdateMobEffect,
             "play:remove_entities": this.handleRemoveEntity,
             "play:remove_mob_effect": this.handleRemoveMobEffect,
             // "play:rotate_head": ,
             "play:set_entity_motion": this.handleSetEntityVelocity,
+
+            "play:open_screen": this.handleOpenScreen,
+            "play:container_close": this.handleCloseContainer,
+            "play:container_set_content": this.handleContainerContent,
+            "play:container_set_data": this.handleContainerProperty,
+
+            "play:tab_list": this.handleSetTablist
         };
     }
 
@@ -76,7 +84,11 @@ export class Listener {
     // Login
 
     private handleLoginDisconnect(data: object) {
-        const { reason } = zodParse(data, zod.object({ reason: zod.record(zod.string(), zod.any()) }));
+        const { reason } = zodParse(data, zod.object({ reason: zod.record(zod.string(), zod.any()).or(zod.string()) }));
+
+        if (typeof reason === "string")
+            return this.disconnect(reason);
+
         const text = getTextFromTextComponent(reason);
 
         this.disconnect(text, reason);
@@ -146,7 +158,9 @@ export class Listener {
                 yaw: 0,
                 pitch: 0,
             },
-            effects: {}
+            effects: {},
+            inventory: new Container(0, -1, {}),
+            carryingItem: undefined
         } satisfies ClientPlayer as any;
         this.sender.sendLoginAck();
     }
@@ -301,8 +315,8 @@ export class Listener {
                 angle: newAngle,
             } satisfies ClientPlayer as any
         );
-        this.state.enqueueEvent("playerPosition", { x: newPosX, y: newPosY, z: newPosZ });
-        this.sender.sendConfirmTeleportation(teleport_id);
+        this.state.enqueueEvent("playerPosition", newPosition);
+        this.sender.sendConfirmTeleportation(teleport_id, newPosition, newAngle);
         this.sender.sendPacket("move_player_pos_rot", {
             x: newPosition.x,
             feet_y: newPosition.y,
@@ -509,89 +523,191 @@ export class Listener {
         this.state.enqueueEvent("spawnEntity", entity);
     }
 
-    private handleTeleportEntity(data: object) {
-        const {
-            entity_id,
-            x,
-            y,
-            z,
-            velocity_x,
-            velocity_y,
-            velocity_z,
-            pitch,
-            yaw
-        } = zodParse(data, zod.object({
-            entity_id: zod.int(),
-            x: zod.number(),
-            y: zod.number(),
-            z: zod.number(),
-            velocity_x: zod.number(),
-            velocity_y: zod.number(),
-            velocity_z: zod.number(),
-            pitch: zod.number(),
-            yaw: zod.number(),
-        }));
+    private handleEntityPositionSync(data: object) {
+        if (this.state.getProtocolId() > 776) {
 
-        if (entity_id in this.state.world!.entities) this.state.enqueueMutation(state => {
-            state.world!.entities[entity_id]!.position = { x, y, z };
-            state.world!.entities[entity_id]!.velocity = { x: velocity_x, y: velocity_y, z: velocity_z };
-            state.world!.entities[entity_id]!.angle = { pitch, yaw };
-        });
-        this.state.enqueueEvent("updateEntity", entity_id);
+            const {
+                entity_id,
+                linear,
+                stepped,
+                pitch,
+                yaw
+            } = zodParse(data, zod.object({
+                entity_id: zod.int(),
+                linear: zod.object({
+                    x: zod.number(),
+                    y: zod.number(),
+                    z: zod.number(),
+                }).nullable(),
+                stepped: zod.object({
+                    x: zod.number(),
+                    y: zod.number(),
+                    z: zod.number(),
+                    tick_offset: zod.number()
+                }).array().nullable(),
+                pitch: zod.number(),
+                yaw: zod.number(),
+            }));
+            const { x, y, z } = linear ? linear : stepped![stepped!.length - 1]!;
+
+            if (entity_id in this.state.world!.entities) this.state.enqueueMutation(state => {
+                state.world!.entities[entity_id]!.position = { x, y, z };
+                state.world!.entities[entity_id]!.angle = { pitch, yaw };
+            });
+            this.state.enqueueEvent("updateEntity", entity_id);
+        } else {
+            const {
+                entity_id,
+                x,
+                y,
+                z,
+                velocity_x,
+                velocity_y,
+                velocity_z,
+                pitch,
+                yaw
+            } = zodParse(data, zod.object({
+                entity_id: zod.int(),
+                x: zod.number(),
+                y: zod.number(),
+                z: zod.number(),
+                velocity_x: zod.number(),
+                velocity_y: zod.number(),
+                velocity_z: zod.number(),
+                pitch: zod.number(),
+                yaw: zod.number(),
+            }));
+
+            if (entity_id in this.state.world!.entities) this.state.enqueueMutation(state => {
+                state.world!.entities[entity_id]!.position = { x, y, z };
+                state.world!.entities[entity_id]!.velocity = { x: velocity_x, y: velocity_y, z: velocity_z };
+                state.world!.entities[entity_id]!.angle = { pitch, yaw };
+            });
+            this.state.enqueueEvent("updateEntity", entity_id);
+        }
     }
 
     private handleUpdateEntityPosition(data: object) {
-        const {
-            entity_id,
-            delta_x,
-            delta_y,
-            delta_z
-        } = zodParse(data, zod.object({
-            entity_id: zod.number(),
-            delta_x: zod.number(),
-            delta_y: zod.number(),
-            delta_z: zod.number(),
-        }));
+        if (this.state.getProtocolId() <= 776) { // Before 26.3
+            const {
+                entity_id,
+                delta_x,
+                delta_y,
+                delta_z
+            } = zodParse(data, zod.object({
+                entity_id: zod.number(),
+                delta_x: zod.number(),
+                delta_y: zod.number(),
+                delta_z: zod.number(),
+            }));
 
-        if (entity_id in this.state.world!.entities) this.state.enqueueMutation(state => {
-            let { x, y, z } = state.world!.entities[entity_id]!.position;
-            x += delta_x;
-            y += delta_y;
-            z += delta_z;
-            state.world!.entities[entity_id]!.position = { x, y, z };
-        });
-        this.state.enqueueEvent("updateEntity", entity_id);
-    }
+            if (entity_id in this.state.world!.entities) this.state.enqueueMutation(state => {
+                let { x, y, z } = state.world!.entities[entity_id]!.position;
+                x += delta_x;
+                y += delta_y;
+                z += delta_z;
+                state.world!.entities[entity_id]!.position = { x, y, z };
+            });
+            this.state.enqueueEvent("updateEntity", entity_id);
+        } else {
+            const {
+                entity_id,
+                step,
+                steps
+            } = zodParse(data, zod.object({
+                entity_id: zod.number(),
+                step: zod.object({
+                    delta_x: zod.number(),
+                    delta_y: zod.number(),
+                    delta_z: zod.number(),
+                }).nullable(),
+                steps: zod.object({
+                    tick_offset: zod.number(),
+                    delta_x: zod.number(),
+                    delta_y: zod.number(),
+                    delta_z: zod.number(),
+                }).array().nullable()
+            }));
+            const { delta_x, delta_y, delta_z } = step ? step : steps![steps!.length - 1]!;
 
-    private handleUpdateEntityPositionRotation(data: object) {
-        const {
-            entity_id,
-            delta_x,
-            delta_y,
-            delta_z,
-            pitch,
-            yaw
-        } = zodParse(data, zod.object({
-            entity_id: zod.number(),
-            delta_x: zod.number(),
-            delta_y: zod.number(),
-            delta_z: zod.number(),
-            pitch: zod.number(),
-            yaw: zod.number(),
-        }));
-        if (entity_id in this.state.world!.entities) {
-            this.state.enqueueMutation(state => {
+            if (entity_id in this.state.world!.entities) this.state.enqueueMutation(state => {
                 let { x, y, z } = state.world!.entities[entity_id]!.position;
                 x += delta_x;
                 y += delta_y;
                 z += delta_z;
                 state.world!.entities[entity_id]!.position = { x, y, z };
-                state.world!.entities[entity_id]!.angle = { yaw, pitch };
             });
             this.state.enqueueEvent("updateEntity", entity_id);
         }
     }
 
+    private handleUpdateEntityPositionRotation(data: object) {
+        if (this.state.getProtocolId() <= 776) { // Before 26.3
+            const {
+                entity_id,
+                delta_x,
+                delta_y,
+                delta_z,
+                pitch,
+                yaw
+            } = zodParse(data, zod.object({
+                entity_id: zod.number(),
+                delta_x: zod.number(),
+                delta_y: zod.number(),
+                delta_z: zod.number(),
+                pitch: zod.number(),
+                yaw: zod.number(),
+            }));
+            if (entity_id in this.state.world!.entities) {
+                this.state.enqueueMutation(state => {
+                    let { x, y, z } = state.world!.entities[entity_id]!.position;
+                    x += delta_x;
+                    y += delta_y;
+                    z += delta_z;
+                    state.world!.entities[entity_id]!.position = { x, y, z };
+                    state.world!.entities[entity_id]!.angle = { yaw, pitch };
+                });
+                this.state.enqueueEvent("updateEntity", entity_id);
+            }
+        } else {
+            const {
+                entity_id,
+                step,
+                steps,
+                pitch,
+                yaw
+            } = zodParse(data, zod.object({
+                entity_id: zod.number(),
+                step: zod.object({
+                    delta_x: zod.number(),
+                    delta_y: zod.number(),
+                    delta_z: zod.number(),
+                }).nullable(),
+                steps: zod.object({
+                    tick_offset: zod.number(),
+                    delta_x: zod.number(),
+                    delta_y: zod.number(),
+                    delta_z: zod.number(),
+                }).array().nullable(),
+                pitch: zod.number(),
+                yaw: zod.number(),
+            }));
+            const { delta_x, delta_y, delta_z } = step ? step : steps![steps!.length - 1]!;
+
+            if (entity_id in this.state.world!.entities) {
+                this.state.enqueueMutation(state => {
+                    let { x, y, z } = state.world!.entities[entity_id]!.position;
+                    x += delta_x;
+                    y += delta_y;
+                    z += delta_z;
+                    state.world!.entities[entity_id]!.position = { x, y, z };
+                    state.world!.entities[entity_id]!.angle = { yaw, pitch };
+                });
+                this.state.enqueueEvent("updateEntity", entity_id);
+            }
+        }
+    }
+
     private handleSetEntityVelocity(data: object) {
         const { entity_id, velocity } = zodParse(data, zod.object({
             entity_id: zod.number(),
@@ -693,12 +809,16 @@ export class Listener {
             filter_type: zod.int(),
             filter_type_bits: zod.array(zod.bigint()).nullable(),
             chat_type: zod.int().or(zod.record(zod.string(), zod.any())),
-            sender_name: zod.record(zod.string(), zod.any()),
-            target_name: zod.record(zod.string(), zod.any()).nullable()
+            sender_name: zod.record(zod.string(), zod.any()).or(zod.string()),
+            target_name: zod.record(zod.string(), zod.any()).or(zod.string()).nullable()
         }));
 
-        const senderNameText = getTextFromTextComponent(sender_name).toString(),
-            targetNameText = target_name ? getTextFromTextComponent(target_name).toString() : undefined;
+        const senderNameText = typeof sender_name === "string" ? sender_name : getTextFromTextComponent(sender_name).toString(),
+            targetNameText = target_name
+                ? typeof target_name === "string"
+                    ? target_name
+                    : getTextFromTextComponent(target_name).toString()
+                : undefined;
 
         const emitObject = {
             sender: senderNameText,
@@ -834,4 +954,83 @@ export class Listener {
             }
         });
     }
+
+    // Container
+    private handleOpenScreen(data: object) {
+        const {
+            window_id,
+            window_type,
+            window_title
+        } = zodParse(data, zod.object({
+            window_id: zod.int(),
+            window_type: zod.int(),
+            window_title: zod.record(zod.string(), zod.any())
+        }));
+        this.state.enqueueMutation(state => {
+            state.openingContainer = new Container(window_id, window_type, window_title);
+            this.emit("openContainer", this.state.openingContainer!);
+        });
+    }
+
+    private handleCloseContainer(data: object) {
+        // Not used by vanilla client
+        const { window_id } = zodParse(data, zod.object({ window_id: zod.int() }));
+
+        this.state.enqueueMutation(state => {
+            state.openingContainer = undefined;
+            this.emit("closeContainer");
+        });
+    }
+
+    private handleContainerContent(data: object) {
+        const {
+            window_id,
+            state_id,
+            slot_data,
+            carried_item
+        } = zodParse(data, zod.object({
+            window_id: zod.int(),
+            state_id: zod.int(),
+            slot_data: zod.array(zod.any() as zod.ZodType<Slot>),
+            carried_item: zod.any() as zod.ZodType<Slot>,
+        }));
+        this.state.enqueueMutation(state => {
+            if (!state.openingContainer) return;
+            state.openingContainer.stateId = state_id;
+            state.openingContainer.slots = slot_data;
+            state.player!.carryingItem = carried_item;
+            this.emit("containerContent", state.openingContainer, state.player!.carryingItem);
+        });
+    }
+
+    private handleContainerProperty(data: object) {
+        const {
+            window_id,
+            property,
+            value
+        } = zodParse(data, zod.object({
+            window_id: zod.number(),
+            property: zod.number(),
+            value: zod.number(),
+        }));
+        this.state.enqueueMutation(state => {
+            if (!state.openingContainer) return;
+            state.openingContainer.setProperty(property, value);
+            this.emit("containerProperty", state.openingContainer);
+        });
+    }
+
+    private handleSetTablist(data: object) {
+        const { header, footer } = zodParse(data, zod.object({
+            header: zod.record(zod.string(), zod.any()),
+            footer: zod.record(zod.string(), zod.any()),
+        }));
+        this.emit(
+            "tablist",
+            {
+                header: { text: getTextFromTextComponent(header), raw: header },
+                footer: { text: getTextFromTextComponent(footer), raw: footer },
+            }
+        );
+    }
 }

package/src/packet/sender.ts

@@ -1,14 +1,15 @@
-import { createPublicKey, publicEncrypt, constants as crypto_constants, randomBytes } from "node:crypto";
+import { createPublicKey, publicEncrypt, constants as crypto_constants, randomBytes, randomInt } 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 { Angle, BaseVec3, Direction } from "../physics/direction";
+import { MessageTooLong, MissingField, NotImplemented } from "../base/error";
 import BitSet from "../base/bitset";
 import { makeMovementFlag } from "../binary/encoder";
+import { BlockFace } from "../world/block";
 
 /**
  * Packet sender
@@ -97,10 +98,22 @@ export class Sender {
         });
     }
 
-    public sendConfirmTeleportation(teleportId: number) {
-        this.sendPacket("accept_teleportation", {
-            teleport_id: teleportId
-        });
+    public sendConfirmTeleportation(teleportId: number): void;
+    public sendConfirmTeleportation(teleportId: number, newPos: BaseVec3, newAngle: Angle): void;
+    public sendConfirmTeleportation(teleportId: number, newPos?: BaseVec3, newAngle?: Angle) {
+        if (this.state.getProtocolId() > 776) {
+            if (!newPos || !newAngle) throw new MissingField("newPos or newAngle", "confirm_teleportation packet on version 26.3 or over");
+            const { x, y, z } = newPos,
+                { yaw, pitch } = newAngle;
+            this.sendPacket("accept_teleportation", {
+                teleport_id: teleportId,
+                x, y, z,
+                yaw, pitch
+            });
+        } else
+            this.sendPacket("accept_teleportation", {
+                teleport_id: teleportId
+            });
     }
 
     public sendKeepAlive(id: bigint) {
@@ -176,4 +189,26 @@ export class Sender {
         });
         this.state.messageCount = 0;
     }
+
+    public sendUseItemOn(
+        hand: "main" | "off",
+        position: BaseVec3,
+        face: BlockFace | Direction,
+        cursorPositionOnBlock: BaseVec3,
+        isInsideBlock: boolean,
+        worldBorderHit: boolean,
+    ) {
+        const face_ = (face instanceof Direction ? face.index3D : face) as number;
+        this.sendPacket("use_item_on", {
+            hand: hand === "off" ? 1 : 0,
+            location: position,
+            face: face_,
+            cursor_position_x: cursorPositionOnBlock.x,
+            cursor_position_y: cursorPositionOnBlock.y,
+            cursor_position_z: cursorPositionOnBlock.z,
+            inside_block: isInsideBlock,
+            world_border_hit: worldBorderHit,
+            sequence: this.state.nextSequence()
+        });
+    }
 }

package/src/physics/aabb.ts

@@ -209,7 +209,7 @@ export class AABB implements BaseAABB {
      * Cliping math. Find smallest distance to reach a face of this AABB.
      */
     public static getDirection(aabb: BaseAABB, from: BaseVec3, delta: BaseVec3, direction_: Direction | null, scaleRef: [number]) {
-        let direction = structuredClone(direction_);
+        let direction = direction_;
         const { minX, maxX, minY, maxY, minZ, maxZ } = aabb;
         if (delta.x > Epsilon)
             direction = this.clipPoint(
@@ -217,7 +217,7 @@ export class AABB implements BaseAABB {
                 scaleRef,
                 { a: delta.x, b: delta.y, c: delta.z },
                 minX,
-                minY, maxX,
+                minY, maxY,
                 minZ, maxZ,
                 from.x, from.y, from.z
             );
@@ -227,7 +227,7 @@ export class AABB implements BaseAABB {
                 scaleRef,
                 { a: delta.x, b: delta.y, c: delta.z },
                 maxX,
-                minY, maxX,
+                minY, maxY,
                 minZ, maxZ,
                 from.x, from.y, from.z
             );
@@ -292,7 +292,7 @@ export class AABB implements BaseAABB {
         /**
          * `s` come from this equation:
          * ```
-         * fromA + s * deltaA = minA (or point here)
+         * fromA + s * deltaA = minA (or `point` here)
          * ```
          * Which find "how far the ray travels to reach a face of this bounding box".
          * 
@@ -305,7 +305,7 @@ export class AABB implements BaseAABB {
             pb = fromB + s * delta.b,
             pc = fromC + s * delta.c;
         if (
-            0 < s && s < scaleRef[0] &&
+            0 < s && s < scaleRef[0] + Epsilon &&
             minB - Epsilon < pb && pb < maxB + Epsilon &&
             minC - Epsilon < pc && pc < maxC + Epsilon
         ) {
@@ -585,13 +585,22 @@ export class VoxelShape {
     }
     private forAllBoxes(consumer: (bb: BaseAABB) => void, mergeNeighbor: boolean) {
         const shape = this.copy();
+        const consumerWithRawInd = (bb: BaseAABB) =>
+            consumer({
+                minX: shape.xs[bb.minX]!,
+                maxX: shape.xs[bb.maxX]!,
+                minY: shape.ys[bb.minY]!,
+                maxY: shape.ys[bb.maxY]!,
+                minZ: shape.zs[bb.minZ]!,
+                maxZ: shape.zs[bb.maxZ]!
+            });
         for (let y = 0; y < shape.getSize(BaseAxis.Y); y++)
             for (let x = 0; x < shape.getSize(BaseAxis.X); x++) {
                 let lastStartZ = -1;
                 for (let z = 0; z <= shape.getSize(BaseAxis.Z); z++) {
                     if (shape.isFullWide(x, y, z)) {
                         if (!mergeNeighbor)
-                            consumer({
+                            consumerWithRawInd({
                                 minX: x,
                                 maxX: x + 1,
                                 minY: y,
@@ -599,9 +608,9 @@ export class VoxelShape {
                                 minZ: z,
                                 maxZ: z + 1
                             });
-                        else if (lastStartZ !== -1)
+                        else if (lastStartZ === -1)
                             lastStartZ = z;
-                    } else if (lastStartZ === -1) {
+                    } else if (lastStartZ !== -1) {
                         let endX = x,
                             endY = y;
                         shape.clearZStrip(lastStartZ, z, endX, endY);
@@ -615,7 +624,7 @@ export class VoxelShape {
                             }
                             endY++;
                         }
-                        consumer({
+                        consumerWithRawInd({
                             minX: x,
                             maxX: endX + 1,
                             minY: y,

package/src/physics/direction.ts

@@ -17,7 +17,7 @@ export class Vec3 implements BaseVec3 {
      * Helper function for loading vec3 args
      */
     static loadArgs(a: BaseVec3 | number, b?: number, c?: number): BaseVec3 {
-        let x = 1, y = 1, z = 1;
+        let x = 0, y = 0, z = 0;
         if (typeof a === "object" && "x" in a) {
             x = a.x;
             y = a.y;
@@ -114,7 +114,7 @@ export class Vec3 implements BaseVec3 {
     public multiply(x: number, y: number, z: number): Vec3;
     public multiply(a: BaseVec3 | number, b?: number, c?: number) {
         let vec: BaseVec3;
-        if ((a && b && c) || (typeof a === "object" && "x" in a)) vec = Vec3.loadArgs(a, b, c);
+        if ((a !== undefined && b !== undefined && c !== undefined) || (typeof a === "object" && "x" in a)) vec = Vec3.loadArgs(a, b, c);
         else vec = { x: a, y: a, z: a };
         const x = this.x * vec.x;
         const y = this.y * vec.y;

package/src/physics/player.ts

@@ -473,11 +473,11 @@ export class Player {
             if (this.fallDistance != 0 && movement.length() >= 1) {
                 const checkDistance = Math.min(movement.length(), 8);
                 const checkTo = this.getPos().add(movement.normalize().scale(checkDistance));
-                const hitResult = BlockGetter.clip(this.getPos(), checkTo, {
-                    from: this.getPos(),
-                    to: checkTo,
-                    getBlockState: (position) => this.blocks.at(position)!.shape
-                });
+                const hitResult = BlockGetter.clip(
+                    this.getPos(), 
+                    checkTo,
+                    (position) => this.blocks.at(position)!.shape
+                );
                 if (hitResult?.miss !== false)
                     this.fallDistance = 0;
             }