sapdon 2.0.2 → 3.0.0

package/src/core/feature_rule/distribution/CoordinateDistribution.js

@@ -1,24 +0,0 @@
-/**
- * 表示单个坐标轴（x/y/z）分布规则的类
- */
-export class CoordinateDistribution {
-    /**
-     * @param {"uniform" | "triangle"} distribution - 分布类型
-     * @param {Array<number>} extent - 范围（如 [0, 16]）
-     */
-    constructor(distribution = "uniform", extent = [0, 16]) {
-        this.distribution = distribution;
-        this.extent = extent;
-    }
-
-    /**
-     * 转换为 JSON 格式
-     * @returns {Object} 返回坐标分布配置
-     */
-    toJson() {
-        return {
-            distribution: this.distribution,
-            extent: this.extent
-        };
-    }
-}

package/src/core/feature_rule/distribution/FeatureDistribution.js

@@ -1,45 +0,0 @@
-import { CoordinateDistribution } from "./CoordinateDistribution.js";
-
-/**
- * 表示功能规则分布配置的类
- */
-export class FeatureDistribution {
-    constructor() {
-        this.distribution = {
-            iterations: 10, // 默认值
-            coordinate_eval_order: "zyx",
-            x: new CoordinateDistribution().toJson(),
-            y: new CoordinateDistribution().toJson(),
-            z: new CoordinateDistribution().toJson()
-        };
-    }
-
-    /**
-     * 设置迭代次数
-     * @param {number} iterations - 放置尝试次数
-     * @returns {FeatureDistribution} 返回自身以支持链式调用
-     */
-    setIterations(iterations) {
-        this.distribution.iterations = iterations;
-        return this;
-    }
-
-    /**
-     * 设置坐标轴的分布规则
-     * @param {"x" | "y" | "z"} axis - 坐标轴
-     * @param {CoordinateDistribution} config - 分布配置
-     * @returns {FeatureDistribution} 返回自身以支持链式调用
-     */
-    setAxisDistribution(axis, config) {
-        this.distribution[axis] = config.toJson();
-        return this;
-    }
-
-    /**
-     * 转换为 JSON 格式
-     * @returns {Object} 返回分布规则对象
-     */
-    toJson() {
-        return this.distribution;
-    }
-}

package/src/core/index.js

@@ -1,35 +0,0 @@
-import { BlockComponent } from "./block/blockComponent.js";
-import { BlockAPI } from "./factory/BlockFactory.js";
-import { EntityAPI } from "./factory/EntityFactory.js";
-import { FeatureAPI } from "./factory/FeatureFactory.js";
-import { ItemAPI } from "./factory/ItemFactory.js";
-import { RecipeAPI } from "./factory/RecipeFactory.js";
-import { ItemComponent } from "./item/ItemComponents.js";
-import { FlipbookTextures, ItemTextureManager, terrainTextureManager } from "./texture.js";
-import { DataBindingObject } from "./ui/DataBindingObject.js";
-import { Image } from "./ui/elements/Image.js";
-import { Label } from "./ui/elements/Label.js";
-import { Panel } from "./ui/elements/Panel.js";
-import { UIElement } from "./ui/elements/UIElement.js";
-import { ServerUISystem } from "./ui/registry/ServerUISystem.js";
-import { UISystem } from "./ui/systems/UISystem.js";
-
-export {
-    ItemAPI,
-    BlockAPI,
-    FeatureAPI,
-    EntityAPI,
-    RecipeAPI,
-    BlockComponent,
-    ItemComponent,
-    Image,
-    Panel,
-    Label,
-    UIElement,
-    UISystem,
-    DataBindingObject,
-    ServerUISystem,
-    ItemTextureManager,
-    terrainTextureManager,
-    FlipbookTextures,
-}

package/src/core/item/Item.js

@@ -1,97 +0,0 @@
-import { ItemComponent } from "./ItemComponents.js";
-import { AddonItem, AddonItemDefinition, AddonItemDescription } from "../addon/item/item.js";
-import { AddonMenuCategory } from "../addon/menu_category.js";
-
-export class Item {
-    /**
-     * 物品类
-     * @param {string} identifier 物品唯一标识符
-     * @param {string} category 菜单栏分类 可选："construction", "nature", "equipment", "items", and "none"
-     * @param {string} texture 物品纹理
-     * @param {Object} options 可选参数
-     * @param {string} options.group 分组 
-     * @param {boolean} options.hide_in_command 是否在命令中隐藏，默认为 false
-     */
-    constructor(identifier, category, texture, options = {}) {
-        // 参数校验
-        if (!identifier || typeof identifier !== "string") {
-            throw new Error("identifier is required and must be a string");
-        }
-        if (!category || typeof category !== "string") {
-            throw new Error("category is required and must be a string");
-        }
-        if (!texture || typeof texture !== "string") {
-            throw new Error("texture is required and must be a string");
-        }
-
-        const { 
-            group, 
-            hide_in_command = false,
-            max_stack_size = 64,
-        } = options;
-
-        this.identifier = identifier;
-        this.category = category;
-        this.texture = texture;
-        this.group = group;
-        this.hide_in_command = hide_in_command;
-        this.components = new Map();
-
-        // 初始化默认组件
-        this.addComponent(
-            ItemComponent.combineComponents(
-                ItemComponent.setIcon(this.texture),
-                ItemComponent.setMaxStackSize(max_stack_size)
-            )
-        );
-    }
-    
-
-    /**
-     * 添加组件
-     * @param {Map} componentMap 组件 Map
-     */
-    addComponent(componentMap) {
-        if (!componentMap || !(componentMap instanceof Map)) {
-            throw new Error("componentMap is required and must be a Map");
-        }
-        for (const [key, value] of componentMap.entries()) {
-            this.components.set(key, value);
-        }
-        return this;
-    }
-
-    /**
-     * 移除组件
-     * @param {string} key 组件名称
-     */
-    removeComponent(key) {
-        if (!key || typeof key !== "string") {
-            throw new Error("key is required and must be a string");
-        }
-        this.components.delete(key);
-        return this;
-    }
-
-    /**
-     * 将物品转换为 JSON 格式
-     * @returns {Object} JSON 格式的物品对象
-     */
-    toJson() {
-        const item = new AddonItem(
-            "1.21.40", // 格式版本
-            new AddonItemDefinition(
-                new AddonItemDescription(
-                    this.identifier,
-                    new AddonMenuCategory(
-                        this.category,
-                        this.group,
-                        this.hide_in_command
-                    )
-                ),
-                Object.fromEntries(this.components) // 将 Map 转换为普通对象
-            )
-        );
-        return item.toJson();
-    }
-}

package/src/core/item/ItemComponents.js

@@ -1,236 +0,0 @@
-export class ItemComponent {
-  static setBlockPlacer(block,replace_block_item, use_on){
-    return new Map().set("minecraft:block_placer",{
-      block:block,
-      replace_block_item: replace_block_item,
-      use_on:use_on
-    })
-  }
-    /**
-  * 
-  * @param {Array} custom_components 
-  * @returns 
-  */
-  static setCustomComponents(custom_components){
-    return new Map().set("minecraft:custom_components",[...custom_components])
-  }
-  /**
-   * 设置物品的可投掷组件。
-   * @param {Boolean} doSwingAnimation - 是否使用挥动动画。
-   * @param {Number} launchPowerScale - 投掷力量的缩放比例。
-   * @param {Number} maxDrawDuration - 最大蓄力时间。
-   * @param {Number} maxLaunchPower - 最大投掷力量。
-   * @param {Number} minDrawDuration - 最小蓄力时间。
-   * @param {Boolean} scalePowerByDrawDuration - 投掷力量是否随蓄力时间增加。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setThrowable(
-    doSwingAnimation = false,
-    launchPowerScale = 1.0,
-    maxDrawDuration = 0.0,
-    maxLaunchPower = 1.0,
-    minDrawDuration = 0.0,
-    scalePowerByDrawDuration = false
-  ) {
-    return new Map().set("minecraft:throwable", {
-      do_swing_animation: doSwingAnimation,
-      launch_power_scale: launchPowerScale,
-      max_draw_duration: maxDrawDuration,
-      max_launch_power: maxLaunchPower,
-      min_draw_duration: minDrawDuration,
-      scale_power_by_draw_duration: scalePowerByDrawDuration,
-    });
-  }
-  /**
-   * 设置物品的显示名称。
-   * @param {String} displayName - 显示名称或本地化键。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setDisplayName(displayName) {
-    if (typeof displayName !== "string") {
-      throw new Error('显示名称必须是字符串类型');
-    }
-    return new Map().set("minecraft:display_name", { value: displayName });
-  }
-
-  /**
-   * 设置物品的食物组件。
-   * @param {Boolean} canAlwaysEat - 是否随时可以食用。
-   * @param {Number} nutrition - 营养值。
-   * @param {Number} saturationModifier - 饱和度修正值。
-   * @param {String} [usingConvertsTo] - 食用后转换的目标物品。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setFoodComponent(canAlwaysEat, nutrition, saturationModifier, usingConvertsTo) {
-    return new Map().set("minecraft:food", {
-      can_always_eat: canAlwaysEat,
-      nutrition: nutrition || 0,
-      saturation_modifier: saturationModifier || 0.6,
-      using_converts_to: usingConvertsTo || undefined,
-    });
-  }
-
-  /**
-   * 设置物品的燃料组件。
-   * @param {Number} duration - 燃料燃烧的持续时间（秒），最小值为 0.05。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setFuel(duration) {
-    if (typeof duration !== "number" || duration < 0.05) {
-      throw new Error('燃料持续时间必须是一个大于或等于 0.05 的数字');
-    }
-    return new Map().set("minecraft:fuel", { duration });
-  }
-
-  /**
-   * 设置物品的附魔光效组件。
-   * @param {Boolean} hasGlint - 是否显示附魔光效。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setGlint(hasGlint) {
-    if (typeof hasGlint !== "boolean") {
-      throw new Error('附魔光效值必须是布尔类型');
-    }
-    return new Map().set("minecraft:glint", hasGlint);
-  }
-
-  /**
-   * 设置物品的手持渲染方式组件。
-   * @param {Boolean} isHandEquipped - 是否像工具一样渲染。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setHandEquipped(isHandEquipped) {
-    if (typeof isHandEquipped !== "boolean") {
-      throw new Error('手持渲染方式值必须是布尔类型');
-    }
-    return new Map().set("minecraft:hand_equipped", isHandEquipped);
-  }
-
-  /**
-   * 设置物品的图标组件。
-   * @param {String} texture - 图标纹理名称。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setIcon(texture) {
-    if (typeof texture !== "string") {
-      throw new Error('图标纹理必须是字符串类型');
-    }
-    return new Map().set("minecraft:icon", texture);
-  }
-
-  /**
-   * 设置物品的最大堆叠数量组件。
-   * @param {Number} maxStackSize - 最大堆叠数量，默认值为 64。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setMaxStackSize(maxStackSize = 64) {
-    if (typeof maxStackSize !== "number" || maxStackSize <= 0 || !Number.isInteger(maxStackSize)) {
-      throw new Error('最大堆叠数量必须是正整数');
-    }
-    return new Map().set("minecraft:max_stack_size", maxStackSize);
-  }
-
-  /**
-   * 设置物品的投射物组件。
-   * @param {Number} [minimumCriticalPower] - 投射物需要蓄力多久才能造成暴击。
-   * @param {String} [projectileEntity] - 作为投射物发射的实体名称。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setProjectile(minimumCriticalPower, projectileEntity) {
-    const projectileComponent = {};
-
-    if (minimumCriticalPower !== undefined) {
-      if (typeof minimumCriticalPower !== "number" || minimumCriticalPower < 0) {
-        throw new Error('minimumCriticalPower 必须是非负数');
-      }
-      projectileComponent.minimum_critical_power = minimumCriticalPower;
-    }
-
-    if (projectileEntity !== undefined) {
-      if (typeof projectileEntity !== "string") {
-        throw new Error('projectileEntity 必须是字符串类型');
-      }
-      projectileComponent.projectile_entity = projectileEntity;
-    }
-
-    return new Map().set("minecraft:projectile", projectileComponent);
-  }
-
-  /**
-   * 设置物品的使用修饰组件。
-   * @param {Number} [movementModifier] - 使用物品时玩家移动速度的缩放值。
-   * @param {Number} [useDuration] - 物品使用所需的时间（秒）。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setUseModifiers(movementModifier, useDuration) {
-    const useModifiersComponent = {};
-
-    if (movementModifier !== undefined) {
-      if (typeof movementModifier !== "number") {
-        throw new Error('movementModifier 必须是数字类型');
-      }
-      useModifiersComponent.movement_modifier = movementModifier;
-    }
-
-    if (useDuration !== undefined) {
-      if (typeof useDuration !== "number" || useDuration < 0) {
-        throw new Error('useDuration 必须是非负数');
-      }
-      useModifiersComponent.use_duration = useDuration;
-    }
-
-    return new Map().set("minecraft:use_modifiers", useModifiersComponent);
-  }
-
-  /**
-   * 设置物品的可穿戴组件。
-   * @param {Number} [protection=0] - 物品提供的保护值。
-   * @param {String} [slot] - 物品可以穿戴的槽位（如 "head"、"chest" 等）。
-   * @returns {Map} - 新的组件集合。
-   */
-  static setWearable(protection = 0, slot) {
-    const wearableComponent = { protection };
-
-    if (slot !== undefined) {
-      if (typeof slot !== "string") {
-        throw new Error('slot 必须是字符串类型');
-      }
-      wearableComponent.slot = slot;
-    }
-
-    return new Map().set("minecraft:wearable", wearableComponent);
-  }
-  /**
-  * 设置物品的使用动画组件。
-  * @param {String} animation - 物品使用时的动画类型（如 "eat"、"drink" 等）。
-  * @returns {Map} - 新的组件集合。
-  * @throws {Error} - 如果 animation 不是字符串类型。
-  */
-  static setUseAnimation(animation) {
-    // 检查 animation 是否为字符串
-    if (typeof animation !== "string") {
-      throw new Error('animation 必须是字符串类型');
-    }
-
-    // 返回包含动画设置的 Map 对象
-    return new Map().set("minecraft:use_animation", animation);
-  }
-
-  /**
-   * 将多个组件集合合并为一个。
-   * @param {...Map} componentMaps - 多个组件集合。
-   * @returns {Map} - 合并后的组件集合。
-   */
-  static combineComponents(...componentMaps) {
-    return new Map(componentMaps.flatMap(map => [...map]));
-  }
-
-  /**
-   * 获取当前组件的 JSON 表示。
-   * @param {Map} components - 组件集合。
-   * @returns {Object} - 组件的 JSON 对象。
-   */
-  static toJSON(components) {
-    return Object.fromEntries(components);
-  }
-}

package/src/core/item/armor.js

@@ -1,89 +0,0 @@
-import { Attachable } from "./Attachable.js";
-import { Item } from "./item.js";
-import { ItemComponent } from "./ItemComponents.js";
-
-
-// 定义 Armor 基类
-export class Armor {
-    constructor(identifier, category, item_texture, texture_path, options = {}) {
-        this.identifier = identifier;
-        // 创建物品
-        this.item = new Item(identifier, category, item_texture, options);
-        // 创建附加物
-        this.attachable = new Attachable(identifier, texture_path, "armor");
-
-        // 配置附加物
-        this.attachable
-            .addTexture("default", texture_path) // 添加默认纹理
-            .addMaterial("default", "armor") // 添加默认材质
-            .addMaterial("enchanted", "armor_enchanted") // 添加附魔材质
-            .addTexture("enchanted", "textures/misc/enchanted_actor_glint") // 添加附魔纹理
-            .addGeometry("default", "geometry.player.armor.chestplate") // 添加几何模型
-            .addRenderController("controller.render.armor") // 添加渲染控制器
-            .setScript("parent_setup", "v.chest_layer_visible = 0.0;"); // 设置脚本
-    }
-}
-
-// 扩展 Armor 类，实现胸甲
-export class Chestplate extends Armor {
-    constructor(identifier, item_texture, texture_path, options = {}) {
-        super(identifier, "equipment", item_texture, texture_path, options);
-
-        // 自定义胸甲物品
-        this.item.addComponent(
-            ItemComponent.combineComponents(
-                ItemComponent.setDisplayName("我的自定义胸甲"), // 设置显示名称
-                ItemComponent.setMaxStackSize(1), // 设置最大堆叠数量
-                ItemComponent.setWearable(5, "slot.armor.chest") // 设置为可穿戴，并指定装备槽
-            )
-        );
-    }
-}
-
-// 扩展 Armor 类，实现靴子
-export class Boot extends Armor {
-    constructor(identifier, item_texture, texture_path, options = {}) {
-        super(identifier, "equipment", item_texture, texture_path, options);
-
-        // 自定义靴子物品
-        this.item.addComponent(
-            ItemComponent.combineComponents(
-                ItemComponent.setDisplayName("我的自定义靴子"), // 设置显示名称
-                ItemComponent.setMaxStackSize(1), // 设置最大堆叠数量
-                ItemComponent.setWearable(4, "slot.armor.feet") // 设置为可穿戴，并指定装备槽
-            )
-        );
-    }
-}
-
-// 扩展 Armor 类，实现裤子
-export class Leggings extends Armor {
-    constructor(identifier, item_texture, texture_path, options = {}) {
-        super(identifier, "equipment", item_texture, texture_path, options);
-
-        // 自定义裤子物品
-        this.item.addComponent(
-            ItemComponent.combineComponents(
-                ItemComponent.setDisplayName("我的自定义裤子"), // 设置显示名称
-                ItemComponent.setMaxStackSize(1), // 设置最大堆叠数量
-                ItemComponent.setWearable(6, "slot.armor.legs") // 设置为可穿戴，并指定装备槽
-            )
-        );
-    }
-}
-
-// 扩展 Armor 类，实现头盔
-export class Helmet extends Armor {
-    constructor(identifier, item_texture, texture_path, options = {}) {
-        super(identifier, "equipment", item_texture, texture_path, options);
-
-        // 自定义头盔物品
-        this.item.addComponent(
-            ItemComponent.combineComponents(
-                ItemComponent.setDisplayName("我的自定义头盔"), // 设置显示名称
-                ItemComponent.setMaxStackSize(1), // 设置最大堆叠数量
-                ItemComponent.setWearable(3, "slot.armor.head") // 设置为可穿戴，并指定装备槽
-            )
-        );
-    }
-}

package/src/core/item/attachable.js

@@ -1,34 +0,0 @@
-import { AddonAttachable, AddonAttachableDefinition, AddonAttachableDescription } from "../addon/item/attachable.js";
-
-
-export class Attachable extends AddonAttachableDescription{
-    constructor(identifier){
-        super(identifier);
-    }
-
-    getId() {
-        return this.identifier;
-    }
-    
-    toJson() {
-        const entity = new AddonAttachable(
-            "1.8.0",
-            new AddonAttachableDefinition(this)
-        );
-        return entity.toJson();
-    }
-}
-
-/*
-const attachable = new Attachable("test")
-      attachable.addMaterial("default", "armor")
-      attachable.addMaterial("enchanted","armor_enchanted")
-      attachable.addTexture("default","textures/models/armor/custom_main")
-      attachable.addTexture("enchanted", "textures/misc/enchanted_actor_glint")
-      attachable.addGeometry("default", "geometry.player.armor.chestplate")
-      attachable.addRenderController("controller.render.armor")
-      attachable.setScript("parent_setup","v.chest_layer_visible = 0.0;")
-
-      console.log(JSON.stringify(attachable.toJson(),null,2))
-debugger
-*/

package/src/core/item/food.js

@@ -1,62 +0,0 @@
-import { ItemComponent } from "./ItemComponents.js";
-import { Item } from "./item.js";
-
-export class Food extends Item {
-    /**
-     * 物品类
-     * @param {string} identifier 物品唯一标识符
-     * @param {string} category 菜单栏分类 可选："construction", "nature", "equipment", "items", and "none"
-     * @param {string} texture 物品纹理
-     * @param {Object} options 可选参数
-     * @param {string} options.group 分组 
-     * @param {boolean} options.hide_in_command 是否在命令中隐藏，默认为 false
-     * @param {string} options.animation 使用动画，默认为 "eat"
-     * @param {boolean} options.canAlwaysEat 是否总是可以食用，默认为 false
-     * @param {number} options.nutrition 营养价值，默认为 0
-     * @param {number} options.saturationModifier 饱和度修正值，默认为 1
-     */
-    constructor(identifier, category, texture, options = {}) {
-        // 继承父类
-        super(identifier, category, texture, options);
-
-        // 解构 options 并设置默认值
-        const {
-            animation = "eat",
-            movement = 1,
-            useDuration = 1,
-            canAlwaysEat = false,
-            nutrition = 0,
-            saturationModifier = 1,
-        } = options;
-
-        // 参数验证
-        if (typeof nutrition !== "number" || nutrition < 0) {
-            throw new Error('nutrition 必须是一个非负数');
-        }
-        if (typeof saturationModifier !== "number" || saturationModifier <= 0) {
-            throw new Error('saturationModifier 必须是一个正数');
-        }
-        if (typeof animation !== "string") {
-            throw new Error('animation 必须是字符串类型');
-        }
-        if (typeof canAlwaysEat !== "boolean") {
-            throw new Error('canAlwaysEat 必须是布尔类型');
-        }
-
-        // 添加组件
-        this.addComponent(
-            ItemComponent.combineComponents(
-                ItemComponent.setUseModifiers(
-                    movement,
-                    useDuration
-                ),
-                ItemComponent.setFoodComponent(
-                    canAlwaysEat,
-                    nutrition,
-                    saturationModifier
-                ),
-                ItemComponent.setUseAnimation(animation)
-            )
-        );
-    }
-}

package/src/core/registry.js

@@ -1,17 +0,0 @@
-
-export class GRegistry {
-	 static dataList = [];
-	 /**
-	  * 生成注册器
-	  * @param {string} name 文件名字
-	  * @param {string} root 根目录，如 "behavior"、"resource" 等
-	  * @param {string} path 数据的路径，如 "blocks/"、"items/"、"recipes/" 等
-	  * @param {string} data 实例 必须包含 toJson 方法
-	  */
-	 static register(name, root, path, data){
-		GRegistry.dataList.push({name, root, path, data});
-	 }
-	 static getDataList(){
-		return [...GRegistry.dataList];
-	 }
-}

package/src/core/texture.js

@@ -1,41 +0,0 @@
-
-export class ItemTextureManager {
-    static item_texture_sets = new Map();
-    static getItemTextureSet(){
-        return this.item_texture_sets;
-    }
-    static getItemTextures(){
-        return Object.fromEntries(this.item_texture_sets);
-    }
-    static registerTextureData(texture_name,texture_data){
-        this.item_texture_sets.set(texture_name,texture_data);
-    }
-    static registerTexture(texture_name,texture_path){
-        this.registerTextureData(texture_name,{textures:texture_path});
-    }
-}
-
-export class terrainTextureManager {
-    static terrain_texture_sets = new Map();
-    static getTerrainTextureSet(){
-        return this.terrain_texture_sets;
-    }
-    static getTerrainTextures(){
-        return Object.fromEntries(this.terrain_texture_sets);
-    }
-    static registerTextureData(texture_name,texture_data){
-        this.terrain_texture_sets.set(texture_name,texture_data);
-    }
-    static registerTexture(texture_name,texture_path){
-        this.registerTextureData(texture_name,{textures:texture_path});
-    }
-}
-
-export const FlipbookTextures = {
-    flipbook_textures: [],
-    registerFlipbookTexture(atlas_tile,texture,ticks_per_frame,options = {}){
-        const flipbook_texture = {"atlas_tile":atlas_tile,"flipbook_texture":texture,ticks_per_frame};
-        Object.assign(flipbook_texture,options);
-        this.flipbook_textures.push(flipbook_texture);
-    }
-}