@vaitosoi/minejs 0.6.0 → 0.6.1

package/src/packet/listener.ts

@@ -56,7 +56,7 @@ 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,
@@ -315,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,
@@ -523,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(),

package/src/packet/sender.ts

@@ -6,7 +6,7 @@ import { ClientStatus, ConnectionState, ServerKnownPack, SharedState } from "../
 import { sliceBuffer } from "../base/buffer";
 import { randomUUIDBytes } from "../base/math";
 import { Angle, BaseVec3, Direction } from "../physics/direction";
-import { MessageTooLong, NotImplemented } from "../base/error";
+import { MessageTooLong, MissingField, NotImplemented } from "../base/error";
 import BitSet from "../base/bitset";
 import { makeMovementFlag } from "../binary/encoder";
 import { BlockFace } from "../world/block";
@@ -98,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) {
@@ -185,7 +197,6 @@ export class Sender {
         cursorPositionOnBlock: BaseVec3,
         isInsideBlock: boolean,
         worldBorderHit: boolean,
-        sequence: number = randomInt(1024),
     ) {
         const face_ = (face instanceof Direction ? face.index3D : face) as number;
         this.sendPacket("use_item_on", {
@@ -197,7 +208,7 @@ export class Sender {
             cursor_position_z: cursorPositionOnBlock.z,
             inside_block: isInsideBlock,
             world_border_hit: worldBorderHit,
-            sequence
+            sequence: this.state.nextSequence()
         });
     }
 }

package/src/physics/aabb.ts

@@ -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,
@@ -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/version/codec.ts

@@ -112,6 +112,21 @@ export class VersionCodec {
         field: FieldNode,
         decoder: BinaryDecoder
     ): any {
+        // 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.dir({
+        //         packetId,
+        //         readObject,
+        //         fieldName,
+        //         field,
+        //         decoder
+        //     }, { depth: null });
         switch (field.type) {
             case "string": return decoder.readString();
             case "boolean": return decoder.readBoolean();
@@ -186,6 +201,23 @@ export class VersionCodec {
                     throw new SkippableNotImplemented();
                 throw new NotImplemented();
             }
+            case "infer": {
+                const args = field.args?.map(val =>
+                    typeof val === "number"
+                        ? val
+                        : val.startsWith("literal:")
+                            ? val.slice(8)
+                            : readObject[val]
+                ) || [];
+                let func: (...args: any[]) => any = () => undefined;
+                switch (field.function) {
+                    case "bit_and": func = (a: number, b: number) => a & b; break;
+                    case "bit_or": func = (a: number, b: number) => a | b; break;
+                    case "shift_left": func = (val: number, pos: number) => val << pos; break;
+                    case "shift_right": func = (val: number, pos: number) => val >>> pos; break;
+                }
+                return func(...args);
+            }
             case "switch": {
                 if (!(field.dependsOn in readObject)) throw new MissingPacketField(packetId, fieldName, field.dependsOn);
                 const dependencyValue = readObject[field.dependsOn];

package/src/version/registry.ts

@@ -204,6 +204,7 @@ export const SupportTypes = z.enum([
     "slot",
     "null", // a constant
     "special",
+    "infer",
 
     /**
      * This is used for handle field that its type depends on previous field type, or value
@@ -226,6 +227,7 @@ export type FieldNode = ({
         | "fixed_bitset"
         | "byte_array"
         | "special"
+        | "infer"
     >,
 } | {
     type: "not_implemented",
@@ -262,13 +264,32 @@ export type FieldNode = ({
 } | {
     type: "special",
     comment: string,
+} | { // Call a function
+    type: "infer",
+    args?: (string | number)[] | undefined,
+    function: string
 }) & {
     skip_able?: boolean | undefined
 }
 /** @hidden */
 export const Field: z.ZodType<FieldNode> = z.union([
     z.object({
-        type: SupportTypes.exclude(["prefixed_array", "prefixed_optional", "string", "id_or_x", "array", "switch", "fixed_point", "enum", "not_implemented", "object", "fixed_bitset", "byte_array", "special"]),
+        type: SupportTypes.exclude([
+            "prefixed_array",
+            "prefixed_optional",
+            "string",
+            "id_or_x",
+            "array",
+            "switch",
+            "fixed_point",
+            "enum",
+            "not_implemented",
+            "object",
+            "fixed_bitset",
+            "byte_array",
+            "special",
+            "infer"
+        ]),
     }),
     z.object({
         type: z.literal(["not_implemented"]),
@@ -290,7 +311,9 @@ export const Field: z.ZodType<FieldNode> = z.union([
         length: z.number().optional()
     }),
     z.object({
-        type: z.literal(["id_or_x", "enum", "prefixed_optional"]),
+        type: z.literal(["id_or_x",
+            "enum",
+            "prefixed_optional"]),
         /**
          * For case like `Array<subType>` or `PrefixedOptional<subType>`
          */
@@ -344,9 +367,14 @@ export const Field: z.ZodType<FieldNode> = z.union([
         length: z.int()
     }),
     z.object({
-        type: z.literal(["special"]),
+        type: z.literal("special"),
         comment: z.string()
     }),
+    z.object({
+        type: z.literal("infer"),
+        args: z.string().or(z.number()).array().optional(),
+        function: z.string(),
+    })
 ])
     .and(
         z.object({
@@ -398,7 +426,8 @@ export class PacketRegistry {
         if (this.loaded) return;
         this.loaded = true;
 
-        const json = getFile(version, "packets") as Record<string, any>;
+        const json = getFile(version,
+            "packets") as Record<string, any>;
 
         const definition = VersionDefinitions.parse(json);
         for (const [stateKey, state] of Object.entries(definition)) {
@@ -427,7 +456,8 @@ export class PacketRegistry {
             numbericId = parseInt(id, 16);
         else numbericId = id;
         if (isNaN(numbericId))
-            throw new UnexpectedValue("valid packet id", id.toString(), "name or number or hex");
+            throw new UnexpectedValue("valid packet id", id.toString(),
+                "name or number or hex");
         else
             return this.definition[state][type]["0x" + numbericId.toString(16).toUpperCase()];
     }

package/src/world/block.ts

@@ -44,6 +44,10 @@ export class BlockState {
         if (defaultVal) return defaultVal;
         return null;
     }
+
+    /**
+     * Get the block facing
+     */
     public getFacing(): "north" | "south" | "west" | "east" | null { return this.get("facing"); }
 }
 
@@ -51,6 +55,9 @@ export class BlockState {
  * Represent a block
  */
 export class Block {
+    /**
+     * A block will have multiple states (example: a stair will have difference facing).
+     */
     public states: BlockState[];
 
     constructor(
@@ -74,16 +81,46 @@ export class Block {
         if (defaultVal) return defaultVal;
         return null;
     }
-    public getType() { return this.get("type")!; }
+    
+    /**
+     * Get the block type.
+     * 
+     * A block type will contain multiple blocks, like type `wall_sign` will have 
+     * `oak_wall_sign`, `spruce_wall_sign`, `acacia_wall_sign`, etc...
+     */
+    public getType() { return this.get<string>("type")!; }
+    /**
+     * Get the block friction.
+     * 
+     * By default, block friction is 0.6, except for ice block family.
+     */
     public getFriction() { return this.get("friction", 0.6); }
+    /**
+     * Get the block bounciness.
+     * 
+     * By default, block friction is 0, except for slime block.
+     */
     public getBounciness() { return this.get("bounciness", 0); }
+    /**
+     * Get the block speed factor.
+     * 
+     * By default, block friction is 1, except for soul sand block.
+     */
     public getSpeedFactor() { return this.get("speed_factor", 1); }
+    /**
+     * Check if the block is climable.
+     * 
+     * By default, block friction is false, except for ladder and vine.
+     */
     public getClimbable() { return this.get("climbable", false); }
+    /**
+     * Get the block jump factor.
+     */
     public getJumpFactor() { return this.get("jump_factor", 1); }
 }
 
 /**
- * Somehow, this is an equivalent implementation of Minecraft `Level`
+ * This class is for fetching blocks and chunks data.
  */
 export class BlockManager {
     constructor(private state: SharedState) { }
@@ -115,7 +152,9 @@ export class BlockManager {
         this.state.checkReady();
         let { x, y, z } = Vec3.loadArgs(a, b, c);
         x = Math.floor(x); y = Math.floor(y); z = Math.floor(z);
+        // Chunk position
         const sx = Math.floor(x / 16), sy = Math.floor((y + 64) / 16), sz = Math.floor(z / 16);
+        // Block position within the chunk
         const px = ((x % 16) + 16) % 16, py = ((y % 16) + 16) % 16, pz = ((z % 16) + 16) % 16;
 
         if (this.state.cache)
@@ -166,6 +205,13 @@ export class BlockManager {
         const state = arr.at(this.getLocalPosKey(localPos))!;
         return this.getBlock(state);
     }
+    /**
+     * Delete the chunk cache
+     * 
+     * @param sx chunk x
+     * @param sy section y
+     * @param sz chunk z
+     */
     public deleteChunkCache(
         sx: number, sy: number, sz: number,
     ) {
@@ -193,7 +239,6 @@ export class BlockManager {
         const stateId = bitsPerEntry <= 8 ? section.palette[localId]! : localId;
 
         return BlockRegistry.getState(String(stateId));
-
     }
     private getLocalPosKey(pos: BaseVec3) {
         return pos.x + 16 * (pos.y + 16 * pos.z);
@@ -255,8 +300,6 @@ export class BlockGetter {
         consumer: (context: C, position: BaseVec3) => T,
         missFactory: (context: C) => T
     ): T {
-        let result: T;
-
         if (from.equal(to)) return missFactory(context);
         const toX = lerp(-Epsilon, to.x, from.x);
         const toY = lerp(-Epsilon, to.y, from.y);
@@ -281,29 +324,28 @@ export class BlockGetter {
         let tX = signX === 0 ? Infinity : tDeltaX * (signX > 0 ? 1 - getFrac(fromX) : getFrac(fromX));
         let tY = signY === 0 ? Infinity : tDeltaY * (signY > 0 ? 1 - getFrac(fromY) : getFrac(fromY));
         let tZ = signZ === 0 ? Infinity : tDeltaZ * (signZ > 0 ? 1 - getFrac(fromZ) : getFrac(fromZ));
-        do {
-            if (tX <= 1.0 || tY <= 1.0 || tZ <= 1.0) {
-                if (tX < tY) {
-                    if (tX < tZ) {
-                        currentBlockX += signX;
-                        tX += tDeltaX;
-                    } else {
-                        currentBlockZ += signZ;
-                        tZ += tDeltaZ;
-                    }
-                } else if (tY < tZ) {
-                    currentBlockY += signY;
-                    tY += tDeltaY;
+        while (tX <= 1.0 || tY <= 1.0 || tZ <= 1.0) {
+            if (tX < tY) {
+                if (tX < tZ) {
+                    currentBlockX += signX;
+                    tX += tDeltaX;
                 } else {
                     currentBlockZ += signZ;
                     tZ += tDeltaZ;
                 }
-                result = consumer(context, { x: currentBlockX, y: currentBlockY, z: currentBlockZ });
+            } else if (tY < tZ) {
+                currentBlockY += signY;
+                tY += tDeltaY;
             } else {
-                return missFactory(context);
+                currentBlockZ += signZ;
+                tZ += tDeltaZ;
             }
-        } while (result == null);
-        return result;
+            const result = consumer(context, { x: currentBlockX, y: currentBlockY, z: currentBlockZ });
+
+            if (result !== null)
+                return result;
+        }
+        return missFactory(context);
     }
 }