sapdon 2.0.0

package/src/core/block/BasicBlock.js

@@ -0,0 +1,127 @@
+import { AddonBlock, AddonBlockDefinition, AddonBlockDescription } from "../addon/block/Block.js";
+import { AddonMenuCategory } from "../addon/menu_category.js";
+
+export class BasicBlock {
+    /**
+     * 基础方块类
+     * @param {string} identifier 方块唯一标识符
+     * @param {string} category 菜单栏分类 可选："construction", "nature", "equipment", "items", and "none"
+     * @param {Array} textures_arr 纹理数组 [上,下,东,西,南,北]
+     * @param {Object} options 可选参数
+     * @param {string} options.group 分组，默认为 "construction"
+     * @param {boolean} options.hide_in_command 是否在命令中隐藏，默认为 false
+     */
+    constructor(identifier, category, textures_arr, 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 (!Array.isArray(textures_arr) ) {
+            throw new Error("textures_arr must be an array ");
+        }
+        if (textures_arr.length !== 6) {
+            for (let i = textures_arr.length; i < 6; i++) {
+                textures_arr.push(textures_arr[0]);
+            }
+        }
+
+        const { hide_in_command = false } = options;
+
+        this.identifier = identifier;
+        this.category = category;
+        this.textures = textures_arr;
+        this.group = options.group;
+        this.hide_in_command = hide_in_command;
+        this.traits = new Map();
+        this.states = new Map();
+        this.components = new Map();
+        this.permutations = [];
+    }
+    
+    getId() {
+        return this.identifier;
+    }
+
+    registerTrait(key,value){
+        this.traits.set(key,value);
+        return this;
+    }
+
+    registerState(key,value){
+        this.states.set(key,value);
+        return this;
+    }
+
+    /**
+     * 添加组件
+     * @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;
+    }
+
+    /**
+     * 添加方块变体
+     * @param {string} condition 变体条件
+     * @param {Map} componentMap 组件 Map
+     */
+    addPermutation(condition, componentMap) {
+        if (!condition || typeof condition !== "string") {
+            throw new Error("condition is required and must be a string");
+        }
+        if (!componentMap || !(componentMap instanceof Map)) {
+            throw new Error("componentMap is required and must be a Map");
+        }
+        this.permutations.push({
+            condition: condition,
+            components: Object.fromEntries(componentMap)
+        });
+        return this;
+    }
+
+    /**
+     * 将方块对象转换为 JSON 格式
+     * @returns {Object} JSON 格式的方块对象
+     */
+    toJson() {
+        const block = new AddonBlock(
+            "1.21.50", // 格式版本
+            new AddonBlockDefinition(
+                new AddonBlockDescription(
+                    this.identifier,
+                    Object.fromEntries(this.traits), // 将 Map 转换为普通对象
+                    Object.fromEntries(this.states), // 将 Map 转换为普通对象
+                    new AddonMenuCategory(
+                        this.category,
+                        this.group,
+                        this.hide_in_command
+                    )
+                ),
+                Object.fromEntries(this.components), // 将 Map 转换为普通对象
+                this.permutations
+            )
+        );
+        return block.toJson();
+    }
+}

package/src/core/block/GeometryBlock.js

@@ -0,0 +1,14 @@
+import { BasicBlock } from "./BasicBlock.js";
+import { BlockComponent } from "./blockComponent.js";
+
+export class GeometryBlock extends BasicBlock{
+    constructor(identifier, category, geometry, material_instances, options = {}) {
+        super(identifier, category, [material_instances["*"]["texture"]], options);
+        this.addComponent(
+            BlockComponent.combineComponents(
+                BlockComponent.setGeometry(geometry),
+                BlockComponent.setMaterialInstances(material_instances)
+            )
+        )
+    }
+}

package/src/core/block/OreBlock.js

@@ -0,0 +1,29 @@
+import { OreFeature } from "../feature/OreFeature.js";
+import { BiomeFilter } from "../feature_rule/condition/BiomeFilter.js";
+import { CoordinateDistribution } from "../feature_rule/distribution/CoordinateDistribution.js";
+import { FeatureRule } from "../feature_rule/FeatureRule.js";
+import { BasicBlock } from "./BasicBlock.js";
+
+export class OreBlock{
+    constructor(identifier, category, textures_arr, options = {}){
+        this.block = new BasicBlock(identifier, category, textures_arr, options);
+        this.feature = new OreFeature(`${identifier}_ore_feature`,6,[
+            {
+                "places_block": identifier,
+                "may_replace": ["minecraft:stone"]
+            },
+        ]);
+        this.feature_rules = new FeatureRule(`${identifier}_orefeatre_rule`,`${identifier}_ore_feature`)
+        this.feature_rules.condition.setPlacementPass("underground_pass").setBiomeFilter(
+            new BiomeFilter().addLogicGroup("any_of",[
+                { test: "has_biome_tag", operator: "==", value: "overworld" },
+                { test: "has_biome_tag", operator: "==", value: "overworld_generation" }
+            ])
+        );
+        this.feature_rules.distribution.setIterations(10)
+        .setAxisDistribution("x",new CoordinateDistribution("uniform",[0,16]))
+        .setAxisDistribution("y",new CoordinateDistribution("uniform",[0,64]))
+        .setAxisDistribution("z",new CoordinateDistribution("uniform",[0,16]))
+
+    }
+}

package/src/core/block/RotatableBlock.js

@@ -0,0 +1,161 @@
+import { BasicBlock } from "./BasicBlock.js";
+import { BlockComponent } from "./blockComponent.js";
+
+export const RotationTypes = {
+    CARDINAL: "cardinal", // 北、南、东、西
+    FACING: "facing", // 上、下、北、南、东、西
+    BLOCK_FACE: "block_face", // 上、下、北、南、东、西（与 FACING 类似，但用途不同）
+    LOG: "log" // 原木旋转（X、Y、Z 轴对齐）
+};
+
+export class RotatableBlock extends BasicBlock {
+    /**
+     * 可旋转方块类
+     * @param {string} identifier 方块唯一标识符
+     * @param {string} category 菜单栏分类
+     * @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
+     */
+    constructor(identifier, category, textures_arr, options = {}) {
+        // 调用父类构造函数
+        super(identifier, category, textures_arr, options);
+
+        const {
+            rotationType = RotationTypes.CARDINAL,
+            yRotationOffset = 180
+        } = options;
+
+        // 根据旋转类型注册特性和添加变体
+        this.#setupRotation(rotationType, yRotationOffset);
+    }
+
+    /**
+     * 根据旋转类型设置特性和变体
+     * @param {string} rotationType 旋转类型
+     * @param {number} yRotationOffset 初始旋转偏移量
+     */
+    #setupRotation(rotationType, yRotationOffset) {
+        switch (rotationType) {
+            case RotationTypes.CARDINAL:
+                // 北、南、东、西
+                this.registerTrait("minecraft:placement_direction", {
+                    enabled_states: ["minecraft:cardinal_direction"],
+                    y_rotation_offset: yRotationOffset
+                });
+                this.#addCardinalDirectionPermutations();
+                break;
+
+            case RotationTypes.FACING:
+                // 上、下、北、南、东、西
+                this.registerTrait("minecraft:placement_direction", {
+                    enabled_states: ["minecraft:facing_direction"]
+                });
+                this.#addFacingDirectionPermutations();
+                break;
+
+            case RotationTypes.BLOCK_FACE:
+                // 上、下、北、南、东、西（与 FACING 类似，但用途不同）
+                this.registerTrait("minecraft:placement_position", {
+                    enabled_states: ["minecraft:block_face"]
+                });
+                this.#addBlockFacePermutations();
+                break;
+
+            case RotationTypes.LOG:
+                // 原木旋转（X、Y、Z 轴对齐）
+                this.registerTrait("minecraft:placement_position", {
+                    enabled_states: ["minecraft:block_face"]
+                });
+                this.#addLogRotationPermutations();
+                break;
+
+            default:
+                throw new Error(`Unknown rotation type: ${rotationType}`);
+        }
+    }
+
+    /**
+     * 添加 Cardinal Direction 旋转变体
+     */
+    #addCardinalDirectionPermutations() {
+        this.addPermutation("q.block_state('minecraft:cardinal_direction') == 'north'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 0, 0])
+        )
+        .addPermutation("q.block_state('minecraft:cardinal_direction') == 'south'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 90, 0])
+        )
+        .addPermutation("q.block_state('minecraft:cardinal_direction') == 'east'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 180, 0])
+        )
+        .addPermutation("q.block_state('minecraft:cardinal_direction') == 'west'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, -90, 0])
+        );
+    }
+
+    /**
+     * 添加 Facing Direction 旋转变体
+     */
+    #addFacingDirectionPermutations() {
+        this.addPermutation("q.block_state('minecraft:facing_direction') == 'down'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [-90, 0, 0] )
+        )
+        .addPermutation("q.block_state('minecraft:facing_direction') == 'up'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [90, 0, 0])
+        )
+        .addPermutation("q.block_state('minecraft:facing_direction') == 'north'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 0, 0])
+        )
+        .addPermutation("q.block_state('minecraft:facing_direction') == 'west'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 90, 0])
+        )
+        .addPermutation("q.block_state('minecraft:facing_direction') == 'south'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1],[0, 0, 0], [0, 180, 0])
+        )
+        .addPermutation("q.block_state('minecraft:facing_direction') == 'east'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1],[0, 0, 0], [0, -90, 0], )
+        );
+    }
+
+    /**
+     * 添加 Block Face 旋转变体
+     */
+    #addBlockFacePermutations() {
+        this.addPermutation("q.block_state('minecraft:block_face') == 'down'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [-90, 0, 0], [0, 0, 0])
+        )
+        .addPermutation("q.block_state('minecraft:block_face') == 'up'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [90, 0, 0], [0, 0, 0])
+        )
+        .addPermutation("q.block_state('minecraft:block_face') == 'north'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 0, 0])
+        )
+        .addPermutation("q.block_state('minecraft:block_face') == 'south'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 180, 0], [0, 90, 0])
+        )
+        .addPermutation("q.block_state('minecraft:block_face') == 'east'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 90, 0], [0, 180, 0])
+        )
+        .addPermutation("q.block_state('minecraft:block_face') == 'west'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, -90, 0], [0, -90, 0])
+        );
+    }
+
+    /**
+     * 添加 Log Rotation 旋转变体
+     */
+    #addLogRotationPermutations() {
+        this.addPermutation("q.block_state('minecraft:block_face') == 'west' || q.block_state('minecraft:block_face') == 'east'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 90], [0, 0, 0])
+        )
+        .addPermutation("q.block_state('minecraft:block_face') == 'down' || q.block_state('minecraft:block_face') == 'up'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 0, 0])
+        )
+        .addPermutation("q.block_state('minecraft:block_face') == 'north' || q.block_state('minecraft:block_face') == 'south'",
+            BlockComponent.setTransformation([0, 0, 0], [1, 1, 1], [90, 0, 0], [0, 0, 0])
+        );
+    }
+}

package/src/core/block/block.js

@@ -0,0 +1,107 @@
+
+import { BasicBlock } from "./BasicBlock.js";
+import { BlockComponent } from "./blockComponent.js";
+
+export class Block extends BasicBlock {
+    /**
+     * 方块类
+     * @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"
+     */
+    constructor(identifier, category, variantDatas, options = {}) {
+        console.log("options:",options);
+        // 检查 variantDatas 是否有效
+        if (!Array.isArray(variantDatas) || variantDatas.length === 0) {
+            throw new Error('variantDatas 必须是一个非空数组');
+        }
+
+        // 调用父类构造函数
+        super(identifier, category, variantDatas[0]["textures"], options);
+
+        this.options = options;
+        this.variantDatas = variantDatas;
+
+        // 初始化方块
+        this.#init();
+    }
+
+    /**
+     * 初始化方块（私有方法）
+     * @param {Array} variantDatas 方块的变体数据
+     * @param {Object} options 材质属性
+     */
+    #init() {
+        // 注册方块状态
+        this.registerState("sapdon:block_variant_tag", {
+            values: {
+                min: 0,
+                max: this.variantDatas.length > 1 ? this.variantDatas.length - 1 : 1
+            }
+        });
+
+        // 为每个变体创建材质实例
+        this.variantDatas.forEach((variant, index) => {
+            const material_instances = this.#createMaterialInstances(variant.textures, this.options);
+            const condition = `q.block_state('sapdon:block_variant_tag') == ${index}`;
+
+            // 添加材质实例组件
+            this.addPermutation(condition, BlockComponent.setMaterialInstances(material_instances));
+        });
+    }
+
+    /**
+     * 创建材质实例（私有方法）
+     * @param {Array} textures 纹理数组
+     * @param {Object} options 材质属性
+     * @returns {Object} 材质实例对象
+     */
+    #createMaterialInstances(textures) {
+        
+        
+        const material_instances = {};
+        const sides = ["*", "up", "down", "north", "south", "east", "west"];
+        
+        textures.forEach((texture, index) => {
+            material_instances[sides[index]] = {
+                texture: texture,
+                ambient_occlusion: this.options.ambient_occlusion || true,
+                face_dimming: this.options.face_dimming || true,
+                render_method: this.options.render_method || "alpha_test"
+            }
+        });
+
+        return material_instances;
+    }
+
+    addVariantComponent(variantIndex, componentMap) {
+        if (variantIndex < 0 || variantIndex >= this.variantDatas.length) {
+            throw new Error('variantIndex 必须在 0 到 variantDatas.length-1 之间');
+        }
+        const condition = `q.block_state('sapdon:block_variant_tag') == ${variantIndex}`;
+        this.addPermutation(condition, componentMap);
+        return this;
+    }
+}
+
+/*
+// 示例用法
+const block = new Block("sapdon:block", "construction", [
+    { stateTag: 1, textures: ["garlic_stage_0"] },
+    { stateTag: 2, textures: ["garlic_stage_1"] },
+    { stateTag: 3, textures: ["garlic_stage_2"] },
+    { stateTag: 4, textures: ["garlic_stage_3"] },
+], {
+    ambient_occlusion: false,
+    face_dimming: false,
+    render_method: "blend"
+});
+console.log(block);
+debugger
+*/