sapdon 3.0.2 → 3.0.3

package/dist/core/block/rotatableBlock.js

@@ -0,0 +1,107 @@
+import { BasicBlock } from "./basicBlock.js";
+import { BlockComponent } from "./blockComponent.js";
+export const RotationTypes = {
+    CARDINAL: "cardinal", // 北、南、东、西
+    FACING: "facing", // 上、下、北、南、东、西
+    BLOCK_FACE: "block_face", // 上、下、北、南、东、西（与 FACING 类似，但用途不同）
+    LOG: "log" // 原木旋转（X、Y、Z 轴对齐）
+};
+export class RotatableBlock extends BasicBlock {
+    /**
+     * 可旋转方块类
+     * @param {string} identifier 方块唯一标识符
+     * @param {string} category 菜单栏分类
+     * @param {Array} textures_arr 纹理数组 [上,下,东,西,南,北]
+     * @param {Object} options 可选参数
+     * @param {string} options.group 分组，默认为 "construction"
+     * @param {boolean} options.hide_in_command 是否在命令中隐藏，默认为 false
+     * @param {string} options.rotationType 旋转类型，默认为 "cardinal"
+     * @param {number} options.yRotationOffset 初始旋转偏移量，默认为 180
+     */
+    constructor(identifier, category, textures_arr, options = {}) {
+        // 调用父类构造函数
+        super(identifier, category, textures_arr, options);
+        const { rotationType = RotationTypes.CARDINAL, yRotationOffset = 180 } = options;
+        // 根据旋转类型注册特性和添加变体
+        this.#setupRotation(rotationType, yRotationOffset);
+    }
+    /**
+     * 根据旋转类型设置特性和变体
+     * @param {string} rotationType 旋转类型
+     * @param {number} yRotationOffset 初始旋转偏移量
+     */
+    #setupRotation(rotationType, yRotationOffset) {
+        switch (rotationType) {
+            case RotationTypes.CARDINAL:
+                // 北、南、东、西
+                this.registerTrait("minecraft:placement_direction", {
+                    enabled_states: ["minecraft:cardinal_direction"],
+                    y_rotation_offset: yRotationOffset
+                });
+                this.#addCardinalDirectionPermutations();
+                break;
+            case RotationTypes.FACING:
+                // 上、下、北、南、东、西
+                this.registerTrait("minecraft:placement_direction", {
+                    enabled_states: ["minecraft:facing_direction"]
+                });
+                this.#addFacingDirectionPermutations();
+                break;
+            case RotationTypes.BLOCK_FACE:
+                // 上、下、北、南、东、西（与 FACING 类似，但用途不同）
+                this.registerTrait("minecraft:placement_position", {
+                    enabled_states: ["minecraft:block_face"]
+                });
+                this.#addBlockFacePermutations();
+                break;
+            case RotationTypes.LOG:
+                // 原木旋转（X、Y、Z 轴对齐）
+                this.registerTrait("minecraft:placement_position", {
+                    enabled_states: ["minecraft:block_face"]
+                });
+                this.#addLogRotationPermutations();
+                break;
+            default:
+                throw new Error(`Unknown rotation type: ${rotationType}`);
+        }
+    }
+    /**
+     * 添加 Cardinal Direction 旋转变体
+     */
+    #addCardinalDirectionPermutations() {
+        this.addPermutation("q.block_state('minecraft:cardinal_direction') == 'north'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 0, 0]))
+            .addPermutation("q.block_state('minecraft:cardinal_direction') == 'south'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 90, 0]))
+            .addPermutation("q.block_state('minecraft:cardinal_direction') == 'east'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 180, 0]))
+            .addPermutation("q.block_state('minecraft:cardinal_direction') == 'west'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, -90, 0]));
+    }
+    /**
+     * 添加 Facing Direction 旋转变体
+     */
+    #addFacingDirectionPermutations() {
+        this.addPermutation("q.block_state('minecraft:facing_direction') == 'down'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [-90, 0, 0]))
+            .addPermutation("q.block_state('minecraft:facing_direction') == 'up'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [90, 0, 0]))
+            .addPermutation("q.block_state('minecraft:facing_direction') == 'north'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 0, 0]))
+            .addPermutation("q.block_state('minecraft:facing_direction') == 'west'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 90, 0]))
+            .addPermutation("q.block_state('minecraft:facing_direction') == 'south'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 180, 0]))
+            .addPermutation("q.block_state('minecraft:facing_direction') == 'east'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, -90, 0]));
+    }
+    /**
+     * 添加 Block Face 旋转变体
+     */
+    #addBlockFacePermutations() {
+        this.addPermutation("q.block_state('minecraft:block_face') == 'down'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [-90, 0, 0], [0, 0, 0]))
+            .addPermutation("q.block_state('minecraft:block_face') == 'up'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [90, 0, 0], [0, 0, 0]))
+            .addPermutation("q.block_state('minecraft:block_face') == 'north'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 0, 0]))
+            .addPermutation("q.block_state('minecraft:block_face') == 'south'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 180, 0], [0, 90, 0]))
+            .addPermutation("q.block_state('minecraft:block_face') == 'east'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 90, 0], [0, 180, 0]))
+            .addPermutation("q.block_state('minecraft:block_face') == 'west'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, -90, 0], [0, -90, 0]));
+    }
+    /**
+     * 添加 Log Rotation 旋转变体
+     */
+    #addLogRotationPermutations() {
+        this.addPermutation("q.block_state('minecraft:block_face') == 'west' || q.block_state('minecraft:block_face') == 'east'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 90], [0, 0, 0]))
+            .addPermutation("q.block_state('minecraft:block_face') == 'down' || q.block_state('minecraft:block_face') == 'up'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 0, 0]))
+            .addPermutation("q.block_state('minecraft:block_face') == 'north' || q.block_state('minecraft:block_face') == 'south'", BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [90, 0, 0], [0, 0, 0]));
+    }
+}

package/dist/core/block/tileBlock.d.ts

@@ -0,0 +1,17 @@
+export class TileBlock {
+    /**
+     * 带实体的方块类
+     * @param {*} identifier
+     * @param {*} category
+     * @param {*} textures_arr
+     * @param {*} options
+     */
+    constructor(identifier: any, category: any, textures_arr: any, options?: any);
+    block: BasicBlock;
+    entity: Entity;
+    setGeometry(geometry: any): void;
+    addAnimation(name: any, animation: any): void;
+    setScript(key: any, value: any): void;
+}
+import { BasicBlock } from "./basicBlock.js";
+import { Entity } from "../entity/entity.js";

package/dist/core/block/tileBlock.js

@@ -0,0 +1,125 @@
+import { Entity } from "../entity/entity.js";
+import { BasicBlock } from "./basicBlock.js";
+import { BlockComponent } from "./blockComponent.js";
+const TileBehData = {
+    component_groups: {
+        "item_despawn": {
+            "minecraft:despawn": {},
+            "minecraft:instant_despawn": {
+                "remove_child_entities": false
+            },
+            "minecraft:transformation": {
+                "drop_inventory": true,
+                "into": "minecraft:air"
+            }
+        }
+    },
+    components: {
+        "minecraft:inventory": {
+            "inventory_size": 27,
+            "can_be_siphoned_from": true,
+            "container_type": "minecart_chest"
+        },
+        "minecraft:nameable": {
+            "allow_name_tag_renaming": false
+        },
+        // Knockback resistance is needed to make it not be Knocked off by an entity.
+        "minecraft:knockback_resistance": {
+            "value": 1
+        },
+        // Tells if the entity can be pushed or not.
+        "minecraft:pushable": {
+            "is_pushable": false,
+            "is_pushable_by_piston": true
+        },
+        // Sets the distance through which the entity can push through.
+        "minecraft:push_through": {
+            "value": 1
+        },
+        "minecraft:custom_hit_test": {
+            "hitboxes": [
+                {
+                    "width": 0.81,
+                    "height": 0.92,
+                    "pivot": [
+                        0,
+                        0.5,
+                        0
+                    ]
+                }
+            ]
+        },
+        //可以被活塞推动，但是不会被实体推动
+        "minecraft:pushable": {
+            "is_pushable": false,
+            "is_pushable_by_piston": true
+        },
+        // Makes it invincible.
+        "minecraft:damage_sensor": {
+            "triggers": [
+                {
+                    "deals_damage": false,
+                    "cause": "all"
+                }
+            ]
+        },
+        "minecraft:persistent": {}
+    },
+    events: {
+        "despawn_event": {
+            "add": {
+                "component_groups": [
+                    "item_despawn"
+                ]
+            }
+        }
+    }
+};
+export class TileBlock {
+    /**
+     * 带实体的方块类
+     * @param {*} identifier
+     * @param {*} category
+     * @param {*} textures_arr
+     * @param {*} options
+     */
+    constructor(identifier, category, textures_arr, options = {}) {
+        this.block = new BasicBlock(identifier, category, textures_arr, options);
+        this.entity = new Entity(`${identifier}_entity`, textures_arr[0], TileBehData, {});
+        // 注册方块状态 0:方块 1:实体
+        this.block.registerState("sapdon:block_or_entity", [0, 1]);
+        this.block.addComponent(BlockComponent.setCustomComponents(["sapdon:block_with_entity"]));
+        this.block.addPermutation("q.block_state('sapdon:block_or_entity') == 1", BlockComponent.combineComponents(BlockComponent.setTick([0, 0], true), //提供tick
+        BlockComponent.setGeometry("geometry.cube"), BlockComponent.setMaterialInstances({ "*": {
+                "texture": "none",
+                "render_method": "alpha_test"
+            } })));
+        //设置生物
+        this.entity.entity.addComponent(new Map().set("minecraft:block_sensor", {
+            "sensor_radius": 1,
+            "on_break": [
+                {
+                    "block_list": [
+                        identifier
+                    ],
+                    "on_block_broken": "despawn_event"
+                }
+            ]
+        }));
+        this.entity.client_entity.addMaterial("default", "entity_alphatest")
+            .addGeometry("default", "geometry.cube")
+            .addRenderController("controller.render.cow");
+    }
+    setGeometry(geometry) {
+        //设置方块模型
+        this.block.addComponent(BlockComponent.setGeometry(geometry));
+        //设置实体模型
+        this.entity.client_entity.addGeometry("default", geometry);
+    }
+    addAnimation(name, animation) {
+        this.entity.client_entity.addAnimation(name, animation);
+    }
+    setScript(key, value) {
+        this.entity.client_entity.setScript(key, value);
+    }
+}

package/dist/core/entity/basicEntity.d.ts

@@ -0,0 +1,111 @@
+export class BasicEntity {
+    /**
+     * 构造函数
+     * @param {string} identifier - 实体的唯一标识符
+     * @param {Object} options - 配置选项
+     * @param {boolean} [options.is_spawnable=true] - 是否可生成
+     * @param {boolean} [options.is_summonable=true] - 是否可召唤
+     * @param {string} [options.runtime_identifier] - 复刻标识符
+     * @param {Object} data - 继承的数据
+     * @param {Object} [data.components={}] - 继承的组件
+     * @param {Object} [data.component_groups={}] - 继承的组件组
+     * @param {Object} [data.events={}] - 继承的事件
+     */
+    constructor(identifier: string, options?: {
+        is_spawnable?: boolean | undefined;
+        is_summonable?: boolean | undefined;
+        runtime_identifier?: string | undefined;
+    }, data?: {
+        components?: Object | undefined;
+        component_groups?: Object | undefined;
+        events?: Object | undefined;
+    });
+    identifier: string;
+    is_spawnable: boolean;
+    is_summonable: boolean;
+    runtime_identifier: string | undefined;
+    properties: Map<string, any>;
+    components: Map<string, any>;
+    component_groups: Map<string, any>;
+    events: Map<string, any>;
+    /**
+     * 添加属性到实体
+     * @param {string} name 属性名称
+     * @param {Object} value 属性值
+     * @returns
+     */
+    addProperty(name: string, value: Object): this;
+    /**
+     * 移除属性
+     * @param {string} name 属性名称
+     * @returns
+     */
+    removeProperty(name: string): this;
+    /**
+     * 移除所有属性
+     * @returns
+     */
+    clearProperties(): this;
+    /**
+     * 添加事件到实体
+     * @param {string} name - 事件名称
+     * @param {Map} eventMap - 事件的键值对 Map
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    addEvent(name: string, eventMap: Map<any, any>): BasicEntity;
+    /**
+     * 删除事件
+     * @param {string} name - 事件名称
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    removeEvent(name: string): BasicEntity;
+    /**
+     * 清除所有事件
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    clearEvents(): BasicEntity;
+    /**
+     * 添加组件组到实体
+     * @param {string} name - 组件组名称
+     * @param {Map} componentMap - 组件组的键值对 Map
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    addComponentGroup(name: string, componentMap: Map<any, any>): BasicEntity;
+    /**
+     * 删除组件组
+     * @param {string} name - 组件组名称
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    removeComponentGroup(name: string): BasicEntity;
+    /**
+     * 清除所有组件组
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    clearComponentGroups(): BasicEntity;
+    /**
+     * 添加组件到实体
+     * @param {Map} componentMap - 组件的键值对 Map
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    addComponent(componentMap: Map<any, any>): BasicEntity;
+    /**
+     * 删除组件
+     * @param {string} key - 组件名称
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    removeComponent(key: string): BasicEntity;
+    /**
+     * 清除所有组件
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    clearComponents(): BasicEntity;
+    /**
+     * 清除所有数据
+     */
+    clearAll(): this;
+    /**
+     * 将实体转换为 JSON 格式
+     * @returns {Object} - 返回 JSON 格式的实体数据
+     */
+    toJson(): Object;
+}

package/dist/core/entity/basicEntity.js

@@ -0,0 +1,170 @@
+import { AddonEntity, AddonEntityDefinition, AddonEntityDescription } from "../addon/entity/entity.js";
+export class BasicEntity {
+    /**
+     * 构造函数
+     * @param {string} identifier - 实体的唯一标识符
+     * @param {Object} options - 配置选项
+     * @param {boolean} [options.is_spawnable=true] - 是否可生成
+     * @param {boolean} [options.is_summonable=true] - 是否可召唤
+     * @param {string} [options.runtime_identifier] - 复刻标识符
+     * @param {Object} data - 继承的数据
+     * @param {Object} [data.components={}] - 继承的组件
+     * @param {Object} [data.component_groups={}] - 继承的组件组
+     * @param {Object} [data.events={}] - 继承的事件
+     */
+    constructor(identifier, options = {}, data = {}) {
+        // 参数验证
+        if (typeof identifier !== 'string' || !identifier) {
+            throw new Error('identifier must be a non-empty string.');
+        }
+        if (options.runtime_identifier && typeof options.runtime_identifier !== 'string') {
+            throw new Error('runtime_identifier must be a string.');
+        }
+        this.identifier = identifier;
+        this.is_spawnable = options.is_spawnable ?? true;
+        this.is_summonable = options.is_summonable ?? true;
+        this.runtime_identifier = options.runtime_identifier;
+        // 初始化 components、component_groups 和 events，确保 data 中的值为对象
+        this.properties = new Map(Object.entries(data.description ? data.description.properties || {} : {}));
+        this.components = new Map(Object.entries(data.components || {}));
+        this.component_groups = new Map(Object.entries(data.component_groups || {}));
+        this.events = new Map(Object.entries(data.events || {}));
+    }
+    /**
+     * 添加属性到实体
+     * @param {string} name 属性名称
+     * @param {Object} value 属性值
+     * @returns
+     */
+    addProperty(name, value) {
+        this.properties.set(name, value);
+        return this;
+    }
+    /**
+     * 移除属性
+     * @param {string} name 属性名称
+     * @returns
+     */
+    removeProperty(name) {
+        this.properties.delete(name);
+        return this;
+    }
+    /**
+     * 移除所有属性
+     * @returns
+     */
+    clearProperties() {
+        this.properties.clear();
+        return this;
+    }
+    /**
+     * 添加事件到实体
+     * @param {string} name - 事件名称
+     * @param {Map} eventMap - 事件的键值对 Map
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    addEvent(name, eventMap) {
+        if (!(eventMap instanceof Map)) {
+            throw new Error("eventMap must be an instance of Map.");
+        }
+        this.events.set(name, eventMap);
+        return this;
+    }
+    /**
+     * 删除事件
+     * @param {string} name - 事件名称
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    removeEvent(name) {
+        this.events.delete(name);
+        return this;
+    }
+    /**
+     * 清除所有事件
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    clearEvents() {
+        this.events.clear();
+        return this;
+    }
+    /**
+     * 添加组件组到实体
+     * @param {string} name - 组件组名称
+     * @param {Map} componentMap - 组件组的键值对 Map
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    addComponentGroup(name, componentMap) {
+        if (!(componentMap instanceof Map)) {
+            throw new Error("componentMap must be an instance of Map.");
+        }
+        this.component_groups.set(name, componentMap);
+        return this;
+    }
+    /**
+     * 删除组件组
+     * @param {string} name - 组件组名称
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    removeComponentGroup(name) {
+        this.component_groups.delete(name);
+        return this;
+    }
+    /**
+     * 清除所有组件组
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    clearComponentGroups() {
+        this.component_groups.clear();
+        return this;
+    }
+    /**
+     * 添加组件到实体
+     * @param {Map} componentMap - 组件的键值对 Map
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    addComponent(componentMap) {
+        if (!(componentMap instanceof Map)) {
+            throw new Error("componentMap must be an instance of Map.");
+        }
+        for (const [key, value] of componentMap) {
+            this.components.set(key, value);
+        }
+        return this; // 支持链式调用
+    }
+    /**
+     * 删除组件
+     * @param {string} key - 组件名称
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    removeComponent(key) {
+        this.components.delete(key);
+        return this;
+    }
+    /**
+     * 清除所有组件
+     * @returns {BasicEntity} - 返回当前实例以支持链式调用
+     */
+    clearComponents() {
+        this.components.clear();
+        return this;
+    }
+    /**
+     * 清除所有数据
+     */
+    clearAll() {
+        this.components.clear();
+        this.component_groups.clear();
+        this.events.clear();
+        return this;
+    }
+    /**
+     * 将实体转换为 JSON 格式
+     * @returns {Object} - 返回 JSON 格式的实体数据
+     */
+    toJson() {
+        return new AddonEntity("1.16.0", new AddonEntityDefinition(new AddonEntityDescription(this.identifier, this.is_spawnable, this.is_summonable, Object.fromEntries(this.properties), this.runtime_identifier), Object.fromEntries(this.components), // 将 Map 转换为普通对象
+        Object.fromEntries(this.component_groups), // 将 Map 转换为普通对象
+        Object.fromEntries(this.events) // 将 Map 转换为普通对象
+        )).toJson();
+    }
+}

package/dist/core/entity/behavior/followMob.d.ts

@@ -0,0 +1,12 @@
+export class FollowMobBehavior {
+    constructor(priority: any);
+    priority: any;
+    searchRange: number;
+    speedMultiplier: number;
+    stopDistance: number;
+    setPriority(priority: any): this;
+    setSearchRange(searchRange: any): this;
+    setSpeedMultiplier(speedMultiplier: any): this;
+    setStopDistance(stopDistance: any): this;
+    toJSON(): Map<any, any>;
+}

package/dist/core/entity/behavior/followMob.js

@@ -0,0 +1,35 @@
+export class FollowMobBehavior {
+    constructor(priority) {
+        this.priority = priority;
+        this.searchRange = 0;
+        this.speedMultiplier = 1.0;
+        this.stopDistance = 2.0;
+    }
+    setPriority(priority) {
+        this.priority = priority;
+        return this; // 支持链式调用
+    }
+    setSearchRange(searchRange) {
+        this.searchRange = searchRange;
+        return this; // 支持链式调用
+    }
+    setSpeedMultiplier(speedMultiplier) {
+        this.speedMultiplier = speedMultiplier;
+        return this; // 支持链式调用
+    }
+    setStopDistance(stopDistance) {
+        this.stopDistance = stopDistance;
+        return this; // 支持链式调用
+    }
+    toJSON() {
+        if (this.priority === null) {
+            throw new Error("Priority must be set for FollowMobBehavior.");
+        }
+        return new Map().set("minecraft:behavior.follow_mob", {
+            priority: this.priority,
+            search_range: this.searchRange,
+            speed_multiplier: this.speedMultiplier,
+            stop_distance: this.stopDistance
+        });
+    }
+}

package/dist/core/entity/behavior/followParent.d.ts

@@ -0,0 +1,7 @@
+export class FollowParentBehavior {
+    constructor(priority: any);
+    priority: any;
+    speed_multiplier: number;
+    setSpeedMultiplier(speed_multiplier: any): void;
+    toJson(): Map<any, any>;
+}

package/dist/core/entity/behavior/followParent.js

@@ -0,0 +1,15 @@
+export class FollowParentBehavior {
+    constructor(priority) {
+        this.priority = priority;
+        this.speed_multiplier = 1.10;
+    }
+    setSpeedMultiplier(speed_multiplier) {
+        this.speed_multiplier = speed_multiplier;
+    }
+    toJson() {
+        return new Map().set("minecraft:behavior.follow_parent", {
+            "priority": this.priority,
+            "speed_multiplier": this.speed_multiplier
+        });
+    }
+}

package/dist/core/entity/behavior/randomStroll.d.ts

@@ -0,0 +1,31 @@
+export class RandomStrollBehavior {
+    /**
+     * 随机漫步行为
+     * @param {number} priority 优先级
+     * @param {number} interval 间隔
+     * @param {number} speed_multiplier 速度倍数
+     */
+    constructor(priority: number, interval: number, speed_multiplier: number);
+    priority: number;
+    interval: number;
+    speed_multiplier: number;
+    xz_dist: number;
+    y_dist: number;
+    /**
+     * 设置水平距离
+     * @param {number} xz_dist 水平距离
+     * @returns {EntityBehaviorRandomStroll} 返回当前实例以支持链式调用
+     */
+    setXZDist(xz_dist: number): EntityBehaviorRandomStroll;
+    /**
+     * 设置垂直距离
+     * @param {number} y_dist 垂直距离
+     * @returns {EntityBehaviorRandomStroll} 返回当前实例以支持链式调用
+     */
+    setYDist(y_dist: number): EntityBehaviorRandomStroll;
+    /**
+     * 将组件转换为 JSON 对象
+     * @returns {Object} minecraft:behavior.random_stroll 组件的 JSON 对象
+     */
+    toJSON(): Object;
+}