sapdon 3.0.2 → 3.0.3

package/dist/core/entity/componets/entityComponet.js

@@ -0,0 +1,347 @@
+export class EntityComponent {
+    static setMovement(speed) {
+        return new Map().set("minecraft:movement", {
+            "value": speed
+        });
+    }
+    static setCollisionBox(width, height) {
+        return new Map().set("minecraft:collision_box", {
+            width: width,
+            height: height,
+        });
+    }
+    /**
+       * 将多个组件集合合并为一个。
+       * @param {...Map} componentMaps - 多个组件集合。
+       * @returns {Map} - 合并后的组件集合。
+       */
+    static combineComponents(...componentMaps) {
+        return new Map(componentMaps.flatMap(map => [...map]));
+    }
+    /**
+       * 创建 minecraft:health 组件。
+       * @param {Object} options 配置选项
+       * @param {number} options.max 实体的最大生命值
+       * @param {number|Object} options.value 实体的初始生命值（可以是固定值或范围值）
+       * @returns {Map} 包含 minecraft:health 组件的 Map 对象
+       * @throws {Error} 如果参数无效。
+       */
+    static setHealth(options = {}) {
+        const { max, value } = options;
+        // 参数验证
+        this.validateHealthParameters(max, value);
+        // 构建组件
+        const healthComponent = {
+            max: max,
+            value: value,
+        };
+        // 返回 Map 对象
+        const healthMap = new Map();
+        healthMap.set("minecraft:health", healthComponent);
+        return healthMap;
+    }
+    /**
+     * 验证 minecraft:health 组件的参数。
+     * @param {number} max 最大生命值
+     * @param {number|Object} value 初始生命值
+     * @throws {Error} 如果参数无效。
+     */
+    static validateHealthParameters(max, value) {
+        if (typeof max !== "number" || max <= 0) {
+            throw new Error("max 必须是一个正数");
+        }
+        if ((typeof value !== "number" && typeof value !== "object") ||
+            (typeof value === "number" && value <= 0) ||
+            (typeof value === "object" &&
+                (typeof value.range_min !== "number" ||
+                    typeof value.range_max !== "number" ||
+                    value.range_min <= 0 ||
+                    value.range_max <= 0))) {
+            throw new Error("value 必须是一个正数或包含 range_min 和 range_max 的对象");
+        }
+    }
+    /**
+     * 创建 minecraft:physics 组件。
+     * @param {boolean} has_collision 是否碰撞（默认：true）
+     * @param {boolean} has_gravity 是否受重力影响（默认：true）
+     * @param {boolean} push_towards_closest_space 是否在卡住时推向最近空间（默认：false）
+     * @returns {Map} 包含 minecraft:physics 组件的 Map 对象
+     * @throws {Error} 如果参数不是布尔类型。
+     */
+    static setPhysics(has_collision = true, has_gravity = true, push_towards_closest_space = false) {
+        // 参数验证
+        if (typeof has_collision !== "boolean" ||
+            typeof has_gravity !== "boolean" ||
+            typeof push_towards_closest_space !== "boolean") {
+            throw new Error("所有参数必须是布尔类型");
+        }
+        // 创建 Map 对象
+        const physicsMap = new Map();
+        physicsMap.set("minecraft:physics", {
+            has_collision: has_collision,
+            has_gravity: has_gravity,
+            push_towards_closest_space: push_towards_closest_space,
+        });
+        return physicsMap;
+    }
+    /**
+   * 创建 minecraft:scale 组件。
+   * @param {number} value 实体的缩放比例（默认：1.0）
+   * @returns {Map} 包含 minecraft:scale 组件的 Map 对象
+   * @throws {Error} 如果参数无效。
+   */
+    static setScale(value = 1.0) {
+        // 参数验证
+        if (typeof value !== "number" || value <= 0) {
+            throw new Error("value 必须是一个正数");
+        }
+        // 返回 Map 对象
+        const scaleMap = new Map();
+        scaleMap.set("minecraft:scale", {
+            value: value,
+        });
+        return scaleMap;
+    }
+    /**
+   * 创建默认的 minecraft:nameable 组件（不填写参数）。
+   * @returns {Map} 包含 minecraft:nameable 组件的 Map 对象
+   */
+    static setDefaultNameable() {
+        const nameableMap = new Map();
+        nameableMap.set("minecraft:nameable", {});
+        return nameableMap;
+    }
+    /**
+     * 创建自定义的 minecraft:nameable 组件（填写参数）。
+     * @param {boolean} allowNameTagRenaming 是否允许使用命名牌重命名（默认：true）
+     * @param {boolean} alwaysShow 是否始终显示名称（默认：false）
+     * @param {Object} defaultTrigger 默认触发事件（可选）
+     * @param {Array} nameActions 特殊名称及其对应的事件（可选）
+     * @returns {Map} 包含 minecraft:nameable 组件的 Map 对象
+     * @throws {Error} 如果参数无效。
+     */
+    static setCustomNameable(allowNameTagRenaming = true, alwaysShow = false, defaultTrigger = null, nameActions = []) {
+        // 参数验证
+        if (typeof allowNameTagRenaming !== "boolean" ||
+            typeof alwaysShow !== "boolean") {
+            throw new Error("allowNameTagRenaming 和 alwaysShow 必须是布尔类型");
+        }
+        // 构建组件
+        const nameableComponent = {
+            allow_name_tag_renaming: allowNameTagRenaming,
+            always_show: alwaysShow,
+        };
+        // 添加 default_trigger（如果存在）
+        if (defaultTrigger) {
+            nameableComponent.default_trigger = defaultTrigger;
+        }
+        // 添加 name_actions（如果存在）
+        if (nameActions.length > 0) {
+            nameableComponent.name_actions = nameActions;
+        }
+        // 返回 Map 对象
+        const nameableMap = new Map();
+        nameableMap.set("minecraft:nameable", nameableComponent);
+        return nameableMap;
+    }
+    /**
+     * 创建 minecraft:pushable 组件。
+     * @param {boolean} isPushable 是否可以被其他实体推动（默认：true）
+     * @param {boolean} isPushableByPiston 是否可以被活塞推动（默认：true）
+     * @returns {Map} 包含 minecraft:pushable 组件的 Map 对象
+     * @throws {Error} 如果参数无效。
+     */
+    static setPushable(isPushable = true, isPushableByPiston = true) {
+        // 参数验证
+        if (typeof isPushable !== "boolean" || typeof isPushableByPiston !== "boolean") {
+            throw new Error("isPushable 和 isPushableByPiston 必须是布尔类型");
+        }
+        // 返回 Map 对象
+        const pushableMap = new Map();
+        pushableMap.set("minecraft:pushable", {
+            is_pushable: isPushable,
+            is_pushable_by_piston: isPushableByPiston,
+        });
+        return pushableMap;
+    }
+    /**
+       * 创建 minecraft:jump.static 组件。
+       * @param {number} jumpPower 跳跃的初始垂直速度（默认：0.42）
+       * @returns {Map} 包含 minecraft:jump.static 组件的 Map 对象
+       * @throws {Error} 如果参数无效。
+       */
+    static setJumpStatic(jumpPower = 0.42) {
+        // 参数验证
+        if (typeof jumpPower !== "number" || jumpPower < 0) {
+            throw new Error("jumpPower 必须是一个非负数");
+        }
+        // 返回 Map 对象
+        const jumpStaticMap = new Map();
+        jumpStaticMap.set("minecraft:jump.static", {
+            jump_power: jumpPower,
+        });
+        return jumpStaticMap;
+    }
+    /**
+    * 创建 minecraft:navigation.walk 组件。
+    * @param {Object} options 配置选项
+    * @param {boolean} options.avoidDamageBlocks 是否避免伤害性方块（默认：false）
+    * @param {boolean} options.avoidPortals 是否避免传送门（默认：false）
+    * @param {boolean} options.avoidSun 是否避免阳光下的方块（默认：false）
+    * @param {boolean} options.avoidWater 是否避免水（默认：false）
+    * @param {Array} options.blocksToAvoid 需要避免的方块列表（默认：[]）
+    * @param {boolean} options.canBreach 是否可以跳出水面（默认：false）
+    * @param {boolean} options.canBreakDoors 是否可以破坏门（默认：false）
+    * @param {boolean} options.canFloat 是否可以漂浮（默认：false）
+    * @param {boolean} options.canJump 是否可以跳跃（默认：true）
+    * @param {boolean} options.canOpenDoors 是否可以开门（默认：false）
+    * @param {boolean} options.canOpenIronDoors 是否可以开铁门（默认：false）
+    * @param {boolean} options.canPassDoors 是否可以穿过门（默认：true）
+    * @param {boolean} options.canPathFromAir 是否可以在空中开始路径规划（默认：false）
+    * @param {boolean} options.canPathOverLava 是否可以在熔岩表面行走（默认：false）
+    * @param {boolean} options.canPathOverWater 是否可以在水面上行走（默认：false）
+    * @param {boolean} options.canSink 是否会在水中下沉（默认：true）
+    * @param {boolean} options.canSwim 是否可以游泳（默认：false）
+    * @param {boolean} options.canWalk 是否可以在地面上行走（默认：true）
+    * @param {boolean} options.canWalkInLava 是否可以在熔岩中行走（默认：false）
+    * @param {boolean} options.isAmphibious 是否可以在水下行走（默认：false）
+    * @returns {Map} 包含 minecraft:navigation.walk 组件的 Map 对象
+    * @throws {Error} 如果参数无效。
+    */
+    static setNavigationWalk(options = {}) {
+        // 默认值
+        const { avoidDamageBlocks = false, avoidPortals = false, avoidSun = false, avoidWater = false, blocksToAvoid = [], canBreach = false, canBreakDoors = false, canFloat = false, canJump = true, canOpenDoors = false, canOpenIronDoors = false, canPassDoors = true, canPathFromAir = false, canPathOverLava = false, canPathOverWater = false, canSink = true, canSwim = false, canWalk = true, canWalkInLava = false, isAmphibious = false, } = options;
+        // 构建组件
+        const navigationWalkComponent = {
+            avoid_damage_blocks: avoidDamageBlocks,
+            avoid_portals: avoidPortals,
+            avoid_sun: avoidSun,
+            avoid_water: avoidWater,
+            blocks_to_avoid: blocksToAvoid,
+            can_breach: canBreach,
+            can_break_doors: canBreakDoors,
+            can_float: canFloat,
+            can_jump: canJump,
+            can_open_doors: canOpenDoors,
+            can_open_iron_doors: canOpenIronDoors,
+            can_pass_doors: canPassDoors,
+            can_path_from_air: canPathFromAir,
+            can_path_over_lava: canPathOverLava,
+            can_path_over_water: canPathOverWater,
+            can_sink: canSink,
+            can_swim: canSwim,
+            can_walk: canWalk,
+            can_walk_in_lava: canWalkInLava,
+            is_amphibious: isAmphibious,
+        };
+        // 返回 Map 对象
+        const navigationWalkMap = new Map();
+        navigationWalkMap.set("minecraft:navigation.walk", navigationWalkComponent);
+        return navigationWalkMap;
+    }
+    /**
+     * 创建 minecraft:movement.basic 组件。
+     * @param {number} maxTurn 实体每 tick 可以转向的最大角度（默认：30.0）
+     * @returns {Map} 包含 minecraft:movement.basic 组件的 Map 对象
+     * @throws {Error} 如果参数无效。
+     */
+    static setMovementBasic(maxTurn = 30.0) {
+        // 参数验证
+        if (typeof maxTurn !== "number" || maxTurn < 0) {
+            throw new Error("maxTurn 必须是一个非负数");
+        }
+        // 返回 Map 对象
+        const movementBasicMap = new Map();
+        movementBasicMap.set("minecraft:movement.basic", {
+            max_turn: maxTurn,
+        });
+        return movementBasicMap;
+    }
+    /**
+     * 创建 minecraft:projectile 组件。
+     * @param {Object} options 配置选项
+     * @param {number} options.anchor 发射锚点（默认：0）
+     * @param {number} options.angleOffset 角度偏移（默认：0.0）
+     * @param {boolean} options.catchFire 是否点燃目标（默认：false）
+     * @param {boolean} options.critParticleOnHurt 是否生成暴击粒子（默认：false）
+     * @param {boolean} options.destroyOnHurt 是否在击中时销毁（默认：false）
+     * @param {string} options.filter 过滤的实体（可选）
+     * @param {boolean} options.fireAffectedByGriefing 是否受游戏规则影响（默认：false）
+     * @param {number} options.gravity 重力值（默认：0.05）
+     * @param {string} options.hitSound 击中声音（可选）
+     * @param {string} options.hitGroundSound 击中地面声音（可选）
+     * @param {boolean} options.homing 是否追踪目标（默认：false）
+     * @param {number} options.inertia 空气惯性（默认：0.99）
+     * @param {boolean} options.isDangerous 是否对玩家危险（默认：false）
+     * @param {boolean} options.knockback 是否击退目标（默认：true）
+     * @param {boolean} options.lightning 是否召唤闪电（默认：false）
+     * @param {number} options.liquidInertia 水中惯性（默认：0.6）
+     * @param {boolean} options.multipleTargets 是否可击中多个目标（默认：true）
+     * @param {number[]} options.offset 发射偏移量（默认：[0, 0, 0]）
+     * @param {number} options.onFireTime 着火时间（默认：0.0）
+     * @param {Object} options.onHit 击中时的行为（可选）
+     * @param {string} options.particle 碰撞粒子（默认："ironcrack"）
+     * @param {number} options.power 初始速度（默认：1.3）
+     * @param {number} options.reflectImmunity 反射免疫时间（默认：0.0）
+     * @param {boolean} options.reflectOnHurt 是否反射（默认：false）
+     * @param {string} options.shootSound 发射声音（可选）
+     * @param {boolean} options.shootTarget 是否朝向目标发射（默认：true）
+     * @param {boolean} options.shouldBounce 是否反弹（默认：false）
+     * @param {boolean} options.splashPotion 是否为喷溅药水（默认：false）
+     * @param {number} options.splashRange 喷溅范围（默认：4）
+     * @param {boolean} options.stopOnHurt 是否在击中时停止（默认：false）
+     * @param {number} options.uncertaintyBase 基础精度（默认：0）
+     * @param {number} options.uncertaintyMultiplier 精度倍数（默认：0）
+     * @returns {Map} 包含 minecraft:projectile 组件的 Map 对象
+     * @throws {Error} 如果参数无效。
+     */
+    static setProjectile(options = {}) {
+        // 默认值
+        const { anchor = 0, angleOffset = 0.0, catchFire = false, critParticleOnHurt = false, destroyOnHurt = false, filter = null, fireAffectedByGriefing = false, gravity = 0.05, hitSound = null, hitGroundSound = null, homing = false, inertia = 0.99, isDangerous = false, knockback = true, lightning = false, liquidInertia = 0.6, multipleTargets = true, offset = [0, 0, 0], onFireTime = 0.0, onHit = null, particle = "ironcrack", power = 1.3, reflectImmunity = 0.0, reflectOnHurt = false, shootSound = null, shootTarget = true, shouldBounce = false, splashPotion = false, splashRange = 4, stopOnHurt = false, uncertaintyBase = 0, uncertaintyMultiplier = 0, } = options;
+        // 构建组件
+        const projectileComponent = {
+            anchor,
+            angle_offset: angleOffset,
+            catch_fire: catchFire,
+            crit_particle_on_hurt: critParticleOnHurt,
+            destroy_on_hurt: destroyOnHurt,
+            fire_affected_by_griefing: fireAffectedByGriefing,
+            gravity,
+            homing,
+            inertia,
+            is_dangerous: isDangerous,
+            knockback,
+            lightning,
+            liquid_inertia: liquidInertia,
+            multiple_targets: multipleTargets,
+            offset,
+            on_fire_time: onFireTime,
+            particle,
+            power,
+            reflect_immunity: reflectImmunity,
+            reflect_on_hurt: reflectOnHurt,
+            shoot_target: shootTarget,
+            should_bounce: shouldBounce,
+            splash_potion: splashPotion,
+            splash_range: splashRange,
+            stop_on_hurt: stopOnHurt,
+            uncertainty_base: uncertaintyBase,
+            uncertainty_multiplier: uncertaintyMultiplier,
+        };
+        // 添加可选参数
+        if (filter)
+            projectileComponent.filter = filter;
+        if (hitSound)
+            projectileComponent.hit_sound = hitSound;
+        if (hitGroundSound)
+            projectileComponent.hit_ground_sound = hitGroundSound;
+        if (onHit)
+            projectileComponent.on_hit = onHit;
+        if (shootSound)
+            projectileComponent.shoot_sound = shootSound;
+        // 返回 Map 对象
+        const projectileMap = new Map();
+        projectileMap.set("minecraft:projectile", projectileComponent);
+        return projectileMap;
+    }
+}

package/dist/core/entity/data/nativeEntityData.d.ts

@@ -0,0 +1,9 @@
+export class NativeEntityData {
+    static behDataPath: string;
+    static resDataPath: string;
+    static behData: null;
+    static resData: null;
+    static loadDataSync(filePath: any): any;
+    static reloadDataSync(): void;
+    static getDataById(type: any, id: any): any;
+}

package/dist/core/entity/data/nativeEntityData.js

@@ -0,0 +1,38 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+// 获取当前文件的目录路径 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export class NativeEntityData {
+    // 使用 __dirname 获取当前文件所在目录
+    static behDataPath = path.join(__dirname, 'data_bp.json');
+    static resDataPath = path.join(__dirname, 'data_rp.json');
+    static behData = null;
+    static resData = null;
+    static loadDataSync(filePath) {
+        try {
+            const data = fs.readFileSync(filePath, 'utf8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            console.error(`Failed to load data from $$${filePath}:`, error);
+            return {};
+        }
+    }
+    static reloadDataSync() {
+        this.behData = this.loadDataSync(this.behDataPath);
+        this.resData = this.loadDataSync(this.resDataPath);
+    }
+    static getDataById(type, id) {
+        if (typeof type !== 'string' || typeof id !== 'string') {
+            throw new Error("type and id must be strings");
+        }
+        if (!this.behData || !this.resData) {
+            this.reloadDataSync();
+        }
+        if (type === 'beh') {
+            return this.behData[id] || null;
+        }
+        return this.resData[id] || null;
+    }
+}

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

@@ -0,0 +1,15 @@
+export class Entity {
+    /**
+     *
+     * @param {*} identifier
+     * @param {*} texture
+     * @param {*} behData
+     * @param {*} resData
+     * @param {*} options
+     */
+    constructor(identifier: any, texture: any, behData: any, resData: any, options?: any);
+    identifier: any;
+    entity: BasicEntity;
+    client_entity: import("../addon/entity/clientEntity.js").AddonClientEntityDescription;
+}
+import { BasicEntity } from "./basicEntity.js";

package/dist/core/entity/entity.js

@@ -0,0 +1,18 @@
+import { BasicEntity } from "./basicEntity.js";
+import { ClientEntity } from "./clientEntity.js";
+export class Entity {
+    /**
+     *
+     * @param {*} identifier
+     * @param {*} texture
+     * @param {*} behData
+     * @param {*} resData
+     * @param {*} options
+     */
+    constructor(identifier, texture, behData, resData, options = {}) {
+        // 创建行为实体和客户端实体
+        this.identifier = identifier;
+        this.entity = new BasicEntity(identifier, options, behData);
+        this.client_entity = new ClientEntity(identifier, resData).addTexture("default", texture);
+    }
+}

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

@@ -0,0 +1,8 @@
+export class NativeEntity {
+    constructor(identifier: any, proto_id: any, options?: {});
+    identifier: any;
+    entity: BasicEntity;
+    client_entity: ClientEntity;
+}
+import { BasicEntity } from "./basicEntity.js";
+import { ClientEntity } from "./clientEntity.js";

package/dist/core/entity/nativeEntity.js

@@ -0,0 +1,28 @@
+import { BasicEntity } from "./basicEntity.js";
+import { ClientEntity } from "./clientEntity.js";
+import { NativeEntityData } from "./data/nativeEntityData.js";
+export class NativeEntity {
+    constructor(identifier, proto_id, options = {}) {
+        try {
+            // 获取行为数据
+            const behData = NativeEntityData.getDataById("beh", proto_id)?.["minecraft:entity"];
+            if (!behData) {
+                throw new Error(`Behavior data not found for proto_id: ${proto_id}`);
+            }
+            // 获取资源数据
+            const resData = NativeEntityData.getDataById("res", proto_id)?.["minecraft:client_entity"]?.["description"];
+            if (!resData) {
+                throw new Error(`Resource data not found for proto_id: ${proto_id}`);
+            }
+            options["runtime_identifier"] = proto_id;
+            // 创建行为实体和客户端实体
+            this.identifier = identifier;
+            this.entity = new BasicEntity(identifier, options, behData);
+            this.client_entity = new ClientEntity(identifier, resData);
+        }
+        catch (error) {
+            console.error(`Failed to create NativeEntity ${identifier}:`, error);
+            throw error; // 抛出错误，避免继续执行
+        }
+    }
+}

package/dist/core/entity/navigation/walk.d.ts

@@ -0,0 +1,23 @@
+export namespace Navigation {
+    function walk(options?: {
+        avoid_damage_blocks?: boolean | undefined;
+        avoid_portals?: boolean | undefined;
+        avoid_sun?: boolean | undefined;
+        avoid_water?: boolean | undefined;
+        blocks_to_avoid?: any[] | undefined;
+        can_breach?: boolean | undefined;
+        can_break_doors?: boolean | undefined;
+        can_jump?: boolean | undefined;
+        can_open_doors?: boolean | undefined;
+        can_open_iron_doors?: boolean | undefined;
+        can_pass_doors?: boolean | undefined;
+        can_path_from_air?: boolean | undefined;
+        can_path_over_lava?: boolean | undefined;
+        can_path_over_water?: boolean | undefined;
+        can_sink?: boolean | undefined;
+        can_swim?: boolean | undefined;
+        can_walk?: boolean | undefined;
+        can_walk_in_lava?: boolean | undefined;
+        is_amphibious?: boolean | undefined;
+    }): Map<any, any>;
+}

package/dist/core/entity/navigation/walk.js

@@ -0,0 +1,56 @@
+export const Navigation = {
+    /**
+     * 创建 minecraft:navigation.walk 组件的配置。
+     * @param {Object} options - 配置选项。
+     * @param {boolean} [options.avoid_damage_blocks=false] - 是否避免伤害方块。
+     * @param {boolean} [options.avoid_portals=false] - 是否避免传送门。
+     * @param {boolean} [options.avoid_sun=false] - 是否避免阳光。
+     * @param {boolean} [options.avoid_water=false] - 是否避免水。
+     * @param {Array} [options.blocks_to_avoid=[]] - 需要避免的方块列表。
+     * @param {boolean} [options.can_breach=false] - 是否可以突破方块。
+     * @param {boolean} [options.can_break_doors=false] - 是否可以破坏门。
+     * @param {boolean} [options.can_jump=true] - 是否可以跳跃。
+     * @param {boolean} [options.can_open_doors=false] - 是否可以开门。
+     * @param {boolean} [options.can_open_iron_doors=false] - 是否可以开铁门。
+     * @param {boolean} [options.can_pass_doors=true] - 是否可以通过门。
+     * @param {boolean} [options.can_path_from_air=false] - 是否可以从空中寻路。
+     * @param {boolean} [options.can_path_over_lava=false] - 是否可以在熔岩上寻路。
+     * @param {boolean} [options.can_path_over_water=false] - 是否可以在水上寻路。
+     * @param {boolean} [options.can_sink=true] - 是否可以沉入水中。
+     * @param {boolean} [options.can_swim=false] - 是否可以游泳。
+     * @param {boolean} [options.can_walk=true] - 是否可以行走。
+     * @param {boolean} [options.can_walk_in_lava=false] - 是否可以在熔岩中行走。
+     * @param {boolean} [options.is_amphibious=false] - 是否是两栖动物。
+     * @returns {Map} - 包含 minecraft:navigation.walk 组件的 Map 对象。
+     */
+    walk: function (options = {}) {
+        // 默认值
+        const defaultOptions = {
+            avoid_damage_blocks: false,
+            avoid_portals: false,
+            avoid_sun: false,
+            avoid_water: false,
+            blocks_to_avoid: [],
+            can_breach: false,
+            can_break_doors: false,
+            can_jump: true,
+            can_open_doors: false,
+            can_open_iron_doors: false,
+            can_pass_doors: true,
+            can_path_from_air: false,
+            can_path_over_lava: false,
+            can_path_over_water: false,
+            can_sink: true,
+            can_swim: false,
+            can_walk: true,
+            can_walk_in_lava: false,
+            is_amphibious: false
+        };
+        // 合并用户提供的选项和默认值
+        const finalOptions = { ...defaultOptions, ...options };
+        // 返回 Map 对象
+        const navigationMap = new Map();
+        navigationMap.set("minecraft:navigation.walk", finalOptions);
+        return navigationMap;
+    }
+};

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

@@ -0,0 +1,3 @@
+export class Projectile extends NativeEntity {
+}
+import { NativeEntity } from "./nativeEntity.js";

package/dist/core/entity/projectile.js

@@ -0,0 +1,7 @@
+import { NativeEntity } from "./nativeEntity.js";
+export class Projectile extends NativeEntity {
+    constructor(identifier, texture_path, options = {}) {
+        super(identifier, "minecraft:snowball", options);
+        this.client_entity.addTexture("default", texture_path);
+    }
+}

package/dist/core/factory/biomeFactory.d.ts

@@ -0,0 +1,4 @@
+export namespace BiomeAPI {
+    function createBiome(identifier: any): Biome;
+}
+import { Biome } from "../biome/biome.js";

package/dist/core/factory/biomeFactory.js

@@ -0,0 +1,13 @@
+import { Biome } from "../biome/biome.js";
+import { GRegistry } from "../registry.js";
+const registerBiome = (biome) => {
+    const biome_name = biome.identifier.split(":")[biome.identifier.split(":").length - 1];
+    GRegistry.register(biome_name, "behavior", "biomes/", biome);
+};
+export const BiomeAPI = {
+    createBiome: function (identifier) {
+        const biome = new Biome(identifier);
+        registerBiome(biome);
+        return biome;
+    }
+};

package/dist/core/factory/blockFactory.d.ts

@@ -0,0 +1,34 @@
+export namespace BlockAPI {
+    function createBasicBlock(identifier: string, category: string, textures_arr: any[], options?: {
+        group: string;
+        hide_in_command: boolean;
+    }): BasicBlock;
+    function createBlock(identifier: string, category: string, variantDatas: any[], options?: {
+        group: string;
+        hide_in_command: boolean;
+        ambient_occlusion: boolean;
+        face_dimming: boolean;
+        render_method: string;
+    }): Block;
+    function createRotatableBlock(identifier: string, category: string, textures_arr: any[], options?: {
+        group: string;
+        hide_in_command: boolean;
+        rotationType: string;
+        yRotationOffset: number;
+    }): RotatableBlock;
+    function createGeometryBlock(identifier: any, category: any, geometry: any, material_instances: any, options?: {}): GeometryBlock;
+    function createOreBlock(identifier: any, category: any, textures_arr: any, options?: {}): OreBlock;
+    function createCropBlock(identifier: string, category: string, variantDatas: any[], options?: {
+        group: string;
+        hide_in_command: boolean;
+        ambient_occlusion: boolean;
+        face_dimming: boolean;
+        render_method: string;
+    }): CropBlock;
+}
+import { BasicBlock } from "../block/basicBlock.js";
+import { Block } from "../block/block.js";
+import { RotatableBlock } from "../block/rotatableBlock.js";
+import { GeometryBlock } from "../block/geometryBlock.js";
+import { OreBlock } from "../block/oreBlock.js";
+import { CropBlock } from "../block/cropBlock.js";