@vaitosoi/minejs 0.4.2 → 0.5.0

package/src/packet/sender.ts

@@ -0,0 +1,176 @@
+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";
+
+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

@@ -348,7 +348,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 +377,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 +433,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 +638,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 +680,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 +703,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/player.ts

@@ -8,7 +8,7 @@ import { LevelHeightLimit } from "../client/static";
 import { SharedState } from "../world/state";
 import { TypedEmmiter } from "../base/event";
 import { ClientEvents } from "../client/client";
-import { makeMovementFlag } from "../packet/encoder";
+import { EffectRegistry } from "../version/registry";
 
 export enum Input {
     Forward = "W",
@@ -175,11 +175,21 @@ export class Player {
         this.state.checkReady();
         return this.state.player!.dimension;
     }
+    private hasEffect(effectName: string) {
+        this.state.checkReady();
+        const id = EffectRegistry.effects[effectName];
+        if (!id) return false;
+        if (!(id in this.state.player!.effects)) return false;
+        const effect = this.state.player!.effects[id]!;
+        if (effect.duration < 0) return true;
+        if (effect.date + (effect.duration / 20) * 1000 < Date.now()) return true;
+        return false;
+    }
 
     private setDeltaMovement(x: number, y: number, z: number): void;
     private setDeltaMovement(vec: BaseVec3): void;
     private setDeltaMovement(a: BaseVec3 | number, b?: number, c?: number): void {
-        const vec3 = a instanceof Vec3 ? a : new Vec3(Vec3.loadArgs(a, b, c));
+        const vec3 = new Vec3(Vec3.loadArgs(a, b, c));
         if (vec3.isFinite())
             this.deltaMovement = vec3;
     }
@@ -320,9 +330,14 @@ export class Player {
         }
         // TODO: Handle in fluid
 
-        // TODO: Handle potion effect: Slow falling and Levitation
+        // Handle potion effect: Slow falling and Levitation
+        if (
+            this.hasEffect("minecraft:levitation") ||
+            this.hasEffect("minecraft:slow_falling")
+        )
+            this.fallDistance = 0;
 
-        // TODO: Push entities
+        // // TODO: Push entities
         // console.log({
         //     type: "BEFORE-TRAVEL",
         //     pos: this.getPos(),
@@ -415,7 +430,7 @@ export class Player {
 
     private getSpeed() {
         // return the base for now
-        // TODO: Handle other cases: sprinting, speed-enchanted gear and potion
+        // TODO: Handle other cases: speed-enchanted gear and potion
         return this.isSprinting ? 0.13 : 0.1;
     }
 

package/src/version/codec.ts

@@ -1,9 +1,10 @@
 import z from "zod";
-import { MissingField, MissingPacketField, NotImplemented, UnexpectedValue } from "../base/error";
-import { BinaryDecoder } from "../packet/decoder";
+import { MissingField, MissingPacketField, NotImplemented, SkippableNotImplemented, UnexpectedValue } from "../base/error";
+import { BinaryDecoder } from "../binary/decoder";
 import { ConnectionState, SharedState } from "../world/state";
 import { FieldNode, PacketObject, PacketRegistry, VersionDefinitions } from "./registry";
-import { BinaryEncoder } from "../packet/encoder";
+import { BinaryEncoder } from "../binary/encoder";
+import { BitSet } from "../base/bitset";
 
 const TCPStateMapping: Record<ConnectionState, keyof z.infer<typeof VersionDefinitions> | null> = {
     [ConnectionState.Disconnected]: null,
@@ -39,6 +40,7 @@ export class VersionCodec {
                 try {
                     resolvedObject[name] = this.readField(packetId, resolvedObject, name, field, decoder);
                 } catch (err) {
+                    if (err instanceof SkippableNotImplemented) break;
                     if (err instanceof NotImplemented) return;
                     throw err;
                 }
@@ -72,7 +74,7 @@ export class VersionCodec {
         for (const [name, field] of Object.entries(structure)) {
             if (!(name in data))
                 throw new MissingField(name, `packet ${packetName}`);
-            if (typeof data[name] === "object")
+            if (data[name] !== null && data[name] !== undefined && typeof data[name] === "object")
                 if ("value" in data[name])
                     if ("metadata" in data[name])
                         encoder = this.writeField(field, encoder, data[name]["value"], data[name]["metadata"]);
@@ -164,7 +166,11 @@ export class VersionCodec {
             case "bitset": return decoder.readPrefixedArray((decoder) => decoder.readLong());
             case "teleport_flags": return decoder.readTeleportFlag();
             case "null": return null;
-            case "not_implemented": throw new NotImplemented();
+            case "not_implemented": {
+                if (field.skip_able === true)
+                    throw new SkippableNotImplemented();
+                throw new NotImplemented();
+            }
             case "switch": {
                 if (!(field.dependsOn in readObject)) throw new MissingPacketField(packetId, fieldName, field.dependsOn);
                 const dependencyValue = readObject[field.dependsOn];
@@ -206,14 +212,20 @@ export class VersionCodec {
             //     return encoder.writeArray(length, (decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
             // }
             case "prefixed_array": {
-                const length = metadata["length"] || field.length;
-                if (!length) throw new MissingField("length", "prefixed array metadata object");
+                const length = metadata["length"] ?? field.length;
+                if (length === null || length === undefined) throw new MissingField("length", "prefixed array metadata object");
                 if (!Array.isArray(value))
                     throw new UnexpectedValue("an array for prefixed array", typeof value);
                 return encoder.writePrefixedArray(length, (encoder, index) => this.writeField(field.subType, encoder, value[index], metadata));
             }
             // case "teleport_flag": return encoder.writeTeleportFlag();
-            // case "prefixed_optional": return encoder.writePrefixedOptional((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            case "prefixed_optional":
+                if (value === null || value === undefined)
+                    return encoder.writeBoolean(false);
+                else {
+                    encoder.writeBoolean(true);
+                    return this.writeField(field.subType, encoder, field, metadata);
+                }
             // case "nbt": return encoder.writeNBT(value);
             case "lpvec3": return encoder.writeLpVec3(value);
             // case "fixed_point": {
@@ -231,6 +243,15 @@ export class VersionCodec {
                     encoder = this.writeField(subField, encoder, value[name], metadata);
                 return encoder;
             }
+            case "fixed_bitset": {
+                if (!(value instanceof BitSet))
+                    throw new UnexpectedValue("bitset instance", typeof value);
+                const arr = value.toByteArray();
+                if ("length" in field)
+                    while (Math.ceil(field.length / 8) > arr.length)
+                        arr.push(0);
+                return encoder.writeRaw(Buffer.from(arr));
+            }
             // case "switch": {
             //     const dependencyValue = readObject[field.dependsOn];
             //     if (!dependencyValue) throw new MissingField(packetId, fieldName, field.dependsOn);

package/src/version/registry.ts

@@ -101,6 +101,30 @@ export class BlockRegistry {
     }
 };
 
+export class EffectRegistry {
+    private static loaded: boolean = false;
+
+    public static readonly effects: Record<string, number> = {};
+
+    /**
+     * Load effects registry from JSON file.
+     * 
+     * Should be called once time
+     */
+    public static async 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>;
+        for (const [name, id] of Object.entries(json)) {
+            this.effects[name] = id;
+        }
+    }
+}
+
 export const SupportTypes = z.enum([
     "byte",
     "unsigned_byte",
@@ -137,6 +161,8 @@ export const SupportTypes = z.enum([
     "heightmap",
     "teleport_flags",
     "bitset",
+    "fixed_bitset",
+    "byte_array",
     "null", // a constant
 
     /**
@@ -144,8 +170,21 @@ export const SupportTypes = z.enum([
      */
     "switch"
 ]);
-export type FieldNode = {
-    type: Exclude<z.infer<typeof SupportTypes>, "prefixed_array" | "prefixed_optional" | "string" | "id_or_x" | "array" | "switch" | "fixed_point" | "enum" | "object" | "not_implemented">,
+export type FieldNode = ({
+    type: Exclude<z.infer<typeof SupportTypes>,
+        | "prefixed_array"
+        | "prefixed_optional"
+        | "string"
+        | "id_or_x"
+        | "array"
+        | "switch"
+        | "fixed_point"
+        | "enum"
+        | "object"
+        | "not_implemented"
+        | "fixed_bitset"
+        | "byte_array"
+    >,
 } | {
     type: "not_implemented",
     comment?: string | undefined
@@ -175,10 +214,15 @@ export type FieldNode = {
     type: "fixed_point",
     subType: FieldNode,
     fractionBits: number
+} | {
+    type: "fixed_bitset" | "byte_array",
+    length: number,
+}) & {
+    skip_able?: boolean | undefined
 }
 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"]),
+        type: SupportTypes.exclude(["prefixed_array", "prefixed_optional", "string", "id_or_x", "array", "switch", "fixed_point", "enum", "not_implemented", "object", "fixed_bitset", "byte_array"]),
     }),
     z.object({
         type: z.literal(["not_implemented"]),
@@ -248,8 +292,17 @@ export const Field: z.ZodType<FieldNode> = z.union([
         subType: z.lazy(() => Field),
         fractionBits: z.number()
     }),
-
-]);
+    z.object({
+        // These type require predefined-length
+        type: z.union([z.literal("fixed_bitset"), z.literal("byte_array")]),
+        length: z.int()
+    })
+])
+    .and(
+        z.object({
+            skip_able: z.boolean().optional()
+        })
+    );
 export const PacketObject = z.object({
     name: z.string(),
     id: z.number(),

package/src/world/block.ts

@@ -1,9 +1,9 @@
-import { TCPClient } from "../client/tcp";
 import { AABB, BaseAABB, VoxelShape } from "../physics/aabb";
 import { Epsilon, getFrac, getSign, lerp } from "../base/math";
 import { BlockRegistry } from "../version/registry";
 import { BaseVec3, Direction, Vec3 } from "../physics/direction";
 import { SharedState } from "./state";
+import { NotImplemented } from "../base/error";
 
 /**
  * Represent a state of a block
@@ -108,9 +108,74 @@ export class BlockManager {
         x = Math.floor(x); y = Math.floor(y); z = Math.floor(z);
         const sx = Math.floor(x / 16), sy = Math.floor((y + 64) / 16), sz = Math.floor(z / 16);
         const px = ((x % 16) + 16) % 16, py = ((y % 16) + 16) % 16, pz = ((z % 16) + 16) % 16;
+
+        if (this.state.cache)
+            return this.getWithCache(sx, sy, sz, px, py, pz);
+        else
+            return this.getWithoutCache(sx, sy, sz, px, py, pz);
+    }
+
+    private getBlock(stateId: number | string) {
+        return BlockRegistry.getState(String(stateId));
+    }
+    private getWithCache(
+        sx: number, sy: number, sz: number,
+        px: number, py: number, pz: number,
+    ) {
+        if (!this.state.cache)
+            throw new NotImplemented();
+        const localPos = { x: px, y: py, z: pz };
+        const sectionKey = `${this.state.player!.dimension}:${sx}:${sy}:${sz}`;
+        const sectionCache = this.state.cache.get(sectionKey);
+        if (sectionCache) {
+            const cachedState = sectionCache.at(this.getLocalPosKey(localPos));
+            if (cachedState) {
+                console.log("cache hit", sectionKey, localPos);
+                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())!;
+
+        const arr = new Uint16Array(16 * 16 * 16);
+        const dataArray = section.data!;
+        const bitsPerEntry = section.bpe;
+        const entriesPerLong = Math.floor(64 / bitsPerEntry);
+        const entryMask = (1 << bitsPerEntry) - 1;
+        for (let localX = 0; localX < 16; localX++)
+            for (let localY = 0; localY < 16; localY++)
+                for (let localZ = 0; localZ < 16; localZ++) {
+                    const entryIndex = this.getLocalPosKey({ x: localX, y: localY, z: localZ });
+                    const longIndex = Math.floor(entryIndex / entriesPerLong);
+                    const bit_index = entryIndex % entriesPerLong * bitsPerEntry;
+                    const localId = Number((dataArray[longIndex]! >> BigInt(bit_index)) & BigInt(entryMask));
+                    const stateId = bitsPerEntry <= 8 ? section.palette[localId]! : localId;
+                    arr[entryIndex]! = stateId;
+                }
+
+        this.state.cache.put(sectionKey, arr);
+        const state = arr.at(this.getLocalPosKey(localPos))!;
+        return this.getBlock(state);
+    }
+    public deleteChunkCache(
+        sx: number, sy: number, sz: number,
+    ) {
+        const sectionKey = `${this.state.player!.dimension}:${sx}:${sy}:${sz}`;
+        if (this.state.cache)
+            this.state.cache.del(sectionKey);
+    }
+
+    private getWithoutCache(
+        sx: number, sy: number, sz: number,
+        px: number, py: number, pz: number,
+    ) {
         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())!;
+
         const dataArray = section.data!;
         const bitsPerEntry = section.bpe;
         const entryIndex = px + (pz * 16) + (py * 16 * 16);
@@ -120,7 +185,12 @@ export class BlockManager {
         const bit_index = entryIndex % entriesPerLong * bitsPerEntry;
         const localId = Number((dataArray[longIndex]! >> BigInt(bit_index)) & BigInt(entryMask));
         const stateId = bitsPerEntry <= 8 ? section.palette[localId]! : localId;
-        return BlockRegistry.getState(String(stateId))!;
+
+        return BlockRegistry.getState(String(stateId));
+
+    }
+    private getLocalPosKey(pos: BaseVec3) {
+        return pos.x + 16 * (pos.y + 16 * pos.z);
     }
 
     /**