@vaitosoi/minejs 0.2.2 → 0.4.0

package/src/version/codec.ts

@@ -0,0 +1,248 @@
+import z from "zod";
+import { MissingField, MissingPacketField, NotImplemented, UnexpectedValue } from "../base/error";
+import { BinaryDecoder } from "../packet/decoder";
+import { ConnectionState, SharedState } from "../world/state";
+import { FieldNode, PacketObject, PacketRegistry, VersionDefinitions } from "./registry";
+import { BinaryEncoder } from "../packet/encoder";
+
+const TCPStateMapping: Record<ConnectionState, keyof z.infer<typeof VersionDefinitions> | null> = {
+    [ConnectionState.Disconnected]: null,
+    [ConnectionState.Handshake]: "handshaking",
+    [ConnectionState.Login]: "login",
+    [ConnectionState.Configure]: "configuration",
+    [ConnectionState.Play]: "play",
+};
+
+export interface EncodeResult {
+    buffer: Buffer,
+    packet: z.infer<typeof PacketObject>,
+}
+
+export class VersionCodec {
+    constructor(private readonly state: SharedState) { }
+
+    public consumePacket: (packetId: string, data: object) => void = () => { throw new NotImplemented(); };
+
+    public handlePacket(packetId: number, decoder: BinaryDecoder) {
+        const mappedState = TCPStateMapping[this.state.state];
+        if (!mappedState) return; // console.log("no state");
+        const packet = PacketRegistry.getPacket(mappedState, "clientbound", packetId);
+        if (!packet) return; // console.log("no packet");
+
+        const { name, structure, skipForNow } = packet;
+
+        if (skipForNow) return;
+
+        const resolvedObject: Record<string, any> = {};
+        if (Object.keys(structure).length > 0)
+            for (const [name, field] of Object.entries(structure))
+                try {
+                    resolvedObject[name] = this.readField(packetId, resolvedObject, name, field, decoder);
+                } catch (err) {
+                    if (err instanceof NotImplemented) return;
+                    throw err;
+                }
+        if (this.state.clientOptions.debug?.packetLogger)
+            console.dir({
+                dir: "to client",
+                state: mappedState,
+                name,
+                data: resolvedObject,
+            });
+
+        this.consumePacket(`${TCPStateMapping[this.state.state]}:${name}`, resolvedObject);
+    }
+
+    public encodePacket(packetId: number | string, data: Record<string, any>): EncodeResult {
+        const mappedState = TCPStateMapping[this.state.state];
+        if (!mappedState) throw new UnexpectedValue("map-able state", this.state.state.toString());
+        const packet = PacketRegistry.getPacket(mappedState, "serverbound", packetId);
+        if (!packet) throw new UnexpectedValue("valid serverbound packet id", packetId.toString());
+
+        if (this.state.clientOptions.debug?.packetLogger)
+            console.dir({
+                dir: "to server",
+                state: mappedState,
+                id: packetId,
+                data,
+            });
+
+        const { name: packetName, structure } = packet;
+        let encoder = new BinaryEncoder();
+        for (const [name, field] of Object.entries(structure)) {
+            if (!(name in data))
+                throw new MissingField(name, `packet ${packetName}`);
+            if (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"]);
+                    else if ("length" in data[name])
+                        encoder = this.writeField(field, encoder, data[name]["value"], { length: data[name]["length"] });
+                    else
+                        encoder = this.writeField(field, encoder, data[name]["value"]);
+                else
+                    encoder = this.writeField(field, encoder, data[name]);
+            else
+                encoder = this.writeField(field, encoder, data[name]);
+        }
+        return { buffer: encoder.getBuffer(), packet };
+    }
+
+    private readField(
+        // Current reading state
+        packetId: number,
+        readObject: Record<string, any>,
+
+        // Current field
+        fieldName: string,
+        field: FieldNode,
+        decoder: BinaryDecoder
+    ): any {
+        switch (field.type) {
+            case "string": return decoder.readString();
+            case "boolean": return decoder.readBoolean();
+            case "byte": return decoder.readByte();
+            case "unsigned_byte": return decoder.readUByte();
+            case "short": return decoder.readShort();
+            case "unsigned_short": return decoder.readUShort();
+            case "int": return decoder.readInt();
+            case "long": return decoder.readLong();
+            case "float": return decoder.readFloat();
+            case "double": return decoder.readDouble();
+            case "var_int": return decoder.readVarInt();
+            case "var_long": return decoder.readVarLong();
+            case "uuid": return decoder.readUUID();
+            case "position": return decoder.readPosition();
+            case "array": {
+                let length;
+                if (!isNaN(Number(field.length)))
+                    length = Number(field.length);
+                else
+                    length = readObject[field.length];
+                if (length === undefined) throw new MissingPacketField(packetId, fieldName, field.length.toString());
+                return decoder.readArray(length, (decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            }
+            case "prefixed_array": return decoder.readPrefixedArray((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            case "teleport_flag": return decoder.readTeleportFlag();
+            case "prefixed_optional": return decoder.readPrefixedOptional((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            case "nbt": return decoder.readNBT();
+            case "lpvec3": return decoder.readLpVec3();
+            case "fixed_point": {
+                const value = this.readField(packetId, readObject, fieldName, field.subType, decoder);
+                return decoder.readFixedPoint(value, field.fractionBits);
+            }
+            case "angle": return decoder.readAngle();
+            case "id_or_x": return decoder.readIdOrX((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            case "id_set": return decoder.readIdSet();
+            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 "object": {
+                const obj: Record<string, any> = {};
+                for (const [key, type] of Object.entries(field.fields))
+                    obj[key] = this.readField(packetId, readObject, key, type, decoder);
+                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())
+                    }))
+                };
+            }
+            case "heightmap": {
+                return {
+                    type: decoder.readVarInt(),
+                    data: decoder.readPrefixedArray((decoder) => decoder.readLong())
+                };
+            }
+            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 "switch": {
+                if (!(field.dependsOn in readObject)) throw new MissingPacketField(packetId, fieldName, field.dependsOn);
+                const dependencyValue = readObject[field.dependsOn];
+                for (const [value, type] of field.cases)
+                    if (dependencyValue === value)
+                        return this.readField(packetId, readObject, fieldName, type, decoder);
+                if (field.default)
+                    return this.readField(packetId, readObject, fieldName, field.default, decoder);
+                return null;
+            }
+        }
+    }
+
+
+    private writeField(
+        field: FieldNode,
+        encoder: BinaryEncoder,
+        value: any,
+        metadata: Record<string, any> = {}
+    ): BinaryEncoder {
+        switch (field.type) {
+            case "string": return encoder.writeString(value);
+            case "boolean": return encoder.writeBoolean(value);
+            case "byte": return encoder.writeByte(value);
+            case "unsigned_byte": return encoder.writeUByte(value);
+            case "short": return encoder.writeShort(value);
+            case "unsigned_short": return encoder.writeUShort(value);
+            case "int": return encoder.writeInt(value);
+            case "long": return encoder.writeLong(value);
+            case "float": return encoder.writeFloat(value);
+            case "double": return encoder.writeDouble(value);
+            case "var_int": return encoder.writeVarInt(value);
+            case "var_long": return encoder.writeVarLong(value);
+            case "uuid": return encoder.writeRaw(value);
+            case "position": return encoder.writePosition(value);
+            // case "array": {
+            //     const length = metadata["length"];
+            //     // if (!length) throw new MissingField(packetId, fieldName, field.length);
+            //     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");
+                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 "nbt": return encoder.writeNBT(value);
+            case "lpvec3": return encoder.writeLpVec3(value);
+            // case "fixed_point": {
+            //     const value = this.readField(packetId, readObject, fieldName, field.subType, encoder);
+            //     return encoder.writeFixedPoint(value, field.fractionBits);
+            // }
+            // case "angle": return encoder.writeAngle();
+            // case "id_or_x": return encoder.writeIdOrX((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            // case "chat_type_decoration": return encoder.writeChatTypeDecoration();
+            // case "chat_type": return encoder.writeChatType();
+            case "enum": return this.writeField(field.subType, encoder, value, metadata);
+            case "json_text": return encoder.writeString(JSON.parse(value));
+            case "object": {
+                for (const [name, subField] of Object.entries(field.fields))
+                    encoder = this.writeField(subField, encoder, value[name], metadata);
+                return encoder;
+            }
+            // case "switch": {
+            //     const dependencyValue = readObject[field.dependsOn];
+            //     if (!dependencyValue) throw new MissingField(packetId, fieldName, field.dependsOn);
+            //     for (const [value, type] of field.cases)
+            //         if (dependencyValue === value)
+            //             return this.readField(packetId, readObject, fieldName, type, encoder);
+            //     if (field.default)
+            //         return this.readField(packetId, readObject, fieldName, field.default, encoder);
+            //     break;
+            // }
+            default:
+                throw new UnexpectedValue("encoding type", field.type);
+        }
+    }
+}

package/src/version/registry.ts

@@ -0,0 +1,328 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { RegistryItemNotFound, UnexpectedValue, VersionNotSupport } from "../base/error";
+import { Block, BlockState } from "../world/block";
+import z from "zod";
+
+export const BASE_REGISTRY_PATH = join(__dirname, "..", "..", "assets", "minecraft");
+export const SupportVersions = [
+    "26.2"
+];
+
+export const ProtocolVersionMapping: Record<string, number> = {
+    "26.2": 776
+};
+
+export class EntityRegistry {
+    private static loaded: boolean = false;
+    public static readonly data: Record<string, { height: number, width: number, type: number }> = {};
+    public static readonly mapTypeToData: Record<number, string> = {};
+
+    /**
+     * Load entity 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, "entities.json"), { encoding: "utf8" });
+        const json = JSON.parse(file);
+        for (const entity in json) {
+            this.data[entity] = json[entity];
+            this.mapTypeToData[json[entity]["id"]] = entity;
+        }
+    }
+
+    /**
+     * Get an entity registy item
+     */
+    public static get(entity: string | number) {
+        if (typeof entity === "string") {
+            return this.data[entity];
+        } else {
+            const key = this.mapTypeToData[entity];
+            return this.data[key!];
+        }
+    }
+};
+
+export class BlockRegistry {
+    private static loaded: boolean = false;
+    /**
+     * block id to block
+     */
+    public static readonly blocks: Record<string, Block> = {};
+    /**
+     * state id to block state
+     */
+    public static readonly states: Record<string, BlockState> = {};
+
+    /**
+     * Load block 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, "blocks.json"), { encoding: "utf8" });
+        const json = JSON.parse(file) 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;
+            for (const state of block.states)
+                this.states[state.id] = state;
+        }
+    }
+
+    /**
+     * Get a block registy item
+     */
+    public static getBlock(type: string) {
+        if (!(type in this.blocks))
+            throw new RegistryItemNotFound(`block ${type}`);
+        return this.blocks[type]!;
+    }
+
+    /**
+     * Get a block state registy item
+     */
+    public static getState(id: string) {
+        if (!(id in this.states))
+            throw new RegistryItemNotFound(`block state ${id}`);
+        return this.states[id]!;
+    }
+};
+
+export const SupportTypes = z.enum([
+    "byte",
+    "unsigned_byte",
+    "short",
+    "unsigned_short",
+    "int",
+    "long",
+    "float",
+    "double",
+    "boolean",
+    "var_int",
+    "var_long",
+    "string",
+    "uuid",
+    "position",
+    "array",
+    "prefixed_array",
+    "teleport_flag",
+    "prefixed_optional",
+    "nbt",
+    "lpvec3",
+    "fixed_point",
+    "angle",
+    "id_or_x",
+    "id_set",
+    "chat_type_decoration",
+    "chat_type",
+    "enum",
+    "json_text",
+    "not_implemented",
+    "varies",
+    "object",
+    "game_profile",
+    "heightmap",
+    "teleport_flags",
+    "bitset",
+    "null", // a constant
+
+    /**
+     * This is used for handle field that its type depends on previous field type, or value
+     */
+    "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">,
+} | {
+    type: "not_implemented",
+    comment?: string | undefined
+} | {
+    type: "object",
+    fields: Record<string, FieldNode>
+} | {
+    type: "prefixed_array",
+    subType: FieldNode,
+    length?: number | undefined,
+} | {
+    type: "id_or_x" | "enum" | "prefixed_optional",
+    subType: FieldNode
+} | {
+    type: "string",
+    length?: number | undefined
+} | {
+    type: "array",
+    subType: FieldNode,
+    length: string | number,
+} | {
+    type: "switch",
+    dependsOn: string,
+    cases: [string, FieldNode][],
+    default?: FieldNode | undefined
+} | {
+    type: "fixed_point",
+    subType: FieldNode,
+    fractionBits: number
+}
+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"]),
+    }),
+    z.object({
+        type: z.literal(["not_implemented"]),
+        comment: z.string().optional()
+    }),
+    z.object({
+        type: z.literal(["object"]),
+        fields: z.record(z.string(), z.lazy(() => Field))
+    }),
+    z.object({
+        type: z.literal(["prefixed_array"]),
+        /**
+         * For case like `Array<subType>` or `PrefixedOptional<subType>`
+         */
+        subType: z.lazy(() => Field),
+        /**
+         * The length of the array type, not used.
+         */
+        length: z.number().optional()
+    }),
+    z.object({
+        type: z.literal(["id_or_x", "enum", "prefixed_optional"]),
+        /**
+         * For case like `Array<subType>` or `PrefixedOptional<subType>`
+         */
+        subType: z.lazy(() => Field),
+    }),
+    z.object({
+        type: z.literal("string"),
+        /**
+         * The length of the string, not used.
+         */
+        length: z.number().optional(),
+    }),
+    z.object({
+        type: z.literal("array"),
+        /**
+         * For case like `Array<subType>` or `PrefixedOptional<subType>`
+         */
+        subType: z.lazy(() => Field),
+        /**
+         * Specially for `array` type, which is not prefixed with length.
+         * 
+         * Point to another field, should be numberic field
+         */
+        length: z.string().or(z.number()),
+    }),
+    z.object({
+        type: z.literal("switch"),
+        /**
+         * Specially for case that this field type depends on other field value.
+         * 
+         * Point to the field that this field is depended on.
+         */
+        dependsOn: z.string(),
+        /**
+         * Mapping depend value to type
+         */
+        cases: z.array(z.tuple([z.any(), z.lazy(() => Field)])),
+        default: z.lazy(() => Field).optional(),
+    }),
+    z.object({
+        type: z.literal(["fixed_point"]),
+        /**
+         * For case like `Array<subType>` or `PrefixedOptional<subType>`
+         */
+        subType: z.lazy(() => Field),
+        fractionBits: z.number()
+    }),
+
+]);
+export const PacketObject = z.object({
+    name: z.string(),
+    id: z.number(),
+    structure: z.record(z.string(), Field),
+    skipForNow: z.boolean().default(false)
+});
+export const PacketsDefinition = z.record(z.string().or(z.number()), PacketObject);
+export const StatesDefinition = z.object({
+    clientbound: PacketsDefinition,
+    serverbound: PacketsDefinition,
+});
+export const VersionDefinitions = z.object({
+    handshaking: StatesDefinition,
+    status: StatesDefinition,
+    login: StatesDefinition,
+    configuration: StatesDefinition,
+    play: StatesDefinition,
+});
+
+export class PacketRegistry {
+    private static loaded: boolean = false;
+    private static definition: z.infer<typeof VersionDefinitions>;
+    private static nameToId: Record<
+        string, // State
+        Record<
+            string, // Type
+            Record<string, number> // Packet
+        >
+    > = {};
+
+    /**
+     * Load block 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, "packets.json"), { encoding: "utf8" });
+        const json = JSON.parse(file) as Record<string, any>;
+
+        const definition = VersionDefinitions.parse(json);
+        for (const [stateKey, state] of Object.entries(definition)) {
+            this.nameToId[stateKey] = {};
+            for (const [typeKey, type] of Object.entries(state)) {
+                this.nameToId[stateKey]![typeKey] = {};
+                // eslint-disable-next-line prefer-const
+                for (let [key, value] of Object.entries(type) as [string | number, any]) {
+                    this.nameToId[stateKey]![typeKey]![value.name] = key;
+                }
+            }
+        }
+        this.definition = definition;
+    }
+
+    public static getPacket(
+        state: keyof z.infer<typeof VersionDefinitions>,
+        type: keyof z.infer<typeof StatesDefinition>,
+        id: string | number
+    ): z.infer<typeof PacketObject> | undefined {
+        const nameToId = this.nameToId[state]?.[type]?.[id]?.toString();
+        if (nameToId)
+            return this.definition[state][type][nameToId]!;
+        let numbericId;
+        if (typeof id === "string")
+            numbericId = parseInt(id, 16);
+        else numbericId = id;
+        if (isNaN(numbericId))
+            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/{base → world}/block.ts

@@ -1,8 +1,9 @@
 import { TCPClient } from "../client/tcp";
-import { AABB, BaseAABB, VoxelShape } from "./aabb";
-import { Epsilon, getFrac, getSign, lerp } from "./math";
-import { BlockRegistry } from "./registry";
-import { BaseVec3, Direction, Vec3 } from "./direction";
+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";
 
 /**
  * Represent a state of a block
@@ -76,7 +77,7 @@ export class Block {
  * Somehow, this is an equivalent implementation of Minecraft `Level`
  */
 export class BlockManager {
-    constructor(private tcp: TCPClient) { }
+    constructor(private state: SharedState) { }
 
     /**
      * Check if the chunk section is loaded
@@ -84,14 +85,14 @@ export class BlockManager {
     public hasChunkAt(x: number, y: number, z: number): boolean;
     public hasChunkAt(position: BaseVec3): boolean;
     public hasChunkAt(a: BaseVec3 | number, b?: number, c?: number): boolean {
-        this.tcp.checkReady();
+        this.state.checkReady();
         const { x, y, z } = Vec3.loadArgs(a, b, c);
         const sx = Math.floor(x / 16), sy = Math.floor((y + 64) / 16), sz = Math.floor(z / 16);
-        // // console.log({
+        // console.log({
         //     key: `${this.tcp.player!.dimension}:${sx}:${sz}`,
         //     hasKey: `${this.tcp.player!.dimension}:${sx}:${sz}` in this.tcp.world!.chunks
         // });
-        const section = this.tcp.world!.chunks[`${this.tcp.player!.dimension}:${sx}:${sz}`]?.sections[sy];
+        const section = this.state.world!.chunks[`${this.state.player!.dimension}:${sx}:${sz}`]?.sections[sy];
         if (!section) return false;
         return true;
     }
@@ -102,12 +103,12 @@ export class BlockManager {
     public at(x: number, y: number, z: number): BlockState | null;
     public at(position: BaseVec3): BlockState | null;
     public at(a: BaseVec3 | number, b?: number, c?: number): BlockState | null {
-        this.tcp.checkReady();
+        this.state.checkReady();
         let { x, y, z } = Vec3.loadArgs(a, b, c);
         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;
-        const section = this.tcp.world!.chunks[`${this.tcp.player!.dimension}:${sx}:${sz}`]?.sections[sy]?.block;
+        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!;
@@ -128,7 +129,7 @@ export class BlockManager {
      * @returns 
      */
     public queryAABB(queryBB: AABB) {
-        this.tcp.checkReady();
+        this.state.checkReady();
 
         const { minX, minY, minZ, maxX, maxY, maxZ } = queryBB;
         const sx0 = Math.floor(minX), sx1 = Math.floor(maxX);

package/src/{base → world}/entity.ts

@@ -1,5 +1,5 @@
-import { TCPClient } from "../client/tcp";
-import { AABB } from "./aabb";
+import { AABB } from "../physics/aabb";
+import { SharedState } from "./state";
 
 export class EntitiesManager {
     /**
@@ -13,7 +13,7 @@ export class EntitiesManager {
      */
     public entityToSection: Map<number, string> = new Map();
 
-    constructor(private tcp: TCPClient) { }
+    constructor(private state: SharedState) { }
 
     /**
      * Clear data
@@ -70,7 +70,7 @@ export class EntitiesManager {
      * @returns
      */
     public queryAABB(queryBB: AABB, exclude: number[] = []) {
-        this.tcp.checkReady();
+        this.state.checkReady();
 
         const { minX, minY, minZ, maxX, maxY, maxZ } = queryBB;
         const results: AABB[] = [];
@@ -84,7 +84,7 @@ export class EntitiesManager {
                     const bucket = this.sections.get(`${sx},${sy},${sz}`);
                     if (bucket) for (const id of bucket) {
                         if (exclude.includes(id)) continue;
-                        const entity = this.tcp.world!.entities[id];
+                        const entity = this.state.world!.entities[id];
                         const entityBB = AABB.fromEntityType(entity!.type);
                         if (queryBB.isIntersect(entityBB))
                             results.push(entityBB);