@vaitosoi/minejs 0.5.1 → 0.6.1

package/src/version/codec.ts

@@ -49,11 +49,14 @@ export class VersionCodec {
                     if (err instanceof NotImplemented) return;
                     throw err;
                 }
-        if (this.state.clientOptions.debug?.packetLogger)
+        if (this.state.clientOptions.debug &&
+            this.state.clientOptions.debug.packetLogger &&
+            (this.state.clientOptions.debug.ignorePackets &&
+                !this.state.clientOptions.debug.ignorePackets.includes(packet.name)))
             console.dir({
                 dir: "to client",
                 state: mappedState,
-                name,
+                name: packet.name,
                 data: resolvedObject,
             });
 
@@ -66,11 +69,15 @@ export class VersionCodec {
         const packet = PacketRegistry.getPacket(mappedState, "serverbound", packetId);
         if (!packet) throw new UnexpectedValue("valid serverbound packet id", packetId.toString());
 
-        if (this.state.clientOptions.debug?.packetLogger)
+        if (this.state.clientOptions.debug &&
+            this.state.clientOptions.debug.packetLogger &&
+            (this.state.clientOptions.debug.ignorePackets &&
+                !this.state.clientOptions.debug.ignorePackets.includes(packet.name)))
             console.dir({
                 dir: "to server",
                 state: mappedState,
-                id: packetId,
+                id: packet.id,
+                name: packet.name,
                 data,
             });
 
@@ -105,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();
@@ -144,7 +166,17 @@ export class VersionCodec {
             case "chat_type_decoration": return decoder.readChatTypeDecoration();
             case "chat_type": return decoder.readChatType();
             case "enum": return this.readField(packetId, readObject, fieldName, field.subType, decoder);
-            case "json_text": return JSON.parse(decoder.readString());
+            case "json_text": {
+                const str = decoder.readString();
+                try {
+                    return JSON.parse(str);
+                } catch (err) {
+                    if (err instanceof SyntaxError)
+                        return str;
+                    else
+                        throw err;
+                }
+            }
             case "object": {
                 const obj: Record<string, any> = {};
                 for (const [key, type] of Object.entries(field.fields))
@@ -152,15 +184,7 @@ export class VersionCodec {
                 return obj;
             }
             case "game_profile": {
-                return {
-                    uuid: decoder.readUUID(),
-                    username: decoder.readString(),
-                    pproperties: decoder.readPrefixedArray((decoder) => ({
-                        name: decoder.readString(),
-                        value: decoder.readString(),
-                        signature: decoder.readPrefixedOptional((decoder) => decoder.readString())
-                    }))
-                };
+                return decoder.readProfile();
             }
             case "heightmap": {
                 return {
@@ -170,12 +194,30 @@ export class VersionCodec {
             }
             case "bitset": return decoder.readPrefixedArray((decoder) => decoder.readLong());
             case "teleport_flags": return decoder.readTeleportFlag();
+            case "slot": return decoder.readSlot();
             case "null": return null;
             case "not_implemented": {
                 if (field.skip_able === true)
                     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

@@ -1,4 +1,4 @@
-import { readFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { RegistryItemNotFound, UnexpectedValue, VersionNotSupport } from "../base/error";
 import { Block, BlockState } from "../world/block";
@@ -7,14 +7,27 @@ import z from "zod";
 const BASE_REGISTRY_PATH = join(__dirname, "..", "..", "assets", "minecraft");
 /** @hidden */
 export const SupportVersions = [
-    "26.2"
+    "26.2",
+    "26.3"
 ];
 
 /** @hidden */
 export const ProtocolVersionMapping: Record<string, number> = {
-    "26.2": 776
+    "26.2": 776,
+    "26.3": 777
 };
 
+function getFile(version: string, module: string) {
+    const map = JSON.parse(readFileSync(join(BASE_REGISTRY_PATH, "versionMapping.json"), "utf-8"));
+    if (!(version in map))
+        throw new VersionNotSupport(version);
+    const versionMap = map[version];
+    if (!(module in versionMap))
+        throw new VersionNotSupport(version);
+    const fileContent = JSON.parse(readFileSync(join(BASE_REGISTRY_PATH, versionMap[module], `${module}.json`), "utf-8"));
+    return fileContent;
+}
+
 export class EntityRegistry {
     private static loaded: boolean = false;
     public static readonly data: Record<string, { height: number, width: number, type: number }> = {};
@@ -25,14 +38,13 @@ export class EntityRegistry {
      * 
      * Should be called once time
      */
-    public static async load(version: string) {
+    public static load(version: string) {
         if (!SupportVersions.includes(version))
             throw new VersionNotSupport(version);
         if (this.loaded) return;
         this.loaded = true;
 
-        const file = await readFile(join(BASE_REGISTRY_PATH, version, "entities.json"), { encoding: "utf8" });
-        const json = JSON.parse(file);
+        const json = getFile(version, "entities");
         for (const entity in json) {
             this.data[entity] = json[entity];
             this.mapTypeToData[json[entity]["id"]] = entity;
@@ -68,14 +80,13 @@ export class BlockRegistry {
      * 
      * Should be called once time
      */
-    public static async load(version: string) {
+    public static load(version: string) {
         if (!SupportVersions.includes(version))
             throw new VersionNotSupport(version);
         if (this.loaded) return;
         this.loaded = true;
 
-        const file = await readFile(join(BASE_REGISTRY_PATH, version, "blocks.json"), { encoding: "utf8" });
-        const json = JSON.parse(file) as Record<string, any>;
+        const json = getFile(version, "blocks") as Record<string, any>;
         for (const [type, blockRaw] of Object.entries(json)) {
             const block = new Block(type, blockRaw['definition'], blockRaw['properties'], blockRaw['states']);
             this.blocks[type] = block;
@@ -113,20 +124,44 @@ export class EffectRegistry {
      * 
      * Should be called once time
      */
-    public static async load(version: string) {
+    public static load(version: string) {
         if (!SupportVersions.includes(version))
             throw new VersionNotSupport(version);
         if (this.loaded) return;
         this.loaded = true;
 
-        const file = await readFile(join(BASE_REGISTRY_PATH, version, "effects.json"), { encoding: "utf8" });
-        const json = JSON.parse(file) as Record<string, any>;
+        const json = getFile(version, "effects") as Record<string, any>;
         for (const [name, id] of Object.entries(json)) {
             this.effects[name] = id;
         }
     }
 }
 
+export class ComponentTypeRegistry {
+    private static loaded: boolean = false;
+
+    public static readonly components: Record<string, number> = {};
+    public static readonly idToName: Record<number, string> = {};
+
+    /**
+     * Load effects registry from JSON file.
+     * 
+     * Should be called once time
+     */
+    public static load(version: string) {
+        if (!SupportVersions.includes(version))
+            throw new VersionNotSupport(version);
+        if (this.loaded) return;
+        this.loaded = true;
+
+        const json = getFile(version, "components") as Record<string, number>;
+        for (const [name, id] of Object.entries(json)) {
+            this.components[name] = id;
+            this.idToName[id] = name;
+        }
+    }
+}
+
 /** @hidden */
 export const SupportTypes = z.enum([
     "byte",
@@ -166,7 +201,10 @@ export const SupportTypes = z.enum([
     "bitset",
     "fixed_bitset",
     "byte_array",
+    "slot",
     "null", // a constant
+    "special",
+    "infer",
 
     /**
      * This is used for handle field that its type depends on previous field type, or value
@@ -188,6 +226,8 @@ export type FieldNode = ({
         | "not_implemented"
         | "fixed_bitset"
         | "byte_array"
+        | "special"
+        | "infer"
     >,
 } | {
     type: "not_implemented",
@@ -221,13 +261,35 @@ export type FieldNode = ({
 } | {
     type: "fixed_bitset" | "byte_array",
     length: number,
+} | {
+    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"]),
+        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"]),
@@ -249,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>`
          */
@@ -301,6 +365,15 @@ export const Field: z.ZodType<FieldNode> = z.union([
         // These type require predefined-length
         type: z.union([z.literal("fixed_bitset"), z.literal("byte_array")]),
         length: z.int()
+    }),
+    z.object({
+        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(
@@ -347,14 +420,14 @@ export class PacketRegistry {
      * 
      * Should be called once time
      */
-    public static async load(version: string) {
+    public static load(version: string) {
         if (!SupportVersions.includes(version))
             throw new VersionNotSupport(version);
         if (this.loaded) return;
         this.loaded = true;
 
-        const file = await readFile(join(BASE_REGISTRY_PATH, version, "packets.json"), { encoding: "utf8" });
-        const json = JSON.parse(file) 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)) {
@@ -383,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

@@ -5,6 +5,15 @@ import { BaseVec3, Direction, Vec3 } from "../physics/direction";
 import { SharedState } from "./state";
 import { NotImplemented } from "../base/error";
 
+export enum BlockFace {
+    Bottom = 0,
+    Top = 1,
+    North = 2,
+    South = 3,
+    West = 4,
+    East = 5,
+}
+
 /**
  * Represent a state of a block
  */
@@ -35,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"); }
 }
 
@@ -42,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(
@@ -65,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) { }
@@ -106,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)
@@ -129,13 +177,10 @@ export class BlockManager {
         const sectionCache = this.state.cache.get(sectionKey);
         if (sectionCache) {
             const cachedState = sectionCache.at(this.getLocalPosKey(localPos));
-            if (cachedState) {
-                console.log("cache hit", sectionKey, localPos);
+            if (cachedState)
                 return this.getBlock(cachedState);
-            }
         }
 
-        console.log("cache miss", sectionKey, localPos);
         const section = this.state.world!.chunks[`${this.state.player!.dimension}:${sx}:${sz}`]?.sections[sy]?.block;
         if (!section) return null;
         if (section.data === null) return BlockRegistry.getState(section.palette[0]!.toString())!;
@@ -160,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,
     ) {
@@ -187,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);
@@ -219,11 +270,6 @@ export class BlockManager {
     }
 }
 
-interface Context {
-    getBlockState: (position: BaseVec3) => VoxelShape,
-    from: Vec3,
-    to: Vec3
-}
 
 /**
  * For clipping math
@@ -231,9 +277,9 @@ interface Context {
  * @hidden
  */
 export class BlockGetter {
-    public static clip(from: Vec3, to: Vec3, context: Context) {
+    public static clip(from: Vec3, to: Vec3, getBlockState: (position: BaseVec3) => VoxelShape) {
         return this.traverseBlocks(
-            from, to, context,
+            from, to, { getBlockState, from, to },
             (context, pos) => {
                 const blockState = context.getBlockState(pos);
                 const { from, to } = context;
@@ -247,14 +293,13 @@ export class BlockGetter {
         );
     }
 
-    public static traverseBlocks<T, C = Context>(
+    public static traverseBlocks<T, C>(
         from: Vec3,
         to: Vec3,
         context: C,
         consumer: (context: C, position: BaseVec3) => T,
-        missFactory: (context: C) => T): T {
-        let result: T;
-
+        missFactory: (context: C) => T
+    ): T {
         if (from.equal(to)) return missFactory(context);
         const toX = lerp(-Epsilon, to.x, from.x);
         const toY = lerp(-Epsilon, to.y, from.y);
@@ -276,32 +321,31 @@ export class BlockGetter {
         const tDeltaX = signX == 0 ? Infinity : signX / dx;
         const tDeltaY = signY == 0 ? Infinity : signY / dy;
         const tDeltaZ = signZ == 0 ? Infinity : signZ / dz;
-        let tX = tDeltaX * (signX > 0 ? 1 - getFrac(fromX) : getFrac(fromX));
-        let tY = tDeltaY * (signY > 0 ? 1 - getFrac(fromY) : getFrac(fromY));
-        let tZ = 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;
+        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));
+        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);
     }
 }
 
@@ -319,7 +363,7 @@ export class BlockHitResult {
     ) { }
 
     public static hit(location: Vec3, direction: Direction, pos: BaseVec3) {
-        return new BlockHitResult(true, location, direction, pos);
+        return new BlockHitResult(false, location, direction, pos);
     }
 
     public static miss(location: Vec3, direction: Direction, pos: BaseVec3) {