cocos2d-cli 1.2.1 → 1.5.0

package/src/commands/add.js

@@ -1,356 +1,177 @@
 /**
- * add 命令 - 添加节点（支持场景和预制体）
- * 
- * 预制体正确结构（深度优先遍历）：
- *   节点 → 子节点(递归) → 组件 → PrefabInfo
- * 
- * 示例：
- * [1] Node (根) _prefab -> [最后]
- * [2] Node (子1) _prefab -> [6]
- * [3] Node (孙) _prefab -> [5]
- * [4] Component (孙的组件)
- * [5] PrefabInfo (孙的)
- * [6] Component (子1的组件)
- * [7] PrefabInfo (子1的)
- * [8] PrefabInfo (根的，在最后)
+ * add 命令 - 添加节点
  */
 
-const { loadScene, saveScene, buildMaps, refreshEditor, isPrefab, generateFileId } = require('../lib/fire-utils');
-const { Components, createNodeData } = require('../lib/components');
+const path = require('path');
+const fs = require('fs');
+const { CCNode, CCSceneAsset, CCPrefab, CCCanvas, CCWidget, CCSprite, CCLabel, CCButton } = require('../lib/cc');
+const { buildTree } = require('../lib/node-utils');
+const { loadScriptMap, isPrefab } = require('../lib/fire-utils');
+const { generateCompressedUUID } = require('../lib/utils');
 
 /**
- * 获取根节点 PrefabInfo 的索引（预制体最后一个元素）
+ * 解析命令行选项
  */
-function getRootPrefabInfoIndex(data) {
-    for (let i = data.length - 1; i >= 0; i--) {
-        if (data[i].__type__ === 'cc.PrefabInfo') {
-            const rootRef = data[i].root?.__id__;
-            if (rootRef === 1) return i;
+function parseOptions(args, startIndex) {
+    const options = {};
+    for (let i = startIndex; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const eqIndex = arg.indexOf('=');
+            if (eqIndex > 0) {
+                const key = arg.substring(2, eqIndex);
+                let value = arg.substring(eqIndex + 1);
+                if (!isNaN(value) && value !== '') {
+                    value = parseFloat(value);
+                }
+                options[key] = value;
+            }
         }
     }
-    return data.length - 1;
+    return options;
 }
 
 /**
- * 获取节点子树的结束索引（子节点 → 组件 → PrefabInfo）
+ * 创建组件
  */
-function getSubtreeEndIndex(data, nodeIndex) {
-    const node = data[nodeIndex];
-    if (!node) return nodeIndex;
-    
-    let lastIndex = nodeIndex;
-    
-    // 递归处理所有子节点
-    if (node._children) {
-        for (const childRef of node._children) {
-            const childEnd = getSubtreeEndIndex(data, childRef.__id__);
-            lastIndex = Math.max(lastIndex, childEnd);
-        }
-    }
-    
-    // 处理组件
-    if (node._components) {
-        for (const compRef of node._components) {
-            lastIndex = Math.max(lastIndex, compRef.__id__);
-        }
-    }
-    
-    // PrefabInfo 在最后（根节点的除外，它在整个数组最后）
-    if (node._prefab && nodeIndex !== 1) {
-        lastIndex = Math.max(lastIndex, node._prefab.__id__);
+function createComponent(type) {
+    switch (type.toLowerCase()) {
+        case 'canvas': return new CCCanvas();
+        case 'widget': return new CCWidget();
+        case 'sprite': return new CCSprite();
+        case 'label': return new CCLabel();
+        case 'button': return new CCButton();
+        default: return null;
     }
-    
-    return lastIndex;
 }
 
 /**
- * 重建所有 __id__ 引用
+ * 查找节点
  */
-function rebuildReferences(data, insertIndex, count) {
-    const indexMap = {};
+function findNode(root, path) {
+    if (!path) return root;
     
-    for (let oldIndex = 0; oldIndex < data.length; oldIndex++) {
-        if (oldIndex < insertIndex) {
-            indexMap[oldIndex] = oldIndex;
-        } else {
-            indexMap[oldIndex] = oldIndex + count;
-        }
-    }
+    const parts = path.split('/').filter(p => p);
+    if (parts.length === 0) return root;
     
-    function updateRef(obj) {
-        if (!obj || typeof obj !== 'object') return;
-        
-        if (obj.__id__ !== undefined) {
-            const oldId = obj.__id__;
-            if (indexMap[oldId] !== undefined) {
-                obj.__id__ = indexMap[oldId];
-            }
-        } else {
-            for (const key of Object.keys(obj)) {
-                updateRef(obj[key]);
-            }
-        }
+    let current = root;
+    
+    // 如果路径以根节点名称开始，跳过
+    if (parts[0] === root._name) {
+        parts.shift();
     }
     
-    for (const item of data) {
-        updateRef(item);
+    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 indexMap;
+    return current;
 }
 
 function run(args) {
     if (args.length < 3) {
-        console.log(JSON.stringify({ error: '用法: cocos2.4 add <场景.fire | 预制体.prefab> <父节点索引> <节点名称> [选项]' }));
+        console.log(JSON.stringify({ error: '用法: cocos2d-cli add <场景.fire|预制体.prefab> <父节点路径> <节点名称> [--type=组件类型] [--x=N] [--y=N]' }));
         return;
     }
     
     const filePath = args[0];
-    const parentRef = args[1];
+    const parentPath = args[1];
     const nodeName = args[2];
+    const options = parseOptions(args, 3);
     
-    // 解析选项
-    const options = {};
-    args.slice(3).forEach(arg => {
-        if (arg.startsWith('--')) {
-            const [key, value] = arg.substring(2).split('=');
-            if (key === 'type') options.type = value;
-            else if (key === 'x') options.x = parseFloat(value) || 0;
-            else if (key === 'y') options.y = parseFloat(value) || 0;
-            else if (key === 'width') options.width = parseFloat(value) || 0;
-            else if (key === 'height') options.height = parseFloat(value) || 0;
-            else if (key === 'at') options.at = parseInt(value);
-            else if (key === 'active') options.active = value !== 'false';
-            else if (key === 'color') options.color = value;
-            else if (key === 'fontSize') options.fontSize = parseInt(value) || 40;
-            else if (key === 'string') options.string = value || '';
-        }
-    });
+    const ext = path.extname(filePath).toLowerCase();
     
     try {
-        const data = loadScene(filePath);
-        const { prefab } = buildMaps(data);
+        let root;
+        let asset;
+        const json = JSON.parse(fs.readFileSync(filePath, 'utf8'));
         
-        if (!/^\d+$/.test(parentRef)) {
-            console.log(JSON.stringify({ error: '父节点必须使用数字索引，请先用 tree 命令查看节点索引' }));
+        if (ext === '.fire') {
+            asset = CCSceneAsset.fromJSON(json);
+            root = asset._scene;
+        } else if (ext === '.prefab') {
+            asset = CCPrefab.fromJSON(json);
+            root = asset._root;
+        } else {
+            console.log(JSON.stringify({ error: '不支持的文件类型，仅支持 .fire 和 .prefab' }));
             return;
         }
         
-        const parentIndex = parseInt(parentRef);
+        const parent = findNode(root, parentPath);
         
-        if (parentIndex < 0 || parentIndex >= data.length || !data[parentIndex]) {
-            console.log(JSON.stringify({ error: `无效的节点索引: ${parentRef}` }));
+        if (!parent) {
+            console.log(JSON.stringify({ error: `父节点不存在: ${parentPath}` }));
             return;
         }
         
-        const parentNode = data[parentIndex];
-        const isRootChild = prefab && parentIndex === 1;
-        
-        // 确定插入位置：紧跟父节点之后（在父节点的子节点/组件/PrefabInfo之前）
-        let insertIndex;
+        // 创建节点
+        const node = new CCNode(nodeName);
         
-        if (!parentNode._children || parentNode._children.length === 0) {
-            // 父节点还没有子节点，插入到父节点之后
-            insertIndex = parentIndex + 1;
-        } else {
-            // 父节点已有子节点，根据 --at 参数确定位置
-            const targetPosition = options.at >= 0 ? options.at : parentNode._children.length;
-            
-            if (targetPosition === 0) {
-                // 插入到第一个子节点之前
-                insertIndex = parentNode._children[0].__id__;
-            } else if (targetPosition >= parentNode._children.length) {
-                // 插入到最后一个子节点之后
-                const lastChildRef = parentNode._children[parentNode._children.length - 1];
-                insertIndex = getSubtreeEndIndex(data, lastChildRef.__id__) + 1;
-            } else {
-                // 插入到中间
-                insertIndex = parentNode._children[targetPosition].__id__;
-            }
+        // 应用属性
+        if (options.x !== undefined) node._trs.array[0] = parseFloat(options.x);
+        if (options.y !== undefined) node._trs.array[1] = parseFloat(options.y);
+        if (options.width !== undefined) node._contentSize.width = parseFloat(options.width);
+        if (options.height !== undefined) node._contentSize.height = parseFloat(options.height);
+        if (options.scaleX !== undefined) node._trs.array[7] = parseFloat(options.scaleX);
+        if (options.scaleY !== undefined) node._trs.array[8] = parseFloat(options.scaleY);
+        if (options.rotation !== undefined) {
+            node._trs.array[5] = parseFloat(options.rotation) * Math.PI / 180;
+            node._eulerAngles.z = parseFloat(options.rotation);
+        }
+        if (options.active !== undefined) {
+            node._active = options.active !== 'false' && options.active !== false;
         }
         
-        let newNodeIndex;
-        
-        if (prefab) {
-            // 预制体模式
-            // 找到根节点的 PrefabInfo
-            const rootPrefabInfoOldIdx = getRootPrefabInfoIndex(data);
-            const rootPrefabInfo = data[rootPrefabInfoOldIdx];
-            
-            // 创建节点
-            const nodeData = {
-                "__type__": "cc.Node",
-                "_name": nodeName,
-                "_objFlags": 0,
-                "_parent": { "__id__": parentIndex },
-                "_children": [],
-                "_active": options.active !== false,
-                "_components": [],
-                "_prefab": null,
-                "_opacity": 255,
-                "_color": parseColor(options.color) || { "__type__": "cc.Color", "r": 255, "g": 255, "b": 255, "a": 255 },
-                "_contentSize": { "__type__": "cc.Size", "width": options.width || 0, "height": options.height || 0 },
-                "_anchorPoint": { "__type__": "cc.Vec2", "x": 0.5, "y": 0.5 },
-                "_trs": { "__type__": "TypedArray", "ctor": "Float64Array", "array": [options.x || 0, options.y || 0, 0, 0, 0, 0, 1, 1, 1, 1] },
-                "_eulerAngles": { "__type__": "cc.Vec3", "x": 0, "y": 0, "z": 0 },
-                "_skewX": 0,
-                "_skewY": 0,
-                "_is3DNode": false,
-                "_groupIndex": 0,
-                "groupIndex": 0,
-                "_id": ""
-            };
-            
-            // 创建组件（如果有）
-            let compData = null;
-            if (options.type) {
-                compData = Components[options.type]?.(insertIndex);
-                // 修改组件属性
-                if (compData) {
-                    if (options.type === 'label') {
-                        if (options.fontSize) {
-                            compData._fontSize = options.fontSize;
-                            compData._lineHeight = options.fontSize;
-                        }
-                        if (options.string) {
-                            compData._string = options.string;
-                            compData._N$string = options.string;
-                        }
+        // 添加组件
+        if (options.type) {
+            const comp = createComponent(options.type);
+            if (comp) {
+                comp.node = node;
+                node._components = [comp];
+                
+                // 组件特殊属性
+                if (options.type.toLowerCase() === 'label') {
+                    if (options.string) {
+                        comp._string = options.string;
+                        comp['_N$string'] = options.string;
                     }
-                }
-            }
-            
-            // 创建 PrefabInfo
-            const prefabInfo = {
-                "__type__": "cc.PrefabInfo",
-                "root": { "__id__": 1 },
-                "asset": { "__id__": 0 },
-                "fileId": generateFileId(),
-                "sync": false
-            };
-            
-            // 构建要插入的元素：节点 → 组件 → PrefabInfo
-            const itemsToInsert = [nodeData];
-            if (compData) itemsToInsert.push(compData);
-            itemsToInsert.push(prefabInfo);
-            
-            // 如果是根节点的子节点，先移除根 PrefabInfo
-            if (isRootChild) {
-                // 如果插入位置在根 PrefabInfo 之后，需要调整
-                if (insertIndex > rootPrefabInfoOldIdx) {
-                    insertIndex--;
-                }
-                data.splice(rootPrefabInfoOldIdx, 1);
-            }
-            
-            // 插入元素
-            for (let i = 0; i < itemsToInsert.length; i++) {
-                data.splice(insertIndex + i, 0, itemsToInsert[i]);
-            }
-            
-            // 重建引用
-            rebuildReferences(data, insertIndex, itemsToInsert.length);
-            
-            newNodeIndex = insertIndex;
-            
-            // 设置引用
-            if (compData) {
-                compData.node = { "__id__": newNodeIndex };
-                nodeData._components.push({ "__id__": newNodeIndex + 1 });
-                nodeData._prefab = { "__id__": newNodeIndex + 2 };
-            } else {
-                nodeData._prefab = { "__id__": newNodeIndex + 1 };
-            }
-            
-            // 如果是根节点的子节点，把根 PrefabInfo 添加到最后
-            if (isRootChild) {
-                data.push(rootPrefabInfo);
-                data[1]._prefab = { "__id__": data.length - 1 };
-            }
-            
-        } else {
-            // 场景模式：节点 + 组件
-            const newNode = createNodeData(nodeName, parentIndex, options);
-            
-            if (options.color) {
-                const color = parseColor(options.color);
-                if (color) newNode._color = color;
-            }
-            
-            const itemsToInsert = [newNode];
-            
-            let compData = null;
-            if (options.type) {
-                compData = Components[options.type]?.(insertIndex);
-                // 修改组件属性
-                if (compData) {
-                    if (options.type === 'label') {
-                        if (options.fontSize) {
-                            compData._fontSize = options.fontSize;
-                            compData._lineHeight = options.fontSize;
-                        }
-                        if (options.string) {
-                            compData._string = options.string;
-                            compData._N$string = options.string;
-                        }
+                    if (options.fontSize) {
+                        comp._fontSize = parseInt(options.fontSize);
+                        comp._lineHeight = parseInt(options.fontSize);
                     }
                 }
-                if (compData) itemsToInsert.push(compData);
-            }
-            
-            for (let i = 0; i < itemsToInsert.length; i++) {
-                data.splice(insertIndex + i, 0, itemsToInsert[i]);
-            }
-            
-            rebuildReferences(data, insertIndex, itemsToInsert.length);
-            
-            newNodeIndex = insertIndex;
-            
-            if (compData) {
-                compData.node = { "__id__": newNodeIndex };
-                newNode._components.push({ "__id__": newNodeIndex + 1 });
             }
         }
         
-        // 更新父节点的 _children
-        if (!parentNode._children) parentNode._children = [];
-        const insertPosition = options.at >= 0 ? options.at : parentNode._children.length;
-        parentNode._children.splice(insertPosition, 0, { "__id__": newNodeIndex });
+        // 添加节点到父节点
+        parent._children = parent._children || [];
+        parent._children.push(node);
+        node._parent = parent;
         
-        // 保存文件
-        saveScene(filePath, data);
+        // 场景节点需要 _id，预制体需要 PrefabInfo
+        if (ext === '.fire') {
+            node._id = generateCompressedUUID();
+        } else if (ext === '.prefab') {
+            const { CCPrefabInfo } = require('../lib/cc');
+            node._prefab = new CCPrefabInfo();
+        }
         
-        // 触发编辑器刷新
-        refreshEditor(filePath);
+        // 保存
+        const data = asset.toJSON();
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
         
-        console.log(JSON.stringify({ 
-            success: true, 
-            nodeIndex: newNodeIndex,
-            name: nodeName,
-            parent: parentRef,
-            type: prefab ? 'prefab' : 'scene'
-        }));
+        // 输出节点树
+        const scriptMap = loadScriptMap(filePath);
+        const prefab = isPrefab(data);
+        const startIndex = prefab ? 0 : 1;
+        console.log(buildTree(data, scriptMap, startIndex).trim());
         
     } catch (err) {
         console.log(JSON.stringify({ error: err.message }));
     }
 }
 
-function parseColor(colorStr) {
-    if (!colorStr) return null;
-    let color = colorStr;
-    if (typeof color === 'string') {
-        if (color.startsWith('#')) color = color.slice(1);
-        if (color.length === 6) {
-            const r = parseInt(color.slice(0, 2), 16);
-            const g = parseInt(color.slice(2, 4), 16);
-            const b = parseInt(color.slice(4, 6), 16);
-            if (!isNaN(r) && !isNaN(g) && !isNaN(b)) {
-                return { "__type__": "cc.Color", r, g, b, a: 255 };
-            }
-        }
-    }
-    return null;
-}
-
 module.exports = { run };

package/src/commands/build.js

@@ -7,7 +7,7 @@ const path = require('path');
 
 function run(args) {
     if (args.length < 1) {
-        console.log(JSON.stringify({ error: '用法: cocos-cli build <项目目录>' }));
+        console.log(JSON.stringify({ error: '用法: cocos2d-cli build <项目目录>' }));
         return;
     }