sapdon 3.0.2 → 3.1.0

package/dist/cli/tools/textureSet.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 生成 block_texture.json 文件
+ * @param {string} itemTexturesPath - 包含 PNG 文件的根目录
+ * @param {string} outputPath - 输出的 JSON 文件路径
+ * @param {string} projectName - 项目名称
+ */
+export function generateBlockTextureJson(itemTexturesPath: string, outputPath: string, projectName: string, userTerrainTextures: any): Promise<void>;
+/**
+ * 生成 item_texture.json 文件
+ * @param {string} itemTexturesPath - 包含 PNG 文件的根目录
+ * @param {string} outputPath - 输出的 JSON 文件路径
+ */
+export function generateItemTextureJson(itemTexturesPath: string, outputPath: string, projectName: any, userItemTextures: any): Promise<void>;

package/dist/cli/tools/textureSet.js

@@ -0,0 +1,103 @@
+import fs from "fs/promises";
+import path from "path";
+/**
+ * 递归遍历目录，收集所有 PNG 文件的路径
+ * @param {string} directory - 要遍历的目录
+ * @param {string} basePath - 基础路径（用于计算相对路径）
+ * @param {string} prefix - 路径前缀（如 "textures/items/"）
+ * @returns {Promise<Object>} - 返回一个对象，键为文件名，值为相对路径（不带 .png 后缀）
+ */
+const traverseDirectory = async (directory, basePath, prefix = "") => {
+    const texturesSet = {};
+    const files = await fs.readdir(directory);
+    for (const file of files) {
+        const filePath = path.join(directory, file);
+        const fileStats = await fs.stat(filePath);
+        if (fileStats.isDirectory()) {
+            // 如果是目录，递归遍历
+            const subDirectoryTextures = await traverseDirectory(filePath, basePath, prefix);
+            Object.assign(texturesSet, subDirectoryTextures);
+        }
+        else if (file.endsWith(".png")) {
+            // 如果是 PNG 文件，提取文件名并生成 texture_data
+            const fileName = path.basename(file, ".png"); // 去掉 .png 后缀
+            const relativePath = path.relative(basePath, filePath).replace(/\.png$/, ""); // 去掉 .png 后缀
+            const normalizedPath = `${prefix}${relativePath.replace(/\\/g, "/")}`; // 确保路径使用正斜杠
+            texturesSet[fileName] = {
+                textures: normalizedPath,
+            };
+        }
+    }
+    return texturesSet;
+};
+/**
+ * 生成 JSON 文件
+ * @param {string} outputPath - 输出的 JSON 文件路径
+ * @param {Object} jsonData - 要写入的 JSON 数据
+ * @param {string} successMessage - 成功时的日志消息
+ */
+const generateJsonFile = async (outputPath, jsonData, successMessage) => {
+    try {
+        const jsonString = JSON.stringify(jsonData, null, 2);
+        await fs.writeFile(outputPath, jsonString);
+        console.log(successMessage);
+    }
+    catch (err) {
+        console.error("Error writing JSON file:", err);
+    }
+};
+/**
+ * 生成 block_texture.json 文件
+ * @param {string} itemTexturesPath - 包含 PNG 文件的根目录
+ * @param {string} outputPath - 输出的 JSON 文件路径
+ * @param {string} projectName - 项目名称
+ */
+export async function generateBlockTextureJson(itemTexturesPath, outputPath, projectName, userTerrainTextures) {
+    try {
+        // 递归遍历目录，获取所有 PNG 文件的路径
+        const itemTexturesSet = await traverseDirectory(itemTexturesPath, itemTexturesPath, "textures/blocks/");
+        // 合并用户自定义的texture_data
+        if (userTerrainTextures) {
+            Object.assign(itemTexturesSet, userTerrainTextures);
+        }
+        // 生成 JSON 数据
+        const jsonData = {
+            texture_name: "atlas.terrain",
+            resource_pack_name: projectName,
+            padding: 8,
+            num_mip_levels: 4,
+            texture_data: itemTexturesSet,
+        };
+        // 写入文件
+        await generateJsonFile(outputPath, jsonData, "Block texture JSON file generated successfully.");
+    }
+    catch (err) {
+        console.error("Error generating block texture JSON:", err);
+    }
+}
+/**
+ * 生成 item_texture.json 文件
+ * @param {string} itemTexturesPath - 包含 PNG 文件的根目录
+ * @param {string} outputPath - 输出的 JSON 文件路径
+ */
+export async function generateItemTextureJson(itemTexturesPath, outputPath, projectName, userItemTextures) {
+    try {
+        // 递归遍历目录，获取所有 PNG 文件的路径
+        const itemTexturesSet = await traverseDirectory(itemTexturesPath, itemTexturesPath, "textures/items/");
+        // 合并用户自定义的texture_data
+        if (userItemTextures) {
+            Object.assign(itemTexturesSet, userItemTextures);
+        }
+        // 生成 JSON 数据
+        const jsonData = {
+            resource_pack_name: projectName,
+            texture_name: "atlas.items",
+            texture_data: itemTexturesSet,
+        };
+        // 写入文件
+        await generateJsonFile(outputPath, jsonData, "Item texture JSON file generated successfully.");
+    }
+    catch (err) {
+        console.error("Error generating item texture JSON:", err);
+    }
+}

package/dist/cli/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 同步复制文件
+ * @param {string} src 源文件路径
+ * @param {string} dest 目标文件路径
+ */
+export function copyFileSync(src: string, dest: string): void;
+export function dirname(importMeta: any): string;
+export function asyncImport(path: any): Promise<any>;
+export function generateUUID(): `${string}-${string}-${string}-${string}-${string}`;
+export function pathNotExist(filePath: any): boolean;
+export function readFile(filePath: any): string | null;
+export function saveFile(filePath: string, data: string): void;
+export function copyFolder(sourcePath: any, destinationPath: any): void;

package/dist/cli/utils.js

@@ -0,0 +1,89 @@
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import { fileURLToPath } from "node:url";
+export const generateUUID = () => {
+    return randomUUID();
+};
+/**
+ * 同步复制文件
+ * @param {string} src 源文件路径
+ * @param {string} dest 目标文件路径
+ */
+export function copyFileSync(src, dest) {
+    try {
+        fs.copyFileSync(src, dest);
+    }
+    catch (err) {
+        console.error("文件复制失败：", err);
+    }
+}
+//检查路径
+export const pathNotExist = filePath => {
+    return !fs.existsSync(filePath);
+};
+//读取文件
+export const readFile = filePath => {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        console.log(error);
+    }
+    return null;
+};
+/**
+ * 保存文件
+ * @param {string} filePath 绝对路径
+ * @param {string} data 数据
+ */
+export const saveFile = (filePath, data) => {
+    // 确保目录存在
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    // 创建文件并写入内容
+    fs.writeFile(filePath, data, err => {
+        if (err) {
+            return console.error(err);
+        }
+    });
+};
+export const copyFolder = (sourcePath, destinationPath) => {
+    // 确保目录存在
+    fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+    // 检查源路径是否存在
+    if (!fs.existsSync(sourcePath)) {
+        console.log(`Source path ${sourcePath} does not exist.`);
+        return;
+    }
+    // 检查目标路径是否存在，如果不存在则创建它
+    if (!fs.existsSync(destinationPath)) {
+        fs.mkdirSync(destinationPath);
+    }
+    // 获取源路径下的所有文件和文件夹
+    const files = fs.readdirSync(sourcePath);
+    // 遍历文件和文件夹
+    files.forEach(file => {
+        const sourceFile = path.join(sourcePath, file);
+        const destinationFile = path.join(destinationPath, file);
+        // 判断是文件还是文件夹
+        if (fs.lstatSync(sourceFile).isDirectory()) {
+            // 如果是文件夹，则递归调用copyFolder函数
+            copyFolder(sourceFile, destinationFile);
+        }
+        else {
+            // 如果是文件，则直接复制到目标路径
+            fs.copyFileSync(sourceFile, destinationFile);
+        }
+    });
+};
+export function dirname(importMeta) {
+    const __filename = fileURLToPath(importMeta.url);
+    const __dirname = path.dirname(__filename);
+    return __dirname;
+}
+export function asyncImport(path) {
+    if (!path.startsWith('.')) {
+        return import('file://' + path);
+    }
+    return import(path);
+}

package/dist/core/addon/biome.d.ts

@@ -0,0 +1,22 @@
+export class AddonBiome {
+    constructor(format_version: any, definition: any);
+    format_version: any;
+    definition: any;
+    toJson(): {
+        format_version: any;
+        "minecraft:biome": any;
+    };
+}
+export class AddonBiomeDescription {
+    constructor(identifier: any);
+    identifier: any;
+}
+export class AddonBiomeDefinition {
+    /**
+     *
+     * @param {AddonBiomeDescription} description
+     */
+    constructor(description: AddonBiomeDescription, components: any);
+    description: AddonBiomeDescription;
+    components: any;
+}

package/dist/core/addon/biome.js

@@ -0,0 +1,27 @@
+export class AddonBiome {
+    constructor(format_version, definition) {
+        this.format_version = format_version;
+        this.definition = definition;
+    }
+    toJson() {
+        return {
+            format_version: this.format_version,
+            ["minecraft:biome"]: this.definition
+        };
+    }
+}
+export class AddonBiomeDescription {
+    constructor(identifier) {
+        this.identifier = identifier;
+    }
+}
+export class AddonBiomeDefinition {
+    /**
+     *
+     * @param {AddonBiomeDescription} description
+     */
+    constructor(description, components) {
+        this.description = description;
+        this.components = components;
+    }
+}

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

@@ -0,0 +1,41 @@
+export class AddonBlock {
+    /**
+     * Addon方块类
+     * @param {string} format_version 格式版本
+     * @param {AddonBlockDefinition} definitions 方块定义
+     */
+    constructor(format_version: string, definitions: AddonBlockDefinition);
+    format_version: string;
+    definitions: AddonBlockDefinition;
+    toJson(): {
+        format_version: string;
+        "minecraft:block": AddonBlockDefinition;
+    };
+}
+export class AddonBlockDefinition {
+    /**
+     * 方块定义类
+     * @param {AddonBlockDescription} description 方块描述
+     * @param {Object} components 方块组件
+     * @param {Array} permutations 方块变体
+     */
+    constructor(description: AddonBlockDescription, components: Object, permutations?: any[]);
+    description: AddonBlockDescription;
+    components: Object;
+    permutations: any[];
+}
+export class AddonBlockDescription {
+    /**
+     * 方块描述类
+     * @param {string} identifier 唯一标识符
+     * @param {map} traits 方块特性
+     * @param {map} states 方块状态
+     * @param {AddonMenuCategory} menu_category
+     */
+    constructor(identifier: string, traits: map, states: map, menu_category: AddonMenuCategory);
+    identifier: string;
+    traits: map;
+    states: map;
+    menu_category: AddonMenuCategory;
+}
+import { AddonMenuCategory } from "../menuCategory.js";

package/dist/core/addon/block/block.js

@@ -0,0 +1,46 @@
+import { AddonMenuCategory } from "../menuCategory.js";
+export class AddonBlock {
+    /**
+     * Addon方块类
+     * @param {string} format_version 格式版本
+     * @param {AddonBlockDefinition} definitions 方块定义
+     */
+    constructor(format_version, definitions) {
+        this.format_version = format_version;
+        this.definitions = definitions;
+    }
+    toJson() {
+        return {
+            format_version: this.format_version,
+            ["minecraft:block"]: this.definitions
+        };
+    }
+}
+export class AddonBlockDefinition {
+    /**
+     * 方块定义类
+     * @param {AddonBlockDescription} description 方块描述
+     * @param {Object} components 方块组件
+     * @param {Array} permutations 方块变体
+     */
+    constructor(description, components, permutations = []) {
+        this.description = description;
+        this.components = components;
+        this.permutations = permutations;
+    }
+}
+export class AddonBlockDescription {
+    /**
+     * 方块描述类
+     * @param {string} identifier 唯一标识符
+     * @param {map} traits 方块特性
+     * @param {map} states 方块状态
+     * @param {AddonMenuCategory} menu_category
+     */
+    constructor(identifier, traits, states, menu_category) {
+        this.identifier = identifier;
+        this.traits = traits;
+        this.states = states;
+        this.menu_category = menu_category;
+    }
+}

package/dist/core/addon/controllers/animationController.d.ts

@@ -0,0 +1,43 @@
+export class AddonAnimationController {
+    constructor(format_version: any, definition: any);
+    format_version: any;
+    definition: any;
+    toJson(): {
+        format_version: any;
+        animation_controllers: any;
+    };
+}
+export class AddonAnimationStateMachine {
+    constructor(identifier: any);
+    identifier: any;
+    namespace: any;
+    name: any;
+    initialState: string | null;
+    states: Map<any, any>;
+    /**
+     * 设置状态机的初始状态。
+     * @param {string} stateName - 初始状态的名称。
+     * @returns {AddonAnimationStateMachine} - 返回实例以支持链式调用。
+     */
+    setInitialState(stateName: string): AddonAnimationStateMachine;
+    /**
+     * 添加一个新状态到状态机。
+     * @param {string} stateName - 状态的名称。
+     * @param {string[]} animations - 该状态播放的动画列表。
+     * @returns {AddonAnimationStateMachine} - 返回实例以支持链式调用。
+     */
+    addState(stateName: string, animations?: string[]): AddonAnimationStateMachine;
+    /**
+     * 添加一个状态之间的过渡条件。
+     * @param {string} fromState - 过渡的起始状态名称。
+     * @param {string} toState - 过渡的目标状态名称。
+     * @param {string} condition - 触发过渡的条件（例如 "q.is_on_ground"）。
+     * @returns {AddonAnimationStateMachine} - 返回实例以支持链式调用。
+     */
+    addTransition(fromState: string, toState: string, condition: string): AddonAnimationStateMachine;
+    /**
+     * 将整个状态机转换为 JSON 兼容的对象。
+     * @returns {object} - 包含格式版本的完整动画控制器定义。
+     */
+    toJson(): object;
+}

package/dist/core/addon/controllers/animationController.js

@@ -0,0 +1,73 @@
+export class AddonAnimationController {
+    constructor(format_version, definition) {
+        this.format_version = format_version;
+        this.definition = definition;
+    }
+    toJson() {
+        return {
+            format_version: this.format_version,
+            ["animation_controllers"]: this.definition
+        };
+    }
+}
+export class AddonAnimationStateMachine {
+    constructor(identifier) {
+        this.identifier = identifier; // 状态机的唯一标识符（例如 "helicopter.blade"）
+        this.namespace = identifier.split(":")[0]; // 标识符的命名空间部分（冒号前的部分）
+        this.name = identifier.split(":")[1]; // 标识符的名称部分（冒号后的部分）
+        // 状态机属性
+        this.initialState = null; // 状态机的初始状态
+        this.states = new Map(); // 使用 Map 存储所有状态，键为状态名，值为状态数据
+    }
+    /**
+     * 设置状态机的初始状态。
+     * @param {string} stateName - 初始状态的名称。
+     * @returns {AddonAnimationStateMachine} - 返回实例以支持链式调用。
+     */
+    setInitialState(stateName) {
+        this.initialState = stateName;
+        return this; // 支持链式调用
+    }
+    /**
+     * 添加一个新状态到状态机。
+     * @param {string} stateName - 状态的名称。
+     * @param {string[]} animations - 该状态播放的动画列表。
+     * @returns {AddonAnimationStateMachine} - 返回实例以支持链式调用。
+     */
+    addState(stateName, animations = []) {
+        this.states.set(stateName, {
+            animations: animations, // 该状态的动画列表
+            transitions: [] // 该状态的过渡条件列表
+        });
+        return this; // 支持链式调用
+    }
+    /**
+     * 添加一个状态之间的过渡条件。
+     * @param {string} fromState - 过渡的起始状态名称。
+     * @param {string} toState - 过渡的目标状态名称。
+     * @param {string} condition - 触发过渡的条件（例如 "q.is_on_ground"）。
+     * @returns {AddonAnimationStateMachine} - 返回实例以支持链式调用。
+     */
+    addTransition(fromState, toState, condition) {
+        if (!this.states.has(fromState)) {
+            throw new Error(`状态 "${fromState}" 不存在。`);
+        }
+        const state = this.states.get(fromState);
+        state.transitions.push({
+            [toState]: condition // 添加过渡条件
+        });
+        return this; // 支持链式调用
+    }
+    /**
+     * 将整个状态机转换为 JSON 兼容的对象。
+     * @returns {object} - 包含格式版本的完整动画控制器定义。
+     */
+    toJson() {
+        return {
+            [`controller.animation.${this.namespace}.${this.name}`]: {
+                initial_state: this.initialState,
+                states: Object.fromEntries(this.states)
+            }
+        };
+    }
+}

package/dist/core/addon/controllers/render_controllers.js

@@ -0,0 +1,162 @@
+/**
+ * 表示 Minecraft 插件中的渲染控制器组。
+ * 该类用于管理一组渲染控制器，并提供添加、设置和转换为 JSON 的方法。
+ */
+export class AddonRenderControllerGroup {
+    /**
+     * 创建一个新的 AddonRenderControllerGroup 实例。
+     * @param {string} format_version - 渲染控制器的格式版本。
+     * @param {Map} [render_controllers] - 渲染控制器的 Map（可选）。默认为空 Map。
+     */
+    constructor(format_version, render_controllers) {
+        /**
+         * 渲染控制器的格式版本。
+         * @type {string}
+         */
+        this.format_version = format_version;
+        /**
+         * 渲染控制器的 Map，键为标识符，值为渲染控制器。
+         * @type {Map<string, AddonRenderController>}
+         */
+        this.render_controllers = render_controllers || new Map();
+    }
+    /**
+     * 设置或更新组中的渲染控制器。
+     * @param {string} identifier - 渲染控制器的唯一标识符。
+     * @param {AddonRenderController} render_controller - 要添加或更新的渲染控制器。
+     */
+    setRenderController(identifier, render_controller) {
+        this.render_controllers.set(identifier, render_controller);
+        return this; // 支持链式调用
+    }
+    /**
+     * 使用渲染控制器的标识符将其添加到组中。
+     * @param {AddonRenderController} render_controller - 要添加的渲染控制器。
+     */
+    addRenderController(render_controller) {
+        this.render_controllers.set(render_controller.name, render_controller.toJson());
+        return this; // 支持链式调用
+    }
+    /**
+     * 将渲染控制器组转换为 JSON 对象。
+     * @returns {Object} - 渲染控制器组的 JSON 表示。
+     */
+    toJson() {
+        return {
+            format_version: this.format_version,
+            render_controllers: Object.fromEntries(this.render_controllers)
+        };
+    }
+}
+/**
+ * 表示 Minecraft 插件中的渲染控制器。
+ * 该类定义了用于渲染实体的几何体、材质、纹理和数组。
+ */
+export class AddonRenderController {
+    /**
+     * 创建一个新的 AddonRenderController 实例。
+     * @param {string} name - 渲染控制器的名称。
+     */
+    constructor(name) {
+        /**
+         * 渲染控制器的名称。
+         * @type {string}
+         */
+        this.name = `render_controller.${name}`;
+        /**
+         * 数组集合（例如纹理、几何体）。
+         * @type {Object}
+         */
+        this.arrays = {};
+        /**
+         * 用于渲染的默认几何体。
+         * @type {string}
+         */
+        this.geometry = "Geometry.default";
+        /**
+         * 用于渲染的材质列表。
+         * @type {Array<string>}
+         */
+        this.material = [];
+        /**
+         * 用于渲染的纹理列表。
+         * @type {Array<string>}
+         */
+        this.texture = [];
+    }
+    /**
+     * 设置渲染控制器的默认几何体。
+     * @param {string} geometry - 要设置的几何体。
+     */
+    setGeometry(geometry) {
+        this.geometry = geometry;
+        return this; // 支持链式调用
+    }
+    /**
+     * 向材质列表中添加一个材质。
+     * @param {string} material - 要添加的材质。
+     */
+    addMaterial(material) {
+        this.material.push(material);
+        return this; // 支持链式调用
+    }
+    /**
+     * 向纹理列表中添加一个纹理。
+     * @param {string} texture - 要添加的纹理。
+     */
+    addTexture(texture) {
+        this.texture.push(texture);
+        return this; // 支持链式调用
+    }
+    /**
+     * 注册一个数组。
+     * @param {string} name - 数组的名称。
+     * @param {Array} array - 要注册的数组。
+     */
+    registerArray(name, array) {
+        this.arrays[`Array.${name}`] = { [name]: array };
+        return this; // 支持链式调用
+    }
+    /**
+     * 注册几何体数组。
+     * @param {Array} array - 要注册的几何体数组。
+     */
+    registerGeometriesArray(array) {
+        this.registerArray("geometries", array);
+        return this; // 支持链式调用
+    }
+    /**
+     * 注册纹理数组。
+     * @param {Array} array - 要注册的纹理数组。
+     */
+    registerTexturesArray(array) {
+        this.registerArray("textures", array);
+        return this; // 支持链式调用
+    }
+    /**
+     * 将渲染控制器转换为 JSON 对象。
+     * @returns {Object} - 渲染控制器的 JSON 表示。
+     */
+    toJson() {
+        return {
+            arrays: this.arrays,
+            geometry: this.geometry,
+            material: this.material,
+            texture: this.texture
+        };
+    }
+}
+/*
+// 示例用法
+const renderControllerGroup = new AddonRenderControllerGroup("1.10.0");
+
+const renderController = new AddonRenderController("custom_entity");
+renderController.setGeometry("Geometry.custom");
+renderController.addMaterial("Material.default");
+renderController.addTexture("Texture.default");
+renderController.registerTexturesArray(["Texture.variant_1", "Texture.variant_2"]);
+
+renderControllerGroup.addRenderController(renderController);
+
+console.log(JSON.stringify(renderControllerGroup.toJson(), null, 4));
+*/