sapdon 2.0.0

package/src/cli/init.js

@@ -0,0 +1,69 @@
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { checkPath, copyFolder, saveFile, readFile } from './utils.js';
+import fs from "fs";
+
+// 获取当前文件的路径
+const __filename = fileURLToPath(import.meta.url);
+// 获取当前文件的目录
+const __dirname = path.dirname(__filename);
+
+
+
+export const initProject = (projectPath, data) => {
+    //检查项目目录是否存在
+    //如果不存在则创建项目目录
+    //从模板下载项目文件
+    //根据用户输入的项目信息生成项目配置文件
+    //根据用户选择是否生成脚本文件，生成脚本文件
+    if(!checkPath(projectPath)) {
+        console.log("项目名称已存在，创建项目目录失败");
+        return;
+    }
+    //模版目录
+    const templateDir = path.join(__dirname, "../templates/test_sapdon");
+    copyFolder(templateDir, projectPath);
+
+    //生成模组介绍文件
+    saveFile(path.join(projectPath, "mod.info"), JSON.stringify(data, null, 2));
+}
+
+export const initNPMProject = (projectPath, data) => {
+    //检查项目文件是否存在
+    //如果不存在则创建项目
+    //从模板下载项目文件
+    //根据用户输入的项目信息生成项目配置文件
+    //根据用户选择是否生成脚本文件，生成脚本文件
+    if(!checkPath(path.join(projectPath, "mod.info"))||!checkPath(path.join(projectPath, "main.mjs"))||!checkPath(path.join(projectPath, "scripts"))||!checkPath(path.join(projectPath, "build.config"))) {
+        console.log("项目已存在...");
+        return;
+    }
+    //模版目录
+    const templateDir = path.join(__dirname, "../templates/test_sapdon");
+    copyFolder(templateDir, projectPath);
+
+    //生成模组介绍文件
+    saveFile(path.join(projectPath, "mod.info"), JSON.stringify(data, null, 2));
+}
+
+// 读取package.json文件并提取信息
+export const readPackageJson = (dir) => {
+    const packageJsonPath = path.join(dir, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            return {
+                name: path.basename(dir),
+                description: packageJson.description || "A new sapdon project",
+                author: packageJson.author || "Sapdon",
+                version: packageJson.version || "1.0.0"
+            };
+        } catch (error) {
+            console.error("读取package.json文件时出错:", error);
+            return null;
+        }
+    } else {
+        return null;
+    }
+}

package/src/cli/load.js

@@ -0,0 +1,113 @@
+import path from "path";
+import { pathToFileURL } from "url";
+import { saveFile } from "./utils.js";
+import { GRegistry } from "../core/registry.js";
+import { generateBlockTextureJson, generateItemTextureJson} from "./tools/textureSet.js";
+import { FlipbookTextures, ItemTextureManager, terrainTextureManager } from "../core/texture.js";
+
+import { ServerUISystem } from "../core/ui/registry/ServerUISystem.js";
+import { ServerFromSystem, updateServerFormSystem } from "../core/ui/systems/server_form.js";
+
+/**
+ * 处理 blocks.json 数据
+ * @param {Object} data blocks.json 数据
+ * @returns {Object} 处理后的 blocks 数据
+ */
+const processBlocksData = (data) => {
+    const textures_arr = data.textures;
+
+    // 检查 textures 数组长度
+    if (textures_arr.length !== 6) {
+        console.warn(`blocks.json 的 textures 数组长度不为 6，实际长度: ${textures_arr.length}`);
+        return {};
+    }
+
+    // 构建 blocks 数据
+    const blocks = {};
+    blocks[data.identifier] = {
+        textures: {
+            up: textures_arr[0],
+            down: textures_arr[1],
+            east: textures_arr[2],
+            west: textures_arr[3],
+            south: textures_arr[4],
+            north: textures_arr[5]
+        }
+    };
+
+    return blocks;
+};
+
+/**
+ * 加载并执行模组文件
+ * @param {string} modPath 模组文件路径
+ * @param {string} buildPath 构建目录路径
+ */
+export const loadAndExecuteMod = async (modPath, buildPath,projectName) => {
+    try {
+        // 将 modPath 解析为绝对路径
+        const absoluteModPath = path.resolve(modPath);
+
+        // 将路径转换为 file:// URL
+        const fileUrl = pathToFileURL(absoluteModPath).href;
+
+        // 动态加载 JavaScript 文件
+        await import(fileUrl);
+
+        const buildBehDirPath = path.join(buildPath,`${projectName}_BP/`);
+        const buildResDirPath = path.join(buildPath,`${projectName}_RP/`);
+
+        // 初始化 blocks.json 数据
+        const blocksJsonPath = path.join(buildPath, `${projectName}_RP`,"blocks.json");
+        const blocks = {"format_version": "1.20.20"};
+
+        //生成item_texture.json
+        const item_texture_dir = path.join(buildResDirPath,"textures/items");
+        const item_texture_json_path = path.join(buildResDirPath,"textures/item_texture.json")
+        generateItemTextureJson(item_texture_dir,item_texture_json_path,projectName,ItemTextureManager.getItemTextures());
+
+         //生成terrain_texture.json
+        const terrain_texture_dir = path.join(buildResDirPath,"textures/blocks")
+        const terrain_texture_json_path = path.join(buildResDirPath,"textures/terrain_texture.json")
+        generateBlockTextureJson(terrain_texture_dir,terrain_texture_json_path,projectName,terrainTextureManager.getTerrainTextures());
+
+        //生成flipbook_textures.json
+        const flipbook_textures_path = path.join(buildResDirPath,"textures/flipbook_textures.json")
+        saveFile(flipbook_textures_path,JSON.stringify(FlipbookTextures.flipbook_textures,null,2));
+
+        //ui server_form
+        
+        GRegistry.register(ServerFromSystem.name,"resource",ServerFromSystem.path,ServerFromSystem);
+        // 从全局注册表中获取数据
+        const dataList = GRegistry.getDataList();
+        //console.log("dataList:", dataList);
+
+        // 遍历数据并保存到相应的目录
+        dataList.forEach(({ name, root, path: dataPath, data }) => {
+            // 处理 blocks.json 数据
+            if (dataPath === "blocks/") {
+                const processedBlocks = processBlocksData(data);
+                Object.assign(blocks, processedBlocks);
+            }
+
+            // 根据数据类型确定根目录
+            const rootPath = root === "behavior" ?  `${projectName}_BP`: `${projectName}_RP`;
+            const buildRootPath = path.join(buildPath, rootPath);
+
+            // 拼接文件路径
+            const filePath = path.join(buildRootPath, dataPath, `${name}.json`);
+
+            // 保存文件
+            saveFile(filePath, JSON.stringify(data.toJson(), null, 2));
+        });
+
+        // 保存 blocks.json
+        console.log("保存 blocks.json 文件:", blocksJsonPath);
+        saveFile(blocksJsonPath, JSON.stringify(blocks, null, 2));
+
+        console.log(`已加载并执行 ${modPath} 文件！`);
+    } catch (err) {
+        console.error(`加载或执行 ${modPath} 失败：${err.message}`);
+        console.error(err.stack); // 打印堆栈跟踪以便调试
+    }
+};

package/src/cli/tools/textureSet.js

@@ -0,0 +1,115 @@
+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/src/cli/utils.js

@@ -0,0 +1,82 @@
+import fs from "fs";
+import path from "path";
+import downlaod from "download";
+import { randomUUID } from "crypto";
+
+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 checkPath = 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);
+		}
+	});
+};

package/src/core/addon/biome.js

@@ -0,0 +1,29 @@
+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/src/core/addon/block/Block.js

@@ -0,0 +1,49 @@
+import { AddonMenuCategory } from "../menu_category.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/src/core/addon/entity/client_entity.js

@@ -0,0 +1,154 @@
+
+export class AddonClientEntity {
+    /**
+     * 客户端实体类
+     * @param {string} format_version 格式版本
+     * @param {AddonClientEntityDefinition} definitions 实体定义
+     */
+    constructor(format_version, definitions) {
+        this.format_version = format_version;
+        this.definitions = definitions;
+    }
+
+    /**
+     * 将对象转换为 JSON 格式
+     * @returns {Object} JSON 对象
+     */
+    toJson() {
+        return {
+            format_version: this.format_version,
+            ["minecraft:client_entity"]: this.definitions
+        };
+    }
+}
+
+export class AddonClientEntityDefinition {
+    /**
+     * 客户端实体定义类
+     * @param {Description} description 实体描述
+     */
+    constructor(description) {
+        this.description = description;
+    }
+}
+
+export class AddonClientEntityDescription {
+    /**
+     * 实体描述类
+     * @param {string} identifier 实体标识符
+     * @param {string} min_engine_version 最低引擎版本
+     */
+    constructor(identifier, min_engine_version) {
+        this.identifier = identifier;
+        this.min_engine_version = min_engine_version;
+    }
+
+    /**
+     * 添加材质
+     * @param {string} name 材质名称
+     * @param {string} material 材质路径
+     * @returns {AddonClientEntityDescription} 返回当前实例以支持链式调用
+     */
+    addMaterial(name, material) {
+        if (this.materials == undefined) this.materials = {};
+        this.materials[name] = material;
+        return this;
+    }
+
+    /**
+     * 添加纹理
+     * @param {string} name 纹理名称
+     * @param {string} texture 纹理路径
+     * @returns {AddonClientEntityDescription} 返回当前实例以支持链式调用
+     */
+    addTexture(name, texture) {
+        if (this.textures == undefined) this.textures = {};
+        this.textures[name] = texture;
+        return this;
+    }
+
+    /**
+     * 添加几何体
+     * @param {string} name 几何体名称
+     * @param {string} geometry 几何体路径
+     * @returns {AddonClientEntityDescription} 返回当前实例以支持链式调用
+     */
+    addGeometry(name, geometry) {
+        if (this.geometry == undefined) this.geometry = {};
+        this.geometry[name] = geometry;
+        return this;
+    }
+
+    /**
+     * 添加动画
+     * @param {string} name 动画名称
+     * @param {string} animation 动画路径
+     * @returns {AddonClientEntityDescription} 返回当前实例以支持链式调用
+     */
+    addAnimation(name, animation) {
+        if (this.animations == undefined) this.animations = {};
+        this.animations[name] = animation;
+        return this;
+    }
+
+    /**
+     * 添加动画控制器
+     * @param {string} name 控制器名称
+     * @param {string} controller 控制器路径
+     * @returns {AddonClientEntityDescription} 返回当前实例以支持链式调用
+     */
+    addAnimationController(name, controller) {
+        if (this.animation_controllers == undefined) this.animation_controllers = [];
+        this.animation_controllers.push({ [name]: controller });
+        return this;
+    }
+
+    /**
+     * 添加渲染控制器
+     * @param {string} controller 渲染控制器路径
+     * @returns {AddonClientEntityDescription} 返回当前实例以支持链式调用
+     */
+    addRenderController(controller) {
+        if (this.render_controllers == undefined) this.render_controllers = [];
+        this.render_controllers.push(controller);
+        return this;
+    }
+
+    /**
+     * 添加定位器
+     * @param {string} name 定位器名称
+     * @param {Object} locator 定位器数据
+     * @returns {AddonClientEntityDescription} 返回当前实例以支持链式调用
+     */
+    addLocator(name, locator) {
+        if (this.locators == undefined) this.locators = {};
+        this.locators[name] = locator;
+        return this;
+    }
+
+    /**
+     * 设置生成蛋
+     * @param {string} texture 生成蛋纹理
+     * @param {number} texture_index 生成蛋纹理索引
+     * @returns {AddonClientEntityDescription} 返回当前实例以支持链式调用
+     */
+    setSpawnEgg(texture, texture_index) {
+        this.spawn_egg = {
+            texture: texture,
+            texture_index: texture_index
+        };
+        return this;
+    }
+
+    /**
+     * 设置脚本
+     * @param {string} key 脚本键
+     * @param {string} value 脚本值
+     * @returns {AddonClientEntityDescription} 返回当前实例以支持链式调用
+     */
+    setScript(key, value) {
+        if (this.scripts == undefined) this.scripts = {};
+        this.scripts[key] = value;
+        return this;
+    }
+}

package/src/core/addon/entity/entity.js

@@ -0,0 +1,52 @@
+export class AddonEntity {
+    /**
+     * 实体类
+     * @param {string} format_version 格式版本
+     * @param {AddonEntityDefinition} definitions 实体定义
+     */
+    constructor(format_version, definitions) {
+        this.format_version = format_version;
+        this.definitions = definitions;
+    }
+
+    /**
+     * 将对象转换为 JSON 格式
+     * @returns {Object} JSON 对象
+     */
+    toJson() {
+        return {
+            format_version: this.format_version,
+            ["minecraft:entity"]: this.definitions
+        };
+    }
+}
+
+export class AddonEntityDefinition {
+    /**
+     * 实体定义类
+     * @param {AddonEntityDescription} description 实体描述
+     * @param {Object} components 实体组件
+     */
+    constructor(description, components = {}, component_groups = {}, events = {}) {
+        this.description = description;
+        this.components = components; // 修正拼写错误
+        this.component_groups = component_groups;
+        this.events = events;   
+    }
+}
+
+export class AddonEntityDescription {
+    /**
+     * 实体描述类
+     * @param {string} identifier 实体标识符
+     * @param {boolean} is_spawnable 是否可生成
+     * @param {boolean} is_summonable 是否可召唤
+     * @param {string} runtime_identifier 复刻标识符
+     */
+    constructor(identifier, is_spawnable = false, is_summonable = false, runtime_identifier) {
+        this.identifier = identifier;
+        this.is_spawnable = is_spawnable;
+        this.is_summonable = is_summonable;
+        this.runtime_identifier = runtime_identifier;
+    }
+}

package/src/core/addon/feature/ore_feature.js

@@ -0,0 +1,26 @@
+export class AddonOreFeature {
+    constructor(format_version,definition) {
+        this.format_version = format_version;
+        this.definition = definition;
+    }
+    toJson(){
+        return {
+            format_version: this.format_version,
+            ["minecraft:ore_feature"]: this.definition
+        }
+    }
+}
+
+export class AddonOreFeatureDescription {
+    constructor(identifier){
+        this.identifier = identifier;
+    }
+}
+
+export class AddonOreFeatureDefinition {
+    constructor(description,count,replace_rules){
+        this.description = description;
+        this.count = count;
+        this.replace_rules = replace_rules;
+    }
+}