cocos2d-cli 1.2.1 → 1.4.0

package/src/commands/remove.js

@@ -1,97 +1,161 @@
 /**
- * remove 命令 - 删除节点或组件
+ * remove 命令 - 统一的删除命令
+ * 支持删除节点和组件
  */
 
-const { loadScene, saveScene, collectNodeAndChildren, rebuildReferences, refreshEditor, loadScriptMap, buildTree } = require('../lib/fire-utils');
+const { loadScene, saveScene, rebuildReferences, refreshEditor, loadScriptMap } = require('../lib/fire-utils');
+const { outputError, outputSuccess } = require('../lib/utils');
+const { buildTree, collectNodeAndChildren, detectItemType } = require('../lib/node-utils');
+
+/**
+ * 删除组件
+ */
+function removeComponent(data, compIndex) {
+    const compData = data[compIndex];
+    if (!compData) {
+        return { error: `组件索引 ${compIndex} 不存在` };
+    }
+    
+    const compType = compData.__type__;
+    const nodeId = compData.node?.__id__;
+    
+    if (nodeId === undefined) {
+        return { error: `索引 ${compIndex} 不是组件` };
+    }
+    
+    const node = data[nodeId];
+    if (!node) {
+        return { error: `组件关联的节点 ${nodeId} 不存在` };
+    }
+    
+    const nodeName = node._name || '(unnamed)';
+    
+    // 从节点的 _components 中移除引用
+    if (node._components) {
+        node._components = node._components.filter(c => c.__id__ !== compIndex);
+    }
+    
+    // 重建引用并删除组件
+    const indicesToDelete = new Set([compIndex]);
+    rebuildReferences(data, indicesToDelete);
+    data.splice(compIndex, 1);
+    
+    return {
+        success: true,
+        type: 'component',
+        componentType: compType,
+        componentIndex: compIndex,
+        nodeName,
+        nodeIndex: nodeId
+    };
+}
+
+/**
+ * 删除节点
+ */
+function removeNode(data, nodeIndex) {
+    const node = data[nodeIndex];
+    if (!node) {
+        return { error: `节点索引 ${nodeIndex} 不存在` };
+    }
+    
+    if (nodeIndex <= 1) {
+        return { error: '不能删除根节点' };
+    }
+    
+    const nodeName = node._name || '(unnamed)';
+    
+    // 收集所有需要删除的索引
+    const indicesToDelete = collectNodeAndChildren(data, nodeIndex);
+    
+    // 从父节点的 _children 中移除引用
+    if (node._parent) {
+        const parentIndex = node._parent.__id__;
+        const parent = data[parentIndex];
+        if (parent && parent._children) {
+            parent._children = parent._children.filter(c => c.__id__ !== nodeIndex);
+        }
+    }
+    
+    // 重建引用
+    rebuildReferences(data, indicesToDelete);
+    
+    // 删除元素
+    const sortedIndices = Array.from(indicesToDelete).sort((a, b) => b - a);
+    for (const idx of sortedIndices) {
+        data.splice(idx, 1);
+    }
+    
+    return {
+        success: true,
+        type: 'node',
+        nodeName,
+        nodeIndex,
+        deletedCount: sortedIndices.length
+    };
+}
 
 function run(args) {
     if (args.length < 2) {
-        console.log(JSON.stringify({ error: '用法: cocos2.4 remove <场景文件路径> <索引>' }));
+        outputError('用法: cocos2d-cli remove <场景文件路径> <索引> [--component|--node]');
         return;
     }
     
     const scenePath = args[0];
     
-    // 索引必须是数字
     if (!/^\d+$/.test(args[1])) {
-        console.log(JSON.stringify({ error: '索引必须是数字，请先用 tree 命令查看节点索引' }));
+        outputError('索引必须是数字，请先用 tree 命令查看节点索引');
         return;
     }
     
     const index = parseInt(args[1]);
+    const forceComponent = args.includes('--component');
+    const forceNode = args.includes('--node');
+    
+    if (forceComponent && forceNode) {
+        outputError('不能同时指定 --component 和 --node');
+        return;
+    }
     
     try {
         let data = loadScene(scenePath);
-        const scriptMap = loadScriptMap(scenePath);
         
-        // 检查索引是否存在
         if (!data[index]) {
-            console.log(JSON.stringify({ error: `索引 ${index} 不存在` }));
+            outputError(`索引 ${index} 不存在`);
             return;
         }
         
-        const item = data[index];
-        const itemType = item.__type__;
-        
-        // 判断是节点还是组件
-        const isNode = itemType === 'cc.Node' || itemType === 'cc.Scene' || item._name !== undefined;
-        const isComponent = item.node !== undefined;
-        
-        if (isNode && index <= 1) {
-            console.log(JSON.stringify({ error: '不能删除根节点' }));
-            return;
+        // 确定删除类型
+        let deleteType;
+        if (forceComponent) {
+            deleteType = 'component';
+        } else if (forceNode) {
+            deleteType = 'node';
+        } else {
+            deleteType = detectItemType(data, index);
         }
         
-        if (isComponent) {
-            // 删除组件
-            const nodeId = item.node.__id__;
-            const node = data[nodeId];
-            
-            if (node && node._components) {
-                node._components = node._components.filter(c => c.__id__ !== index);
-            }
-            
-            // 真正从数组中删除组件并重建引用
-            const indicesToDelete = new Set([index]);
-            rebuildReferences(data, indicesToDelete);
-            data.splice(index, 1);
-            
+        // 执行删除
+        let result;
+        if (deleteType === 'component') {
+            result = removeComponent(data, index);
         } else {
-            // 删除节点
-            // 收集所有需要删除的索引
-            const indicesToDelete = collectNodeAndChildren(data, index);
-            
-            // 从父节点的 _children 中移除引用
-            if (item._parent) {
-                const parentIndex = item._parent.__id__;
-                const parent = data[parentIndex];
-                if (parent && parent._children) {
-                    parent._children = parent._children.filter(c => c.__id__ !== index);
-                }
-            }
-            
-            // 重建引用
-            rebuildReferences(data, indicesToDelete);
-            
-            // 删除元素
-            const sortedIndices = Array.from(indicesToDelete).sort((a, b) => b - a);
-            for (const idx of sortedIndices) {
-                data.splice(idx, 1);
-            }
+            result = removeNode(data, index);
+        }
+        
+        if (result.error) {
+            outputError(result.error);
+            return;
         }
         
         // 保存场景
         saveScene(scenePath, data);
-        
-        // 触发编辑器刷新
         refreshEditor(scenePath);
         
-        // 重新加载并显示最新树
-        data = loadScene(scenePath);
-        console.log(buildTree(data, scriptMap, 1));
+        outputSuccess(result);
         
     } catch (err) {
-        console.log(JSON.stringify({ error: err.message }));
+        outputError(err.message);
     }
 }
 

package/src/commands/set.js

@@ -1,271 +1,42 @@
 /**
- * set 命令 - 修改节点属性 
- * 修改成功后返回节点最终状态（与 get 命令格式一致）
+ * set 命令 - 修改节点属性
  */
 
 const { loadScene, saveScene, buildMaps, findNodeIndex, refreshEditor } = require('../lib/fire-utils');
-
-/**
- * 将 _color 对象转为 #RRGGBB 字符串
- */
-function colorToHex(color) {
-    if (!color) return '#ffffff';
-    const r = (color.r || 0).toString(16).padStart(2, '0');
-    const g = (color.g || 0).toString(16).padStart(2, '0');
-    const b = (color.b || 0).toString(16).padStart(2, '0');
-    return `#${r}${g}${b}`;
-}
-
-/**
- * 提取组件的关键属性（对应 Inspector 面板显示）
- */
-function extractComponentProps(comp) {
-    if (!comp) return null;
-    const type = comp.__type__;
-    const base = comp._enabled ? { type } : { type, enabled: false };
-
-    const clean = (obj) => {
-        if (!obj || typeof obj !== 'object') return obj;
-        if (Array.isArray(obj)) return obj.map(clean);
-        const result = {};
-        for (const [k, v] of Object.entries(obj)) {
-            if (k === '__type__') continue;
-            result[k] = typeof v === 'object' ? clean(v) : v;
-        }
-        return result;
-    };
-
-    switch (type) {
-        case 'cc.Sprite':
-            return {
-                ...base,
-                spriteFrame: comp._spriteFrame?.__uuid__ || null,
-                sizeMode: ['CUSTOM', 'TRIMMED', 'RAW'][comp._sizeMode] || comp._sizeMode,
-                spriteType: ['SIMPLE', 'SLICED', 'TILED', 'FILLED', 'MESH'][comp._type] || comp._type,
-                trim: comp._isTrimmedMode
-            };
-        case 'cc.Label':
-            return {
-                ...base,
-                string: comp._string,
-                fontSize: comp._fontSize,
-                lineHeight: comp._lineHeight,
-                horizontalAlign: ['LEFT', 'CENTER', 'RIGHT'][comp._N$horizontalAlign] || comp._N$horizontalAlign,
-                verticalAlign: ['TOP', 'CENTER', 'BOTTOM'][comp._N$verticalAlign] || comp._N$verticalAlign,
-                overflow: ['NONE', 'CLAMP', 'SHRINK', 'RESIZE_HEIGHT'][comp._N$overflow] || comp._N$overflow,
-                fontFamily: comp._N$fontFamily,
-                enableWrapText: comp._enableWrapText
-            };
-        case 'cc.Button':
-            return {
-                ...base,
-                interactable: comp._N$interactable,
-                transition: ['NONE', 'COLOR', 'SPRITE', 'SCALE'][comp._N$transition] || comp._N$transition,
-                zoomScale: comp.zoomScale,
-                duration: comp.duration
-            };
-        case 'cc.Widget':
-            return {
-                ...base,
-                alignMode: ['ONCE', 'ON_WINDOW_RESIZE', 'ALWAYS'][comp.alignMode] || comp.alignMode,
-                left: comp._left,
-                right: comp._right,
-                top: comp._top,
-                bottom: comp._bottom
-            };
-        case 'cc.Layout':
-            return {
-                ...base,
-                layoutType: ['NONE', 'HORIZONTAL', 'VERTICAL', 'GRID'][comp._N$layoutType] || comp._N$layoutType,
-                spacingX: comp._N$spacingX,
-                spacingY: comp._N$spacingY,
-                paddingLeft: comp._N$paddingLeft,
-                paddingRight: comp._N$paddingRight,
-                paddingTop: comp._N$paddingTop,
-                paddingBottom: comp._N$paddingBottom
-            };
-        case 'cc.Canvas':
-            return {
-                ...base,
-                designResolution: clean(comp._designResolution),
-                fitWidth: comp._fitWidth,
-                fitHeight: comp._fitHeight
-            };
-        case 'cc.Camera':
-            return {
-                ...base,
-                depth: comp._depth,
-                zoomRatio: comp._zoomRatio,
-                ortho: comp._ortho,
-                cullingMask: comp._cullingMask
-            };
-        case 'cc.ParticleSystem':
-            return {
-                ...base,
-                playOnLoad: comp.playOnLoad,
-                totalParticles: comp.totalParticles,
-                duration: comp.duration
-            };
-        default:
-            const result = { ...base };
-            for (const key of Object.keys(comp)) {
-                if (!key.startsWith('_') && key !== '__type__') {
-                    result[key] = comp[key];
-                }
-            }
-            return result;
-    }
-}
-
-// 解析颜色
-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;
-}
-
-/**
- * 获取节点的完整状态（与 get 命令一致）
- */
-function getNodeState(data, node, nodeIndex) {
-    const trs = node._trs?.array || [0,0,0, 0,0,0,1, 1,1,1];
-    const components = (node._components || []).map(ref => extractComponentProps(data[ref.__id__]));
-    const children = (node._children || []).map(ref => data[ref.__id__]?._name || '(unknown)');
-
-    const result = {
-        name: node._name,
-        active: node._active,
-        position: { x: trs[0], y: trs[1] },
-        rotation: node._eulerAngles?.z ?? 0,
-        scale: { x: trs[7], y: trs[8] },
-        anchor: { x: node._anchorPoint?.x ?? 0.5, y: node._anchorPoint?.y ?? 0.5 },
-        size: { w: node._contentSize?.width ?? 0, h: node._contentSize?.height ?? 0 },
-        color: colorToHex(node._color),
-        opacity: node._opacity ?? 255,
-        group: node._groupIndex ?? 0
-    };
-
-    if (children.length > 0) result.children = children;
-    if (components.length > 0) result.components = components;
-
-    return result;
-}
+const { parseOptions, outputError, outputJson } = require('../lib/utils');
+const { setNodeProperties, getNodeState } = require('../lib/node-utils');
 
 function run(args) {
     if (args.length < 2) {
-        console.log(JSON.stringify({ error: '用法: cocos2.4 set <场景.fire | 预制体.prefab> <节点索引|名称> [选项]' }));
+        outputError('用法: cocos2d-cli set <场景.fire | 预制体.prefab> <节点索引|名称> [选项]');
         return;
     }
     
     const scenePath = args[0];
     const nodeRef = args[1];
-    
-    // 解析选项
-    const options = {};
-    args.slice(2).forEach(arg => {
-        if (arg.startsWith('--')) {
-            const [key, value] = arg.substring(2).split('=');
-            options[key] = value;
-        }
-    });
+    const options = parseOptions(args, 2);
     
     try {
         const data = loadScene(scenePath);
         const { indexMap } = buildMaps(data);
         
-        // 查找节点
         const nodeIndex = findNodeIndex(data, indexMap, nodeRef);
         
         if (nodeIndex === null || !data[nodeIndex]) {
-            console.log(JSON.stringify({ error: `找不到节点: ${nodeRef}` }));
+            outputError(`找不到节点: ${nodeRef}`);
             return;
         }
         
         const node = data[nodeIndex];
         
-        // 修改名称
-        if (options.name !== undefined) {
-            node._name = options.name;
-        }
-        
-        // 修改激活状态
-        if (options.active !== undefined) {
-            node._active = options.active !== 'false';
-        }
-        
-        // 修改位置
-        if (options.x !== undefined || options.y !== undefined) {
-            if (!node._trs) {
-                node._trs = { "__type__": "TypedArray", "ctor": "Float64Array", "array": [0, 0, 0, 0, 0, 0, 1, 1, 1, 1] };
-            }
-            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 || options.height !== undefined) {
-            if (!node._contentSize) {
-                node._contentSize = { "__type__": "cc.Size", width: 0, height: 0 };
-            }
-            if (options.width !== undefined) node._contentSize.width = parseFloat(options.width);
-            if (options.height !== undefined) node._contentSize.height = parseFloat(options.height);
-        }
-        
-        // 修改锚点
-        if (options.anchorX !== undefined || options.anchorY !== undefined) {
-            if (!node._anchorPoint) {
-                node._anchorPoint = { "__type__": "cc.Vec2", x: 0.5, y: 0.5 };
-            }
-            if (options.anchorX !== undefined) node._anchorPoint.x = parseFloat(options.anchorX);
-            if (options.anchorY !== undefined) node._anchorPoint.y = parseFloat(options.anchorY);
-        }
+        // 设置节点属性
+        setNodeProperties(node, options);
         
-        // 修改透明度
-        if (options.opacity !== undefined) {
-            node._opacity = Math.max(0, Math.min(255, parseInt(options.opacity)));
-        }
-        
-        // 修改颜色
-        if (options.color !== undefined) {
-            const color = parseColor(options.color);
-            if (color) {
-                node._color = color;
-            }
-        }
-        
-        // 修改旋转角度
-        if (options.rotation !== undefined) {
-            if (!node._eulerAngles) {
-                node._eulerAngles = { "__type__": "cc.Vec3", x: 0, y: 0, z: 0 };
-            }
-            node._eulerAngles.z = parseFloat(options.rotation);
-        }
-        
-        // 修改缩放
-        if (options.scaleX !== undefined || options.scaleY !== undefined) {
-            if (!node._trs) {
-                node._trs = { "__type__": "TypedArray", "ctor": "Float64Array", "array": [0, 0, 0, 0, 0, 0, 1, 1, 1, 1] };
-            }
-            if (options.scaleX !== undefined) node._trs.array[7] = parseFloat(options.scaleX);
-            if (options.scaleY !== undefined) node._trs.array[8] = parseFloat(options.scaleY);
-        }
-        
-        // 修改 Label 文字内容及字体属性
+        // 修改 Label 文字属性
         if (options.string !== undefined || options.fontSize !== undefined || options.lineHeight !== undefined) {
             const labelComp = (node._components || []).map(ref => data[ref.__id__]).find(c => c && c.__type__ === 'cc.Label');
             if (!labelComp) {
-                console.log(JSON.stringify({ error: `节点 ${node._name} 没有 cc.Label 组件，无法设置文字属性` }));
+                outputError(`节点 ${node._name} 没有 cc.Label 组件，无法设置文字属性`);
                 return;
             }
             if (options.string !== undefined) {
@@ -280,16 +51,12 @@ function run(args) {
             }
         }
         
-        // 保存场景
         saveScene(scenePath, data);
-        
-        // 触发编辑器刷新
         refreshEditor(scenePath);
         
-        // 返回节点最终状态（与 get 命令格式一致）
-        console.log(JSON.stringify(getNodeState(data, node, nodeIndex)));
+        outputJson(getNodeState(data, node, nodeIndex));
     } catch (err) {
-        console.log(JSON.stringify({ error: err.message }));
+        outputError(err.message);
     }
 }
 

package/src/commands/tree.js

@@ -2,13 +2,14 @@
  * tree 命令 - 查看节点树（支持场景和预制体）
  */
 
-const { loadScene, loadScriptMap, buildTree, isPrefab } = require('../lib/fire-utils');
+const { loadScene, loadScriptMap, isPrefab } = require('../lib/fire-utils');
+const { buildTree } = require('../lib/node-utils');
 
 function run(args) {
     const filePath = args[0];
     
     if (!filePath) {
-        console.log(JSON.stringify({ error: '用法: cocos2.4 tree <场景.fire | 预制体.prefab>' }));
+        console.log(JSON.stringify({ error: '用法: cocos2d-cli tree <场景.fire | 预制体.prefab>' }));
         return;
     }
     
@@ -30,4 +31,4 @@ function run(args) {
     }
 }
 
-module.exports = { run };
+module.exports = { run };

package/src/lib/components/button.js

@@ -0,0 +1,137 @@
+/**
+ * cc.Button 组件
+ */
+
+const { generateId } = require('../utils');
+
+const BUTTON_NORMAL_SPRITE = { "__uuid__": "f0048c10-f03e-4c97-b9d3-3506e1d58952" };
+const BUTTON_PRESSED_SPRITE = { "__uuid__": "e9ec654c-97a2-4787-9325-e6a10375219a" };
+const BUTTON_DISABLED_SPRITE = { "__uuid__": "29158224-f8dd-4661-a796-1ffab537140e" };
+
+// 属性映射
+const PROP_MAP = {
+    'interactable': '_N$interactable',
+    'transition': '_N$transition',
+    'zoomScale': 'zoomScale',
+    'duration': 'duration',
+    'target': '_N$target'
+};
+
+// 枚举值
+const ENUMS = {
+    transition: ['NONE', 'COLOR', 'SPRITE', 'SCALE']
+};
+
+/**
+ * 创建 Button 组件
+ * @param {number} nodeId - 节点索引
+ * @returns {object} 组件数据
+ */
+function create(nodeId) {
+    return {
+        "__type__": "cc.Button",
+        "_name": "",
+        "_objFlags": 0,
+        "node": { "__id__": nodeId },
+        "_enabled": true,
+        "_normalMaterial": null,
+        "_grayMaterial": null,
+        "duration": 0.1,
+        "zoomScale": 1.2,
+        "clickEvents": [],
+        "_N$interactable": true,
+        "_N$enableAutoGrayEffect": false,
+        "_N$transition": 3,
+        "transition": 3,
+        "_N$normalColor": {
+            "__type__": "cc.Color",
+            "r": 255,
+            "g": 255,
+            "b": 255,
+            "a": 255
+        },
+        "_N$pressedColor": {
+            "__type__": "cc.Color",
+            "r": 200,
+            "g": 200,
+            "b": 200,
+            "a": 255
+        },
+        "pressedColor": {
+            "__type__": "cc.Color",
+            "r": 200,
+            "g": 200,
+            "b": 200,
+            "a": 255
+        },
+        "_N$hoverColor": {
+            "__type__": "cc.Color",
+            "r": 255,
+            "g": 255,
+            "b": 255,
+            "a": 255
+        },
+        "hoverColor": {
+            "__type__": "cc.Color",
+            "r": 255,
+            "g": 255,
+            "b": 255,
+            "a": 255
+        },
+        "_N$disabledColor": {
+            "__type__": "cc.Color",
+            "r": 120,
+            "g": 120,
+            "b": 120,
+            "a": 200
+        },
+        "_N$normalSprite": BUTTON_NORMAL_SPRITE,
+        "_N$pressedSprite": BUTTON_PRESSED_SPRITE,
+        "pressedSprite": BUTTON_PRESSED_SPRITE,
+        "_N$hoverSprite": BUTTON_NORMAL_SPRITE,
+        "hoverSprite": BUTTON_NORMAL_SPRITE,
+        "_N$disabledSprite": BUTTON_DISABLED_SPRITE,
+        "_N$target": null,
+        "_id": generateId()
+    };
+}
+
+/**
+ * 应用属性
+ * @param {object} comp - 组件对象
+ * @param {object} props - 属性对象
+ */
+function applyProps(comp, props) {
+    if (!props) return;
+    
+    for (const [key, value] of Object.entries(props)) {
+        const compKey = PROP_MAP[key];
+        if (compKey) {
+            comp[compKey] = value;
+        }
+    }
+}
+
+/**
+ * 提取属性（用于显示）
+ * @param {object} comp - 组件对象
+ * @returns {object} 提取的属性
+ */
+function extractProps(comp) {
+    return {
+        interactable: comp._N$interactable,
+        transition: ENUMS.transition[comp._N$transition] || comp._N$transition,
+        zoomScale: comp.zoomScale,
+        duration: comp.duration
+    };
+}
+
+module.exports = {
+    type: 'button',
+    ccType: 'cc.Button',
+    create,
+    applyProps,
+    extractProps,
+    PROP_MAP,
+    ENUMS
+};