sapdon 2.0.2 → 3.0.0

package/src/core/entity/BasicEntity.js

@@ -1,167 +0,0 @@
-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.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 {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,
-                    this.runtime_identifier
-                ),
-                Object.fromEntries(this.components), // 将 Map 转换为普通对象
-                Object.fromEntries(this.component_groups), // 将 Map 转换为普通对象
-                Object.fromEntries(this.events) // 将 Map 转换为普通对象
-            )
-        ).toJson();
-    }
-}

package/src/core/entity/ClientEntity.js

@@ -1,41 +0,0 @@
-import { AddonClientEntity, AddonClientEntityDefinition, AddonClientEntityDescription } from "../addon/entity/client_entity.js";
-
-/**
- * ClientEntity 类，用于表示客户端实体。
- * 继承自 AddonClientEntityDescription，并扩展了实体的数据加载和 JSON 序列化功能。
- */
-export class ClientEntity extends AddonClientEntityDescription {
-    /**
-     * 构造函数，用于创建一个客户端实体实例。
-     * 
-     * @param {string} identifier - 实体的唯一标识符。
-     * @param {Object} data - 实体的初始数据，默认为空对象。
-     */
-    constructor(identifier, data = {}) {
-        // 调用父类构造函数，初始化实体的标识符
-        super(identifier);
-
-        // 遍历传入的数据对象，将属性赋值到当前实例
-        const keys = Object.keys(data);
-        keys.forEach((key) => {
-            // 跳过 "identifier" 属性，因为已经在父类中处理
-            if (key === "identifier") return;
-
-            // 将数据对象的属性赋值到当前实例
-            this[key] = data[key];
-        });
-    }
-
-    /**
-     * 将当前实体实例转换为 JSON 格式。
-     * 
-     * @returns {Object} - 表示实体的 JSON 对象。
-     */
-    toJson() {
-        // 创建一个 AddonClientEntity 实例，包含实体定义和版本信息
-        return new AddonClientEntity(
-            "1.10.0", // 版本号
-            new AddonClientEntityDefinition(this) // 实体定义
-        ).toJson(); // 调用 toJson 方法，返回 JSON 格式的数据
-    }
-}

package/src/core/entity/Entity.js

@@ -1,19 +0,0 @@
-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/src/core/entity/NativeEntity.js

@@ -1,30 +0,0 @@
-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/src/core/entity/Projectile.js

@@ -1,8 +0,0 @@
-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/src/core/entity/behavior/follow_mod.js

@@ -1,43 +0,0 @@
-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/src/core/entity/behavior/follow_parent.js

@@ -1,15 +0,0 @@
-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/src/core/entity/behavior/random_stroll.js

@@ -1,69 +0,0 @@
-export class RandomStrollBehavior {
-    /**
-     * 随机漫步行为
-     * @param {number} priority 优先级
-     * @param {number} interval 间隔
-     * @param {number} speed_multiplier 速度倍数
-     */
-    constructor(priority, interval, speed_multiplier) {
-      // 参数验证
-      if (typeof priority !== "number" || priority < 0) {
-        throw new Error("priority 必须是一个非负数");
-      }
-      if (typeof interval !== "number" || interval <= 0) {
-        throw new Error("interval 必须是一个正数");
-      }
-      if (typeof speed_multiplier !== "number" || speed_multiplier <= 0) {
-        throw new Error("speed_multiplier 必须是一个正数");
-      }
-  
-      // 初始化属性
-      this.priority = priority;
-      this.interval = interval;
-      this.speed_multiplier = speed_multiplier;
-      this.xz_dist = 10; // 默认水平距离
-      this.y_dist = 7; // 默认垂直距离
-    }
-  
-    /**
-     * 设置水平距离
-     * @param {number} xz_dist 水平距离
-     * @returns {EntityBehaviorRandomStroll} 返回当前实例以支持链式调用
-     */
-    setXZDist(xz_dist) {
-      if (typeof xz_dist !== "number" || xz_dist < 1) {
-        throw new Error("xz_dist 必须是一个至少为 1 的整数");
-      }
-      this.xz_dist = xz_dist;
-      return this;
-    }
-  
-    /**
-     * 设置垂直距离
-     * @param {number} y_dist 垂直距离
-     * @returns {EntityBehaviorRandomStroll} 返回当前实例以支持链式调用
-     */
-    setYDist(y_dist) {
-      if (typeof y_dist !== "number" || y_dist < 1) {
-        throw new Error("y_dist 必须是一个至少为 1 的整数");
-      }
-      this.y_dist = y_dist;
-      return this;
-    }
-  
-    /**
-     * 将组件转换为 JSON 对象
-     * @returns {Object} minecraft:behavior.random_stroll 组件的 JSON 对象
-     */
-    toJSON() {
-      return new Map().set("minecraft:behavior.random_stroll",
-        {
-          priority: this.priority,
-          interval: this.interval,
-          speed_multiplier: this.speed_multiplier,
-          xz_dist: this.xz_dist,
-          y_dist: this.y_dist,
-        },
-      );
-    }
-  }

package/src/core/entity/behavior/tempt.js

@@ -1,145 +0,0 @@
-export class TemptBehavior {
-    /**
-     * 创建 minecraft:behavior.tempt 组件。
-     * @param {number} priority 行为的优先级
-     */
-    constructor(priority) {
-      if (typeof priority !== "number" || priority < 0) {
-        throw new Error("priority 必须是一个非负数");
-      }
-      this.priority = priority;
-      this.can_get_scared = false;
-      this.can_tempt_vertically = false;
-      this.can_tempt_while_ridden = false;
-      this.items = [];
-      this.sound_interval = { range_min: 0.0, range_max: 0.0 };
-      this.speed_multiplier = 1.0;
-      this.tempt_sound = null;
-      this.within_radius = 0.0;
-    }
-  
-    /**
-     * 设置是否会被吓跑。
-     * @param {boolean} canGetScared 是否会被吓跑
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    canGetScared(canGetScared) {
-      if (typeof canGetScared !== "boolean") {
-        throw new Error("canGetScared 必须是布尔类型");
-      }
-      this.can_get_scared = canGetScared;
-      return this;
-    }
-  
-    /**
-     * 设置是否考虑垂直距离。
-     * @param {boolean} canTemptVertically 是否考虑垂直距离
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    canTemptVertically(canTemptVertically) {
-      if (typeof canTemptVertically !== "boolean") {
-        throw new Error("canTemptVertically 必须是布尔类型");
-      }
-      this.can_tempt_vertically = canTemptVertically;
-      return this;
-    }
-  
-    /**
-     * 设置是否在被骑乘时被吸引。
-     * @param {boolean} canTemptWhileRidden 是否在被骑乘时被吸引
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    canTemptWhileRidden(canTemptWhileRidden) {
-      if (typeof canTemptWhileRidden !== "boolean") {
-        throw new Error("canTemptWhileRidden 必须是布尔类型");
-      }
-      this.can_tempt_while_ridden = canTemptWhileRidden;
-      return this;
-    }
-  
-    /**
-     * 设置吸引实体的物品列表。
-     * @param {Array} items 吸引实体的物品列表
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setItems(items) {
-      if (!Array.isArray(items) || items.length === 0) {
-        throw new Error("items 必须是一个非空数组");
-      }
-      this.items = items;
-      return this;
-    }
-  
-    /**
-     * 设置播放吸引声音的随机间隔时间。
-     * @param {number} min 最小间隔时间
-     * @param {number} max 最大间隔时间
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setSoundInterval(min, max) {
-      if (typeof min !== "number" || typeof max !== "number" || min < 0 || max < 0) {
-        throw new Error("min 和 max 必须是非负数");
-      }
-      this.sound_interval = { range_min: min, range_max: max };
-      return this;
-    }
-  
-    /**
-     * 设置移动速度倍数。
-     * @param {number} speedMultiplier 移动速度倍数
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setSpeedMultiplier(speedMultiplier) {
-      if (typeof speedMultiplier !== "number" || speedMultiplier <= 0) {
-        throw new Error("speedMultiplier 必须是一个正数");
-      }
-      this.speed_multiplier = speedMultiplier;
-      return this;
-    }
-  
-    /**
-     * 设置吸引时播放的声音。
-     * @param {string} temptSound 吸引时播放的声音
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setTemptSound(temptSound) {
-      if (typeof temptSound !== "string") {
-        throw new Error("temptSound 必须是字符串");
-      }
-      this.tempt_sound = temptSound;
-      return this;
-    }
-  
-    /**
-     * 设置吸引的最大距离。
-     * @param {number} withinRadius 吸引的最大距离
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setWithinRadius(withinRadius) {
-      if (typeof withinRadius !== "number" || withinRadius < 0) {
-        throw new Error("withinRadius 必须是一个非负数");
-      }
-      this.within_radius = withinRadius;
-      return this;
-    }
-  
-    /**
-     * 将组件转换为 JSON 对象。
-     * @returns {Object} minecraft:behavior.tempt 组件的 JSON 对象
-     */
-    toJSON() {
-      return new Map().set(
-        "minecraft:behavior.tempt", {
-          priority: this.priority,
-          can_get_scared: this.can_get_scared,
-          can_tempt_vertically: this.can_tempt_vertically,
-          can_tempt_while_ridden: this.can_tempt_while_ridden,
-          items: this.items,
-          sound_interval: this.sound_interval,
-          speed_multiplier: this.speed_multiplier,
-          tempt_sound: this.tempt_sound,
-          within_radius: this.within_radius,
-        },
-      );
-    }
-  }