sapdon 3.0.2 → 3.0.3

package/dist/core/factory/blockFactory.js

@@ -0,0 +1,143 @@
+import { BasicBlock } from "../block/basicBlock.js";
+import { Block } from "../block/block.js";
+import { CropBlock } from "../block/cropBlock.js";
+import { GeometryBlock } from "../block/geometryBlock.js";
+import { OreBlock } from "../block/oreBlock.js";
+import { RotatableBlock } from "../block/rotatableBlock.js";
+import { GRegistry } from "../registry.js";
+/**
+ * 注册方块到注册表中。
+ * @param {Block} block - 要注册的方块对象。
+ */
+const registerBlock = (block) => {
+    if (!block || !block.identifier) {
+        throw new Error("无效的方块对象或缺少 identifier。");
+    }
+    const block_name = block.identifier.replace(":", "_");
+    GRegistry.register(block_name, "behavior", "blocks/", block);
+};
+const registerFeature = (feature) => {
+    const feature_name = feature.identifier.split(":")[feature.identifier.split(":").length - 1];
+    GRegistry.register(feature_name, "behavior", "features/", feature);
+};
+const registerFeatureRule = (feature_rule) => {
+    const feature_rule_name = feature_rule.identifier.split(":")[feature_rule.identifier.split(":").length - 1];
+    GRegistry.register(feature_rule_name, "behavior", "feature_rules/", feature_rule);
+};
+export const BlockAPI = {
+    /**
+     * 创建一个基础方块。
+     * @param {string} identifier - 方块的唯一标识符。
+     * @param {string} category - 方块的分类（如 "construction"）。
+     * @param {Array} textures_arr - 纹理数组，顺序为 [上, 下, 东, 西, 南, 北]。
+     * @param {Object} options - 可选参数。
+     * @param {string} options.group - 分组，默认为 "construction"。
+     * @param {boolean} options.hide_in_command - 是否在命令中隐藏，默认为 false。
+     * @returns {BasicBlock} 创建的基础方块对象。
+     */
+    createBasicBlock: function (identifier, category, textures_arr, options = {}) {
+        if (!identifier || !category || !textures_arr) {
+            throw new Error("必须提供 identifier、category 和长度为 6 的 textures_arr。");
+        }
+        const block = new BasicBlock(identifier, category, textures_arr, {
+            hide_in_command: false,
+            ...options, // 用传入的选项覆盖默认值
+        });
+        registerBlock(block); // 调用注册方法
+        return block;
+    },
+    /**
+     * 创建一个普通方块。
+     * @param {string} identifier - 方块的唯一标识符。
+     * @param {string} category - 方块的分类（如 "construction"）。
+     * @param {Array} variantDatas - 方块的变体数据，包含每个变体的状态标签和纹理。
+     * @param {Object} options - 可选参数。
+     * @param {string} options.group - 分组，默认为 "construction"。
+     * @param {boolean} options.hide_in_command - 是否在命令中隐藏，默认为 false。
+     * @param {boolean} options.ambient_occlusion - 是否应用环境光遮蔽，默认为 false。
+     * @param {boolean} options.face_dimming - 是否根据面的方向进行亮度调整，默认为 false。
+     * @param {string} options.render_method - 渲染方法，默认为 "alpha_test"。
+     * @returns {Block} 创建的方块对象。
+     */
+    createBlock: function (identifier, category, variantDatas, options = {}) {
+        if (!identifier || !category || !variantDatas || variantDatas.length === 0) {
+            throw new Error("必须提供 identifier、category 和 variantDatas。");
+        }
+        const block = new Block(identifier, category, variantDatas, {
+            hide_in_command: false,
+            ambient_occlusion: false,
+            face_dimming: false,
+            render_method: "alpha_test",
+            ...options, // 用传入的选项覆盖默认值
+        });
+        registerBlock(block); // 调用注册方法
+        return block;
+    },
+    /**
+     * 创建一个可旋转方块。
+     * @param {string} identifier - 方块的唯一标识符。
+     * @param {string} category - 方块的分类（如 "construction"）。
+     * @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。
+     * @returns {RotatableBlock} 创建的可旋转方块对象。
+     */
+    createRotatableBlock: function (identifier, category, textures_arr, options = {}) {
+        if (!identifier || !category || !textures_arr) {
+            throw new Error("必须提供 identifier、category 和 textures_arr。");
+        }
+        const block = new RotatableBlock(identifier, category, textures_arr, {
+            hide_in_command: false,
+            rotationType: "cardinal",
+            yRotationOffset: 180,
+            ...options, // 用传入的选项覆盖默认值
+        });
+        registerBlock(block); // 调用注册方法
+        return block;
+    },
+    createGeometryBlock: function (identifier, category, geometry, material_instances, options = {}) {
+        if (!identifier || !category || !geometry || !material_instances) {
+            throw new Error("必须提供 identifier、category、geometry 和 material_instances。");
+        }
+        const block = new GeometryBlock(identifier, category, geometry, material_instances, options);
+        registerBlock(block); // 调用注册方法
+        return block;
+    },
+    createOreBlock(identifier, category, textures_arr, options = {}) {
+        const ore_block = new OreBlock(identifier, category, textures_arr, options);
+        registerBlock(ore_block.block); // 调用注册方法
+        registerFeature(ore_block.feature); // 调用注册方法
+        registerFeatureRule(ore_block.feature_rules); // 调用注册方法
+        return ore_block;
+    },
+    /**
+     * 创建一个作物方块。
+     * @param {string} identifier - 方块的唯一标识符。
+     * @param {string} category - 方块的分类（如 "construction"）。
+     * @param {Array} variantDatas - 方块的变体数据，包含每个变体的状态标签和纹理。
+     * @param {Object} options - 可选参数。
+     * @param {string} options.group - 分组，默认为 "construction"。
+     * @param {boolean} options.hide_in_command - 是否在命令中隐藏，默认为 false。
+     * @param {boolean} options.ambient_occlusion - 是否应用环境光遮蔽，默认为 false。
+     * @param {boolean} options.face_dimming - 是否根据面的方向进行亮度调整，默认为 false。
+     * @param {string} options.render_method - 渲染方法，默认为 "alpha_test"。
+     * @returns {CropBlock} 创建的方块对象。
+     */
+    createCropBlock: function (identifier, category, variantDatas, options = {}) {
+        if (!identifier || !category || !variantDatas || variantDatas.length === 0) {
+            throw new Error("必须提供 identifier、category 和 variantDatas。");
+        }
+        const block = new CropBlock(identifier, category, variantDatas, {
+            hide_in_command: false,
+            ambient_occlusion: true,
+            face_dimming: true,
+            render_method: "alpha_test",
+            ...options, // 用传入的选项覆盖默认值
+        });
+        registerBlock(block); // 调用注册方法
+        return block;
+    },
+};

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

@@ -0,0 +1,17 @@
+export function registerEntity(behData: any, resData: any): void;
+export namespace EntityAPI {
+    function createNativeEntity(identifier: string, proto_id: string, options?: Object): {
+        behavior: BasicEntity;
+        resource: ClientEntity;
+    };
+    function createEntity(identifier: string, texture: string, behData: Object, resData: Object, options?: Object): {
+        behavior: BasicEntity;
+        resource: ClientEntity;
+    };
+    function createProjectile(identifier: string, texture: string, options?: Object): {
+        behavior: BasicEntity;
+        resource: ClientEntity;
+    };
+}
+import { BasicEntity } from "../entity/basicEntity.js";
+import { ClientEntity } from "../entity/clientEntity.js";

package/dist/core/factory/entityFactory.js

@@ -0,0 +1,75 @@
+import { BasicEntity } from "../entity/basicEntity.js";
+import { ClientEntity } from "../entity/clientEntity.js";
+import { Entity } from "../entity/entity.js";
+import { NativeEntity } from "../entity/nativeEntity.js";
+import { Projectile } from "../entity/projectile.js";
+import { GRegistry } from "../registry.js";
+export const registerEntity = (behData, resData) => {
+    // 如果 behData 存在且不为空，则注册行为数据
+    if (behData && Object.keys(behData).length > 0) {
+        GRegistry.register(behData.identifier.replace(":", "_"), "behavior", "entities/", behData);
+    }
+    // 如果 resData 存在且不为空，则注册资源数据
+    if (resData && Object.keys(resData).length > 0) {
+        GRegistry.register(resData.identifier.replace(":", "_"), "resource", "entity/", resData);
+    }
+};
+export const EntityAPI = {
+    /**
+     * 创建一个原生实体。
+     * @param {string} identifier - 实体的唯一标识符。
+     * @param {string} proto_id - 实体的原型 ID。
+     * @param {string} texture - 实体的纹理。
+     * @param {Object} options - 额外选项。
+     * @returns {{ behavior: BasicEntity, resource: ClientEntity }} 包含行为数据和资源数据的对象。
+     */
+    createNativeEntity: function (identifier, proto_id, options = {}) {
+        if (!identifier || !proto_id) {
+            throw new Error("必须提供 identifier、proto_id 和 texture。");
+        }
+        const nativeEntity = new NativeEntity(identifier, proto_id, options);
+        registerEntity(nativeEntity.entity, nativeEntity.client_entity);
+        return {
+            behavior: nativeEntity.entity,
+            resource: nativeEntity.client_entity,
+        };
+    },
+    /**
+     * 创建一个普通实体。
+     * @param {string} identifier - 实体的唯一标识符。
+     * @param {string} texture - 实体的纹理。
+     * @param {Object} behData - 实体的行为数据。
+     * @param {Object} resData - 实体的资源数据。
+     * @param {Object} options - 额外选项。
+     * @returns {{ behavior: BasicEntity, resource: ClientEntity }} 包含行为数据和资源数据的对象。
+     */
+    createEntity: function (identifier, texture, behData, resData, options = {}) {
+        if (!identifier || !texture) {
+            throw new Error("必须提供 identifier 和 texture。");
+        }
+        const entity = new Entity(identifier, texture, behData, resData, options);
+        registerEntity(entity.entity, entity.client_entity);
+        return {
+            behavior: entity.entity,
+            resource: entity.client_entity,
+        };
+    },
+    /**
+     * 创建一个投射物实体。
+     * @param {string} identifier - 投射物的唯一标识符。
+     * @param {string} texture - 投射物的纹理。
+     * @param {Object} options - 额外选项。
+     * @returns {{ behavior: BasicEntity, resource: ClientEntity }} 包含行为数据和资源数据的对象。
+     */
+    createProjectile: function (identifier, texture, options = {}) {
+        if (!identifier || !texture) {
+            throw new Error("必须提供 identifier 和 texture。");
+        }
+        const entity = new Projectile(identifier, texture, options);
+        registerEntity(entity.entity, entity.client_entity);
+        return {
+            behavior: entity.entity,
+            resource: entity.client_entity,
+        };
+    },
+};

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

@@ -0,0 +1,6 @@
+export namespace FeatureAPI {
+    function createOreFeature(identifier: any, count: any, replace_rules: any): OreFeature;
+    function createFeatureRules(identifier: any, places_feature: any): FeatureRule;
+}
+import { OreFeature } from "../feature/oreFeature.js";
+import { FeatureRule } from "../feature-rule/featureRule.js";

package/dist/core/factory/featureFactory.js

@@ -0,0 +1,23 @@
+import { OreFeature } from "../feature/oreFeature.js";
+import { FeatureRule } from "../feature-rule/featureRule.js";
+import { GRegistry } from "../registry.js";
+const registerFeature = (feature) => {
+    const feature_name = feature.identifier.split(":")[feature.identifier.split(":").length - 1];
+    GRegistry.register(feature_name, "behavior", "features/", feature);
+};
+const registerFeatureRule = (feature_rule) => {
+    const feature_rule_name = feature_rule.identifier.split(":")[feature_rule.identifier.split(":").length - 1];
+    GRegistry.register(feature_rule_name, "behavior", "feature_rules/", feature_rule);
+};
+export const FeatureAPI = {
+    createOreFeature: function (identifier, count, replace_rules) {
+        const feature = new OreFeature(identifier, count, replace_rules);
+        registerFeature(feature);
+        return feature;
+    },
+    createFeatureRules: function (identifier, places_feature) {
+        const feature_rules = new FeatureRule(identifier, places_feature);
+        registerFeatureRule(feature_rules);
+        return feature_rules;
+    }
+};

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

@@ -0,0 +1,8 @@
+export declare enum ItemCategory {
+    Commands = "commands",
+    Construction = "construction",
+    Equipment = "equipment",
+    Nature = "nature",
+    Items = "items",
+    None = "none"
+}

package/dist/core/factory/itemExtra.js

@@ -0,0 +1,9 @@
+export var ItemCategory;
+(function (ItemCategory) {
+    ItemCategory["Commands"] = "commands";
+    ItemCategory["Construction"] = "construction";
+    ItemCategory["Equipment"] = "equipment";
+    ItemCategory["Nature"] = "nature";
+    ItemCategory["Items"] = "items";
+    ItemCategory["None"] = "none";
+})(ItemCategory || (ItemCategory = {}));

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

@@ -0,0 +1,27 @@
+export namespace ItemAPI {
+    function createItem(identifier: string, category: string, texture: string, options?: {
+        group: string;
+        hight_resolution: boolean;
+        hide_in_command: boolean;
+    }): Item;
+    function createFood(identifier: string, category: string, texture: string, options?: {
+        group: string;
+        hide_in_command: boolean;
+        animation: string;
+        canAlwaysEat: boolean;
+        nutrition: number;
+        saturationModifier: number;
+    }): Food;
+    function createAttachable(identifier: string, texture: string, material: string, options?: Object): Attachable;
+    function createChestplateArmor(identifier: any, item_texture: any, texture_path: any, options?: {}): Chestplate;
+    function createHelmetArmor(identifier: any, item_texture: any, texture_path: any, options?: {}): Helmet;
+    function createBootArmor(identifier: any, item_texture: any, texture_path: any, options?: {}): Boot;
+    function createLeggingsArmor(identifier: any, item_texture: any, texture_path: any, options?: {}): Leggings;
+}
+import { Item } from "../item/item.js";
+import { Food } from "../item/food.js";
+import { Attachable } from "../item/attachable.js";
+import { Chestplate } from "../item/armor.js";
+import { Helmet } from "../item/armor.js";
+import { Boot } from "../item/armor.js";
+import { Leggings } from "../item/armor.js";

package/dist/core/factory/itemFactory.js

@@ -0,0 +1,112 @@
+import { Boot, Chestplate, Helmet, Leggings } from "../item/armor.js";
+import { Attachable } from "../item/attachable.js";
+import { Food } from "../item/food.js";
+import { Item } from "../item/item.js";
+import { GRegistry } from "../registry.js";
+const registerItem = (itemData, attachableData) => {
+    // 如果 itemData 存在且不为空，则注册
+    if (itemData && Object.keys(itemData).length > 0) {
+        GRegistry.register(itemData.identifier.replace(":", "_"), "behavior", "items/", itemData);
+    }
+    // 如果 attachableData 存在且不为空，则注册
+    if (attachableData && Object.keys(attachableData).length > 0) {
+        GRegistry.register(attachableData.identifier.replace(":", "_"), "resource", "attachables/", attachableData);
+    }
+};
+// 物品创建的工厂函数
+export const ItemAPI = {
+    /**
+     * 创建一个普通物品。
+     * @param {string} identifier - 物品的唯一标识符。
+     * @param {string} category - 物品在创造菜单中的分类（如 "construction", "nature"）。
+     * @param {string} texture - 物品的纹理。
+     * @param {Object} options - 额外选项。
+     * @param {string} options.group - 物品的分组。
+     * @param {boolean} options.hight_resolution -是否是高分辨率
+     * @param {boolean} options.hide_in_command - 是否在命令中隐藏物品。
+     * @returns {Item} 创建的物品。
+     */
+    createItem: function (identifier, category, texture, options = {}) {
+        if (!identifier || !category || !texture) {
+            throw new Error("必须提供 identifier、category 和 texture。");
+        }
+        const item = new Item(identifier, category, texture, options);
+        let attachable = {};
+        if (options.hide_in_command === true) {
+            attachable = new Attachable(identifier)
+                .addMaterial("default", "entity_alphatest")
+                .addMaterial("enchanted", "entity_alphatest_glint")
+                .addTexture("default", `textures/items/${texture}`)
+                .addTexture("enchanted", "textures/misc/enchanted_item_glint")
+                .addGeometry("default", "geometry.large_item");
+        }
+        registerItem(item, attachable);
+        return item;
+    },
+    /**
+     * 创建一个食物物品。
+     * @param {string} identifier - 食物的唯一标识符。
+     * @param {string} category - 食物在创造菜单中的分类。
+     * @param {string} texture - 食物的纹理。
+     * @param {Object} options - 额外选项。
+     * @param {string} options.group - 食物的分组。
+     * @param {boolean} options.hide_in_command - 是否在命令中隐藏食物。
+     * @param {string} options.animation - 食用时的动画（默认："eat"）。
+     * @param {boolean} options.canAlwaysEat - 是否总是可以食用。
+     * @param {number} options.nutrition - 食物的营养价值。
+     * @param {number} options.saturationModifier - 饱和度修正值。
+     * @returns {Food} 创建的食物物品。
+     */
+    createFood: function (identifier, category, texture, options = {}) {
+        if (!identifier || !category || !texture) {
+            throw new Error("必须提供 identifier、category 和 texture。");
+        }
+        const food = new Food(identifier, category, texture, {
+            animation: "eat",
+            canAlwaysEat: false,
+            nutrition: 0,
+            saturationModifier: 1,
+            ...options, // 用传入的选项覆盖默认值
+        });
+        registerItem(food, {});
+        return food;
+    },
+    /**
+     * 创建一个可附着物品。
+     * @param {string} identifier - 可附着物品的唯一标识符。
+     * @param {string} texture - 可附着物品的纹理。
+     * @param {string} material - 可附着物品的材质。
+     * @param {Object} options - 额外选项。
+     * @returns {Attachable} 创建的可附着物品。
+     */
+    createAttachable: function (identifier, texture, material, options = {}) {
+        if (!identifier || !texture || !material) {
+            throw new Error("必须提供 identifier、texture 和 material。");
+        }
+        const attachable = new Attachable(identifier);
+        attachable.addTexture("default", texture);
+        attachable.addMaterial("default", material);
+        registerItem({}, attachable);
+        return attachable;
+    },
+    createChestplateArmor: function (identifier, item_texture, texture_path, options = {}) {
+        const item = new Chestplate(identifier, item_texture, texture_path, options);
+        registerItem(item.item, item.attachable);
+        return item;
+    },
+    createHelmetArmor: function (identifier, item_texture, texture_path, options = {}) {
+        const item = new Helmet(identifier, item_texture, texture_path, options);
+        registerItem(item.item, item.attachable);
+        return item;
+    },
+    createBootArmor: function (identifier, item_texture, texture_path, options = {}) {
+        const item = new Boot(identifier, item_texture, texture_path, options);
+        registerItem(item.item, item.attachable);
+        return item;
+    },
+    createLeggingsArmor: function (identifier, item_texture, texture_path, options = {}) {
+        const item = new Leggings(identifier, item_texture, texture_path, options);
+        registerItem(item.item, item.attachable);
+        return item;
+    },
+};

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

@@ -0,0 +1,18 @@
+export const RecipeAPI: RecipeRegistry;
+declare class RecipeRegistry {
+    /**
+     *
+     * @param {AddonRecipeFurnace_1_17} recipe
+     */
+    registerRecipe(recipe: AddonRecipeFurnace_1_17): void;
+    registerSimpleFurnace(identifier: any, output: any, input: any): AddonRecipeFurnace_1_17;
+    registerFurnace(identifier: any): AddonRecipeFurnace_1_17;
+    registerSimpleShaped(identifier: any, output: any, pattern: any, key: any): AddonRecipeShaped_1_20;
+    registerShaped(identifier: any): AddonRecipeShaped_1_20;
+    registerSimpleShapeless(identifier: any, output: any, ingredients: any): AddonRecipeShapeless_1_17;
+    registerShapeless(identifier: any): AddonRecipeShapeless_1_17;
+}
+import { AddonRecipeFurnace_1_17 } from "../addon/recipe/furnace.js";
+import { AddonRecipeShaped_1_20 } from "../addon/recipe/shaped.js";
+import { AddonRecipeShapeless_1_17 } from "../addon/recipe/shapeless.js";
+export {};

package/dist/core/factory/recipeFactory.js

@@ -0,0 +1,39 @@
+import { RecipeTags } from "../addon/recipe/data.js";
+import { AddonRecipeFurnace_1_17 } from "../addon/recipe/furnace.js";
+import { AddonRecipeShaped_1_20 } from "../addon/recipe/shaped.js";
+import { AddonRecipeShapeless_1_17 } from "../addon/recipe/shapeless.js";
+import { GRegistry } from "../registry.js";
+class RecipeRegistry {
+    /**
+     *
+     * @param {AddonRecipeFurnace_1_17} recipe
+     */
+    registerRecipe(recipe) {
+        GRegistry.register(recipe.getId().replace(":", "_"), "behavior", "recipes/", recipe);
+    }
+    registerSimpleFurnace(identifier, output, input) {
+        return this.registerFurnace(identifier).tags([RecipeTags.Furnace]).input(input).output(output);
+    }
+    registerFurnace(identifier) {
+        const recipe = new AddonRecipeFurnace_1_17().identifier(identifier);
+        this.registerRecipe(recipe);
+        return recipe;
+    }
+    registerSimpleShaped(identifier, output, pattern, key) {
+        return this.registerShaped(identifier).tags([RecipeTags.CraftingTable]).pattern(pattern).key(key).output(output);
+    }
+    registerShaped(identifier) {
+        const recipe = new AddonRecipeShaped_1_20().identifier(identifier);
+        this.registerRecipe(recipe);
+        return recipe;
+    }
+    registerSimpleShapeless(identifier, output, ingredients) {
+        return this.registerShapeless(identifier).tags([RecipeTags.CraftingTable]).ingredients(ingredients).output(output);
+    }
+    registerShapeless(identifier) {
+        const recipe = new AddonRecipeShapeless_1_17().identifier(identifier);
+        this.registerRecipe(recipe);
+        return recipe;
+    }
+}
+export const RecipeAPI = new RecipeRegistry();

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

@@ -0,0 +1,12 @@
+export namespace UiAPI {
+    function createUISystem(identifier: any, path: any): UISystem;
+    function createUIElement(id: any, type: any, template: any): UIElement;
+    function createPanel(id: any, template: any): Panel;
+    function createImage(id: any, template: any): Image;
+    function createLabel(id: any, template: any): Label;
+}
+import { UISystem } from "../ui/systems/system.js";
+import { UIElement } from "../ui/elements/uiElement.js";
+import { Panel } from "../ui/elements/panel.js";
+import { Image } from "../ui/elements/image.js";
+import { Label } from "../ui/elements/label.js";

package/dist/core/factory/uiFactory.js

@@ -0,0 +1,32 @@
+import { GRegistry } from "../registry.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 { UISystem } from "../ui/systems/system.js";
+const registerUIsystem = (ui_system) => {
+    GRegistry.register(ui_system.name, "behavior", ui_system.path, ui_system);
+};
+export const UiAPI = {
+    createUISystem(identifier, path) {
+        const ui_system = new UISystem(identifier, path);
+        registerUIsystem(ui_system);
+        return ui_system;
+    },
+    createUIElement(id, type, template) {
+        const ui_element = new UIElement(id, type, template);
+        return ui_element;
+    },
+    createPanel(id, template) {
+        const panel = new Panel(id, template);
+        return panel;
+    },
+    createImage(id, template) {
+        const image = new Image(id, template);
+        return image;
+    },
+    createLabel(id, template) {
+        const label = new Label(id, template);
+        return label;
+    }
+};

package/dist/core/feature/oreFeature.d.ts

@@ -0,0 +1,10 @@
+export class OreFeature {
+    constructor(identifier: any, count: any, replace_rules: any);
+    identifier: any;
+    count: any;
+    replace_rules: any;
+    toJson(): {
+        format_version: any;
+        "minecraft:ore_feature": any;
+    };
+}

package/dist/core/feature/oreFeature.js

@@ -0,0 +1,11 @@
+import { AddonOreFeature, AddonOreFeatureDefinition, AddonOreFeatureDescription } from "../addon/feature/oreFeature.js";
+export class OreFeature {
+    constructor(identifier, count, replace_rules) {
+        this.identifier = identifier;
+        this.count = count;
+        this.replace_rules = replace_rules;
+    }
+    toJson() {
+        return new AddonOreFeature("1.17.0", new AddonOreFeatureDefinition(new AddonOreFeatureDescription(this.identifier), this.count, this.replace_rules)).toJson();
+    }
+}

package/dist/core/feature-rule/condition/biomeFilter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 表示生物群系过滤条件的类
+ */
+export class BiomeFilter {
+    filters: any[];
+    /**
+     * 添加一个逻辑条件组（如 any_of, all_of）
+     * @param {"any_of" | "all_of"} logicType - 逻辑类型
+     * @param {Array<Object>} conditions - 条件数组
+     * @returns {BiomeFilter} 返回自身以支持链式调用
+     */
+    addLogicGroup(logicType: "any_of" | "all_of", conditions: Array<Object>): BiomeFilter;
+    /**
+     * 添加一个简单条件（如 has_biome_tag）
+     * @param {string} test - 测试类型（如 "has_biome_tag"）
+     * @param {"==" | "!="} operator - 操作符
+     * @param {string} value - 目标值（如 "overworld"）
+     * @returns {BiomeFilter} 返回自身以支持链式调用
+     */
+    addSimpleCondition(test: string, operator: "==" | "!=", value: string): BiomeFilter;
+    /**
+     * 转换为 JSON 格式
+     * @returns {Array<Object>} 返回生物群系过滤条件数组
+     */
+    toJson(): Array<Object>;
+}

package/dist/core/feature-rule/condition/biomeFilter.js

@@ -0,0 +1,36 @@
+/**
+ * 表示生物群系过滤条件的类
+ */
+export class BiomeFilter {
+    constructor() {
+        this.filters = [];
+    }
+    /**
+     * 添加一个逻辑条件组（如 any_of, all_of）
+     * @param {"any_of" | "all_of"} logicType - 逻辑类型
+     * @param {Array<Object>} conditions - 条件数组
+     * @returns {BiomeFilter} 返回自身以支持链式调用
+     */
+    addLogicGroup(logicType, conditions) {
+        this.filters.push({ [logicType]: conditions });
+        return this;
+    }
+    /**
+     * 添加一个简单条件（如 has_biome_tag）
+     * @param {string} test - 测试类型（如 "has_biome_tag"）
+     * @param {"==" | "!="} operator - 操作符
+     * @param {string} value - 目标值（如 "overworld"）
+     * @returns {BiomeFilter} 返回自身以支持链式调用
+     */
+    addSimpleCondition(test, operator, value) {
+        this.filters.push({ test, operator, value });
+        return this;
+    }
+    /**
+     * 转换为 JSON 格式
+     * @returns {Array<Object>} 返回生物群系过滤条件数组
+     */
+    toJson() {
+        return this.filters;
+    }
+}

package/dist/core/feature-rule/condition/featureConditions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 表示功能规则生成条件的类
+ */
+export class FeatureConditions {
+    conditions: {
+        placement_pass: string;
+        "minecraft:biome_filter": never[];
+    };
+    /**
+     * 设置生成阶段（placement_pass）
+     * @param {string} pass - 生成阶段标识符（如 "underground_pass"）
+     * @returns {FeatureConditions} 返回自身以支持链式调用
+     */
+    setPlacementPass(pass: string): FeatureConditions;
+    /**
+     * 设置生物群系过滤器
+     * @param {BiomeFilter} biomeFilter - 生物群系过滤条件对象
+     * @returns {FeatureConditions} 返回自身以支持链式调用
+     */
+    setBiomeFilter(biomeFilter: BiomeFilter): FeatureConditions;
+    /**
+     * 转换为 JSON 格式
+     * @returns {Object} 返回生成条件对象
+     */
+    toJson(): Object;
+}
+import { BiomeFilter } from "./biomeFilter.js";