sapdon 2.0.0

package/src/core/entity/BasicEntity.js

@@ -0,0 +1,167 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -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/src/core/entity/behavior/random_stroll.js

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,145 @@
+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,
+        },
+      );
+    }
+  }