cocos2d-cli 1.0.3

package/src/commands/get.js

@@ -0,0 +1,53 @@
+/**
+ * get 命令 - 获取节点信息
+ */
+
+const { loadScene, buildMaps, findNodeIndex } = require('../lib/fire-utils');
+
+function run(args) {
+    if (args.length < 2) {
+        console.log(JSON.stringify({ error: '用法: cocos2.4 get <场景文件路径> <节点索引|名称>' }));
+        return;
+    }
+    
+    const scenePath = args[0];
+    const nodeRef = args[1];
+    
+    try {
+        const data = loadScene(scenePath);
+        const { indexMap } = buildMaps(data);
+        
+        // 查找节点
+        const idx = findNodeIndex(data, indexMap, nodeRef);
+        
+        if (idx === null || idx < 0 || idx >= data.length) {
+            console.log(JSON.stringify({ error: `无效的节点索引: ${nodeRef}` }));
+            return;
+        }
+        
+        const node = data[idx];
+        if (!node) {
+            console.log(JSON.stringify({ error: `节点不存在: ${nodeRef}` }));
+            return;
+        }
+        
+        // 返回节点信息
+        const info = indexMap[idx] || {};
+        console.log(JSON.stringify({
+            success: true,
+            index: idx,
+            ...info,
+            node: {
+                active: node._active,
+                position: node._trs?.array?.slice(0, 2) || [0, 0],
+                size: node._contentSize || { width: 0, height: 0 },
+                children: node._children?.map(c => c.__id__) || [],
+                components: node._components?.map(c => c.__id__) || []
+            }
+        }, null, 2));
+    } catch (err) {
+        console.log(JSON.stringify({ error: err.message }));
+    }
+}
+
+module.exports = { run };

package/src/commands/remove-component.js

@@ -0,0 +1,63 @@
+/**
+ * remove-component 命令 - 删除节点上的组件
+ */
+
+const { loadScene, saveScene } = require('../lib/fire-utils');
+
+function run(args) {
+    if (args.length < 2) {
+        console.log('用法: cocos2.4 remove-component <场景文件路径> <组件索引>');
+        return;
+    }
+    
+    const scenePath = args[0];
+    const compIndex = parseInt(args[1]);
+    
+    if (isNaN(compIndex)) {
+        console.log('错误: 组件索引必须是数字');
+        return;
+    }
+    
+    try {
+        const data = loadScene(scenePath);
+        
+        // 检查组件数据是否存在
+        const compData = data[compIndex];
+        if (!compData) {
+            console.log(`错误: 组件索引 ${compIndex} 不存在`);
+            return;
+        }
+        
+        const compType = compData.__type__;
+        const nodeId = compData.node?.__id__;
+        
+        if (nodeId === undefined) {
+            console.log(`错误: 组件 ${compIndex} 没有关联的节点`);
+            return;
+        }
+        
+        const node = data[nodeId];
+        if (!node) {
+            console.log(`错误: 组件关联的节点 ${nodeId} 不存在`);
+            return;
+        }
+        
+        // 从节点的 _components 中移除引用
+        if (node._components) {
+            node._components = node._components.filter(c => c.__id__ !== compIndex);
+        }
+        
+        // 从数组中删除组件（设为 null，保持索引）
+        data[compIndex] = null;
+        
+        // 保存场景
+        saveScene(scenePath, data);
+        
+        console.log(`已删除组件: ${compType} (索引: ${compIndex})`);
+        console.log(`从节点: ${node._name || '(unnamed)'} (索引: ${nodeId})`);
+    } catch (err) {
+        console.log(`错误: ${err.message}`);
+    }
+}
+
+module.exports = { run };

package/src/commands/remove.js

@@ -0,0 +1,163 @@
+/**
+ * remove 命令 - 删除节点或组件
+ */
+
+const { loadScene, saveScene, buildMaps, collectNodeAndChildren, rebuildReferences, refreshEditor, installPlugin } = require('../lib/fire-utils');
+const fs = require('fs');
+const path = require('path');
+
+// 加载脚本映射
+function loadScriptMap(scenePath) {
+    const projectPath = path.dirname(path.dirname(scenePath));
+    const mapPath = path.join(projectPath, 'data', 'script_map.json');
+    try {
+        if (fs.existsSync(mapPath)) {
+            return JSON.parse(fs.readFileSync(mapPath, 'utf-8'));
+        }
+    } catch (e) {}
+    return {};
+}
+
+// 构建树形结构
+function buildTree(data, scriptMap, nodeIndex, prefix = '', isLast = true, isRoot = true) {
+    const node = data[nodeIndex];
+    if (!node) return '';
+    
+    const nodeName = isRoot ? 'Root' : (node._name || '(unnamed)');
+    const active = node._active !== false ? '●' : '○';
+    const uuidRegex = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+    
+    let result = prefix + (isRoot ? '' : active + ' ') + nodeName + ' #' + nodeIndex;
+    
+    // 添加组件信息
+    if (node._components && node._components.length > 0) {
+        const comps = node._components.map(c => {
+            const comp = data[c.__id__];
+            if (!comp) return `? #${c.__id__}`;
+            const typeName = comp.__type__;
+            let displayName;
+            if (uuidRegex.test(typeName)) {
+                const scriptInfo = scriptMap[typeName];
+                if (scriptInfo && scriptInfo.name) {
+                    displayName = scriptInfo.name;
+                } else {
+                    displayName = '⚠️MissingScript';
+                }
+            } else if (typeName === 'MissingScript') {
+                displayName = '⚠️MissingScript';
+            } else {
+                displayName = typeName.replace('cc.', '');
+            }
+            return `${displayName} #${c.__id__}`;
+        }).join(', ');
+        result += ` (${comps})`;
+    }
+    
+    result += '\n';
+    
+    // 处理子节点
+    if (node._children && node._children.length > 0) {
+        node._children.forEach((childRef, idx) => {
+            const childIsLast = idx === node._children.length - 1;
+            const childPrefix = prefix + (isRoot ? '' : (isLast ? '    ' : '│   '));
+            result += buildTree(data, scriptMap, childRef.__id__, childPrefix, childIsLast, false);
+        });
+    }
+    
+    return result;
+}
+
+function run(args) {
+    if (args.length < 2) {
+        console.log('用法: cocos2.4 remove <场景文件路径> <索引>');
+        return;
+    }
+    
+    const scenePath = args[0];
+    
+    // 安装 CLI Helper 插件（如果不存在）
+    installPlugin(scenePath);
+    
+    const index = parseInt(args[1]);
+    
+    if (isNaN(index)) {
+        console.log('错误: 索引必须是数字');
+        return;
+    }
+    
+    try {
+        let data = loadScene(scenePath);
+        const scriptMap = loadScriptMap(scenePath);
+        
+        // 检查索引是否存在
+        if (!data[index]) {
+            console.log(`错误: 索引 ${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('错误: 不能删除根节点');
+            return;
+        }
+        
+        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);
+            
+        } 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);
+            }
+        }
+        
+        // 保存场景
+        saveScene(scenePath, data);
+        
+        // 触发编辑器刷新
+        refreshEditor(scenePath);
+        
+        // 重新加载并显示最新树
+        data = loadScene(scenePath);
+        console.log(buildTree(data, scriptMap, 1));
+        
+    } catch (err) {
+        console.log(`错误: ${err.message}`);
+    }
+}
+
+module.exports = { run };

package/src/commands/set.js

@@ -0,0 +1,163 @@
+/**
+ * set 命令 - 修改节点属性
+ */
+
+const { loadScene, saveScene, buildMaps, findNodeIndex, refreshEditor } = require('../lib/fire-utils');
+
+// 解析颜色
+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;
+}
+
+function run(args) {
+    if (args.length < 2) {
+        console.log(JSON.stringify({ error: '用法: cocos2.4 set <场景文件路径> <节点索引|名称> [选项]' }));
+        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;
+        }
+    });
+    
+    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}` }));
+            return;
+        }
+        
+        const node = data[nodeIndex];
+        const changes = {};
+        
+        // 修改名称
+        if (options.name !== undefined) {
+            const oldName = node._name;
+            node._name = options.name;
+            changes.name = { from: oldName, to: options.name };
+        }
+        
+        // 修改激活状态
+        if (options.active !== undefined) {
+            const oldActive = node._active;
+            node._active = options.active !== 'false';
+            changes.active = { from: oldActive, to: node._active };
+        }
+        
+        // 修改位置
+        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] };
+            }
+            const oldX = node._trs.array[0];
+            const oldY = node._trs.array[1];
+            if (options.x !== undefined) node._trs.array[0] = parseFloat(options.x);
+            if (options.y !== undefined) node._trs.array[1] = parseFloat(options.y);
+            changes.position = { from: [oldX, oldY], to: [node._trs.array[0], node._trs.array[1]] };
+        }
+        
+        // 修改大小
+        if (options.width !== undefined || options.height !== undefined) {
+            if (!node._contentSize) {
+                node._contentSize = { "__type__": "cc.Size", width: 0, height: 0 };
+            }
+            const oldW = node._contentSize.width;
+            const oldH = node._contentSize.height;
+            if (options.width !== undefined) node._contentSize.width = parseFloat(options.width);
+            if (options.height !== undefined) node._contentSize.height = parseFloat(options.height);
+            changes.size = { from: { width: oldW, height: oldH }, to: { width: node._contentSize.width, height: node._contentSize.height } };
+        }
+        
+        // 修改锚点
+        if (options.anchorX !== undefined || options.anchorY !== undefined) {
+            if (!node._anchorPoint) {
+                node._anchorPoint = { "__type__": "cc.Vec2", x: 0.5, y: 0.5 };
+            }
+            const oldX = node._anchorPoint.x;
+            const oldY = node._anchorPoint.y;
+            if (options.anchorX !== undefined) node._anchorPoint.x = parseFloat(options.anchorX);
+            if (options.anchorY !== undefined) node._anchorPoint.y = parseFloat(options.anchorY);
+            changes.anchor = { from: [oldX, oldY], to: [node._anchorPoint.x, node._anchorPoint.y] };
+        }
+        
+        // 修改透明度
+        if (options.opacity !== undefined) {
+            const oldOpacity = node._opacity;
+            node._opacity = Math.max(0, Math.min(255, parseInt(options.opacity)));
+            changes.opacity = { from: oldOpacity, to: node._opacity };
+        }
+        
+        // 修改颜色
+        if (options.color !== undefined) {
+            const color = parseColor(options.color);
+            if (color) {
+                node._color = color;
+                changes.color = { to: options.color };
+            }
+        }
+        
+        // 修改旋转角度
+        if (options.rotation !== undefined) {
+            if (!node._eulerAngles) {
+                node._eulerAngles = { "__type__": "cc.Vec3", x: 0, y: 0, z: 0 };
+            }
+            const oldRotation = node._eulerAngles.z;
+            node._eulerAngles.z = parseFloat(options.rotation);
+            changes.rotation = { from: oldRotation, to: node._eulerAngles.z };
+        }
+        
+        // 修改缩放
+        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] };
+            }
+            const oldScaleX = node._trs.array[7];
+            const oldScaleY = node._trs.array[8];
+            if (options.scaleX !== undefined) node._trs.array[7] = parseFloat(options.scaleX);
+            if (options.scaleY !== undefined) node._trs.array[8] = parseFloat(options.scaleY);
+            changes.scale = { from: [oldScaleX, oldScaleY], to: [node._trs.array[7], node._trs.array[8]] };
+        }
+        
+        // 保存场景
+        saveScene(scenePath, data);
+        
+        // 触发编辑器刷新（传入场景路径以重新打开场景）
+        refreshEditor(scenePath);
+        
+        console.log(JSON.stringify({
+            success: true,
+            index: nodeIndex,
+            name: node._name,
+            changes
+        }, null, 2));
+    } catch (err) {
+        console.log(JSON.stringify({ error: err.message }));
+    }
+}
+
+module.exports = { run };

package/src/commands/tree.js

@@ -0,0 +1,92 @@
+/**
+ * tree 命令 - 查看节点树
+ */
+
+const { loadScene, buildMaps } = require('../lib/fire-utils');
+const fs = require('fs');
+const path = require('path');
+
+// 加载脚本映射
+function loadScriptMap(scenePath) {
+    const projectPath = path.dirname(path.dirname(scenePath));
+    const mapPath = path.join(projectPath, 'data', 'script_map.json');
+    try {
+        if (fs.existsSync(mapPath)) {
+            return JSON.parse(fs.readFileSync(mapPath, 'utf-8'));
+        }
+    } catch (e) {}
+    return {};
+}
+
+function run(args) {
+    const scenePath = args[0];
+    
+    if (!scenePath) {
+        console.log(JSON.stringify({ error: '用法: cocos2.4 tree <场景文件路径>' }));
+        return;
+    }
+    
+    try {
+        const data = loadScene(scenePath);
+        const { indexMap } = buildMaps(data);
+        const scriptMap = loadScriptMap(scenePath);
+        const uuidRegex = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+        
+        // 构建树形结构输出
+        function buildTree(nodeIndex, prefix = '', isLast = true, isRoot = true) {
+            const node = data[nodeIndex];
+            if (!node) return '';
+            
+            const nodeName = isRoot ? 'Root' : (node._name || '(unnamed)');
+            const active = node._active !== false ? '●' : '○';
+            const connector = isRoot ? '' : (isLast ? '└── ' : '├── ');
+            
+            let result = prefix + (isRoot ? '' : active + ' ') + nodeName + ' #' + nodeIndex;
+            
+            // 添加组件信息
+            if (node._components && node._components.length > 0) {
+                const comps = node._components.map(c => {
+                    const comp = data[c.__id__];
+                    if (!comp) return `? #${c.__id__}`;
+                    const typeName = comp.__type__;
+                    let displayName;
+                    // 如果是 UUID，尝试从 scriptMap 查找类名
+                    if (uuidRegex.test(typeName)) {
+                        const scriptInfo = scriptMap[typeName];
+                        if (scriptInfo && scriptInfo.name) {
+                            displayName = scriptInfo.name;
+                        } else {
+                            displayName = '⚠️MissingScript';
+                        }
+                    } else if (typeName === 'MissingScript') {
+                        displayName = '⚠️MissingScript';
+                    } else {
+                        displayName = typeName.replace('cc.', '');
+                    }
+                    return `${displayName} #${c.__id__}`;
+                }).join(', ');
+                result += ` (${comps})`;
+            }
+            
+            result += '\n';
+            
+            // 处理子节点
+            if (node._children && node._children.length > 0) {
+                node._children.forEach((childRef, idx) => {
+                    const childIsLast = idx === node._children.length - 1;
+                    const childPrefix = prefix + (isRoot ? '' : (isLast ? '    ' : '│   '));
+                    result += buildTree(childRef.__id__, childPrefix, childIsLast, false);
+                });
+            }
+            
+            return result;
+        }
+        
+        const treeStr = buildTree(1);
+        console.log(treeStr);
+    } catch (err) {
+        console.log(`Error: ${err.message}`);
+    }
+}
+
+module.exports = { run };