sapdon 3.0.2 → 3.0.3

package/dist/core/biome/biomeComponent.js

@@ -0,0 +1,77 @@
+export class BiomeComponent {
+    /**
+     * 将多个组件集合合并为一个。
+     * @param {...Map} componentMaps - 多个组件集合。
+     * @returns {Map} - 合并后的组件集合。
+   */
+    static combineComponents(...componentMaps) {
+        return new Map(componentMaps.flatMap(map => [...map]));
+    }
+    /**
+     * 设置生物群系的气候参数
+     * @param {number} downfall - 降水量（范围通常为 0 到 1）
+     * @param {number} snow_accumulation - 积雪量（范围通常为 0 到 1）
+     * @param {number} temperature - 温度（范围通常为 0 到 1）
+     * @returns {Map} 返回一个包含气候参数的 Map 对象，键为 "minecraft:climate"
+     */
+    static setClimate(downfall, snow_accumulation, temperature) {
+        return new Map([
+            ["minecraft:climate", {
+                    downfall: downfall,
+                    snow_accumulation: snow_accumulation,
+                    temperature: temperature
+                }]
+        ]);
+    }
+    /**
+     * 设置生物群系的世界高度参数（通常用于生成地形）
+     * @param {Object} noise_params - 噪声参数，用于控制地形生成
+     * @returns {Map} 返回一个包含高度参数的 Map 对象，键为 "minecraft:overworld_height"
+     */
+    static setOverworldHeight(noise_params) {
+        return new Map([
+            ["minecraft:overworld_height", {
+                    noise_params: noise_params
+                }]
+        ]);
+    }
+    /**
+     * 设置生物群系的表面参数（如地表材料、海底材料等）
+     * @param {Object} params - 表面参数对象，包含以下属性：
+     * @param {number} params.sea_floor_depth - 海底深度
+     * @param {string} params.sea_floor_material - 海底材料（如 "minecraft:sand"）
+     * @param {string} params.foundation_material - 基础材料（如 "minecraft:stone"）
+     * @param {string} params.mid_material - 中间层材料（如 "minecraft:dirt"）
+     * @param {string} params.top_material - 顶层材料（如 "minecraft:grass_block"）
+     * @param {string} params.sea_material - 海洋材料（如 "minecraft:water"）
+     * @returns {Map} 返回一个包含表面参数的 Map 对象，键为 "minecraft:surface_parameters"
+     */
+    static setSurfaceParameters(params) {
+        const { sea_floor_depth, sea_floor_material, foundation_material, mid_material, top_material, sea_material } = params;
+        return new Map([
+            ["minecraft:surface_parameters", {
+                    sea_floor_depth: sea_floor_depth,
+                    sea_floor_material: sea_floor_material,
+                    foundation_material: foundation_material,
+                    mid_material: mid_material,
+                    top_material: top_material,
+                    sea_material: sea_material
+                }]
+        ]);
+    }
+    /**
+    * 设置生物群系在生成时的规则（如适用于哪些气候类型）
+    * @returns {Map} 返回一个包含生成规则的 Map 对象，键为 "minecraft:overworld_generation_rules"
+    */
+    static setOverworldGenerationRules(medium_weight, warm_weight, cold_weight) {
+        return new Map([
+            ["minecraft:overworld_generation_rules", {
+                    "generate_for_climates": [
+                        ["medium", medium_weight], // 适用于中等气候，权重为 100
+                        ["warm", warm_weight], // 适用于温暖气候，权重为 100
+                        ["cold", cold_weight] // 适用于寒冷气候，权重为 100
+                    ]
+                }]
+        ]);
+    }
+}

package/dist/core/block/basicBlock.d.ts

@@ -0,0 +1,48 @@
+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: string, category: string, textures_arr: any[], options?: {
+        group: string;
+        hide_in_command: boolean;
+    });
+    identifier: string;
+    category: string;
+    textures: any[];
+    group: string;
+    hide_in_command: boolean;
+    traits: Map<any, any>;
+    states: Map<any, any>;
+    components: Map<any, any>;
+    permutations: any[];
+    getId(): string;
+    registerTrait(key: any, value: any): this;
+    registerState(key: any, value: any): this;
+    /**
+     * 添加组件
+     * @param {Map} componentMap 组件 Map
+     */
+    addComponent(componentMap: Map<any, any>): this;
+    /**
+     * 移除组件
+     * @param {string} key 组件名称
+     */
+    removeComponent(key: string): this;
+    /**
+     * 添加方块变体
+     * @param {string} condition 变体条件
+     * @param {Map} componentMap 组件 Map
+     */
+    addPermutation(condition: string, componentMap: Map<any, any>): this;
+    /**
+     * 将方块对象转换为 JSON 格式
+     * @returns {Object} JSON 格式的方块对象
+     */
+    toJson(): Object;
+}

package/dist/core/block/basicBlock.js

@@ -0,0 +1,105 @@
+import { AddonBlock, AddonBlockDefinition, AddonBlockDescription } from "../addon/block/block.js";
+import { AddonMenuCategory } from "../addon/menuCategory.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/dist/core/block/block.d.ts

@@ -0,0 +1,32 @@
+export class Block extends BasicBlock {
+    /**
+     * 方块类
+     * @param {string} identifier 方块的唯一标识符
+     * @param {string} category 方块的分类 "construction", "nature", "equipment", "items", and "none"
+     * @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: string, category: string, variantDatas: any[], options?: {
+        group: string;
+        hide_in_command: boolean;
+        ambient_occlusion: boolean;
+        face_dimming: boolean;
+        render_method: string;
+    });
+    options: {
+        group: string;
+        hide_in_command: boolean;
+        ambient_occlusion: boolean;
+        face_dimming: boolean;
+        render_method: string;
+    };
+    variantDatas: any[];
+    addVariantComponent(variantIndex: any, componentMap: any): this;
+    #private;
+}
+import { BasicBlock } from "./basicBlock.js";

package/dist/core/block/block.js

@@ -0,0 +1,92 @@
+import { BasicBlock } from "./basicBlock.js";
+import { BlockComponent } from "./blockComponent.js";
+export class Block extends BasicBlock {
+    /**
+     * 方块类
+     * @param {string} identifier 方块的唯一标识符
+     * @param {string} category 方块的分类 "construction", "nature", "equipment", "items", and "none"
+     * @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
+*/ 

package/dist/core/block/blockComponent.d.ts

@@ -0,0 +1,187 @@
+export class BlockComponent {
+    static setTick(interval_range: any, looping: any): Map<any, any>;
+    /**
+     *
+     * @param {Array} custom_components
+     * @returns
+     */
+    static setCustomComponents(custom_components: any[]): Map<any, any>;
+    /**
+   * 创建一个用于 Minecraft 方块的变换对象，并返回一个 Map。
+   * @param {number[]} [translation=[0, 0, 0]] - 平移向量 [x, y, z]。
+   * @param {number[]} [scale=[1, 1, 1]] - 缩放向量 [x, y, z]。
+   * @param {number[]} [scale_pivot=[0, 0, 0]] - 缩放的枢轴点 [x, y, z]。
+   * @param {number[]} [rotation=[0, 0, 0]] - 旋转向量（角度）[x, y, z]。
+   * @param {number[]} [rotation_pivot=[0, 0, 0]] - 旋转的枢轴点 [x, y, z]。
+   * @returns {Map} - 一个包含变换数据的 Map 对象。
+   * @throws {Error} - 如果任何参数无效，则抛出错误。
+   */
+    static setTransformation(translation?: number[], scale?: number[], scale_pivot?: number[], rotation?: number[], rotation_pivot?: number[]): Map<any, any>;
+    /**
+     * 设置方块的呼吸行为。
+     * @param {String} value - 呼吸行为，可选值为 "solid" 或 "air"。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setBreathability(value: string): Map<any, any>;
+    /**
+     * 启用或禁用方块的碰撞箱。
+     * @param {Boolean} enabled - 是否启用碰撞箱。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setCollisionBoxEnabled(enabled: boolean): Map<any, any>;
+    /**
+     * 设置自定义的碰撞箱。
+     * @param {Array} origin - 碰撞箱的起点坐标 [x, y, z]。
+     * @param {Array} size - 碰撞箱的大小 [width, height, depth]。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setCollisionBoxCustom(origin: any[], size: any[]): Map<any, any>;
+    /**
+     * 设置方块的合成台属性。
+     * @param {Array} craftingTags - 合成标签。
+     * @param {String} tableName - 合成台名称。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setCraftingTable(craftingTags: any[], tableName: string): Map<any, any>;
+    /**
+     * 启用或禁用方块的爆炸抗性。
+     * @param {Boolean} enabled - 是否启用爆炸抗性。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setDestructibleByExplosionEnabled(enabled: boolean): Map<any, any>;
+    /**
+     * 设置自定义的爆炸抗性。
+     * @param {Number} explosionResistance - 爆炸抗性值。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setDestructibleByExplosionCustom(explosionResistance: number): Map<any, any>;
+    /**
+     * 启用或禁用方块的挖掘抗性。
+     * @param {Boolean} enabled - 是否启用挖掘抗性。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setDestructibleByMiningEnabled(enabled: boolean): Map<any, any>;
+    /**
+     * 设置自定义的挖掘抗性。
+     * @param {Number} secondsToDestroy - 破坏所需时间（秒）。
+     * @param {Array} itemSpecificSpeeds - 特定工具的挖掘速度。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setDestructibleByMiningCustom(secondsToDestroy: number, itemSpecificSpeeds: any[]): Map<any, any>;
+    /**
+     * 设置方块的显示名称。
+     * @param {String} displayName - 显示名称。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setDisplayName(displayName: string): Map<any, any>;
+    /**
+     * 启用或禁用方块的易燃性。
+     * @param {Boolean} enabled - 是否启用易燃性。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setFlammableEnabled(enabled: boolean): Map<any, any>;
+    /**
+     * 设置自定义的易燃性。
+     * @param {Number} catchChanceModifier - 着火概率。
+     * @param {Number} destroyChanceModifier - 被火焰摧毁的概率。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setFlammableCustom(catchChanceModifier: number, destroyChanceModifier: number): Map<any, any>;
+    /**
+     * 设置方块的摩擦力。
+     * @param {Number} value - 摩擦力值，范围为 0.0 到 0.9。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setFriction(value: number): Map<any, any>;
+    /**
+     * 设置方块的几何模型。
+     * @param {String} identifier - 几何模型标识符。
+     * @param {Object} bone_visibility - 骨骼可见性配置。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setGeometry(identifier: string, bone_visibility: Object): Map<any, any>;
+    /**
+     * 设置方块的物品视觉属性。
+     * @param {String} geometry - 几何模型标识符。
+     * @param {Object} materialInstances - 材质实例配置。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setItemVisual(geometry: string, materialInstances: Object): Map<any, any>;
+    /**
+     * 设置方块的光衰减值。
+     * @param {Number} value - 光的衰减值，范围为 0 到 15。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setLightDampening(value: number): Map<any, any>;
+    /**
+     * 设置方块的光照强度。
+     * @param {Number} value - 光照强度，范围为 0 到 15。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setLightEmission(value: number): Map<any, any>;
+    /**
+     * 设置方块的液体检测属性。
+     * @param {Boolean} canContainLiquid - 是否可以包含液体。
+     * @param {String} liquidType - 液体类型。
+     * @param {String} onLiquidTouches - 对液体的反应方式。
+     * @param {Array} stopsLiquidFlowingFromDirection - 阻止液体流动的方向。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setLiquidDetection(canContainLiquid: boolean, liquidType: string, onLiquidTouches: string, stopsLiquidFlowingFromDirection: any[]): Map<any, any>;
+    /**
+     * 设置方块的战利品表路径。
+     * @param {String} path - 战利品表路径。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setLoot(path: string): Map<any, any>;
+    /**
+     * 设置方块的地图颜色。
+     * @param {String|Array} value - 地图颜色，可以是十六进制字符串或 RGB 数组。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setMapColor(value: string | any[]): Map<any, any>;
+    /**
+     * 设置方块的材质实例。
+     * @param {Object} instances - 材质实例配置。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setMaterialInstances(instances: Object): Map<any, any>;
+    /**
+     * 设置方块的放置过滤条件。
+     * @param {Array} conditions - 放置条件列表。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setPlacementFilter(conditions: any[]): Map<any, any>;
+    /**
+     * 设置方块的红石导电性。
+     * @param {Boolean} allowsWireToStepDown - 是否允许红石线向下阶梯连接。
+     * @param {Boolean} redstoneConductor - 方块是否可以被红石信号激活。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setRedstoneConductivity(allowsWireToStepDown: boolean, redstoneConductor: boolean): Map<any, any>;
+    /**
+     * 启用或禁用方块的选择框。
+     * @param {Boolean} enabled - 是否启用选择框。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setSelectionBoxEnabled(enabled: boolean): Map<any, any>;
+    /**
+     * 设置自定义的选择框。
+     * @param {Array} origin - 选择框的起点坐标 [x, y, z]。
+     * @param {Array} size - 选择框的大小 [width, height, depth]。
+     * @returns {Map} - 新的组件集合。
+     */
+    static setSelectionBoxCustom(origin: any[], size: any[]): Map<any, any>;
+    /**
+     * 将多个组件集合合并为一个。
+     * @param {...Map} componentMaps - 多个组件集合。
+     * @returns {Map} - 合并后的组件集合。
+     */
+    static combineComponents(...componentMaps: Map<any, any>[]): Map<any, any>;
+    /**
+     * 获取当前组件的 JSON 表示。
+     * @param {Map} components - 组件集合。
+     * @returns {Object} - 组件的 JSON 对象。
+     */
+    static toJSON(components: Map<any, any>): Object;
+}