cocos2d-cli 1.4.0 → 1.5.1

package/src/commands/create-scene.js

@@ -1,75 +1,120 @@
 /**
- * create-scene 命令 - 从 JSON 结构创建场景文件
+ * create-scene 命令 - 创建场景文件
  */
 
 const fs = require('fs');
 const path = require('path');
-const { outputError, outputSuccess } = require('../lib/utils');
-const { createNodeData } = require('../lib/node-utils');
-const { parseComponent, createComponent, applyComponentProps } = require('../lib/components');
-const { createScene } = require('../lib/templates');
+const { CCNode, CCScene, CCSceneAsset, CCCanvas, CCWidget, CCCamera } = require('../lib/cc');
+const { buildTree } = require('../lib/node-utils');
+const { loadScriptMap, createSceneMeta, saveMetaFile } = require('../lib/fire-utils');
+const { generateUUID, generateCompressedUUID } = require('../lib/utils');
+const { fromJSON } = require('../lib/json-parser');
 
 /**
- * 从 JSON 定义创建场景数据
+ * 从项目配置读取设计分辨率
  */
-function createSceneData(nodeDefs, sceneName) {
-    const data = createScene(sceneName);
+function getDesignResolution(outputPath) {
+    const defaultResolution = { width: 960, height: 640 };
     
-    // Canvas 节点索引
-    const canvasIndex = 2;
-
-    // 支持数组或单个节点
-    const nodes = Array.isArray(nodeDefs) ? nodeDefs : [nodeDefs];
+    let currentDir = path.dirname(path.resolve(outputPath));
+    while (currentDir !== path.dirname(currentDir)) {
+        const settingsPath = path.join(currentDir, 'settings', 'project.json');
+        if (fs.existsSync(settingsPath)) {
+            try {
+                const config = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+                if (config['design-resolution-width'] && config['design-resolution-height']) {
+                    return {
+                        width: config['design-resolution-width'],
+                        height: config['design-resolution-height']
+                    };
+                }
+            } catch (e) {}
+        }
+        currentDir = path.dirname(currentDir);
+    }
     
-    // 添加用户节点到 Canvas
-    for (const nodeDef of nodes) {
-        addUserNode(data, nodeDef, canvasIndex);
+    return defaultResolution;
+}
+
+/**
+ * 从 meta 文件读取 uuid
+ */
+function readUuidFromMeta(scenePath) {
+    const metaPath = scenePath + '.meta';
+    if (fs.existsSync(metaPath)) {
+        try {
+            const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+            return meta.uuid || null;
+        } catch (e) {
+            return null;
+        }
     }
+    return null;
+}
 
-    return data;
+/**
+ * 为节点树设置 _id
+ */
+function setNodeId(node) {
+    node._id = generateCompressedUUID();
+    if (node._children) {
+        node._children.forEach(child => setNodeId(child));
+    }
 }
 
 /**
- * 添加用户节点
+ * 创建默认场景结构（Canvas + Main Camera）
  */
-function addUserNode(data, def, parentIndex) {
-    const nodeIndex = data.length;
-    const node = createNodeData(def.name || 'Node', parentIndex, def);
+function createDefaultScene(asset, resolution) {
+    const { width, height } = resolution;
+    const scene = asset._scene;
     
-    data.push(node);
+    // 创建 Canvas 节点
+    const canvas = new CCNode('Canvas');
+    canvas._contentSize.width = width;
+    canvas._contentSize.height = height;
+    canvas._anchorPoint.x = 0.5;
+    canvas._anchorPoint.y = 0.5;
+    canvas._trs.array[0] = width / 2;
+    canvas._trs.array[1] = height / 2;
+    canvas._is3DNode = false;
+    canvas._id = generateCompressedUUID();
     
-    // 添加组件
-    if (def.components) {
-        for (const compDef of def.components) {
-            const parsed = parseComponent(compDef);
-            if (parsed) {
-                const comp = createComponent(parsed.type, nodeIndex);
-                if (comp) {
-                    applyComponentProps(comp, parsed.props, node);
-                    data.push(comp);
-                    node._components.push({ "__id__": data.length - 1 });
-                }
-            }
-        }
-    }
+    // Canvas 组件
+    const canvasComp = new CCCanvas();
+    canvasComp.setDesignResolution(width, height);
+    canvasComp.node = canvas;
     
-    // 更新父节点的 _children
-    data[parentIndex]._children.push({ "__id__": nodeIndex });
+    // Widget 组件
+    const widget = new CCWidget();
+    widget.node = canvas;
     
-    // 递归处理子节点
-    if (def.children && def.children.length > 0) {
-        for (const childDef of def.children) {
-            addUserNode(data, childDef, nodeIndex);
-        }
-    }
+    canvas._components = [canvasComp, widget];
+    canvas._parent = scene;
+    scene._children = [canvas];
+    
+    // 创建 Main Camera 节点
+    const camera = new CCNode('Main Camera');
+    camera._contentSize.width = 0;
+    camera._contentSize.height = 0;
+    camera._anchorPoint.x = 0.5;
+    camera._anchorPoint.y = 0.5;
+    camera._is3DNode = false;
+    camera._id = generateCompressedUUID();
+    
+    // Camera 组件
+    const cameraComp = new CCCamera();
+    cameraComp.node = camera;
+    
+    camera._components = [cameraComp];
+    camera._parent = canvas;
+    canvas._children = [camera];
 }
 
 function run(args) {
     if (args.length < 1) {
-        outputError({ 
-            message: '用法: cocos2d-cli create-scene [JSON文件路径] <输出路径.fire>',
-            hint: '不传 JSON 则创建默认场景'
-        });
+        console.log(JSON.stringify({ error: '用法: cocos2d-cli create-scene [JSON文件路径] <输出路径.fire>' }));
+        console.log(JSON.stringify({ hint: '不传 JSON 则创建默认场景（含 Canvas 和 Main Camera）' }));
         return;
     }
 
@@ -85,77 +130,56 @@ function run(args) {
 
     const sceneName = path.basename(outputPath, '.fire');
 
-    // 没有传 JSON，创建默认场景
-    if (!jsonPath) {
-        try {
-            if (fs.existsSync(outputPath)) {
-                outputError(`文件已存在: ${outputPath}`);
-                return;
-            }
-            
-            const dir = path.dirname(outputPath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            
-            const data = createScene(sceneName);
-            fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
+    try {
+        // 创建场景
+        const asset = new CCSceneAsset();
+        const scene = new CCScene(sceneName);
+        asset._scene = scene;
+        scene._children = [];
+        
+        // 从 JSON 创建
+        if (jsonPath && fs.existsSync(jsonPath)) {
+            const input = fs.readFileSync(jsonPath, 'utf8');
+            const nodeDef = JSON.parse(input.replace(/^\uFEFF/, '').trim());
             
-            let nodeCount = 0, compCount = 0;
-            for (const item of data) {
-                if (item.__type__ === 'cc.Node') nodeCount++;
-                else if (item.__type__?.startsWith('cc.') && !['cc.Scene', 'cc.SceneAsset'].includes(item.__type__)) {
-                    compCount++;
-                }
+            const nodes = Array.isArray(nodeDef) ? nodeDef : [nodeDef];
+            for (const def of nodes) {
+                const node = fromJSON(def);
+                setNodeId(node);
+                node._parent = scene;
+                scene._children.push(node);
             }
-            
-            outputSuccess({ 
-                path: outputPath,
-                nodes: nodeCount,
-                components: compCount
-            });
-            return;
-        } catch (err) {
-            outputError(err.message);
-            return;
+        } else {
+            // 没有 JSON，创建默认场景结构
+            const resolution = getDesignResolution(outputPath);
+            createDefaultScene(asset, resolution);
         }
-    }
-
-    if (!fs.existsSync(jsonPath)) {
-        outputError(`JSON 文件不存在: ${jsonPath}`);
-        return;
-    }
 
-    try {
-        const input = fs.readFileSync(jsonPath, 'utf8');
-        const cleanInput = input.replace(/^\uFEFF/, '').trim();
-        const nodeDef = JSON.parse(cleanInput);
-
-        const sceneData = createSceneData(nodeDef, sceneName);
-
-        const outputDir = path.dirname(outputPath);
-        if (!fs.existsSync(outputDir)) {
-            fs.mkdirSync(outputDir, { recursive: true });
+        // 确保目录存在
+        const dir = path.dirname(outputPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
         }
 
-        fs.writeFileSync(outputPath, JSON.stringify(sceneData, null, 2), 'utf8');
-
-        let nodeCount = 0, compCount = 0;
-        for (const item of sceneData) {
-            if (item.__type__ === 'cc.Node') nodeCount++;
-            else if (item.__type__?.startsWith('cc.') && !['cc.Scene', 'cc.SceneAsset'].includes(item.__type__)) {
-                compCount++;
-            }
+        // 设置 Scene._id
+        const uuid = readUuidFromMeta(outputPath);
+        scene._id = uuid || generateUUID();
+
+        // 保存
+        const data = asset.toJSON();
+        fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
+        
+        // 生成并保存 meta 文件（如果不存在）
+        if (!uuid) {
+            saveMetaFile(outputPath, createSceneMeta(scene._id));
         }
 
-        outputSuccess({
-            path: outputPath,
-            nodes: nodeCount,
-            components: compCount
-        });
+        // 输出 tree
+        const scriptMap = loadScriptMap(outputPath);
+        console.log(buildTree(data, scriptMap, 1).trim());
 
     } catch (err) {
-        outputError(err.message);
+        console.log(JSON.stringify({ error: err.message }));
     }
 }
 

package/src/commands/get.js

@@ -1,38 +1,133 @@
 /**
- * get 命令 - 获取节点信息
+ * get 命令 - 获取节点或组件属性
  */
 
-const { loadScene, buildMaps, findNodeIndex } = require('../lib/fire-utils');
-const { getNodeState } = require('../lib/node-utils');
+const path = require('path');
+const fs = require('fs');
+const { CCSceneAsset, CCPrefab } = require('../lib/cc');
+
+/**
+ * 查找节点
+ */
+function findNode(root, path) {
+    if (!path) return root;
+    
+    const parts = path.split('/').filter(p => p);
+    if (parts.length === 0) return root;
+    
+    let current = root;
+    
+    if (parts[0] === root._name) {
+        parts.shift();
+    }
+    
+    for (const part of parts) {
+        if (!current._children || current._children.length === 0) return null;
+        const found = current._children.find(c => c._name === part);
+        if (!found) return null;
+        current = found;
+    }
+    
+    return current;
+}
+
+/**
+ * 查找组件
+ */
+function findComponent(node, compType) {
+    if (!node._components) return null;
+    
+    const type = compType.toLowerCase();
+    const typeName = 'cc.' + type.charAt(0).toUpperCase() + type.slice(1);
+    
+    return node._components.find(c => c.__type__ === typeName);
+}
+
+/**
+ * 获取节点属性值
+ */
+function getNodeProp(node, prop) {
+    switch (prop.toLowerCase()) {
+        case 'name': return node._name;
+        case 'active': return node._active;
+        case 'x': return node._trs.array[0];
+        case 'y': return node._trs.array[1];
+        case 'width': return node._contentSize.width;
+        case 'height': return node._contentSize.height;
+        case 'scalex': return node._trs.array[7];
+        case 'scaley': return node._trs.array[8];
+        case 'rotation': return node._eulerAngles.z;
+        case 'anchorx': return node._anchorPoint.x;
+        case 'anchory': return node._anchorPoint.y;
+        case 'opacity': return node._opacity;
+        case 'color': return node._color;
+        default: return undefined;
+    }
+}
 
 function run(args) {
-    if (args.length < 2) {
-        console.log(JSON.stringify({ error: '用法: cocos2d-cli get <场景.fire | 预制体.prefab> <节点索引|名称>' }));
+    if (args.length < 3) {
+        console.log(JSON.stringify({ error: '用法: cocos2d-cli get <场景.fire|预制体.prefab> <节点路径> <属性名|组件.属性>' }));
         return;
     }
     
-    const scenePath = args[0];
-    const nodeRef = args[1];
+    const filePath = args[0];
+    const nodePath = args[1];
+    const propPath = args[2];
+    
+    const ext = path.extname(filePath).toLowerCase();
     
     try {
-        const data = loadScene(scenePath);
-        const { indexMap } = buildMaps(data);
-        
-        const idx = findNodeIndex(data, indexMap, nodeRef);
+        let root;
+        const json = JSON.parse(fs.readFileSync(filePath, 'utf8'));
         
-        if (idx === null || idx < 0 || idx >= data.length) {
-            console.log(JSON.stringify({ error: `无效的节点索引: ${nodeRef}` }));
+        if (ext === '.fire') {
+            const asset = CCSceneAsset.fromJSON(json);
+            root = asset._scene;
+        } else if (ext === '.prefab') {
+            const asset = CCPrefab.fromJSON(json);
+            root = asset._root;
+        } else {
+            console.log(JSON.stringify({ error: '不支持的文件类型，仅支持 .fire 和 .prefab' }));
             return;
         }
         
-        const node = data[idx];
+        const node = findNode(root, nodePath);
+        
         if (!node) {
-            console.log(JSON.stringify({ error: `节点不存在: ${nodeRef}` }));
+            console.log(JSON.stringify({ error: `节点不存在: ${nodePath}` }));
             return;
         }
-
-        console.log(JSON.stringify(getNodeState(data, node, idx)));
-
+        
+        // 检查是否是组件属性（格式: 组件.属性）
+        const parts = propPath.split('.');
+        
+        if (parts.length === 2) {
+            // 组件属性
+            const comp = findComponent(node, parts[0]);
+            if (!comp) {
+                console.log(JSON.stringify({ error: `组件不存在: ${parts[0]}` }));
+                return;
+            }
+            
+            const value = comp[parts[1]];
+            if (value === undefined) {
+                console.log(JSON.stringify({ error: `属性不存在: ${parts[1]}` }));
+                return;
+            }
+            
+            console.log(JSON.stringify({ value }));
+        } else {
+            // 节点属性
+            const value = getNodeProp(node, propPath);
+            if (value === undefined) {
+                console.log(JSON.stringify({ error: `属性不存在: ${propPath}` }));
+                return;
+            }
+            
+            console.log(JSON.stringify({ value }));
+        }
+        
     } catch (err) {
         console.log(JSON.stringify({ error: err.message }));
     }

package/src/commands/prefab-create.js

@@ -4,108 +4,21 @@
 
 const fs = require('fs');
 const path = require('path');
-const { outputError, outputSuccess } = require('../lib/utils');
-const { createNodeData } = require('../lib/node-utils');
-const { parseComponent, createComponent, applyComponentProps } = require('../lib/components');
-const { createPrefab, generateFileId } = require('../lib/templates');
+const { outputError } = require('../lib/utils');
+const { buildTree } = require('../lib/node-utils');
+const { createPrefab } = require('../lib/templates');
+const { CCPrefab, CCPrefabInfo } = require('../lib/cc');
+const { loadScriptMap, createPrefabMeta, saveMetaFile } = require('../lib/fire-utils');
+const { fromJSON } = require('../lib/json-parser');
 
 /**
- * 从 JSON 定义创建预制体数据
+ * 为节点树添加 PrefabInfo
  */
-function createPrefabData(nodeDef) {
-    const data = createPrefab(nodeDef.name || 'Node');
+function addPrefabInfo(node, isRoot = false) {
+    node._prefab = new CCPrefabInfo();
     
-    // 更新根节点
-    const root = data[1];
-    applyNodeDefToNode(root, nodeDef, null);
-    
-    // 递归添加子节点
-    if (nodeDef.children && nodeDef.children.length > 0) {
-        for (const childDef of nodeDef.children) {
-            addChildNode(data, childDef, 1);
-        }
-    }
-    
-    return data;
-}
-
-/**
- * 应用 JSON 定义到节点
- */
-function applyNodeDefToNode(node, def, parentId) {
-    if (def.name) node._name = def.name;
-    if (def.active !== undefined) node._active = def.active;
-    if (def.opacity !== undefined) node._opacity = def.opacity;
-    if (def.width !== undefined) node._contentSize.width = def.width;
-    if (def.height !== undefined) node._contentSize.height = def.height;
-    if (def.x !== undefined) node._trs.array[0] = def.x;
-    if (def.y !== undefined) node._trs.array[1] = def.y;
-    if (def.rotation !== undefined) {
-        node._trs.array[5] = def.rotation * Math.PI / 180;
-        node._eulerAngles.z = def.rotation;
-    }
-    if (def.scaleX !== undefined) node._trs.array[7] = def.scaleX;
-    if (def.scaleY !== undefined) node._trs.array[8] = def.scaleY;
-    if (def.anchorX !== undefined) node._anchorPoint.x = def.anchorX;
-    if (def.anchorY !== undefined) node._anchorPoint.y = def.anchorY;
-    if (def.color) {
-        const { parseColor } = require('../lib/utils');
-        const parsed = parseColor(def.color);
-        if (parsed) {
-            node._color = { "__type__": "cc.Color", ...parsed };
-        }
-    }
-    if (parentId !== null) {
-        node._parent = { "__id__": parentId };
-    }
-}
-
-/**
- * 添加子节点
- */
-function addChildNode(data, def, parentIndex) {
-    const nodeIndex = data.length;
-    const node = createNodeData(def.name || 'Node', parentIndex, def);
-    
-    // 设置 _prefab 为 null，后面会添加 PrefabInfo
-    node._prefab = null;
-    
-    data.push(node);
-    
-    // 添加组件
-    if (def.components) {
-        for (const compDef of def.components) {
-            const parsed = parseComponent(compDef);
-            if (parsed) {
-                const comp = createComponent(parsed.type, nodeIndex);
-                if (comp) {
-                    applyComponentProps(comp, parsed.props, node);
-                    data.push(comp);
-                    node._components.push({ "__id__": data.length - 1 });
-                }
-            }
-        }
-    }
-    
-    // 添加 PrefabInfo
-    const prefabInfo = {
-        "__type__": "cc.PrefabInfo",
-        "root": { "__id__": 1 },
-        "asset": { "__id__": 0 },
-        "fileId": generateFileId(),
-        "sync": false
-    };
-    data.push(prefabInfo);
-    node._prefab = { "__id__": data.length - 1 };
-    
-    // 更新父节点
-    data[parentIndex]._children.push({ "__id__": nodeIndex });
-    
-    // 递归处理子节点
-    if (def.children && def.children.length > 0) {
-        for (const childDef of def.children) {
-            addChildNode(data, childDef, nodeIndex);
-        }
+    if (node._children) {
+        node._children.forEach(child => addPrefabInfo(child, false));
     }
 }
 
@@ -128,11 +41,11 @@ function run(args) {
         outputPath = args[1];
     }
 
-    // 没有传 JSON，创建默认预制体
-    if (!jsonPath) {
-        const prefabName = path.basename(outputPath, '.prefab');
-        
-        try {
+    const prefabName = path.basename(outputPath, '.prefab');
+
+    try {
+        // 没有传 JSON，创建默认预制体
+        if (!jsonPath) {
             if (fs.existsSync(outputPath)) {
                 outputError(`文件已存在: ${outputPath}`);
                 return;
@@ -143,59 +56,56 @@ function run(args) {
                 fs.mkdirSync(dir, { recursive: true });
             }
             
-            const data = createPrefab(prefabName);
+            const prefab = createPrefab(prefabName);
+            const data = prefab.toJSON();
             fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
             
-            outputSuccess({ 
-                path: outputPath,
-                rootName: prefabName,
-                nodes: 1,
-                components: 0
-            });
-            return;
-        } catch (err) {
-            outputError(err.message);
+            // 生成并保存 meta 文件
+            saveMetaFile(outputPath, createPrefabMeta());
+            
+            const scriptMap = loadScriptMap(outputPath);
+            console.log(buildTree(data, scriptMap, 1).trim());
             return;
         }
-    }
 
-    if (!fs.existsSync(jsonPath)) {
-        outputError(`JSON 文件不存在: ${jsonPath}`);
-        return;
-    }
+        // 从 JSON 文件创建
+        if (!fs.existsSync(jsonPath)) {
+            outputError(`JSON 文件不存在: ${jsonPath}`);
+            return;
+        }
 
-    try {
         const input = fs.readFileSync(jsonPath, 'utf8');
-        const cleanInput = input.replace(/^\uFEFF/, '').trim();
-        const nodeDef = JSON.parse(cleanInput);
-
-        const rootNode = Array.isArray(nodeDef) ? nodeDef[0] : nodeDef;
-        const prefabData = createPrefabData(rootNode);
+        const rootNode = fromJSON(input);
+        
+        // 确保根节点名称
+        if (!rootNode._name || rootNode._name === 'Node') {
+            rootNode._name = prefabName;
+        }
+        
+        // 为所有节点添加 PrefabInfo
+        addPrefabInfo(rootNode, true);
+        
+        // 创建预制体
+        const prefab = new CCPrefab();
+        prefab._root = rootNode;
 
         const outputDir = path.dirname(outputPath);
         if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true });
         }
 
-        fs.writeFileSync(outputPath, JSON.stringify(prefabData, null, 2), 'utf8');
-
-        let nodeCount = 0, compCount = 0;
-        for (const item of prefabData) {
-            if (item.__type__ === 'cc.Node') nodeCount++;
-            else if (item.__type__?.startsWith('cc.') && !['cc.Prefab', 'cc.PrefabInfo'].includes(item.__type__)) {
-                compCount++;
-            }
-        }
+        const data = prefab.toJSON();
+        fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
+        
+        // 生成并保存 meta 文件
+        saveMetaFile(outputPath, createPrefabMeta());
 
-        outputSuccess({
-            path: outputPath,
-            nodes: nodeCount,
-            components: compCount
-        });
+        const scriptMap = loadScriptMap(outputPath);
+        console.log(buildTree(data, scriptMap, 1).trim());
 
     } catch (err) {
         outputError(err.message);
     }
 }
 
-module.exports = { run };
+module.exports = { run };