sapdon 2.0.0

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

@@ -0,0 +1,58 @@
+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/src/core/factory/BiomeFactory.js

@@ -0,0 +1,15 @@
+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/src/core/factory/BlockFactory.js

@@ -0,0 +1,159 @@
+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/src/core/factory/EntityFactory.js

@@ -0,0 +1,83 @@
+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";
+
+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/src/core/factory/FeatureFactory.js

@@ -0,0 +1,26 @@
+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/src/core/factory/ItemFactory.js

@@ -0,0 +1,96 @@
+import { Chestplate } 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.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);
+        registerItem(item, {});
+        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;
+    },
+};

package/src/core/factory/RecipeFactory.js

@@ -0,0 +1,47 @@
+
+import { RecipeTags } from "../addon/recipe/data.js";
+import { AddonRecipeFurnace_1_17 } from "../addon/recipe/recipeFurnace.js";
+import { AddonRecipeShaped_1_20 } from "../addon/recipe/recipeShaped.js";
+import { AddonRecipeShapeless_1_17 } from "../addon/recipe/recipeShapeless.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/src/core/factory/UIFactory.js

@@ -0,0 +1,37 @@
+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/UISystem.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/src/core/feature/OreFeature.js

@@ -0,0 +1,19 @@
+import { AddonOreFeature, AddonOreFeatureDefinition, AddonOreFeatureDescription } from "../addon/feature/ore_feature.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/src/core/feature_rule/FeatureRule.js

@@ -0,0 +1,37 @@
+import { AddonFeatureRule, AddonFeatureRuleDecription, AddonFeatureRuleDenifition } from "../addon/feature_rule.js";
+import { FeatureConditions } from "./condition/FeatureConditions.js";
+import { FeatureDistribution } from "./distribution/FeatureDistribution.js";
+
+export class FeatureRule {
+  constructor(identifier,places_feature) {
+    this.identifier = identifier;   
+    this.places_feature = places_feature;
+    this.condition = new FeatureConditions();
+    this.distribution = new FeatureDistribution();
+  }
+  setPlacementPass(pass) {
+    this.condition.setPlacementPass(pass);
+  }
+  setBiomeFilter(biomeFilter) {
+    this.condition.setBiomeFilter(biomeFilter);
+  }
+  setIterations(iterations) {
+    this.distribution.setIterations(iterations);
+  }
+  setAxisDistribution(axis, config) {
+    this.distribution.setAxisDistribution(axis, config);
+  }
+  toJson(){
+    return new AddonFeatureRule(
+        "1.13.0",
+        new AddonFeatureRuleDenifition(
+            new AddonFeatureRuleDecription(
+                this.identifier,
+                this.places_feature
+            ),
+            this.condition.toJson(),
+            this.distribution.toJson()
+        )
+    ).toJson()
+  }
+}

package/src/core/feature_rule/condition/BiomeFilter.js

@@ -0,0 +1,39 @@
+/**
+ * 表示生物群系过滤条件的类
+ */
+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/src/core/feature_rule/condition/FeatureConditions.js

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