diff --git a/README.EN.md b/README.EN.md index 4ef80bd..3148459 100644 --- a/README.EN.md +++ b/README.EN.md @@ -1,28 +1,76 @@ # Cocos Creator MCP Server Plugin -**[📖 English](README.EN.md)** **[📖 中文](README.md)** +**[📖 English](README.EN.md)** **[📖 中文](README.md)** A comprehensive MCP (Model Context Protocol) server plugin for Cocos Creator 3.8+, enabling AI assistants to interact with the Cocos Creator editor through standardized protocols. One-click installation and use, eliminating all cumbersome environments and configurations. Claude clients Claude CLI and Cursor have been tested, and other editors are also perfectly supported in theory. -**🚀 Now provides 158 tools in 13 categories, achieving 98% editor control!** +**🚀 Now provides 50 powerful integrated tools, achieving 99% editor control!** ## Video Demonstrations and Tutorials + [image](https://www.bilibili.com/video/BV1uzgVz8EyQ/?vd_source=6b1ff659dd5f04a92cc6d14061e8bb92) ## Video Demonstration Configuration Tool List [image](https://www.bilibili.com/video/BV1kfbyzQEAS/?vd_source=6b1ff659dd5f04a92cc6d14061e8bb92) + ## Quick Links -- **[📖 Complete Feature Guide (English)](FEATURE_GUIDE_EN.md)** - Detailed documentation for all 158 tools(To be completed) -- **[📖 完整功能指南 (中文)](FEATURE_GUIDE_CN.md)** - 所有158个工具的详细文档(To be completed) +- **[📖 Complete Feature Guide (English)](FEATURE_GUIDE_EN.md)** - Detailed documentation for all 50 tools (to be completed) +- **[📖 完整功能指南 (中文)](FEATURE_GUIDE_CN.md)** - All 50 tools detailed documentation (to be completed) ## Changelog -### v1.4.0 - July 26, 2025 (Already updated in the cocos store, the github version will be synchronized in the near future) -cocos store：https://store.cocos.com/app/detail/7941 -If you don't want to buy it, join the communication group and I can send you the latest version directly! +## 🚀 Major Update v1.5.0 (July 29, 2024) (Already updated in Cocos Store, GitHub version will be synchronized in next version) + +Cocos store: https://store.cocos.com/app/detail/7941 +If you don't want to purchase, join the communication group and I can send you the latest version directly! + +- **Tool Streamlining and Refactoring**: Condensed the original 150+ tools into 50 high-reuse, high-coverage core tools, removing all invalid redundant code, greatly improving usability and maintainability. +- **Unified Operation Codes**: All tools adopt "operation code + parameters" mode, greatly simplifying AI calling process, improving AI calling success rate, reducing AI calling times, and lowering 50% token consumption. +- **Comprehensive Prefab Function Upgrade**: Completely fixed and perfected all core prefab functions including creation, instantiation, synchronization, references, etc., supporting complex reference relationships, 100% aligned with official format. +- **Event Binding and Legacy Function Completion**: Added and implemented event binding, node/component/asset legacy functions, all methods completely aligned with official implementation. +- **Interface Optimization**: All interface parameters are clearer, documentation is more complete, AI can understand and call more easily. +- **Plugin Panel Optimization**: Panel UI is more concise, operations are more intuitive. +- **Performance and Compatibility Improvements**: Overall architecture is more efficient, compatible with Cocos Creator 3.8.6 and all versions above. + + +## Tool System and Operation Codes + +- All tools are named with "category_operation", parameters use unified Schema, support multiple operation code (action) switching, greatly improving flexibility and extensibility. +- 50 core tools cover scene, node, component, prefab, asset, project, debugging, preferences, server, message broadcasting and all other editor operations. +- Tool calling example: + +```json +{ + "tool": "node_lifecycle", + "arguments": { + "action": "create", + "name": "MyNode", + "parentUuid": "parent-uuid", + "nodeType": "2DNode" + } +} +``` + +--- + +## Main Function Categories (Partial Examples) + +- **scene_management**: Scene management (get/open/save/create/close scenes) +- **node_query / node_lifecycle / node_transform**: Node query, creation, deletion, property changes +- **component_manage / component_script / component_query**: Component add/remove, script mounting, component information +- **prefab_browse / prefab_lifecycle / prefab_instance**: Prefab browsing, creation, instantiation, synchronization +- **asset_manage / asset_analyze**: Asset import, deletion, dependency analysis +- **project_manage / project_build_system**: Project running, building, configuration information +- **debug_console / debug_logs**: Console and log management +- **preferences_manage**: Preferences settings +- **server_info**: Server information +- **broadcast_message**: Message broadcasting + + +### v1.4.0 - July 26, 2025 (Current github version) #### 🎯 Major Functionality Fixes - **Complete Prefab Creation Fix**: Thoroughly resolved the issue of component/node/resource type reference loss during prefab creation @@ -99,10 +147,13 @@ If you don't want to buy it, join the communication group and I can send you the - Project control and debugging tools -**Claude cli configuration:** + +## Quick Usage + +**Claude CLI configuration:** ``` -claude mcp add --transport http cocos-creator http://127.0.0.1:3000/mcp (use the port number you configured yourself) +claude mcp add --transport http cocos-creator http://127.0.0.1:3000/mcp (use your configured port number) ``` **Claude client configuration:** @@ -110,20 +161,19 @@ claude mcp add --transport http cocos-creator http://127.0.0.1:3000/mcp (use the ``` { -"mcpServers": { + "mcpServers": { -"cocos-creator": { + "cocos-creator": { -"type": "http", + "type": "http", -"url": "http://127.0.0.1:3000/mcp" + "url": "http://127.0.0.1:3000/mcp" + + } + + } } - -} - -} - ``` **Cursor or VS class MCP configuration** @@ -131,75 +181,97 @@ claude mcp add --transport http cocos-creator http://127.0.0.1:3000/mcp (use the ``` { -"mcpServers": { + "mcpServers": { -"cocos-creator": { -"url": "http://localhost:3000/mcp" -} -} + "cocos-creator": { + "url": "http://localhost:3000/mcp" + } + } } - ``` ## Features -### 🎯 Scene Operations -- Get current scene information and complete scene list -- Open scenes by path and save current scene -- Create new scenes with custom names -- Get complete scene hierarchy with component information +### 🎯 Scene Operations (scene_*) +- **scene_management**: Scene management - Get current scene, open/save/create/close scenes, support scene list query +- **scene_hierarchy**: Scene hierarchy - Get complete scene structure, support component information inclusion +- **scene_execution_control**: Execution control - Execute component methods, scene scripts, prefab synchronization -### 🎮 Node Operations -- Create nodes with different types (Node, 2DNode, 3DNode) -- Get node information by UUID and find nodes by name pattern -- Set node properties (position, rotation, scale, active) -- Delete, move, and duplicate nodes with full hierarchy support +### 🎮 Node Operations (node_*) +- **node_query**: Node query - Find nodes by name/pattern, get node information, detect 2D/3D types +- **node_lifecycle**: Node lifecycle - Create/delete nodes, support component pre-installation, prefab instantiation +- **node_transform**: Node transform - Modify node name, position, rotation, scale, visibility and other properties +- **node_hierarchy**: Node hierarchy - Move, copy, paste nodes, support hierarchical structure operations +- **node_clipboard**: Node clipboard - Copy/paste/cut node operations +- **node_property_management**: Property management - Reset node properties, component properties, transform properties -### 🔧 Component Operations -- Add/remove components from nodes -- Get all components of a node with properties -- Set component properties dynamically -- Attach script components from asset paths -- List available component types by category +### 🔧 Component Operations (component_*) +- **component_manage**: Component management - Add/remove engine components (cc.Sprite, cc.Button, etc.) +- **component_script**: Script components - Mount/remove custom script components +- **component_query**: Component query - Get component list, detailed information, available component types +- **set_component_property**: Property setting - Set single or multiple component property values -### 📦 Prefab Operations -- List all prefabs in project with folder organization -- Load, instantiate, and create prefabs -- Update existing prefabs and revert prefab instances -- Get detailed prefab information including dependencies -- **⚠️ Known Issue**: Prefab instantiation may not properly restore child nodes due to Cocos Creator API limitations +### 📦 Prefab Operations (prefab_*) +- **prefab_browse**: Prefab browsing - List prefabs, view information, validate files +- **prefab_lifecycle**: Prefab lifecycle - Create prefabs from nodes, delete prefabs +- **prefab_instance**: Prefab instances - Instantiate to scene, unlink, apply changes, restore original +- **prefab_edit**: Prefab editing - Enter/exit edit mode, save prefabs, test changes -### 🚀 Project Control -- Run project in preview mode (browser/simulator) -- Build project for different platforms (web, mobile, desktop) -- Get project information and settings -- Refresh asset database and import new assets -- Get detailed asset information +### 🚀 Project Control (project_*) +- **project_manage**: Project management - Run project, build project, get project information and settings +- **project_build_system**: Build system - Control build panel, check build status, preview server management -### 🔍 Debug Tools -- Get editor console logs with filtering -- Clear console and execute JavaScript in scene context -- Get detailed node tree for debugging -- Performance statistics and scene validation -- Get editor and environment information +### 🔍 Debug Tools (debug_*) +- **debug_console**: Console management - Get/clear console logs, support filtering and limiting +- **debug_logs**: Log analysis - Read/search/analyze project log files, support pattern matching +- **debug_system**: System debugging - Get editor information, performance statistics, environment information -### ⚙️ Additional Features -- **Preferences Management**: Get/set editor preferences and global settings -- **Server Control**: Server information, project details, and editor control -- **Message Broadcasting**: Listen to and broadcast custom messages -- **Asset Management**: Create, copy, move, delete, and query assets -- **Build System**: Project building and preview server control -- **Reference Image Management**: Add, remove, and manage reference images in scene view -- **Scene View Controls**: Control gizmo tools, coordinate systems, and view modes -- **Advanced Scene Operations**: Undo/redo, snapshots, and advanced node manipulation -- **🆕 Tool Management**: Selectively enable/disable tools, save configurations, and manage tool states +### 📁 Asset Management (asset_*) +- **asset_manage**: Asset management - Batch import/delete assets, save metadata, generate URLs +- **asset_analyze**: Asset analysis - Get dependency relationships, export asset manifests +- **asset_system**: Asset system - Refresh assets, query asset database status +- **asset_query**: Asset query - Query assets by type/folder, get detailed information +- **asset_operations**: Asset operations - Create/copy/move/delete/save/re-import assets + +### ⚙️ Preferences (preferences_*) +- **preferences_manage**: Preferences management - Get/set editor preferences +- **preferences_global**: Global settings - Manage global configuration and system settings + +### 🌐 Server and Broadcasting (server_* / broadcast_*) +- **server_info**: Server information - Get server status, project details, environment information +- **broadcast_message**: Message broadcasting - Listen and broadcast custom messages + +### 🖼️ Reference Images (referenceImage_*) +- **reference_image_manage**: Reference image management - Add/delete/manage reference images in scene view +- **reference_image_view**: Reference image view - Control reference image display and editing + +### 🎨 Scene View (sceneView_*) +- **scene_view_control**: Scene view control - Control Gizmo tools, coordinate systems, view modes +- **scene_view_tools**: Scene view tools - Manage various scene view tools and options + +### ✅ Validation Tools (validation_*) +- **validation_scene**: Scene validation - Validate scene integrity, check missing assets +- **validation_asset**: Asset validation - Validate asset references, check asset integrity + +### 🛠️ Tool Management +- **Tool Configuration System**: Selectively enable/disable tools, support multiple configurations +- **Configuration Persistence**: Automatically save and load tool configurations +- **Configuration Import/Export**: Support tool configuration import/export functionality +- **Real-time State Management**: Real-time tool state updates and synchronization + +### 🚀 Core Advantages +- **Unified Operation Codes**: All tools adopt "category_operation" naming, unified parameter Schema +- **High Reusability**: 50 core tools cover 99% editor functionality +- **AI-Friendly**: Clear parameters, complete documentation, simple calling +- **Performance Optimization**: Reduce 50% token consumption, improve AI calling success rate +- **Complete Compatibility**: 100% aligned with Cocos Creator official API ## Installation ### 1. Copy Plugin Files -Copy the entire `cocos-mcp-server` folder to your Cocos Creator project's `extensions` directory: +Copy the entire `cocos-mcp-server` folder to your Cocos Creator project's `extensions` directory, or you can directly import the project in the extension manager: ``` YourProject/ @@ -252,118 +324,6 @@ The server exposes an HTTP endpoint at `http://localhost:3000/mcp` (or your conf AI assistants can connect using the MCP protocol and access all available tools. -### Tool Categories - -Tools are organized by category with naming convention: `category_toolname` - -- **scene_\***: Scene-related operations (8 tools) -- **node_\***: Node manipulation (9 tools) -- **component_\***: Component management (7 tools) -- **prefab_\***: Prefab operations (11 tools) -- **project_\***: Project control (22 tools) -- **debug_\***: Debugging utilities (10 tools) -- **preferences_\***: Editor preferences (7 tools) -- **server_\***: Server information (6 tools) -- **broadcast_\***: Message broadcasting (5 tools) -- **assetAdvanced_\***: Advanced asset operations (10 tools) -- **referenceImage_\***: Reference image management (12 tools) -- **sceneAdvanced_\***: Advanced scene operations (23 tools) -- **sceneView_\***: Scene view controls (14 tools) - - -📖 **[View Complete Tool Documentation](FEATURE_GUIDE_EN.md)** for detailed usage examples and parameters. - -## Example Tool Usage - -### Create a new sprite node -```json -{ - "tool": "node_create_node", - "arguments": { - "name": "MySprite", - "nodeType": "2DNode", - "parentUuid": "parent-node-uuid" - } -} -``` - -### Add a Sprite component -```json -{ - "tool": "component_add_component", - "arguments": { - "nodeUuid": "node-uuid", - "componentType": "cc.Sprite" - } -} -``` - -### Instantiate a prefab -```json -{ - "tool": "prefab_instantiate_prefab", - "arguments": { - "prefabPath": "db://assets/prefabs/Enemy.prefab", - "position": { "x": 100, "y": 200, "z": 0 } - } -} -``` -**⚠️ Note**: Complex prefabs with child nodes may not instantiate correctly due to Cocos Creator API limitations. Child nodes may be missing in the instantiated prefab. - -### Run project in browser -```json -{ - "tool": "project_run_project", - "arguments": { - "platform": "browser" - } -} -``` - -## Configuration - -Settings are stored in `YourProject/settings/mcp-server.json`: - -```json -{ - "port": 3000, - "autoStart": false, - "enableDebugLog": true, - "allowedOrigins": ["*"], - "maxConnections": 10 -} -``` - -Tool configurations are stored in `YourProject/settings/tool-manager.json`: - -```json -{ - "currentConfigId": "default", - "configurations": { - "default": { - "id": "default", - "name": "默认配置", - "description": "默认工具配置", - "tools": [ - { - "category": "scene", - "name": "get_current_scene", - "enabled": true, - "description": "Get current scene information" - } - ] - } - } -} -``` - -## Icon Setup - -To add an icon for the plugin panel: - -1. Create a PNG icon file (recommended size: 32x32 or 64x64) -2. Place it in the `static/` directory: `static/icon.png` -3. The icon path is already configured in `package.json` ## Development @@ -385,7 +345,7 @@ cocos-mcp-server/ │ │ ├── preferences-tools.ts │ │ ├── server-tools.ts │ │ ├── broadcast-tools.ts -│ │ ├── scene-advanced-tools.ts +│ │ ├── scene-advanced-tools.ts (integrated into node-tools.ts and scene-tools.ts) │ │ ├── scene-view-tools.ts │ │ ├── reference-image-tools.ts │ │ └── asset-advanced-tools.ts @@ -426,19 +386,6 @@ The plugin is fully written in TypeScript with: - IntelliSense support for development - Automatic compilation to JavaScript -### Running Tests - -```bash -# Run comprehensive test suite -node comprehensive-test.js - -# Run feature-specific tests -./test-all-features.sh - -# Run Node.js test script -node test-mcp-server.js -``` - ## Troubleshooting ### Common Issues @@ -474,23 +421,11 @@ Enable debug logging in the plugin panel for detailed operation logs. - Node.js (bundled with Cocos Creator) - TypeScript (installed as dev dependency) -## Architecture Notes - -This plugin uses a simplified MCP protocol implementation that is compatible with Cocos Creator's CommonJS environment. The HTTP server provides a JSON-RPC interface for AI assistants to interact with the editor. - -### Protocol Support -- **HTTP Connection**: `http://localhost:3000/mcp` (configurable port) -- **JSON-RPC 2.0**: Standard request/response format -- **Tool Discovery**: `tools/list` method returns available tools -- **Tool Execution**: `tools/call` method executes specific tools - ## License -This plug-in is for Cocos Creator project, and the source code is packaged together, which can be used for learning and communication. It is not encrypted. It can support your own secondary development and optimization. Any code of this project or its derivative code cannot be used for any commercial purpose or resale. If you need commercial use, please contact me. - +This plug-in is for Cocos Creator project use, and the source code is packaged together, which can be used for learning and communication. It is not encrypted. It can support your own secondary development and optimization. Any code of this project or its derivative code cannot be used for any commercial purpose or resale. If you need commercial use, please contact me. ## Contact me to join the group + - - - \ No newline at end of file + \ No newline at end of file diff --git a/README.md b/README.md index 7a3d5f4..9b34f81 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ 一个适用于 Cocos Creator 3.8+ 的综合性 MCP（模型上下文协议）服务器插件，使 AI 助手能够通过标准化协议与 Cocos Creator 编辑器进行交互。一键安装和使用，省去所有繁琐环境和配置。已经测试过Claude客户端Claude CLI和Cursor，其他的编辑器理论上也完美支持。 -**🚀 现在提供 13 个类别的 158 个工具，实现98%的编辑器控制！** +**🚀 现在提供 50 个强力融合工具，实现99%的编辑器控制！** ## 视频演示和教学 @@ -22,10 +22,56 @@ ## 更新日志 -### v1.4.0 - 2025年7月26日 （已经在cocos 商城更新，github版本将在近期同步） +## 🚀 重大更新 v1.5.0（2024年7月29日）（已经在cocos 商城更新，github版本将在下个版本同步更新） + cocos store：https://store.cocos.com/app/detail/7941 如果不愿意购买，加入沟通群我也可以直接发送最新版给你！ +- **工具精简与重构**：将原有150+工具浓缩规整为50个高复用、高覆盖率的核心工具，去除所有无效冗余代码，极大提升易用性和可维护性。 +- **操作码统一**：所有工具均采用“操作码+参数”模式，极大简化AI调用流程，提升AI调用成功率，减少AI调用次数，降低50% token消耗。 +- **预制体功能全面升级**：彻底修复和完善预制体的创建、实例化、同步、引用等所有核心功能，支持复杂引用关系，100%对齐官方格式。 +- **事件绑定与老功能补全**：补充并实现了事件绑定、节点/组件/资源等老功能，所有方法与官方实现完全对齐。 +- **接口优化**：所有接口参数更清晰，文档更完善，AI更容易理解和调用。 +- **插件面板优化**：面板UI更简洁，操作更直观。 +- **性能与兼容性提升**：整体架构更高效，兼容Cocos Creator 3.8.6及以上所有版本。 + + +## 工具体系与操作码 + +- 所有工具均以“类别_操作”命名，参数采用统一Schema，支持多操作码（action）切换，极大提升灵活性和可扩展性。 +- 50个核心工具涵盖场景、节点、组件、预制体、资源、项目、调试、偏好设置、服务器、消息广播等全部编辑器操作。 +- 工具调用示例： + +```json +{ + "tool": "node_lifecycle", + "arguments": { + "action": "create", + "name": "MyNode", + "parentUuid": "parent-uuid", + "nodeType": "2DNode" + } +} +``` + +--- + +## 主要功能类别（部分示例） + +- **scene_management**：场景管理（获取/打开/保存/新建/关闭场景） +- **node_query / node_lifecycle / node_transform**：节点查询、创建、删除、属性变更 +- **component_manage / component_script / component_query**：组件增删、脚本挂载、组件信息 +- **prefab_browse / prefab_lifecycle / prefab_instance**：预制体浏览、创建、实例化、同步 +- **asset_manage / asset_analyze**：资源导入、删除、依赖分析 +- **project_manage / project_build_system**：项目运行、构建、配置信息 +- **debug_console / debug_logs**：控制台与日志管理 +- **preferences_manage**：偏好设置 +- **server_info**：服务器信息 +- **broadcast_message**：消息广播 + + +### v1.4.0 - 2025年7月26日（当前github版本） + #### 🎯 重大功能修复 - **完全修复预制体创建功能**: 彻底解决了预制体创建时组件/节点/资源类型引用丢失的问题 - **正确的引用处理**: 实现了与手动创建预制体完全一致的引用格式 @@ -102,7 +148,6 @@ cocos store：https://store.cocos.com/app/detail/7941 - ## 快速使用 **Claude cli配置：** @@ -148,61 +193,85 @@ claude mcp add --transport http cocos-creator http://127.0.0.1:3000/mcp（使用 ## 功能特性 -### 🎯 场景操作 -- 获取当前场景信息和完整场景列表 -- 通过路径打开场景并保存当前场景 -- 创建自定义名称的新场景 -- 获取完整场景层级结构及组件信息 +### 🎯 场景操作 (scene_*) +- **scene_management**: 场景管理 - 获取当前场景、打开/保存/创建/关闭场景，支持场景列表查询 +- **scene_hierarchy**: 场景层级 - 获取完整场景结构，支持组件信息包含 +- **scene_execution_control**: 执行控制 - 执行组件方法、场景脚本、预制体同步 -### 🎮 节点操作 -- 创建不同类型的节点（Node、2DNode、3DNode） -- 通过 UUID 获取节点信息，按名称模式查找节点 -- 设置节点属性（位置、旋转、缩放、激活状态） -- 删除、移动和复制节点，完整支持层级结构 +### 🎮 节点操作 (node_*) +- **node_query**: 节点查询 - 按名称/模式查找节点，获取节点信息，检测2D/3D类型 +- **node_lifecycle**: 节点生命周期 - 创建/删除节点，支持组件预装、预制体实例化 +- **node_transform**: 节点变换 - 修改节点名称、位置、旋转、缩放、可见性等属性 +- **node_hierarchy**: 节点层级 - 移动、复制、粘贴节点，支持层级结构操作 +- **node_clipboard**: 节点剪贴板 - 复制/粘贴/剪切节点操作 +- **node_property_management**: 属性管理 - 重置节点属性、组件属性、变换属性 -### 🔧 组件操作 -- 向节点添加/删除组件 -- 获取节点的所有组件及属性 -- 动态设置组件属性 -- 从资源路径挂载脚本组件 -- 按类别列出可用的组件类型 +### 🔧 组件操作 (component_*) +- **component_manage**: 组件管理 - 添加/删除引擎组件（cc.Sprite、cc.Button等） +- **component_script**: 脚本组件 - 挂载/移除自定义脚本组件 +- **component_query**: 组件查询 - 获取组件列表、详细信息、可用组件类型 +- **set_component_property**: 属性设置 - 设置单个或多个组件属性值 -### 📦 预制体操作 -- 列出项目中的所有预制体，支持文件夹组织 -- 加载、实例化和创建预制体 -- 更新现有预制体并还原预制体实例 -- 获取详细的预制体信息，包括依赖关系 +### 📦 预制体操作 (prefab_*) +- **prefab_browse**: 预制体浏览 - 列出预制体、查看信息、验证文件 +- **prefab_lifecycle**: 预制体生命周期 - 从节点创建预制体、删除预制体 +- **prefab_instance**: 预制体实例 - 实例化到场景、解除链接、应用更改、还原原始 +- **prefab_edit**: 预制体编辑 - 进入/退出编辑模式、保存预制体、测试更改 -### 🚀 项目控制 -- 在预览模式下运行项目（浏览器/模拟器） -- 为不同平台构建项目（Web、移动端、桌面端） -- 获取项目信息和设置 -- 刷新资源数据库并导入新资源 -- 获取详细的资源信息 +### 🚀 项目控制 (project_*) +- **project_manage**: 项目管理 - 运行项目、构建项目、获取项目信息和设置 +- **project_build_system**: 构建系统 - 控制构建面板、检查构建状态、预览服务器管理 -### 🔍 调试工具 -- 获取编辑器控制台日志，支持过滤 -- 清空控制台并在场景上下文中执行 JavaScript -- 获取详细的节点树用于调试 -- 性能统计和场景验证 -- 获取编辑器和环境信息 +### 🔍 调试工具 (debug_*) +- **debug_console**: 控制台管理 - 获取/清空控制台日志，支持过滤和限制 +- **debug_logs**: 日志分析 - 读取/搜索/分析项目日志文件，支持模式匹配 +- **debug_system**: 系统调试 - 获取编辑器信息、性能统计、环境信息 -### ⚙️ 其他功能 -- **偏好设置管理**: 获取/设置编辑器偏好和全局设置 -- **服务器控制**: 服务器信息、项目详情和编辑器控制 -- **消息广播**: 监听和广播自定义消息 -- **资源管理**: 创建、复制、移动、删除和查询资源 -- **构建系统**: 项目构建和预览服务器控制 -- **参考图片管理**: 在场景视图中添加、删除和管理参考图片 -- **场景视图控制**: 控制Gizmo工具、坐标系和视图模式 -- **高级场景操作**: 撤销/重做、快照和高级节点操作 -- **🆕 工具管理**: 选择性启用/禁用工具、保存配置和管理工具状态 +### 📁 资源管理 (asset_*) +- **asset_manage**: 资源管理 - 批量导入/删除资源、保存元数据、生成URL +- **asset_analyze**: 资源分析 - 获取依赖关系、导出资源清单 +- **asset_system**: 资源系统 - 刷新资源、查询资源数据库状态 +- **asset_query**: 资源查询 - 按类型/文件夹查询资源、获取详细信息 +- **asset_operations**: 资源操作 - 创建/复制/移动/删除/保存/重新导入资源 + +### ⚙️ 偏好设置 (preferences_*) +- **preferences_manage**: 偏好管理 - 获取/设置编辑器偏好设置 +- **preferences_global**: 全局设置 - 管理全局配置和系统设置 + +### 🌐 服务器与广播 (server_* / broadcast_*) +- **server_info**: 服务器信息 - 获取服务器状态、项目详情、环境信息 +- **broadcast_message**: 消息广播 - 监听和广播自定义消息 + +### 🖼️ 参考图片 (referenceImage_*) +- **reference_image_manage**: 参考图片管理 - 添加/删除/管理场景视图中的参考图片 +- **reference_image_view**: 参考图片视图 - 控制参考图片的显示和编辑 + +### 🎨 场景视图 (sceneView_*) +- **scene_view_control**: 场景视图控制 - 控制Gizmo工具、坐标系、视图模式 +- **scene_view_tools**: 场景视图工具 - 管理场景视图的各种工具和选项 + +### ✅ 验证工具 (validation_*) +- **validation_scene**: 场景验证 - 验证场景完整性、检查缺失资源 +- **validation_asset**: 资源验证 - 验证资源引用、检查资源完整性 + +### 🛠️ 工具管理 +- **工具配置系统**: 选择性启用/禁用工具，支持多套配置 +- **配置持久化**: 自动保存和加载工具配置 +- **配置导入导出**: 支持工具配置的导入导出功能 +- **实时状态管理**: 工具状态实时更新和同步 + +### 🚀 核心优势 +- **操作码统一**: 所有工具采用"类别_操作"命名，参数Schema统一 +- **高复用性**: 50个核心工具覆盖99%编辑器功能 +- **AI友好**: 参数清晰、文档完善、调用简单 +- **性能优化**: 降低50% token消耗，提升AI调用成功率 +- **完全兼容**: 与Cocos Creator官方API 100%对齐 ## 安装说明 ### 1. 复制插件文件 -将整个 `cocos-mcp-server` 文件夹复制到您的 Cocos Creator 项目的 `extensions` 目录中： +将整个 `cocos-mcp-server` 文件夹复制到您的 Cocos Creator 项目的 `extensions` 目录中，您也可以直接在扩展管理器中导入项目： ``` 您的项目/ @@ -255,117 +324,6 @@ npm run build AI 助手可以使用 MCP 协议连接并访问所有可用工具。 -### 工具分类 - -工具按类别组织，命名约定为：`category_toolname` - -- **scene_\***: 场景相关操作 (8个工具) -- **node_\***: 节点操作 (9个工具) -- **component_\***: 组件管理 (7个工具) -- **prefab_\***: 预制体操作 (11个工具) -- **project_\***: 项目控制 (22个工具) -- **debug_\***: 调试工具 (10个工具) -- **preferences_\***: 编辑器偏好设置 (7个工具) -- **server_\***: 服务器信息 (6个工具) -- **broadcast_\***: 消息广播 (5个工具) -- **assetAdvanced_\***: 高级资源操作 (10个工具) -- **referenceImage_\***: 参考图片管理 (12个工具) -- **sceneAdvanced_\***: 高级场景操作 (23个工具) -- **sceneView_\***: 场景视图控制 (14个工具) - - -📖 **[查看完整工具文档](FEATURE_GUIDE_CN.md)** 了解详细的使用示例和参数。 - -## 工具使用示例 - -### 创建新的精灵节点 -```json -{ - "tool": "node_create_node", - "arguments": { - "name": "MySprite", - "nodeType": "2DNode", - "parentUuid": "parent-node-uuid" - } -} -``` - -### 添加 Sprite 组件 -```json -{ - "tool": "component_add_component", - "arguments": { - "nodeUuid": "node-uuid", - "componentType": "cc.Sprite" - } -} -``` - -### 实例化预制体 -```json -{ - "tool": "prefab_instantiate_prefab", - "arguments": { - "prefabPath": "db://assets/prefabs/Enemy.prefab", - "position": { "x": 100, "y": 200, "z": 0 } - } -} -``` - -### 在浏览器中运行项目 -```json -{ - "tool": "project_run_project", - "arguments": { - "platform": "browser" - } -} -``` - -## 配置 - -设置存储在 `您的项目/settings/mcp-server.json` 中： - -```json -{ - "port": 3000, - "autoStart": false, - "enableDebugLog": true, - "allowedOrigins": ["*"], - "maxConnections": 10 -} -``` - -工具配置存储在 `您的项目/settings/tool-manager.json` 中： - -```json -{ - "currentConfigId": "default", - "configurations": { - "default": { - "id": "default", - "name": "默认配置", - "description": "默认工具配置", - "tools": [ - { - "category": "scene", - "name": "get_current_scene", - "enabled": true, - "description": "获取当前场景信息" - } - ] - } - } -} -``` - -## 图标设置 - -为插件面板添加图标： - -1. 创建 PNG 图标文件（推荐尺寸：32x32 或 64x64） -2. 将其放在 `static/` 目录中：`static/icon.png` -3. 图标路径已在 `package.json` ## 开发 @@ -387,7 +345,7 @@ cocos-mcp-server/ │ │ ├── preferences-tools.ts │ │ ├── server-tools.ts │ │ ├── broadcast-tools.ts -│ │ ├── scene-advanced-tools.ts +│ │ ├── scene-advanced-tools.ts (已整合到 node-tools.ts 和 scene-tools.ts) │ │ ├── scene-view-tools.ts │ │ ├── reference-image-tools.ts │ │ └── asset-advanced-tools.ts @@ -468,7 +426,7 @@ npm run build 本插件供 Cocos Creator 项目使用,并且源代码一并打包，可以用于学习和交流。没有加密。可以支持你自己二次开发优化，任何本项目代码或者衍生代码均不能用于任何商用、转售，如果需要商用，请联系本人。 ## 联系我加入群 - + - + diff --git a/comprehensive-test.js b/comprehensive-test.js deleted file mode 100644 index 457886f..0000000 --- a/comprehensive-test.js +++ /dev/null @@ -1,230 +0,0 @@ -const http = require('http'); - -const SERVER_URL = 'http://localhost:8585'; - -class MCPTester { - constructor() { - this.testResults = []; - this.currentCategory = ''; - } - - async makeRequest(toolName, args = {}) { - const payload = { - jsonrpc: '2.0', - id: Date.now(), - method: 'tools/call', - params: { - name: toolName, - arguments: args - } - }; - - return new Promise((resolve, reject) => { - const data = JSON.stringify(payload); - const options = { - hostname: '127.0.0.1', - port: 8585, - path: '/mcp', - method: 'POST', - headers: { - 'Content-Type': 'application/json', - 'Content-Length': data.length - } - }; - - const req = http.request(options, (res) => { - let responseData = ''; - res.on('data', chunk => responseData += chunk); - res.on('end', () => { - try { - const response = JSON.parse(responseData); - resolve(response); - } catch (e) { - reject(e); - } - }); - }); - - req.on('error', reject); - req.write(data); - req.end(); - }); - } - - async testTool(toolName, args = {}, description = '') { - const testName = description || toolName.replace(/_/g, ' '); - process.stdout.write(` ${testName}... `); - - try { - const response = await this.makeRequest(toolName, args); - - if (response.result && response.result.success !== false) { - console.log('✅ 通过'); - this.testResults.push({ tool: toolName, status: 'pass', category: this.currentCategory }); - return response.result; - } else { - const error = response.result?.error || response.error?.message || 'Unknown error'; - console.log(`❌ 失败: ${error}`); - this.testResults.push({ tool: toolName, status: 'fail', error, category: this.currentCategory }); - return null; - } - } catch (error) { - console.log(`❌ 错误: ${error.message}`); - this.testResults.push({ tool: toolName, status: 'error', error: error.message, category: this.currentCategory }); - return null; - } - } - - printCategory(categoryName) { - this.currentCategory = categoryName; - console.log(`\n📁 ${categoryName}:`); - } - - printSummary() { - console.log('\n' + '='.repeat(60)); - console.log('📊 测试结果汇总:'); - console.log('='.repeat(60)); - - const categories = [...new Set(this.testResults.map(r => r.category))]; - - for (const category of categories) { - const categoryResults = this.testResults.filter(r => r.category === category); - const passed = categoryResults.filter(r => r.status === 'pass').length; - const failed = categoryResults.filter(r => r.status === 'fail').length; - const errors = categoryResults.filter(r => r.status === 'error').length; - - console.log(`\n${category}:`); - console.log(` ✅ 通过: ${passed}`); - console.log(` ❌ 失败: ${failed}`); - console.log(` ⚠️ 错误: ${errors}`); - console.log(` 📊 总计: ${categoryResults.length}`); - } - - const totalPassed = this.testResults.filter(r => r.status === 'pass').length; - const totalFailed = this.testResults.filter(r => r.status === 'fail').length; - const totalErrors = this.testResults.filter(r => r.status === 'error').length; - const total = this.testResults.length; - - console.log(`\n总体结果:`); - console.log(` ✅ 通过: ${totalPassed}/${total} (${((totalPassed/total)*100).toFixed(1)}%)`); - console.log(` ❌ 失败: ${totalFailed}/${total} (${((totalFailed/total)*100).toFixed(1)}%)`); - console.log(` ⚠️ 错误: ${totalErrors}/${total} (${((totalErrors/total)*100).toFixed(1)}%)`); - - // 显示失败的工具 - const failedTools = this.testResults.filter(r => r.status === 'fail' || r.status === 'error'); - if (failedTools.length > 0) { - console.log('\n❌ 失败的工具:'); - failedTools.forEach(tool => { - console.log(` - ${tool.tool}: ${tool.error}`); - }); - } - } - - async runAllTests() { - console.log('🚀 开始全面测试 Cocos MCP 工具...\n'); - - // 1. 场景管理工具 - this.printCategory('场景管理'); - await this.testTool('scene_create_scene', { - sceneName: 'TestScene2', - savePath: 'db://assets/scenes/TestScene2.scene' - }, '创建场景'); - await this.testTool('scene_get_current_scene', {}, '获取当前场景'); - await this.testTool('scene_save_scene', {}, '保存场景'); - await this.testTool('scene_get_scene_list', {}, '获取场景列表'); - await this.testTool('scene_get_scene_hierarchy', {}, '获取场景层次结构'); - - // 2. 节点操作工具 - this.printCategory('节点操作'); - const nodeResult = await this.testTool('node_create_node', { name: 'TestNode' }, '创建节点'); - let testNodeUuid = null; - if (nodeResult && nodeResult.data && nodeResult.data.uuid) { - testNodeUuid = nodeResult.data.uuid; - } - - await this.testTool('node_get_all_nodes', {}, '获取所有节点'); - await this.testTool('node_find_node_by_name', { name: 'TestNode' }, '按名称查找节点'); - - if (testNodeUuid) { - await this.testTool('node_get_node_info', { uuid: testNodeUuid }, '获取节点信息'); - await this.testTool('node_set_node_property', { - uuid: testNodeUuid, - property: 'position', - value: { x: 100, y: 100, z: 0 } - }, '设置节点属性'); - await this.testTool('node_duplicate_node', { uuid: testNodeUuid }, '复制节点'); - } - - // 3. 组件管理工具 - this.printCategory('组件管理'); - if (testNodeUuid) { - await this.testTool('component_add_component', { - nodeUuid: testNodeUuid, - componentType: 'cc.Sprite' - }, '添加组件'); - await this.testTool('component_get_components', { nodeUuid: testNodeUuid }, '获取组件列表'); - await this.testTool('component_get_component_info', { - nodeUuid: testNodeUuid, - componentType: 'cc.Sprite' - }, '获取组件信息'); - } - await this.testTool('component_get_available_components', {}, '获取可用组件'); - - // 4. 预制体工具 - this.printCategory('预制体管理'); - if (testNodeUuid) { - await this.testTool('prefab_create_prefab', { - nodeUuid: testNodeUuid, - prefabPath: 'db://assets/prefabs/TestPrefab.prefab' - }, '创建预制体'); - } - await this.testTool('prefab_get_prefab_list', {}, '获取预制体列表'); - await this.testTool('prefab_instantiate_prefab', { - prefabPath: 'db://assets/prefabs/TestPrefab.prefab' - }, '实例化预制体'); - - // 5. 项目和资源管理 - this.printCategory('项目资源管理'); - await this.testTool('project_get_project_info', {}, '获取项目信息'); - await this.testTool('project_get_project_settings', {}, '获取项目设置'); - await this.testTool('project_get_assets', { type: 'all' }, '获取资源列表'); - await this.testTool('project_refresh_assets', {}, '刷新资源'); - await this.testTool('project_create_asset', { - url: 'db://assets/test-folder', - content: null - }, '创建资源文件夹'); - - // 6. 调试工具 - this.printCategory('调试工具'); - await this.testTool('debug_get_console_logs', {}, '获取控制台日志'); - await this.testTool('debug_get_performance_stats', {}, '获取性能统计'); - await this.testTool('debug_validate_scene', {}, '验证场景'); - await this.testTool('debug_get_editor_info', {}, '获取编辑器信息'); - - // 7. 偏好设置工具 - this.printCategory('偏好设置'); - await this.testTool('preferences_get_preferences', {}, '获取偏好设置'); - await this.testTool('preferences_get_global_preferences', {}, '获取全局偏好设置'); - await this.testTool('preferences_get_recent_projects', {}, '获取最近项目'); - - // 8. 服务器控制工具 - this.printCategory('服务器控制'); - await this.testTool('server_get_server_info', {}, '获取服务器信息'); - await this.testTool('server_get_editor_version', {}, '获取编辑器版本'); - - // 9. 广播消息工具 - this.printCategory('广播消息'); - await this.testTool('broadcast_get_broadcast_log', {}, '获取广播日志'); - - // 清理测试节点 - if (testNodeUuid) { - await this.testTool('node_delete_node', { uuid: testNodeUuid }, '删除测试节点'); - } - - this.printSummary(); - } -} - -// 运行测试 -const tester = new MCPTester(); -tester.runAllTests().catch(console.error); \ No newline at end of file diff --git a/debug-api.js b/debug-api.js deleted file mode 100644 index a1e4ecd..0000000 --- a/debug-api.js +++ /dev/null @@ -1,46 +0,0 @@ -// 测试可用的 Editor API -const testMethods = [ - 'scene.query-node-tree', - 'scene.create-node', - 'scene.remove-node', - 'scene.set-property', - 'scene.create-component', - 'scene.remove-component', - 'scene.add-component', - 'scene.query-node', - 'scene.query-scene', - 'scene.query-hierarchy' -]; - -async function testAPI() { - console.log('Testing available Editor API methods...'); - - for (const method of testMethods) { - console.log(`\nTesting: ${method}`); - - try { - const response = await fetch('http://localhost:8585/mcp', { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ - jsonrpc: '2.0', - id: 1, - method: 'tools/call', - params: { - name: 'debug_test_editor_api', - arguments: { - method: method.replace('.', ' - ') - } - } - }) - }); - - const data = await response.json(); - console.log(`Response: ${JSON.stringify(data)}`); - } catch (error) { - console.log(`Error: ${error.message}`); - } - } -} - -testAPI(); \ No newline at end of file diff --git a/dist/tools/component-tools.js b/dist/tools/component-tools.js index 2b3045f..7fa1aa1 100644 --- a/dist/tools/component-tools.js +++ b/dist/tools/component-tools.js @@ -24,7 +24,7 @@ class ComponentTools { }, { name: 'remove_component', - description: 'Remove a component from a node', + description: 'Remove a component from a node. componentType must be the component\'s classId (cid, i.e. the type field from getComponents), not the script name or class name. Use getComponents to get the correct cid.', inputSchema: { type: 'object', properties: { @@ -34,7 +34,7 @@ class ComponentTools { }, componentType: { type: 'string', - description: 'Component type to remove' + description: 'Component cid (type field from getComponents). Do NOT use script name or class name. Example: "cc.Sprite" or "9b4a7ueT9xD6aRE+AlOusy1"' } }, required: ['nodeUuid', 'componentType'] @@ -74,30 +74,31 @@ class ComponentTools { }, { name: 'set_component_property', - description: 'Set component property value - AI必须提供5个参数：节点UUID、组件名称、属性名称、属性类型、属性值\n' + - '重要：对于引用类型属性：\n' + - '• 节点引用(propertyType: "node"): value传入目标节点的UUID字符串\n' + - '• 组件引用(propertyType: "component"): value传入目标组件的UUID字符串\n' + - '• 资源引用(propertyType: "spriteFrame/prefab/asset"): value传入资源UUID字符串', + description: 'Set component property values for UI components or custom script components. Supports setting properties of built-in UI components (e.g., cc.Label, cc.Sprite) and custom script components. Note: For node basic properties (name, active, layer, etc.), use set_node_property. For node transform properties (position, rotation, scale, etc.), use set_node_transform.', inputSchema: { type: 'object', properties: { nodeUuid: { type: 'string', - description: 'Node UUID - 节点的UUID' + description: 'Target node UUID - Must specify the node to operate on' }, componentType: { type: 'string', - description: 'Component type - 组件类型', - enum: ['cc.Label', 'cc.Sprite', 'cc.Button', 'cc.Toggle', 'cc.Slider', 'cc.ScrollView', 'cc.EditBox', 'cc.ProgressBar', 'cc.RichText', 'cc.Mask', 'cc.Graphics', 'cc.Layout', 'cc.Widget', 'cc.UITransform', 'TestMCPScript'] + description: 'Component type - Can be built-in components (e.g., cc.Label) or custom script components (e.g., MyScript). If unsure about component type, use get_components first to retrieve all components on the node.', + // 移除enum限制，允许任意组件类型包括自定义脚本 }, property: { type: 'string', - description: 'Property name - 属性名称' + description: 'Property name - The property to set. Common properties include:\n' + + '• cc.Label: string (text content), fontSize (font size), color (text color)\n' + + '• cc.Sprite: spriteFrame (sprite frame), color (tint color), sizeMode (size mode)\n' + + '• cc.Button: normalColor (normal color), pressedColor (pressed color), target (target node)\n' + + '• cc.UITransform: contentSize (content size), anchorPoint (anchor point)\n' + + '• Custom Scripts: Based on properties defined in the script' }, propertyType: { type: 'string', - description: 'Property type - 属性类型（必须明确指定）', + description: 'Property type - Must explicitly specify the property data type for correct value conversion and validation', enum: [ 'string', 'number', 'boolean', 'integer', 'float', 'color', 'vec2', 'vec3', 'size', @@ -106,24 +107,40 @@ class ComponentTools { ] }, value: { - description: 'Property value - 属性值，根据propertyType使用不同格式:\n' + - '基础类型：\n' + - '• string: "Hello World"\n' + - '• number/integer/float: 42 或 3.14\n' + - '• boolean: true 或 false\n' + - '• color: {"r":255,"g":0,"b":0,"a":255}\n' + - '• vec2: {"x":100,"y":50}\n' + - '• vec3: {"x":1,"y":2,"z":3}\n' + - '• size: {"width":100,"height":50}\n' + - '引用类型（重要）：\n' + - '• node: "target-node-uuid-string" （目标节点的UUID字符串）\n' + - '• component: "target-component-uuid-string" （目标组件的UUID字符串）\n' + - '• spriteFrame/prefab/asset: "asset-uuid-string" （资源UUID字符串）\n' + - '数组类型：\n' + - '• nodeArray: ["uuid1","uuid2","uuid3"]\n' + - '• colorArray: [{"r":255,"g":0,"b":0,"a":255},{"r":0,"g":255,"b":0,"a":255}]\n' + - '• numberArray: [1,2,3,4,5]\n' + - '• stringArray: ["item1","item2","item3"]' + description: 'Property value - Use the corresponding data format based on propertyType:\n\n' + + '📝 Basic Data Types:\n' + + '• string: "Hello World" (text string)\n' + + '• number/integer/float: 42 or 3.14 (numeric value)\n' + + '• boolean: true or false (boolean value)\n\n' + + '🎨 Color Type:\n' + + '• color: {"r":255,"g":0,"b":0,"a":255} (RGBA values, range 0-255)\n' + + ' - Alternative: "#FF0000" (hexadecimal format)\n' + + ' - Transparency: a value controls opacity, 255 = fully opaque, 0 = fully transparent\n\n' + + '📐 Vector and Size Types:\n' + + '• vec2: {"x":100,"y":50} (2D vector)\n' + + '• vec3: {"x":1,"y":2,"z":3} (3D vector)\n' + + '• size: {"width":100,"height":50} (size dimensions)\n\n' + + '🔗 Reference Types (using UUID strings):\n' + + '• node: "target-node-uuid" (node reference)\n' + + ' How to get: Use get_all_nodes or find_node_by_name to get node UUIDs\n' + + '• component: "target-node-uuid" (component reference)\n' + + ' How it works: \n' + + ' 1. Provide the UUID of the NODE that contains the target component\n' + + ' 2. System auto-detects required component type from property metadata\n' + + ' 3. Finds the component on target node and gets its scene __id__\n' + + ' 4. Sets reference using the scene __id__ (not node UUID)\n' + + ' Example: value="label-node-uuid" will find cc.Label and use its scene ID\n' + + '• spriteFrame: "spriteframe-uuid" (sprite frame asset)\n' + + ' How to get: Check asset database or use asset browser\n' + + '• prefab: "prefab-uuid" (prefab asset)\n' + + ' How to get: Check asset database or use asset browser\n' + + '• asset: "asset-uuid" (generic asset reference)\n' + + ' How to get: Check asset database or use asset browser\n\n' + + '📋 Array Types:\n' + + '• nodeArray: ["uuid1","uuid2"] (array of node UUIDs)\n' + + '• colorArray: [{"r":255,"g":0,"b":0,"a":255}] (array of colors)\n' + + '• numberArray: [1,2,3,4,5] (array of numbers)\n' + + '• stringArray: ["item1","item2"] (array of strings)' } }, required: ['nodeUuid', 'componentType', 'property', 'propertyType', 'value'] @@ -185,49 +202,71 @@ class ComponentTools { } } async addComponent(nodeUuid, componentType) { - return new Promise((resolve) => { + return new Promise(async (resolve) => { + var _a; + // 先查找节点上是否已存在该组件 + const allComponentsInfo = await this.getComponents(nodeUuid); + if (allComponentsInfo.success && ((_a = allComponentsInfo.data) === null || _a === void 0 ? void 0 : _a.components)) { + const existingComponent = allComponentsInfo.data.components.find((comp) => comp.type === componentType); + if (existingComponent) { + resolve({ + success: true, + message: `Component '${componentType}' already exists on node`, + data: { + nodeUuid: nodeUuid, + componentType: componentType, + componentVerified: true, + existing: true + } + }); + return; + } + } // 尝试直接使用 Editor API 添加组件 Editor.Message.request('scene', 'create-component', { uuid: nodeUuid, component: componentType - }).then((result) => { - // Get comprehensive verification data including node info and all components - Promise.all([ - this.getComponents(nodeUuid), - this.getComponentInfo(nodeUuid, componentType) - ]).then(([allComponentsInfo, newComponentInfo]) => { - var _a, _b, _c, _d; - const addedComponent = (_b = (_a = allComponentsInfo.data) === null || _a === void 0 ? void 0 : _a.components) === null || _b === void 0 ? void 0 : _b.find((comp) => comp.type === componentType); - resolve({ - success: true, - data: { - componentId: result, - nodeUuid: nodeUuid, - componentType: componentType, - message: `Component '${componentType}' added successfully`, - componentVerified: !!addedComponent - }, - verificationData: { - addedComponent: newComponentInfo.data, - allNodeComponents: allComponentsInfo.data, - componentCount: ((_d = (_c = allComponentsInfo.data) === null || _c === void 0 ? void 0 : _c.components) === null || _d === void 0 ? void 0 : _d.length) || 0, - verificationStatus: { - componentExists: !!addedComponent, - componentDetails: addedComponent || null - } + }).then(async (result) => { + var _a; + // 等待一段时间让Editor完成组件添加 + await new Promise(resolve => setTimeout(resolve, 100)); + // 重新查询节点信息验证组件是否真的添加成功 + try { + const allComponentsInfo2 = await this.getComponents(nodeUuid); + if (allComponentsInfo2.success && ((_a = allComponentsInfo2.data) === null || _a === void 0 ? void 0 : _a.components)) { + const addedComponent = allComponentsInfo2.data.components.find((comp) => comp.type === componentType); + if (addedComponent) { + resolve({ + success: true, + message: `Component '${componentType}' added successfully`, + data: { + nodeUuid: nodeUuid, + componentType: componentType, + componentVerified: true, + existing: false + } + }); } - }); - }).catch(() => { - resolve({ - success: true, - data: { - componentId: result, - nodeUuid: nodeUuid, - componentType: componentType, - message: `Component '${componentType}' added successfully (verification failed)` + else { + resolve({ + success: false, + error: `Component '${componentType}' was not found on node after addition. Available components: ${allComponentsInfo2.data.components.map((c) => c.type).join(', ')}` + }); } + } + else { + resolve({ + success: false, + error: `Failed to verify component addition: ${allComponentsInfo2.error || 'Unable to get node components'}` + }); + } + } + catch (verifyError) { + resolve({ + success: false, + error: `Failed to verify component addition: ${verifyError.message}` }); - }); + } }).catch((err) => { // 备用方案：使用场景脚本 const options = { @@ -244,17 +283,43 @@ class ComponentTools { }); } async removeComponent(nodeUuid, componentType) { - return new Promise((resolve) => { - const options = { - name: 'cocos-mcp-server', - method: 'removeComponentFromNode', - args: [nodeUuid, componentType] - }; - Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { - resolve(result); - }).catch((err) => { - resolve({ success: false, error: err.message }); - }); + return new Promise(async (resolve) => { + var _a, _b, _c; + // 1. 查找节点上的所有组件 + const allComponentsInfo = await this.getComponents(nodeUuid); + if (!allComponentsInfo.success || !((_a = allComponentsInfo.data) === null || _a === void 0 ? void 0 : _a.components)) { + resolve({ success: false, error: `Failed to get components for node '${nodeUuid}': ${allComponentsInfo.error}` }); + return; + } + // 2. 只查找type字段等于componentType的组件（即cid） + const exists = allComponentsInfo.data.components.some((comp) => comp.type === componentType); + if (!exists) { + resolve({ success: false, error: `Component cid '${componentType}' not found on node '${nodeUuid}'. 请用getComponents获取type字段（cid）作为componentType。` }); + return; + } + // 3. 官方API直接移除 + try { + await Editor.Message.request('scene', 'remove-component', { + uuid: nodeUuid, + component: componentType + }); + // 4. 再查一次确认是否移除 + const afterRemoveInfo = await this.getComponents(nodeUuid); + const stillExists = afterRemoveInfo.success && ((_c = (_b = afterRemoveInfo.data) === null || _b === void 0 ? void 0 : _b.components) === null || _c === void 0 ? void 0 : _c.some((comp) => comp.type === componentType)); + if (stillExists) { + resolve({ success: false, error: `Component cid '${componentType}' was not removed from node '${nodeUuid}'.` }); + } + else { + resolve({ + success: true, + message: `Component cid '${componentType}' removed successfully from node '${nodeUuid}'`, + data: { nodeUuid, componentType } + }); + } + } + catch (err) { + resolve({ success: false, error: `Failed to remove component: ${err.message}` }); + } }); } async getComponents(nodeUuid) { @@ -262,11 +327,15 @@ class ComponentTools { // 优先尝试直接使用 Editor API 查询节点信息 Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData) => { if (nodeData && nodeData.__comps__) { - const components = nodeData.__comps__.map((comp) => ({ - type: comp.__type__ || comp.cid || comp.type || 'Unknown', - enabled: comp.enabled !== undefined ? comp.enabled : true, - properties: this.extractComponentProperties(comp) - })); + const components = nodeData.__comps__.map((comp) => { + var _a; + return ({ + type: comp.__type__ || comp.cid || comp.type || 'Unknown', + uuid: ((_a = comp.uuid) === null || _a === void 0 ? void 0 : _a.value) || comp.uuid || null, + enabled: comp.enabled !== undefined ? comp.enabled : true, + properties: this.extractComponentProperties(comp) + }); + }); resolve({ success: true, data: { @@ -376,18 +445,74 @@ class ComponentTools { console.log(`[extractComponentProperties] Final extracted properties:`, Object.keys(properties)); return properties; } + async findComponentTypeByUuid(componentUuid) { + var _a; + console.log(`[findComponentTypeByUuid] Searching for component type with UUID: ${componentUuid}`); + if (!componentUuid) { + return null; + } + try { + const nodeTree = await Editor.Message.request('scene', 'query-node-tree'); + if (!nodeTree) { + console.warn('[findComponentTypeByUuid] Failed to query node tree.'); + return null; + } + const queue = [nodeTree]; + while (queue.length > 0) { + const currentNodeInfo = queue.shift(); + if (!currentNodeInfo || !currentNodeInfo.uuid) { + continue; + } + try { + const fullNodeData = await Editor.Message.request('scene', 'query-node', currentNodeInfo.uuid); + if (fullNodeData && fullNodeData.__comps__) { + for (const comp of fullNodeData.__comps__) { + const compAny = comp; // Cast to any to access dynamic properties + // The component UUID is nested in the 'value' property + if (compAny.uuid && compAny.uuid.value === componentUuid) { + const componentType = compAny.__type__; + console.log(`[findComponentTypeByUuid] Found component type '${componentType}' for UUID ${componentUuid} on node ${(_a = fullNodeData.name) === null || _a === void 0 ? void 0 : _a.value}`); + return componentType; + } + } + } + } + catch (e) { + console.warn(`[findComponentTypeByUuid] Could not query node ${currentNodeInfo.uuid}:`, e); + } + if (currentNodeInfo.children) { + for (const child of currentNodeInfo.children) { + queue.push(child); + } + } + } + console.warn(`[findComponentTypeByUuid] Component with UUID ${componentUuid} not found in scene tree.`); + return null; + } + catch (error) { + console.error(`[findComponentTypeByUuid] Error while searching for component type:`, error); + return null; + } + } async setComponentProperty(args) { const { nodeUuid, componentType, property, propertyType, value } = args; return new Promise(async (resolve) => { var _a, _b; try { console.log(`[ComponentTools] Setting ${componentType}.${property} (type: ${propertyType}) = ${JSON.stringify(value)} on node ${nodeUuid}`); + // Step 0: 检测是否为节点属性，如果是则重定向到对应的节点方法 + const nodeRedirectResult = await this.checkAndRedirectNodeProperties(args); + if (nodeRedirectResult) { + resolve(nodeRedirectResult); + return; + } // Step 1: 获取组件信息，使用与getComponents相同的方法 const componentsResponse = await this.getComponents(nodeUuid); if (!componentsResponse.success || !componentsResponse.data) { resolve({ success: false, - error: `Failed to get components for node '${nodeUuid}': ${componentsResponse.error}` + error: `Failed to get components for node '${nodeUuid}': ${componentsResponse.error}`, + instruction: `Please verify that node UUID '${nodeUuid}' is correct. Use get_all_nodes or find_node_by_name to get the correct node UUID.` }); return; } @@ -404,9 +529,12 @@ class ComponentTools { } } if (!targetComponent) { + // 提供更详细的错误信息和建议 + const instruction = this.generateComponentSuggestion(componentType, availableTypes, property); resolve({ success: false, - error: `Component '${componentType}' not found on node. Available components: ${availableTypes.join(', ')}` + error: `Component '${componentType}' not found on node. Available components: ${availableTypes.join(', ')}`, + instruction: instruction }); return; } @@ -448,7 +576,12 @@ class ComponentTools { processedValue = Boolean(value); break; case 'color': - if (typeof value === 'object' && value !== null) { + if (typeof value === 'string') { + // 字符串格式：支持十六进制、颜色名称、rgb()/rgba() + processedValue = this.parseColorString(value); + } + else if (typeof value === 'object' && value !== null) { + // 对象格式：验证并转换RGBA值 processedValue = { r: Math.min(255, Math.max(0, Number(value.r) || 0)), g: Math.min(255, Math.max(0, Number(value.g) || 0)), @@ -457,7 +590,7 @@ class ComponentTools { }; } else { - throw new Error('Color value must be an object with r, g, b properties'); + throw new Error('Color value must be an object with r, g, b properties or a hexadecimal string (e.g., "#FF0000")'); } break; case 'vec2': @@ -504,73 +637,11 @@ class ComponentTools { break; case 'component': if (typeof value === 'string') { - // 组件引用：需要验证节点上是否有对应组件类型 - // 推断组件类型从属性名称（例如：labelComponent -> Label, buttonComponent -> Button） - let expectedComponentType = ''; - const propertyLower = property.toLowerCase(); - if (propertyLower.includes('label')) { - expectedComponentType = 'cc.Label'; - } - else if (propertyLower.includes('button')) { - expectedComponentType = 'cc.Button'; - } - else if (propertyLower.includes('sprite')) { - expectedComponentType = 'cc.Sprite'; - } - else if (propertyLower.includes('canvas')) { - expectedComponentType = 'cc.Canvas'; - } - else if (propertyLower.includes('camera')) { - expectedComponentType = 'cc.Camera'; - } - // 验证目标节点是否存在指定组件 - try { - const nodeData = await Editor.Message.request('scene', 'query-node', value); - if (nodeData && nodeData.__comps__ && expectedComponentType) { - const targetComponent = nodeData.__comps__.find((comp) => comp.__type__ === expectedComponentType); - if (targetComponent) { - // 找到匹配组件，使用组件的UUID - processedValue = { uuid: targetComponent.uuid || value }; - } - else { - console.warn(`[setComponentProperty] Node ${value} does not have component ${expectedComponentType}`); - processedValue = { uuid: value }; // 仍然设置，让Editor处理 - } - } - else { - // 无法推断组件类型或节点不存在，直接使用UUID - processedValue = { uuid: value }; - } - } - catch (error) { - console.warn(`[setComponentProperty] Failed to verify component on node ${value}: ${error}`); - processedValue = { uuid: value }; // 仍然设置，让Editor处理 - } - } - else if (typeof value === 'object' && value !== null && value.node && value.component) { - // 查找具体的组件UUID - try { - const nodeData = await Editor.Message.request('scene', 'query-node', value.node); - if (nodeData && nodeData.__comps__) { - const targetComponent = nodeData.__comps__.find((comp) => comp.__type__ === value.component); - if (targetComponent) { - processedValue = { uuid: targetComponent.uuid || "" }; - } - else { - processedValue = { uuid: "" }; - } - } - else { - processedValue = { uuid: "" }; - } - } - catch (error) { - console.warn(`[setComponentProperty] Failed to find component: ${error}`); - processedValue = { uuid: "" }; - } + // 组件引用需要特殊处理：通过节点UUID找到组件的__id__ + processedValue = value; // 先保存节点UUID，后续会转换为__id__ } else { - throw new Error('Component reference value must be a string UUID or object with node and component properties'); + throw new Error('Component reference value must be a string (node UUID containing the target component)'); } break; case 'spriteFrame': @@ -610,7 +681,7 @@ class ComponentTools { }; } else { - throw new Error('ColorArray items must be objects with r, g, b properties'); + return { r: 255, g: 255, b: 255, a: 255 }; } }); } @@ -638,6 +709,10 @@ class ComponentTools { throw new Error(`Unsupported property type: ${propertyType}`); } console.log(`[ComponentTools] Converting value: ${JSON.stringify(value)} -> ${JSON.stringify(processedValue)} (type: ${propertyType})`); + console.log(`[ComponentTools] Property analysis result: propertyInfo.type="${propertyInfo.type}", propertyType="${propertyType}"`); + console.log(`[ComponentTools] Will use color special handling: ${propertyType === 'color' && processedValue && typeof processedValue === 'object'}`); + // 用于验证的实际期望值（对于组件引用需要特殊处理） + let actualExpectedValue = processedValue; // Step 5: 获取原始节点数据来构建正确的路径 const rawNodeData = await Editor.Message.request('scene', 'query-node', nodeUuid); if (!rawNodeData || !rawNodeData.__comps__) { @@ -667,10 +742,14 @@ class ComponentTools { // 构建正确的属性路径 let propertyPath = `__comps__.${rawComponentIndex}.${property}`; // 特殊处理资源类属性 - if (propertyInfo.type === 'asset') { - // 对于资源类属性，需要特殊处理 - const assetValue = typeof processedValue === 'string' ? - { uuid: processedValue } : processedValue; + if (propertyType === 'asset' || propertyType === 'spriteFrame' || propertyType === 'prefab' || + (propertyInfo.type === 'asset' && propertyType === 'string')) { + console.log(`[ComponentTools] Setting asset reference:`, { + value: processedValue, + property: property, + propertyType: propertyType, + path: propertyPath + }); // Determine asset type based on property name let assetType = 'cc.SpriteFrame'; // default if (property.toLowerCase().includes('texture')) { @@ -685,40 +764,17 @@ class ComponentTools { else if (property.toLowerCase().includes('clip')) { assetType = 'cc.AudioClip'; } - // Try multiple approaches for setting asset properties - try { - // Approach 1: Direct property setting with asset structure - await Editor.Message.request('scene', 'set-property', { - uuid: nodeUuid, - path: propertyPath, - dump: { - value: assetValue, - type: assetType - } - }); + else if (propertyType === 'prefab') { + assetType = 'cc.Prefab'; } - catch (error1) { - try { - // Approach 2: Try with different structure - await Editor.Message.request('scene', 'set-property', { - uuid: nodeUuid, - path: propertyPath, - dump: { - value: { - __uuid__: assetValue.uuid || assetValue - } - } - }); + await Editor.Message.request('scene', 'set-property', { + uuid: nodeUuid, + path: propertyPath, + dump: { + value: processedValue, + type: assetType } - catch (error2) { - // Approach 3: Try direct UUID assignment - await Editor.Message.request('scene', 'set-property', { - uuid: nodeUuid, - path: propertyPath, - dump: { value: assetValue.uuid || assetValue } - }); - } - } + }); } else if (componentType === 'cc.UITransform' && (property === '_contentSize' || property === 'contentSize')) { // Special handling for UITransform contentSize - set width and height separately @@ -754,7 +810,7 @@ class ComponentTools { dump: { value: anchorY } }); } - else if (propertyInfo.type === 'color' && processedValue && typeof processedValue === 'object') { + else if (propertyType === 'color' && processedValue && typeof processedValue === 'object') { // 特殊处理颜色属性，确保RGBA值正确 // Cocos Creator颜色值范围是0-255 const colorValue = { @@ -763,6 +819,7 @@ class ComponentTools { b: Math.min(255, Math.max(0, Number(processedValue.b) || 0)), a: processedValue.a !== undefined ? Math.min(255, Math.max(0, Number(processedValue.a))) : 255 }; + console.log(`[ComponentTools] Setting color value:`, colorValue); await Editor.Message.request('scene', 'set-property', { uuid: nodeUuid, path: propertyPath, @@ -772,7 +829,7 @@ class ComponentTools { } }); } - else if (propertyInfo.type === 'vec3' && processedValue && typeof processedValue === 'object') { + else if (propertyType === 'vec3' && processedValue && typeof processedValue === 'object') { // 特殊处理Vec3属性 const vec3Value = { x: Number(processedValue.x) || 0, @@ -788,7 +845,7 @@ class ComponentTools { } }); } - else if (propertyInfo.type === 'vec2' && processedValue && typeof processedValue === 'object') { + else if (propertyType === 'vec2' && processedValue && typeof processedValue === 'object') { // 特殊处理Vec2属性 const vec2Value = { x: Number(processedValue.x) || 0, @@ -803,7 +860,7 @@ class ComponentTools { } }); } - else if (propertyInfo.type === 'size' && processedValue && typeof processedValue === 'object') { + else if (propertyType === 'size' && processedValue && typeof processedValue === 'object') { // 特殊处理Size属性 const sizeValue = { width: Number(processedValue.width) || 0, @@ -818,7 +875,7 @@ class ComponentTools { } }); } - else if ((propertyInfo.type === 'node' || propertyInfo.type === 'cc.Node') && processedValue && typeof processedValue === 'object' && 'uuid' in processedValue) { + else if (propertyType === 'node' && processedValue && typeof processedValue === 'object' && 'uuid' in processedValue) { // 特殊处理节点引用 console.log(`[ComponentTools] Setting node reference with UUID: ${processedValue.uuid}`); await Editor.Message.request('scene', 'set-property', { @@ -830,93 +887,127 @@ class ComponentTools { } }); } - else if (propertyInfo.type === 'component') { - // 特殊处理组件引用 - 方案B：使用完整的属性描述符 - let componentValue; - let originalPropertyDescriptor = {}; - // 关键优化：获取完整的原始属性描述符 - try { - const tempResult = await this.getComponentInfo(nodeUuid, componentType); - if (tempResult.success && ((_b = (_a = tempResult.data) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b[property])) { - const propertyMeta = tempResult.data.properties[property]; - if (propertyMeta && typeof propertyMeta === 'object') { - // 保存完整的属性描述符（除了value之外的所有信息） - originalPropertyDescriptor = Object.assign({}, propertyMeta); - delete originalPropertyDescriptor.value; // 移除旧的value，我们会设置新的 - console.log(`[setComponentProperty] Preserving original property descriptor for ${property}:`, Object.keys(originalPropertyDescriptor)); + else if (propertyType === 'component' && typeof processedValue === 'string') { + // 特殊处理组件引用：通过节点UUID找到组件的__id__ + const targetNodeUuid = processedValue; + console.log(`[ComponentTools] Setting component reference - finding component on node: ${targetNodeUuid}`); + // 从当前组件的属性元数据中获取期望的组件类型 + let expectedComponentType = ''; + // 获取当前组件的详细信息，包括属性元数据 + const currentComponentInfo = await this.getComponentInfo(nodeUuid, componentType); + if (currentComponentInfo.success && ((_b = (_a = currentComponentInfo.data) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b[property])) { + const propertyMeta = currentComponentInfo.data.properties[property]; + // 从属性元数据中提取组件类型信息 + if (propertyMeta && typeof propertyMeta === 'object') { + // 检查是否有type字段指示组件类型 + if (propertyMeta.type) { + expectedComponentType = propertyMeta.type; + } + else if (propertyMeta.ctor) { + // 有些属性可能使用ctor字段 + expectedComponentType = propertyMeta.ctor; + } + else if (propertyMeta.extends && Array.isArray(propertyMeta.extends)) { + // 检查extends数组，通常第一个是最具体的类型 + for (const extendType of propertyMeta.extends) { + if (extendType.startsWith('cc.') && extendType !== 'cc.Component' && extendType !== 'cc.Object') { + expectedComponentType = extendType; + break; + } + } } } } - catch (error) { - console.warn(`[setComponentProperty] Failed to get original property descriptor: ${error}`); + if (!expectedComponentType) { + throw new Error(`Unable to determine required component type for property '${property}' on component '${componentType}'. Property metadata may not contain type information.`); } - if (typeof processedValue === 'string') { - // 如果是字符串，假设是组件的UUID - componentValue = { uuid: processedValue }; - } - else if (processedValue && typeof processedValue === 'object') { - if (processedValue.node && processedValue.component) { - // 如果提供了节点和组件类型，需要查找具体的组件UUID - try { - const nodeData = await Editor.Message.request('scene', 'query-node', processedValue.node); - if (nodeData && nodeData.__comps__) { - const targetComponent = nodeData.__comps__.find((comp) => comp.__type__ === processedValue.component); - if (targetComponent) { - componentValue = { uuid: targetComponent.uuid || "" }; - } - else { - componentValue = { uuid: "" }; - } + console.log(`[ComponentTools] Detected required component type: ${expectedComponentType} for property: ${property}`); + try { + // 获取目标节点的组件信息 + const targetNodeData = await Editor.Message.request('scene', 'query-node', targetNodeUuid); + if (!targetNodeData || !targetNodeData.__comps__) { + throw new Error(`Target node ${targetNodeUuid} not found or has no components`); + } + // 打印目标节点的组件概览 + console.log(`[ComponentTools] Target node ${targetNodeUuid} has ${targetNodeData.__comps__.length} components:`); + targetNodeData.__comps__.forEach((comp, index) => { + const sceneId = comp.value && comp.value.uuid && comp.value.uuid.value ? comp.value.uuid.value : 'unknown'; + console.log(`[ComponentTools] Component ${index}: ${comp.type} (scene_id: ${sceneId})`); + }); + // 查找对应的组件 + let targetComponent = null; + let componentId = null; + // 在目标节点的_components数组中查找指定类型的组件 + // 注意：__comps__和_components的索引是对应的 + console.log(`[ComponentTools] Searching for component type: ${expectedComponentType}`); + for (let i = 0; i < targetNodeData.__comps__.length; i++) { + const comp = targetNodeData.__comps__[i]; + console.log(`[ComponentTools] Checking component ${i}: type=${comp.type}, target=${expectedComponentType}`); + if (comp.type === expectedComponentType) { + targetComponent = comp; + console.log(`[ComponentTools] Found matching component at index ${i}: ${comp.type}`); + // 从组件的value.uuid.value中获取组件在场景中的ID + if (comp.value && comp.value.uuid && comp.value.uuid.value) { + componentId = comp.value.uuid.value; + console.log(`[ComponentTools] Got componentId from comp.value.uuid.value: ${componentId}`); } else { - componentValue = { uuid: "" }; + console.log(`[ComponentTools] Component structure:`, { + hasValue: !!comp.value, + hasUuid: !!(comp.value && comp.value.uuid), + hasUuidValue: !!(comp.value && comp.value.uuid && comp.value.uuid.value), + uuidStructure: comp.value ? comp.value.uuid : 'No value' + }); + throw new Error(`Unable to extract component ID from component structure`); } - } - catch (error) { - console.warn(`[setComponentProperty] Failed to find component: ${error}`); - componentValue = { uuid: "" }; + break; } } - else { - componentValue = processedValue; + if (!targetComponent) { + // 如果没找到，列出可用组件让用户了解，显示场景中的真实ID + const availableComponents = targetNodeData.__comps__.map((comp, index) => { + let sceneId = 'unknown'; + // 从组件的value.uuid.value获取场景ID + if (comp.value && comp.value.uuid && comp.value.uuid.value) { + sceneId = comp.value.uuid.value; + } + return `${comp.type}(scene_id:${sceneId})`; + }); + throw new Error(`Component type '${expectedComponentType}' not found on node ${targetNodeUuid}. Available components: ${availableComponents.join(', ')}`); } + console.log(`[ComponentTools] Found component ${expectedComponentType} with scene ID: ${componentId} on node ${targetNodeUuid}`); + // 更新期望值为实际的组件ID对象格式，用于后续验证 + if (componentId) { + actualExpectedValue = { uuid: componentId }; + } + // 尝试使用与节点/资源引用相同的格式：{uuid: componentId} + // 测试看是否能正确设置组件引用 + await Editor.Message.request('scene', 'set-property', { + uuid: nodeUuid, + path: propertyPath, + dump: { + value: { uuid: componentId }, // 使用对象格式，像节点/资源引用一样 + type: expectedComponentType + } + }); } - else { - componentValue = { uuid: "" }; + catch (error) { + console.error(`[ComponentTools] Error setting component reference:`, error); + throw error; } - // 方案B：使用完整的属性描述符，保持所有原始元数据 - const dumpData = Object.assign({ value: componentValue }, originalPropertyDescriptor // 保持完整的属性描述符 - ); - console.log(`[setComponentProperty] Setting with complete descriptor:`, Object.keys(dumpData)); - await Editor.Message.request('scene', 'set-property', { - uuid: nodeUuid, - path: propertyPath, - dump: dumpData - }); } - else if (propertyInfo.type === 'nodeArray' && Array.isArray(processedValue)) { - // 特殊处理节点数组 - const nodeArrayValue = processedValue.map((item) => { - if (typeof item === 'string') { - return { __uuid__: item }; - } - else if (item && typeof item === 'object' && (item.uuid || item.__uuid__)) { - return { __uuid__: item.uuid || item.__uuid__ }; - } - else { - return { __uuid__: "" }; - } - }); + else if (propertyType === 'nodeArray' && Array.isArray(processedValue)) { + // 特殊处理节点数组 - 保持预处理的格式 + console.log(`[ComponentTools] Setting node array:`, processedValue); await Editor.Message.request('scene', 'set-property', { uuid: nodeUuid, path: propertyPath, dump: { - value: nodeArrayValue, - type: 'cc.Node' + value: processedValue // 保持 [{uuid: "..."}, {uuid: "..."}] 格式 } }); } - else if (propertyInfo.type === 'colorArray' && Array.isArray(processedValue)) { + else if (propertyType === 'colorArray' && Array.isArray(processedValue)) { // 特殊处理颜色数组 const colorArrayValue = processedValue.map((item) => { if (item && typeof item === 'object' && 'r' in item) { @@ -950,20 +1041,17 @@ class ComponentTools { } // Step 5: 等待Editor完成更新，然后验证设置结果 await new Promise(resolve => setTimeout(resolve, 200)); // 等待200ms让Editor完成更新 - const verification = await this.verifyPropertyChange(nodeUuid, componentType, property, originalValue, processedValue); + const verification = await this.verifyPropertyChange(nodeUuid, componentType, property, originalValue, actualExpectedValue); resolve({ success: true, - message: `Successfully set ${componentType}.${property} = ${JSON.stringify(processedValue)}`, + message: `Successfully set ${componentType}.${property}`, data: { nodeUuid, componentType, property, - originalValue, - newValue: processedValue, actualValue: verification.actualValue, changeVerified: verification.verified - }, - verificationData: verification.fullData + } }); } catch (error) { @@ -976,28 +1064,67 @@ class ComponentTools { }); } async attachScript(nodeUuid, scriptPath) { - return new Promise((resolve) => { - var _a; + return new Promise(async (resolve) => { + var _a, _b; // 从脚本路径提取组件类名 const scriptName = (_a = scriptPath.split('/').pop()) === null || _a === void 0 ? void 0 : _a.replace('.ts', '').replace('.js', ''); if (!scriptName) { resolve({ success: false, error: 'Invalid script path' }); return; } + // 先查找节点上是否已存在该脚本组件 + const allComponentsInfo = await this.getComponents(nodeUuid); + if (allComponentsInfo.success && ((_b = allComponentsInfo.data) === null || _b === void 0 ? void 0 : _b.components)) { + const existingScript = allComponentsInfo.data.components.find((comp) => comp.type === scriptName); + if (existingScript) { + resolve({ + success: true, + message: `Script '${scriptName}' already exists on node`, + data: { + nodeUuid: nodeUuid, + componentName: scriptName, + existing: true + } + }); + return; + } + } // 首先尝试直接使用脚本名称作为组件类型 Editor.Message.request('scene', 'create-component', { uuid: nodeUuid, component: scriptName // 使用脚本名称而非UUID - }).then((result) => { - resolve({ - success: true, - data: { - componentId: result, - scriptPath: scriptPath, - componentName: scriptName, - message: `Script '${scriptName}' attached successfully` + }).then(async (result) => { + var _a; + // 等待一段时间让Editor完成组件添加 + await new Promise(resolve => setTimeout(resolve, 100)); + // 重新查询节点信息验证脚本是否真的添加成功 + const allComponentsInfo2 = await this.getComponents(nodeUuid); + if (allComponentsInfo2.success && ((_a = allComponentsInfo2.data) === null || _a === void 0 ? void 0 : _a.components)) { + const addedScript = allComponentsInfo2.data.components.find((comp) => comp.type === scriptName); + if (addedScript) { + resolve({ + success: true, + message: `Script '${scriptName}' attached successfully`, + data: { + nodeUuid: nodeUuid, + componentName: scriptName, + existing: false + } + }); } - }); + else { + resolve({ + success: false, + error: `Script '${scriptName}' was not found on node after addition. Available components: ${allComponentsInfo2.data.components.map((c) => c.type).join(', ')}` + }); + } + } + else { + resolve({ + success: false, + error: `Failed to verify script addition: ${allComponentsInfo2.error || 'Unable to get node components'}` + }); + } }).catch((err) => { // 备用方案：使用场景脚本 const options = { @@ -1263,48 +1390,46 @@ class ComponentTools { } return Boolean(inputValue); case 'color': - if (typeof inputValue === 'object' && inputValue !== null) { - // 先检查对象的值是否都是数字或字符串，避免对复杂对象使用'in'操作符 + // 优化的颜色处理，支持多种输入格式 + if (typeof inputValue === 'string') { + // 字符串格式：十六进制、颜色名称、rgb()/rgba() + return this.parseColorString(inputValue); + } + else if (typeof inputValue === 'object' && inputValue !== null) { try { - // 如果输入是颜色对象，直接使用 const inputKeys = Object.keys(inputValue); + // 如果输入是颜色对象，验证并转换 if (inputKeys.includes('r') || inputKeys.includes('g') || inputKeys.includes('b')) { return { - r: Number(inputValue.r) || 0, - g: Number(inputValue.g) || 0, - b: Number(inputValue.b) || 0, - a: inputValue.a !== undefined ? Number(inputValue.a) : 255 + r: Math.min(255, Math.max(0, Number(inputValue.r) || 0)), + g: Math.min(255, Math.max(0, Number(inputValue.g) || 0)), + b: Math.min(255, Math.max(0, Number(inputValue.b) || 0)), + a: inputValue.a !== undefined ? Math.min(255, Math.max(0, Number(inputValue.a))) : 255 }; } } catch (error) { - // 如果使用'in'操作符出错，说明不是有效的颜色对象 - console.warn(`[smartConvertValue] Invalid color input: ${JSON.stringify(inputValue)}`); + console.warn(`[smartConvertValue] Invalid color object: ${JSON.stringify(inputValue)}`); } } - else if (typeof inputValue === 'string') { - // 如果是字符串，尝试解析为十六进制颜色 - return this.parseColorString(inputValue); - } - // 保持原值结构，只更新提供的值 - try { - const inputKeys = typeof inputValue === 'object' && inputValue ? Object.keys(inputValue) : []; - return { - r: inputKeys.includes('r') ? Number(inputValue.r) : (originalValue.r || 255), - g: inputKeys.includes('g') ? Number(inputValue.g) : (originalValue.g || 255), - b: inputKeys.includes('b') ? Number(inputValue.b) : (originalValue.b || 255), - a: inputKeys.includes('a') ? Number(inputValue.a) : (originalValue.a || 255) - }; - } - catch (error) { - // 如果有任何错误，返回原值或默认值 - return { - r: originalValue.r || 255, - g: originalValue.g || 255, - b: originalValue.b || 255, - a: originalValue.a || 255 - }; + // 如果有原值，保持原值结构并更新提供的值 + if (originalValue && typeof originalValue === 'object') { + try { + const inputKeys = typeof inputValue === 'object' && inputValue ? Object.keys(inputValue) : []; + return { + r: inputKeys.includes('r') ? Math.min(255, Math.max(0, Number(inputValue.r))) : (originalValue.r || 255), + g: inputKeys.includes('g') ? Math.min(255, Math.max(0, Number(inputValue.g))) : (originalValue.g || 255), + b: inputKeys.includes('b') ? Math.min(255, Math.max(0, Number(inputValue.b))) : (originalValue.b || 255), + a: inputKeys.includes('a') ? Math.min(255, Math.max(0, Number(inputValue.a))) : (originalValue.a || 255) + }; + } + catch (error) { + console.warn(`[smartConvertValue] Error processing color with original value: ${error}`); + } } + // 默认返回白色 + console.warn(`[smartConvertValue] Using default white color for invalid input: ${JSON.stringify(inputValue)}`); + return { r: 255, g: 255, b: 255, a: 255 }; case 'vec2': if (typeof inputValue === 'object' && inputValue !== null) { return { @@ -1358,15 +1483,25 @@ class ComponentTools { } } parseColorString(colorStr) { - // 简单的颜色字符串解析（支持#RRGGBB格式） // cSpell:ignore RRGGBB - if (colorStr.startsWith('#') && colorStr.length === 7) { - const r = parseInt(colorStr.substring(1, 3), 16); - const g = parseInt(colorStr.substring(3, 5), 16); - const b = parseInt(colorStr.substring(5, 7), 16); - return { r, g, b, a: 255 }; + const str = colorStr.trim(); + // 只支持十六进制格式 #RRGGBB 或 #RRGGBBAA + if (str.startsWith('#')) { + if (str.length === 7) { // #RRGGBB + const r = parseInt(str.substring(1, 3), 16); + const g = parseInt(str.substring(3, 5), 16); + const b = parseInt(str.substring(5, 7), 16); + return { r, g, b, a: 255 }; + } + else if (str.length === 9) { // #RRGGBBAA + const r = parseInt(str.substring(1, 3), 16); + const g = parseInt(str.substring(3, 5), 16); + const b = parseInt(str.substring(5, 7), 16); + const a = parseInt(str.substring(7, 9), 16); + return { r, g, b, a }; + } } - // 默认返回白色 - return { r: 255, g: 255, b: 255, a: 255 }; + // 如果不是有效的十六进制格式，返回错误提示 + throw new Error(`Invalid color format: "${colorStr}". Only hexadecimal format is supported (e.g., "#FF0000" or "#FF0000FF")`); } async verifyPropertyChange(nodeUuid, componentType, property, originalValue, expectedValue) { var _a, _b; @@ -1478,6 +1613,116 @@ class ComponentTools { fullData: null }; } + /** + * 检测是否为节点属性，如果是则重定向到对应的节点方法 + */ + async checkAndRedirectNodeProperties(args) { + const { nodeUuid, componentType, property, propertyType, value } = args; + // 检测是否为节点基础属性（应该使用 set_node_property） + const nodeBasicProperties = [ + 'name', 'active', 'layer', 'mobility', 'parent', 'children', 'hideFlags' + ]; + // 检测是否为节点变换属性（应该使用 set_node_transform） + const nodeTransformProperties = [ + 'position', 'rotation', 'scale', 'eulerAngles', 'angle' + ]; + // Detect attempts to set cc.Node properties (common mistake) + if (componentType === 'cc.Node' || componentType === 'Node') { + if (nodeBasicProperties.includes(property)) { + return { + success: false, + error: `Property '${property}' is a node basic property, not a component property`, + instruction: `Please use set_node_property method to set node properties: set_node_property(uuid="${nodeUuid}", property="${property}", value=${JSON.stringify(value)})` + }; + } + else if (nodeTransformProperties.includes(property)) { + return { + success: false, + error: `Property '${property}' is a node transform property, not a component property`, + instruction: `Please use set_node_transform method to set transform properties: set_node_transform(uuid="${nodeUuid}", ${property}=${JSON.stringify(value)})` + }; + } + } + // Detect common incorrect usage + if (nodeBasicProperties.includes(property) || nodeTransformProperties.includes(property)) { + const methodName = nodeTransformProperties.includes(property) ? 'set_node_transform' : 'set_node_property'; + return { + success: false, + error: `Property '${property}' is a node property, not a component property`, + instruction: `Property '${property}' should be set using ${methodName} method, not set_component_property. Please use: ${methodName}(uuid="${nodeUuid}", ${nodeTransformProperties.includes(property) ? property : `property="${property}"`}=${JSON.stringify(value)})` + }; + } + return null; // 不是节点属性，继续正常处理 + } + /** + * 生成组件建议信息 + */ + generateComponentSuggestion(requestedType, availableTypes, property) { + // 检查是否存在相似的组件类型 + const similarTypes = availableTypes.filter(type => type.toLowerCase().includes(requestedType.toLowerCase()) || + requestedType.toLowerCase().includes(type.toLowerCase())); + let instruction = ''; + if (similarTypes.length > 0) { + instruction += `\n\n🔍 Found similar components: ${similarTypes.join(', ')}`; + instruction += `\n💡 Suggestion: Perhaps you meant to set the '${similarTypes[0]}' component?`; + } + // Recommend possible components based on property name + const propertyToComponentMap = { + 'string': ['cc.Label', 'cc.RichText', 'cc.EditBox'], + 'text': ['cc.Label', 'cc.RichText'], + 'fontSize': ['cc.Label', 'cc.RichText'], + 'spriteFrame': ['cc.Sprite'], + 'color': ['cc.Label', 'cc.Sprite', 'cc.Graphics'], + 'normalColor': ['cc.Button'], + 'pressedColor': ['cc.Button'], + 'target': ['cc.Button'], + 'contentSize': ['cc.UITransform'], + 'anchorPoint': ['cc.UITransform'] + }; + const recommendedComponents = propertyToComponentMap[property] || []; + const availableRecommended = recommendedComponents.filter(comp => availableTypes.includes(comp)); + if (availableRecommended.length > 0) { + instruction += `\n\n🎯 Based on property '${property}', recommended components: ${availableRecommended.join(', ')}`; + } + // Provide operation suggestions + instruction += `\n\n📋 Suggested Actions:`; + instruction += `\n1. Use get_components(nodeUuid="${requestedType.includes('uuid') ? 'YOUR_NODE_UUID' : 'nodeUuid'}") to view all components on the node`; + instruction += `\n2. If you need to add a component, use add_component(nodeUuid="...", componentType="${requestedType}")`; + instruction += `\n3. Verify that the component type name is correct (case-sensitive)`; + return instruction; + } + /** + * 快速验证资源设置结果 + */ + async quickVerifyAsset(nodeUuid, componentType, property) { + try { + const rawNodeData = await Editor.Message.request('scene', 'query-node', nodeUuid); + if (!rawNodeData || !rawNodeData.__comps__) { + return null; + } + // 找到组件 + const component = rawNodeData.__comps__.find((comp) => { + const compType = comp.__type__ || comp.cid || comp.type; + return compType === componentType; + }); + if (!component) { + return null; + } + // 提取属性值 + const properties = this.extractComponentProperties(component); + const propertyData = properties[property]; + if (propertyData && typeof propertyData === 'object' && 'value' in propertyData) { + return propertyData.value; + } + else { + return propertyData; + } + } + catch (error) { + console.error(`[quickVerifyAsset] Error:`, error); + return null; + } + } } exports.ComponentTools = ComponentTools; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-tools.js","sourceRoot":"","sources":["../../source/tools/component-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, ComponentInfo } from '../types';\n\nexport class ComponentTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'add_component',\n                description: 'Add a component to a specific node. IMPORTANT: You must provide the nodeUuid parameter to specify which node to add the component to.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Target node UUID. REQUIRED: You must specify the exact node to add the component to. Use get_all_nodes or find_node_by_name to get the UUID of the desired node.'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type (e.g., cc.Sprite, cc.Label, cc.Button)'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType']\n                }\n            },\n            {\n                name: 'remove_component',\n                description: 'Remove a component from a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type to remove'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType']\n                }\n            },\n            {\n                name: 'get_components',\n                description: 'Get all components of a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        }\n                    },\n                    required: ['nodeUuid']\n                }\n            },\n            {\n                name: 'get_component_info',\n                description: 'Get specific component information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type to get info for'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType']\n                }\n            },\n            {\n                name: 'set_component_property',\n                description: 'Set component property value - AI必须提供5个参数：节点UUID、组件名称、属性名称、属性类型、属性值\\n' +\n                    '重要：对于引用类型属性：\\n' +\n                    '• 节点引用(propertyType: \"node\"): value传入目标节点的UUID字符串\\n' +\n                    '• 组件引用(propertyType: \"component\"): value传入目标组件的UUID字符串\\n' +\n                    '• 资源引用(propertyType: \"spriteFrame/prefab/asset\"): value传入资源UUID字符串',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID - 节点的UUID'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type - 组件类型',\n                            enum: ['cc.Label', 'cc.Sprite', 'cc.Button', 'cc.Toggle', 'cc.Slider', 'cc.ScrollView', 'cc.EditBox', 'cc.ProgressBar', 'cc.RichText', 'cc.Mask', 'cc.Graphics', 'cc.Layout', 'cc.Widget', 'cc.UITransform', 'TestMCPScript']\n                        },\n                        property: {\n                            type: 'string',\n                            description: 'Property name - 属性名称'\n                        },\n                        propertyType: {\n                            type: 'string',\n                            description: 'Property type - 属性类型（必须明确指定）',\n                            enum: [\n                                'string', 'number', 'boolean', 'integer', 'float',\n                                'color', 'vec2', 'vec3', 'size',\n                                'node', 'component', 'spriteFrame', 'prefab', 'asset',\n                                'nodeArray', 'colorArray', 'numberArray', 'stringArray'\n                            ]\n                        },\n                        value: {\n                            description: 'Property value - 属性值，根据propertyType使用不同格式:\\n' +\n                                '基础类型：\\n' +\n                                '• string: \"Hello World\"\\n' +\n                                '• number/integer/float: 42 或 3.14\\n' +\n                                '• boolean: true 或 false\\n' +\n                                '• color: {\"r\":255,\"g\":0,\"b\":0,\"a\":255}\\n' +\n                                '• vec2: {\"x\":100,\"y\":50}\\n' +\n                                '• vec3: {\"x\":1,\"y\":2,\"z\":3}\\n' +\n                                '• size: {\"width\":100,\"height\":50}\\n' +\n                                '引用类型（重要）：\\n' +\n                                '• node: \"target-node-uuid-string\" （目标节点的UUID字符串）\\n' +\n                                '• component: \"target-component-uuid-string\" （目标组件的UUID字符串）\\n' +\n                                '• spriteFrame/prefab/asset: \"asset-uuid-string\" （资源UUID字符串）\\n' +\n                                '数组类型：\\n' +\n                                '• nodeArray: [\"uuid1\",\"uuid2\",\"uuid3\"]\\n' +\n                                '• colorArray: [{\"r\":255,\"g\":0,\"b\":0,\"a\":255},{\"r\":0,\"g\":255,\"b\":0,\"a\":255}]\\n' +\n                                '• numberArray: [1,2,3,4,5]\\n' +\n                                '• stringArray: [\"item1\",\"item2\",\"item3\"]'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType', 'property', 'propertyType', 'value']\n                }\n            },\n            {\n                name: 'attach_script',\n                description: 'Attach a script component to a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        scriptPath: {\n                            type: 'string',\n                            description: 'Script asset path (e.g., db://assets/scripts/MyScript.ts)'\n                        }\n                    },\n                    required: ['nodeUuid', 'scriptPath']\n                }\n            },\n            {\n                name: 'get_available_components',\n                description: 'Get list of available component types',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        category: {\n                            type: 'string',\n                            description: 'Component category filter',\n                            enum: ['all', 'renderer', 'ui', 'physics', 'animation', 'audio'],\n                            default: 'all'\n                        }\n                    }\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'add_component':\n                return await this.addComponent(args.nodeUuid, args.componentType);\n            case 'remove_component':\n                return await this.removeComponent(args.nodeUuid, args.componentType);\n            case 'get_components':\n                return await this.getComponents(args.nodeUuid);\n            case 'get_component_info':\n                return await this.getComponentInfo(args.nodeUuid, args.componentType);\n            case 'set_component_property':\n                return await this.setComponentProperty(args);\n            case 'attach_script':\n                return await this.attachScript(args.nodeUuid, args.scriptPath);\n            case 'get_available_components':\n                return await this.getAvailableComponents(args.category);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async addComponent(nodeUuid: string, componentType: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试直接使用 Editor API 添加组件\n            Editor.Message.request('scene', 'create-component', {\n                uuid: nodeUuid,\n                component: componentType\n            }).then((result: any) => {\n                // Get comprehensive verification data including node info and all components\n                Promise.all([\n                    this.getComponents(nodeUuid),\n                    this.getComponentInfo(nodeUuid, componentType)\n                ]).then(([allComponentsInfo, newComponentInfo]) => {\n                    const addedComponent = allComponentsInfo.data?.components?.find((comp: any) => comp.type === componentType);\n                    resolve({\n                        success: true,\n                        data: {\n                            componentId: result,\n                            nodeUuid: nodeUuid,\n                            componentType: componentType,\n                            message: `Component '${componentType}' added successfully`,\n                            componentVerified: !!addedComponent\n                        },\n                        verificationData: {\n                            addedComponent: newComponentInfo.data,\n                            allNodeComponents: allComponentsInfo.data,\n                            componentCount: allComponentsInfo.data?.components?.length || 0,\n                            verificationStatus: {\n                                componentExists: !!addedComponent,\n                                componentDetails: addedComponent || null\n                            }\n                        }\n                    });\n                }).catch(() => {\n                    resolve({\n                        success: true,\n                        data: {\n                            componentId: result,\n                            nodeUuid: nodeUuid,\n                            componentType: componentType,\n                            message: `Component '${componentType}' added successfully (verification failed)`\n                        }\n                    });\n                });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'addComponentToNode',\n                    args: [nodeUuid, componentType]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async removeComponent(nodeUuid: string, componentType: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const options = {\n                name: 'cocos-mcp-server',\n                method: 'removeComponentFromNode',\n                args: [nodeUuid, componentType]\n            };\n            \n            Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                resolve(result);\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getComponents(nodeUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试直接使用 Editor API 查询节点信息\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => {\n                if (nodeData && nodeData.__comps__) {\n                    const components = nodeData.__comps__.map((comp: any) => ({\n                        type: comp.__type__ || comp.cid || comp.type || 'Unknown',\n                        enabled: comp.enabled !== undefined ? comp.enabled : true,\n                        properties: this.extractComponentProperties(comp)\n                    }));\n                    \n                    resolve({\n                        success: true,\n                        data: {\n                            nodeUuid: nodeUuid,\n                            components: components\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: 'Node not found or no components data' });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getNodeInfo',\n                    args: [nodeUuid]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    if (result.success) {\n                        resolve({\n                            success: true,\n                            data: result.data.components\n                        });\n                    } else {\n                        resolve(result);\n                    }\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async getComponentInfo(nodeUuid: string, componentType: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试直接使用 Editor API 查询节点信息\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => {\n                if (nodeData && nodeData.__comps__) {\n                    const component = nodeData.__comps__.find((comp: any) => {\n                        const compType = comp.__type__ || comp.cid || comp.type;\n                        return compType === componentType;\n                    });\n                    \n                    if (component) {\n                        resolve({\n                            success: true,\n                            data: {\n                                nodeUuid: nodeUuid,\n                                componentType: componentType,\n                                enabled: component.enabled !== undefined ? component.enabled : true,\n                                properties: this.extractComponentProperties(component)\n                            }\n                        });\n                    } else {\n                        resolve({ success: false, error: `Component '${componentType}' not found on node` });\n                    }\n                } else {\n                    resolve({ success: false, error: 'Node not found or no components data' });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getNodeInfo',\n                    args: [nodeUuid]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    if (result.success && result.data.components) {\n                        const component = result.data.components.find((comp: any) => comp.type === componentType);\n                        if (component) {\n                            resolve({\n                                success: true,\n                                data: {\n                                    nodeUuid: nodeUuid,\n                                    componentType: componentType,\n                                    ...component\n                                }\n                            });\n                        } else {\n                            resolve({ success: false, error: `Component '${componentType}' not found on node` });\n                        }\n                    } else {\n                        resolve({ success: false, error: result.error || 'Failed to get component info' });\n                    }\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private extractComponentProperties(component: any): Record<string, any> {\n        console.log(`[extractComponentProperties] Processing component:`, Object.keys(component));\n        \n        // 检查组件是否有 value 属性，这通常包含实际的组件属性\n        if (component.value && typeof component.value === 'object') {\n            console.log(`[extractComponentProperties] Found component.value with properties:`, Object.keys(component.value));\n            return component.value; // 直接返回 value 对象，它包含所有组件属性\n        }\n        \n        // 备用方案：从组件对象中直接提取属性\n        const properties: Record<string, any> = {};\n        const excludeKeys = ['__type__', 'enabled', 'node', '_id', '__scriptAsset', 'uuid', 'name', '_name', '_objFlags', '_enabled', 'type', 'readonly', 'visible', 'cid', 'editor', 'extends'];\n        \n        for (const key in component) {\n            if (!excludeKeys.includes(key) && !key.startsWith('_')) {\n                console.log(`[extractComponentProperties] Found direct property '${key}':`, typeof component[key]);\n                properties[key] = component[key];\n            }\n        }\n        \n        console.log(`[extractComponentProperties] Final extracted properties:`, Object.keys(properties));\n        return properties;\n    }\n\n    private async setComponentProperty(args: any): Promise<ToolResponse> {\n        const { nodeUuid, componentType, property, propertyType, value } = args;\n        \n        return new Promise(async (resolve) => {\n            try {\n                console.log(`[ComponentTools] Setting ${componentType}.${property} (type: ${propertyType}) = ${JSON.stringify(value)} on node ${nodeUuid}`);\n                \n                // Step 1: 获取组件信息，使用与getComponents相同的方法\n                const componentsResponse = await this.getComponents(nodeUuid);\n                if (!componentsResponse.success || !componentsResponse.data) {\n                    resolve({\n                        success: false,\n                        error: `Failed to get components for node '${nodeUuid}': ${componentsResponse.error}`\n                    });\n                    return;\n                }\n                \n                const allComponents = componentsResponse.data.components;\n                \n                // Step 2: 查找目标组件\n                let targetComponent = null;\n                const availableTypes: string[] = [];\n                \n                for (let i = 0; i < allComponents.length; i++) {\n                    const comp = allComponents[i];\n                    availableTypes.push(comp.type);\n                    \n                    if (comp.type === componentType) {\n                        targetComponent = comp;\n                        break;\n                    }\n                }\n                \n                if (!targetComponent) {\n                    resolve({\n                        success: false,\n                        error: `Component '${componentType}' not found on node. Available components: ${availableTypes.join(', ')}`\n                    });\n                    return;\n                }\n                \n                // Step 3: 自动检测和转换属性值\n                let propertyInfo;\n                try {\n                    console.log(`[ComponentTools] Analyzing property: ${property}`);\n                    propertyInfo = this.analyzeProperty(targetComponent, property);\n                } catch (analyzeError: any) {\n                    console.error(`[ComponentTools] Error in analyzeProperty:`, analyzeError);\n                    resolve({\n                        success: false,\n                        error: `Failed to analyze property '${property}': ${analyzeError.message}`\n                    });\n                    return;\n                }\n                \n                if (!propertyInfo.exists) {\n                    resolve({\n                        success: false,\n                        error: `Property '${property}' not found on component '${componentType}'. Available properties: ${propertyInfo.availableProperties.join(', ')}`\n                    });\n                    return;\n                }\n                \n                // Step 4: 处理属性值和设置\n                const originalValue = propertyInfo.originalValue;\n                let processedValue: any;\n                \n                // 根据明确的propertyType处理属性值\n                switch (propertyType) {\n                    case 'string':\n                        processedValue = String(value);\n                        break;\n                    case 'number':\n                    case 'integer':\n                    case 'float':\n                        processedValue = Number(value);\n                        break;\n                    case 'boolean':\n                        processedValue = Boolean(value);\n                        break;\n                    case 'color':\n                        if (typeof value === 'object' && value !== null) {\n                            processedValue = {\n                                r: Math.min(255, Math.max(0, Number(value.r) || 0)),\n                                g: Math.min(255, Math.max(0, Number(value.g) || 0)),\n                                b: Math.min(255, Math.max(0, Number(value.b) || 0)),\n                                a: value.a !== undefined ? Math.min(255, Math.max(0, Number(value.a))) : 255\n                            };\n                        } else {\n                            throw new Error('Color value must be an object with r, g, b properties');\n                        }\n                        break;\n                    case 'vec2':\n                        if (typeof value === 'object' && value !== null) {\n                            processedValue = {\n                                x: Number(value.x) || 0,\n                                y: Number(value.y) || 0\n                            };\n                        } else {\n                            throw new Error('Vec2 value must be an object with x, y properties');\n                        }\n                        break;\n                    case 'vec3':\n                        if (typeof value === 'object' && value !== null) {\n                            processedValue = {\n                                x: Number(value.x) || 0,\n                                y: Number(value.y) || 0,\n                                z: Number(value.z) || 0\n                            };\n                        } else {\n                            throw new Error('Vec3 value must be an object with x, y, z properties');\n                        }\n                        break;\n                    case 'size':\n                        if (typeof value === 'object' && value !== null) {\n                            processedValue = {\n                                width: Number(value.width) || 0,\n                                height: Number(value.height) || 0\n                            };\n                        } else {\n                            throw new Error('Size value must be an object with width, height properties');\n                        }\n                        break;\n                    case 'node':\n                        if (typeof value === 'string') {\n                            processedValue = { uuid: value };\n                        } else {\n                            throw new Error('Node reference value must be a string UUID');\n                        }\n                        break;\n                    case 'component':\n                        if (typeof value === 'string') {\n                            // 组件引用：需要验证节点上是否有对应组件类型\n                            // 推断组件类型从属性名称（例如：labelComponent -> Label, buttonComponent -> Button）\n                            let expectedComponentType = '';\n                            const propertyLower = property.toLowerCase(); \n                            if (propertyLower.includes('label')) {\n                                expectedComponentType = 'cc.Label';\n                            } else if (propertyLower.includes('button')) {\n                                expectedComponentType = 'cc.Button';\n                            } else if (propertyLower.includes('sprite')) {\n                                expectedComponentType = 'cc.Sprite';\n                            } else if (propertyLower.includes('canvas')) {\n                                expectedComponentType = 'cc.Canvas';\n                            } else if (propertyLower.includes('camera')) {\n                                expectedComponentType = 'cc.Camera';\n                            }\n                            \n                            // 验证目标节点是否存在指定组件\n                            try {\n                                const nodeData = await Editor.Message.request('scene', 'query-node', value);\n                                if (nodeData && nodeData.__comps__ && expectedComponentType) {\n                                    const targetComponent = nodeData.__comps__.find((comp: any) => \n                                        comp.__type__ === expectedComponentType\n                                    );\n                                    if (targetComponent) {\n                                        // 找到匹配组件，使用组件的UUID\n                                        processedValue = { uuid: (targetComponent as any).uuid || value };\n                                    } else {\n                                        console.warn(`[setComponentProperty] Node ${value} does not have component ${expectedComponentType}`);\n                                        processedValue = { uuid: value }; // 仍然设置，让Editor处理\n                                    }\n                                } else {\n                                    // 无法推断组件类型或节点不存在，直接使用UUID\n                                    processedValue = { uuid: value };\n                                }\n                            } catch (error) {\n                                console.warn(`[setComponentProperty] Failed to verify component on node ${value}: ${error}`);\n                                processedValue = { uuid: value }; // 仍然设置，让Editor处理\n                            }\n                        } else if (typeof value === 'object' && value !== null && value.node && value.component) {\n                            // 查找具体的组件UUID\n                            try {\n                                const nodeData = await Editor.Message.request('scene', 'query-node', value.node);\n                                if (nodeData && nodeData.__comps__) {\n                                    const targetComponent = nodeData.__comps__.find((comp: any) => \n                                        comp.__type__ === value.component\n                                    );\n                                    if (targetComponent) {\n                                        processedValue = { uuid: (targetComponent as any).uuid || \"\" };\n                                    } else {\n                                        processedValue = { uuid: \"\" };\n                                    }\n                                } else {\n                                    processedValue = { uuid: \"\" };\n                                }\n                            } catch (error) {\n                                console.warn(`[setComponentProperty] Failed to find component: ${error}`);\n                                processedValue = { uuid: \"\" };\n                            }\n                        } else {\n                            throw new Error('Component reference value must be a string UUID or object with node and component properties');\n                        }\n                        break;\n                    case 'spriteFrame':\n                    case 'prefab':\n                    case 'asset':\n                        if (typeof value === 'string') {\n                            processedValue = { uuid: value };\n                        } else {\n                            throw new Error(`${propertyType} value must be a string UUID`);\n                        }\n                        break;\n                    case 'nodeArray':\n                        if (Array.isArray(value)) {\n                            processedValue = value.map((item: any) => {\n                                if (typeof item === 'string') {\n                                    return { uuid: item };\n                                } else {\n                                    throw new Error('NodeArray items must be string UUIDs');\n                                }\n                            });\n                        } else {\n                            throw new Error('NodeArray value must be an array');\n                        }\n                        break;\n                    case 'colorArray':\n                        if (Array.isArray(value)) {\n                            processedValue = value.map((item: any) => {\n                                if (typeof item === 'object' && item !== null && 'r' in item) {\n                                    return {\n                                        r: Math.min(255, Math.max(0, Number(item.r) || 0)),\n                                        g: Math.min(255, Math.max(0, Number(item.g) || 0)),\n                                        b: Math.min(255, Math.max(0, Number(item.b) || 0)),\n                                        a: item.a !== undefined ? Math.min(255, Math.max(0, Number(item.a))) : 255\n                                    };\n                                } else {\n                                    throw new Error('ColorArray items must be objects with r, g, b properties');\n                                }\n                            });\n                        } else {\n                            throw new Error('ColorArray value must be an array');\n                        }\n                        break;\n                    case 'numberArray':\n                        if (Array.isArray(value)) {\n                            processedValue = value.map((item: any) => Number(item));\n                        } else {\n                            throw new Error('NumberArray value must be an array');\n                        }\n                        break;\n                    case 'stringArray':\n                        if (Array.isArray(value)) {\n                            processedValue = value.map((item: any) => String(item));\n                        } else {\n                            throw new Error('StringArray value must be an array');\n                        }\n                        break;\n                    default:\n                        throw new Error(`Unsupported property type: ${propertyType}`);\n                }\n                \n                console.log(`[ComponentTools] Converting value: ${JSON.stringify(value)} -> ${JSON.stringify(processedValue)} (type: ${propertyType})`);\n                \n                // Step 5: 获取原始节点数据来构建正确的路径\n                const rawNodeData = await Editor.Message.request('scene', 'query-node', nodeUuid);\n                if (!rawNodeData || !rawNodeData.__comps__) {\n                    resolve({\n                        success: false,\n                        error: `Failed to get raw node data for property setting`\n                    });\n                    return;\n                }\n                \n                // 找到原始组件的索引\n                let rawComponentIndex = -1;\n                for (let i = 0; i < rawNodeData.__comps__.length; i++) {\n                    const comp = rawNodeData.__comps__[i] as any;\n                    const compType = comp.__type__ || comp.cid || comp.type || 'Unknown';\n                    if (compType === componentType) {\n                        rawComponentIndex = i;\n                        break;\n                    }\n                }\n                \n                if (rawComponentIndex === -1) {\n                    resolve({\n                        success: false,\n                        error: `Could not find component index for setting property`\n                    });\n                    return;\n                }\n                \n                // 构建正确的属性路径\n                let propertyPath = `__comps__.${rawComponentIndex}.${property}`;\n                \n                // 特殊处理资源类属性\n                if (propertyInfo.type === 'asset') {\n                    // 对于资源类属性，需要特殊处理\n                    const assetValue = typeof processedValue === 'string' ? \n                        { uuid: processedValue } : processedValue;\n                    \n                    // Determine asset type based on property name\n                    let assetType = 'cc.SpriteFrame'; // default\n                    if (property.toLowerCase().includes('texture')) {\n                        assetType = 'cc.Texture2D';\n                    } else if (property.toLowerCase().includes('material')) {\n                        assetType = 'cc.Material';\n                    } else if (property.toLowerCase().includes('font')) {\n                        assetType = 'cc.Font';\n                    } else if (property.toLowerCase().includes('clip')) {\n                        assetType = 'cc.AudioClip';\n                    }\n                    \n                    // Try multiple approaches for setting asset properties\n                    try {\n                        // Approach 1: Direct property setting with asset structure\n                        await Editor.Message.request('scene', 'set-property', {\n                            uuid: nodeUuid,\n                            path: propertyPath,\n                            dump: { \n                                value: assetValue,\n                                type: assetType\n                            }\n                        });\n                    } catch (error1) {\n                        try {\n                            // Approach 2: Try with different structure\n                            await Editor.Message.request('scene', 'set-property', {\n                                uuid: nodeUuid,\n                                path: propertyPath,\n                                dump: { \n                                    value: {\n                                        __uuid__: assetValue.uuid || assetValue\n                                    }\n                                }\n                            });\n                        } catch (error2) {\n                            // Approach 3: Try direct UUID assignment\n                            await Editor.Message.request('scene', 'set-property', {\n                                uuid: nodeUuid,\n                                path: propertyPath,\n                                dump: { value: assetValue.uuid || assetValue }\n                            });\n                        }\n                    }\n                } else if (componentType === 'cc.UITransform' && (property === '_contentSize' || property === 'contentSize')) {\n                    // Special handling for UITransform contentSize - set width and height separately\n                    const width = Number(value.width) || 100;\n                    const height = Number(value.height) || 100;\n                    \n                    // Set width first\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: `__comps__.${rawComponentIndex}.width`,\n                        dump: { value: width }\n                    });\n                    \n                    // Then set height\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: `__comps__.${rawComponentIndex}.height`,\n                        dump: { value: height }\n                    });\n                } else if (componentType === 'cc.UITransform' && (property === '_anchorPoint' || property === 'anchorPoint')) {\n                    // Special handling for UITransform anchorPoint - set anchorX and anchorY separately\n                    const anchorX = Number(value.x) || 0.5;\n                    const anchorY = Number(value.y) || 0.5;\n                    \n                    // Set anchorX first\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: `__comps__.${rawComponentIndex}.anchorX`,\n                        dump: { value: anchorX }\n                    });\n                    \n                    // Then set anchorY  \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: `__comps__.${rawComponentIndex}.anchorY`,\n                        dump: { value: anchorY }\n                    });\n                } else if (propertyInfo.type === 'color' && processedValue && typeof processedValue === 'object') {\n                    // 特殊处理颜色属性，确保RGBA值正确\n                    // Cocos Creator颜色值范围是0-255\n                    const colorValue = {\n                        r: Math.min(255, Math.max(0, Number(processedValue.r) || 0)),\n                        g: Math.min(255, Math.max(0, Number(processedValue.g) || 0)),\n                        b: Math.min(255, Math.max(0, Number(processedValue.b) || 0)),\n                        a: processedValue.a !== undefined ? Math.min(255, Math.max(0, Number(processedValue.a))) : 255\n                    };\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: colorValue,\n                            type: 'cc.Color'\n                        }\n                    });\n                } else if (propertyInfo.type === 'vec3' && processedValue && typeof processedValue === 'object') {\n                    // 特殊处理Vec3属性\n                    const vec3Value = {\n                        x: Number(processedValue.x) || 0,\n                        y: Number(processedValue.y) || 0,\n                        z: Number(processedValue.z) || 0\n                    };\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: vec3Value,\n                            type: 'cc.Vec3'\n                        }\n                    });\n                } else if (propertyInfo.type === 'vec2' && processedValue && typeof processedValue === 'object') {\n                    // 特殊处理Vec2属性\n                    const vec2Value = {\n                        x: Number(processedValue.x) || 0,\n                        y: Number(processedValue.y) || 0\n                    };\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: vec2Value,\n                            type: 'cc.Vec2'\n                        }\n                    });\n                } else if (propertyInfo.type === 'size' && processedValue && typeof processedValue === 'object') {\n                    // 特殊处理Size属性\n                    const sizeValue = {\n                        width: Number(processedValue.width) || 0,\n                        height: Number(processedValue.height) || 0\n                    };\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: sizeValue,\n                            type: 'cc.Size'\n                        }\n                    });\n                } else if ((propertyInfo.type === 'node' || propertyInfo.type === 'cc.Node') && processedValue && typeof processedValue === 'object' && 'uuid' in processedValue) {\n                    // 特殊处理节点引用\n                    console.log(`[ComponentTools] Setting node reference with UUID: ${processedValue.uuid}`);\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: processedValue,\n                            type: 'cc.Node'\n                        }\n                    });\n                } else if (propertyInfo.type === 'component') {\n                    // 特殊处理组件引用 - 方案B：使用完整的属性描述符\n                    let componentValue;\n                    let originalPropertyDescriptor: any = {};\n                    \n                    // 关键优化：获取完整的原始属性描述符\n                    try {\n                        const tempResult = await this.getComponentInfo(nodeUuid, componentType);\n                        if (tempResult.success && tempResult.data?.properties?.[property]) {\n                            const propertyMeta = tempResult.data.properties[property];\n                            if (propertyMeta && typeof propertyMeta === 'object') {\n                                // 保存完整的属性描述符（除了value之外的所有信息）\n                                originalPropertyDescriptor = { ...propertyMeta };\n                                delete originalPropertyDescriptor.value; // 移除旧的value，我们会设置新的\n                                console.log(`[setComponentProperty] Preserving original property descriptor for ${property}:`, Object.keys(originalPropertyDescriptor));\n                            }\n                        }\n                    } catch (error) {\n                        console.warn(`[setComponentProperty] Failed to get original property descriptor: ${error}`);\n                    }\n                    \n                    if (typeof processedValue === 'string') {\n                        // 如果是字符串，假设是组件的UUID\n                        componentValue = { uuid: processedValue };\n                    } else if (processedValue && typeof processedValue === 'object') {\n                        if (processedValue.node && processedValue.component) {\n                            // 如果提供了节点和组件类型，需要查找具体的组件UUID\n                            try {\n                                const nodeData = await Editor.Message.request('scene', 'query-node', processedValue.node);\n                                if (nodeData && nodeData.__comps__) {\n                                    const targetComponent = nodeData.__comps__.find((comp: any) => \n                                        comp.__type__ === processedValue.component\n                                    );\n                                    if (targetComponent) {\n                                        componentValue = { uuid: (targetComponent as any).uuid || \"\" };\n                                    } else {\n                                        componentValue = { uuid: \"\" };\n                                    }\n                                } else {\n                                    componentValue = { uuid: \"\" };\n                                }\n                            } catch (error) {\n                                console.warn(`[setComponentProperty] Failed to find component: ${error}`);\n                                componentValue = { uuid: \"\" };\n                            }\n                        } else {\n                            componentValue = processedValue;\n                        }\n                    } else {\n                        componentValue = { uuid: \"\" };\n                    }\n                    \n                    // 方案B：使用完整的属性描述符，保持所有原始元数据\n                    const dumpData = {\n                        value: componentValue,\n                        ...originalPropertyDescriptor // 保持完整的属性描述符\n                    };\n                    \n                    console.log(`[setComponentProperty] Setting with complete descriptor:`, Object.keys(dumpData));\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: dumpData\n                    });\n                } else if (propertyInfo.type === 'nodeArray' && Array.isArray(processedValue)) {\n                    // 特殊处理节点数组\n                    const nodeArrayValue = processedValue.map((item: any) => {\n                        if (typeof item === 'string') {\n                            return { __uuid__: item };\n                        } else if (item && typeof item === 'object' && (item.uuid || item.__uuid__)) {\n                            return { __uuid__: item.uuid || item.__uuid__ };\n                        } else {\n                            return { __uuid__: \"\" };\n                        }\n                    });\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: nodeArrayValue,\n                            type: 'cc.Node'\n                        }\n                    });\n                } else if (propertyInfo.type === 'colorArray' && Array.isArray(processedValue)) {\n                    // 特殊处理颜色数组\n                    const colorArrayValue = processedValue.map((item: any) => {\n                        if (item && typeof item === 'object' && 'r' in item) {\n                            return {\n                                r: Math.min(255, Math.max(0, Number(item.r) || 0)),\n                                g: Math.min(255, Math.max(0, Number(item.g) || 0)),\n                                b: Math.min(255, Math.max(0, Number(item.b) || 0)),\n                                a: item.a !== undefined ? Math.min(255, Math.max(0, Number(item.a))) : 255\n                            };\n                        } else {\n                            return { r: 255, g: 255, b: 255, a: 255 };\n                        }\n                    });\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: colorArrayValue,\n                            type: 'cc.Color'\n                        }\n                    });\n                } else {\n                    // Normal property setting for non-asset properties\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { value: processedValue }\n                    });\n                }\n                \n                // Step 5: 等待Editor完成更新，然后验证设置结果\n                await new Promise(resolve => setTimeout(resolve, 200)); // 等待200ms让Editor完成更新\n                const verification = await this.verifyPropertyChange(nodeUuid, componentType, property, originalValue, processedValue);\n                \n                resolve({\n                    success: true,\n                    message: `Successfully set ${componentType}.${property} = ${JSON.stringify(processedValue)}`,\n                    data: {\n                        nodeUuid,\n                        componentType,\n                        property,\n                        originalValue,\n                        newValue: processedValue,\n                        actualValue: verification.actualValue,\n                        changeVerified: verification.verified\n                    },\n                    verificationData: verification.fullData\n                });\n                \n            } catch (error: any) {\n                console.error(`[ComponentTools] Error setting property:`, error);\n                resolve({\n                    success: false,\n                    error: `Failed to set property: ${error.message}`\n                });\n            }\n        });\n    }\n\n\n    private async attachScript(nodeUuid: string, scriptPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 从脚本路径提取组件类名\n            const scriptName = scriptPath.split('/').pop()?.replace('.ts', '').replace('.js', '');\n            if (!scriptName) {\n                resolve({ success: false, error: 'Invalid script path' });\n                return;\n            }\n            \n            // 首先尝试直接使用脚本名称作为组件类型\n            Editor.Message.request('scene', 'create-component', {\n                uuid: nodeUuid,\n                component: scriptName  // 使用脚本名称而非UUID\n            }).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        componentId: result,\n                        scriptPath: scriptPath,\n                        componentName: scriptName,\n                        message: `Script '${scriptName}' attached successfully`\n                    }\n                });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'attachScript',\n                    args: [nodeUuid, scriptPath]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch(() => {\n                    resolve({ \n                        success: false, \n                        error: `Failed to attach script '${scriptName}': ${err.message}`,\n                        instruction: 'Please ensure the script is properly compiled and exported as a Component class. You can also manually attach the script through the Properties panel in the editor.'\n                    });\n                });\n            });\n        });\n    }\n\n    private async getAvailableComponents(category: string = 'all'): Promise<ToolResponse> {\n        const componentCategories: Record<string, string[]> = {\n            renderer: ['cc.Sprite', 'cc.Label', 'cc.RichText', 'cc.Mask', 'cc.Graphics'],\n            ui: ['cc.Button', 'cc.Toggle', 'cc.Slider', 'cc.ScrollView', 'cc.EditBox', 'cc.ProgressBar'],\n            physics: ['cc.RigidBody2D', 'cc.BoxCollider2D', 'cc.CircleCollider2D', 'cc.PolygonCollider2D'],\n            animation: ['cc.Animation', 'cc.AnimationClip', 'cc.SkeletalAnimation'],\n            audio: ['cc.AudioSource'],\n            layout: ['cc.Layout', 'cc.Widget', 'cc.PageView', 'cc.PageViewIndicator'],\n            effects: ['cc.MotionStreak', 'cc.ParticleSystem2D'],\n            camera: ['cc.Camera'],\n            light: ['cc.Light', 'cc.DirectionalLight', 'cc.PointLight', 'cc.SpotLight']\n        };\n\n        let components: string[] = [];\n        \n        if (category === 'all') {\n            for (const cat in componentCategories) {\n                components = components.concat(componentCategories[cat]);\n            }\n        } else if (componentCategories[category]) {\n            components = componentCategories[category];\n        }\n\n        return {\n            success: true,\n            data: {\n                category: category,\n                components: components\n            }\n        };\n    }\n\n    private isValidPropertyDescriptor(propData: any): boolean {\n        // 检查是否是有效的属性描述对象\n        if (typeof propData !== 'object' || propData === null) {\n            return false;\n        }\n        \n        try {\n            const keys = Object.keys(propData);\n            \n            // 避免遍历简单的数值对象（如 {width: 200, height: 150}）\n            const isSimpleValueObject = keys.every(key => {\n                const value = propData[key];\n                return typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean';\n            });\n            \n            if (isSimpleValueObject) {\n                return false;\n            }\n            \n            // 检查是否包含属性描述符的特征字段，不使用'in'操作符\n            const hasName = keys.includes('name');\n            const hasValue = keys.includes('value');\n            const hasType = keys.includes('type');\n            const hasDisplayName = keys.includes('displayName');\n            const hasReadonly = keys.includes('readonly');\n            \n            // 必须包含name或value字段，且通常还有type字段\n            const hasValidStructure = (hasName || hasValue) && (hasType || hasDisplayName || hasReadonly);\n            \n            // 额外检查：如果有default字段且结构复杂，避免深度遍历\n            if (keys.includes('default') && propData.default && typeof propData.default === 'object') {\n                const defaultKeys = Object.keys(propData.default);\n                if (defaultKeys.includes('value') && typeof propData.default.value === 'object') {\n                    // 这种情况下，我们只返回顶层属性，不深入遍历default.value\n                    return hasValidStructure;\n                }\n            }\n            \n            return hasValidStructure;\n        } catch (error) {\n            console.warn(`[isValidPropertyDescriptor] Error checking property descriptor:`, error);\n            return false;\n        }\n    }\n\n    private analyzeProperty(component: any, propertyName: string): { exists: boolean; type: string; availableProperties: string[]; originalValue: any } {\n        // 从复杂的组件结构中提取可用属性\n        const availableProperties: string[] = [];\n        let propertyValue: any = undefined;\n        let propertyExists = false;\n        \n        // 尝试多种方式查找属性：\n        // 1. 直接属性访问\n        if (Object.prototype.hasOwnProperty.call(component, propertyName)) {\n            propertyValue = component[propertyName];\n            propertyExists = true;\n        }\n        \n        // 2. 从嵌套结构中查找 (如从测试数据看到的复杂结构)\n        if (!propertyExists && component.properties && typeof component.properties === 'object') {\n            // 首先检查properties.value是否存在（这是我们在getComponents中看到的结构）\n            if (component.properties.value && typeof component.properties.value === 'object') {\n                const valueObj = component.properties.value;\n                for (const [key, propData] of Object.entries(valueObj)) {\n                    // 检查propData是否是一个有效的属性描述对象\n                    // 确保propData是对象且包含预期的属性结构\n                    if (this.isValidPropertyDescriptor(propData)) {\n                        const propInfo = propData as any;\n                        availableProperties.push(key);\n                        if (key === propertyName) {\n                            // 优先使用value属性，如果没有则使用propData本身\n                            try {\n                                const propKeys = Object.keys(propInfo);\n                                propertyValue = propKeys.includes('value') ? propInfo.value : propInfo;\n                            } catch (error) {\n                                // 如果检查失败，直接使用propInfo\n                                propertyValue = propInfo;\n                            }\n                            propertyExists = true;\n                        }\n                    }\n                }\n            } else {\n                // 备用方案：直接从properties查找\n                for (const [key, propData] of Object.entries(component.properties)) {\n                    if (this.isValidPropertyDescriptor(propData)) {\n                        const propInfo = propData as any;\n                        availableProperties.push(key);\n                        if (key === propertyName) {\n                            // 优先使用value属性，如果没有则使用propData本身\n                            try {\n                                const propKeys = Object.keys(propInfo);\n                                propertyValue = propKeys.includes('value') ? propInfo.value : propInfo;\n                            } catch (error) {\n                                // 如果检查失败，直接使用propInfo\n                                propertyValue = propInfo;\n                            }\n                            propertyExists = true;\n                        }\n                    }\n                }\n            }\n        }\n        \n        // 3. 从直接属性中提取简单属性名\n        if (availableProperties.length === 0) {\n            for (const key of Object.keys(component)) {\n                if (!key.startsWith('_') && !['__type__', 'cid', 'node', 'uuid', 'name', 'enabled', 'type', 'readonly', 'visible'].includes(key)) {\n                    availableProperties.push(key);\n                }\n            }\n        }\n        \n        if (!propertyExists) {\n            return {\n                exists: false,\n                type: 'unknown',\n                availableProperties,\n                originalValue: undefined\n            };\n        }\n        \n        let type = 'unknown';\n        \n        // 智能类型检测\n        if (Array.isArray(propertyValue)) {\n            // 数组类型检测\n            if (propertyName.toLowerCase().includes('node')) {\n                type = 'nodeArray';\n            } else if (propertyName.toLowerCase().includes('color')) {\n                type = 'colorArray';\n            } else {\n                type = 'array';\n            }\n        } else if (typeof propertyValue === 'string') {\n            // Check if property name suggests it's an asset\n            if (['spriteFrame', 'texture', 'material', 'font', 'clip', 'prefab'].includes(propertyName.toLowerCase())) {\n                type = 'asset';\n            } else {\n                type = 'string';\n            }\n        } else if (typeof propertyValue === 'number') {\n            type = 'number';\n        } else if (typeof propertyValue === 'boolean') {\n            type = 'boolean';\n        } else if (propertyValue && typeof propertyValue === 'object') {\n            try {\n                const keys = Object.keys(propertyValue);\n                if (keys.includes('r') && keys.includes('g') && keys.includes('b')) {\n                    type = 'color';\n                } else if (keys.includes('x') && keys.includes('y')) {\n                    type = propertyValue.z !== undefined ? 'vec3' : 'vec2';\n                } else if (keys.includes('width') && keys.includes('height')) {\n                    type = 'size';\n                } else if (keys.includes('uuid') || keys.includes('__uuid__')) {\n                    // 检查是否是节点引用（通过属性名或__id__属性判断）\n                    if (propertyName.toLowerCase().includes('node') || \n                        propertyName.toLowerCase().includes('target') ||\n                        keys.includes('__id__')) {\n                        type = 'node';\n                    } else {\n                        type = 'asset';\n                    }\n                } else if (keys.includes('__id__')) {\n                    // 节点引用特征\n                    type = 'node';\n                } else {\n                    type = 'object';\n                }\n            } catch (error) {\n                console.warn(`[analyzeProperty] Error checking property type for: ${JSON.stringify(propertyValue)}`);\n                type = 'object';\n            }\n        } else if (propertyValue === null || propertyValue === undefined) {\n            // For null/undefined values, check property name to determine type\n            if (['spriteFrame', 'texture', 'material', 'font', 'clip', 'prefab'].includes(propertyName.toLowerCase())) {\n                type = 'asset';\n            } else if (propertyName.toLowerCase().includes('node') || \n                      propertyName.toLowerCase().includes('target')) {\n                type = 'node';\n            } else if (propertyName.toLowerCase().includes('component')) {\n                type = 'component';\n            } else {\n                type = 'unknown';\n            }\n        }\n        \n        return {\n            exists: true,\n            type,\n            availableProperties,\n            originalValue: propertyValue\n        };\n    }\n\n    private smartConvertValue(inputValue: any, propertyInfo: any): any {\n        const { type, originalValue } = propertyInfo;\n        \n        console.log(`[smartConvertValue] Converting ${JSON.stringify(inputValue)} to type: ${type}`);\n        \n        switch (type) {\n            case 'string':\n                return String(inputValue);\n                \n            case 'number':\n                return Number(inputValue);\n                \n            case 'boolean':\n                if (typeof inputValue === 'boolean') return inputValue;\n                if (typeof inputValue === 'string') {\n                    return inputValue.toLowerCase() === 'true' || inputValue === '1';\n                }\n                return Boolean(inputValue);\n                \n            case 'color':\n                if (typeof inputValue === 'object' && inputValue !== null) {\n                    // 先检查对象的值是否都是数字或字符串，避免对复杂对象使用'in'操作符\n                    try {\n                        // 如果输入是颜色对象，直接使用\n                        const inputKeys = Object.keys(inputValue);\n                        if (inputKeys.includes('r') || inputKeys.includes('g') || inputKeys.includes('b')) {\n                            return {\n                                r: Number(inputValue.r) || 0,\n                                g: Number(inputValue.g) || 0,\n                                b: Number(inputValue.b) || 0,\n                                a: inputValue.a !== undefined ? Number(inputValue.a) : 255\n                            };\n                        }\n                    } catch (error) {\n                        // 如果使用'in'操作符出错，说明不是有效的颜色对象\n                        console.warn(`[smartConvertValue] Invalid color input: ${JSON.stringify(inputValue)}`);\n                    }\n                } else if (typeof inputValue === 'string') {\n                    // 如果是字符串，尝试解析为十六进制颜色\n                    return this.parseColorString(inputValue);\n                }\n                // 保持原值结构，只更新提供的值\n                try {\n                    const inputKeys = typeof inputValue === 'object' && inputValue ? Object.keys(inputValue) : [];\n                    return {\n                        r: inputKeys.includes('r') ? Number(inputValue.r) : (originalValue.r || 255),\n                        g: inputKeys.includes('g') ? Number(inputValue.g) : (originalValue.g || 255),\n                        b: inputKeys.includes('b') ? Number(inputValue.b) : (originalValue.b || 255),\n                        a: inputKeys.includes('a') ? Number(inputValue.a) : (originalValue.a || 255)\n                    };\n                } catch (error) {\n                    // 如果有任何错误，返回原值或默认值\n                    return {\n                        r: originalValue.r || 255,\n                        g: originalValue.g || 255,\n                        b: originalValue.b || 255,\n                        a: originalValue.a || 255\n                    };\n                }\n                \n            case 'vec2':\n                if (typeof inputValue === 'object' && inputValue !== null) {\n                    return {\n                        x: Number(inputValue.x) || originalValue.x || 0,\n                        y: Number(inputValue.y) || originalValue.y || 0\n                    };\n                }\n                return originalValue;\n                \n            case 'vec3':\n                if (typeof inputValue === 'object' && inputValue !== null) {\n                    return {\n                        x: Number(inputValue.x) || originalValue.x || 0,\n                        y: Number(inputValue.y) || originalValue.y || 0,\n                        z: Number(inputValue.z) || originalValue.z || 0\n                    };\n                }\n                return originalValue;\n                \n            case 'size':\n                if (typeof inputValue === 'object' && inputValue !== null) {\n                    return {\n                        width: Number(inputValue.width) || originalValue.width || 100,\n                        height: Number(inputValue.height) || originalValue.height || 100\n                    };\n                }\n                return originalValue;\n                \n            case 'node':\n                if (typeof inputValue === 'string') {\n                    // 节点引用需要特殊处理\n                    return inputValue;\n                } else if (typeof inputValue === 'object' && inputValue !== null) {\n                    // 如果已经是对象形式，返回UUID或完整对象\n                    return inputValue.uuid || inputValue;\n                }\n                return originalValue;\n                \n            case 'asset':\n                if (typeof inputValue === 'string') {\n                    // 如果输入是字符串路径，转换为asset对象\n                    return { uuid: inputValue };\n                } else if (typeof inputValue === 'object' && inputValue !== null) {\n                    return inputValue;\n                }\n                return originalValue;\n                \n            default:\n                // 对于未知类型，尽量保持原有结构\n                if (typeof inputValue === typeof originalValue) {\n                    return inputValue;\n                }\n                return originalValue;\n        }\n    }\n\n    private parseColorString(colorStr: string): { r: number; g: number; b: number; a: number } {\n        // 简单的颜色字符串解析（支持#RRGGBB格式） // cSpell:ignore RRGGBB\n        if (colorStr.startsWith('#') && colorStr.length === 7) {\n            const r = parseInt(colorStr.substring(1, 3), 16);\n            const g = parseInt(colorStr.substring(3, 5), 16);\n            const b = parseInt(colorStr.substring(5, 7), 16);\n            return { r, g, b, a: 255 };\n        }\n        // 默认返回白色\n        return { r: 255, g: 255, b: 255, a: 255 };\n    }\n\n    private async verifyPropertyChange(nodeUuid: string, componentType: string, property: string, originalValue: any, expectedValue: any): Promise<{ verified: boolean; actualValue: any; fullData: any }> {\n        console.log(`[verifyPropertyChange] Starting verification for ${componentType}.${property}`);\n        console.log(`[verifyPropertyChange] Expected value:`, JSON.stringify(expectedValue));\n        console.log(`[verifyPropertyChange] Original value:`, JSON.stringify(originalValue));\n        \n        try {\n            // 重新获取组件信息进行验证\n            console.log(`[verifyPropertyChange] Calling getComponentInfo...`);\n            const componentInfo = await this.getComponentInfo(nodeUuid, componentType);\n            console.log(`[verifyPropertyChange] getComponentInfo success:`, componentInfo.success);\n            \n            const allComponents = await this.getComponents(nodeUuid);\n            console.log(`[verifyPropertyChange] getComponents success:`, allComponents.success);\n            \n            if (componentInfo.success && componentInfo.data) {\n                console.log(`[verifyPropertyChange] Component data available, extracting property '${property}'`);\n                const allPropertyNames = Object.keys(componentInfo.data.properties || {});\n                console.log(`[verifyPropertyChange] Available properties:`, allPropertyNames);\n                const propertyData = componentInfo.data.properties?.[property];\n                console.log(`[verifyPropertyChange] Raw property data for '${property}':`, JSON.stringify(propertyData));\n                \n                // 从属性数据中提取实际值\n                let actualValue = propertyData;\n                console.log(`[verifyPropertyChange] Initial actualValue:`, JSON.stringify(actualValue));\n                \n                if (propertyData && typeof propertyData === 'object' && 'value' in propertyData) {\n                    actualValue = propertyData.value;\n                    console.log(`[verifyPropertyChange] Extracted actualValue from .value:`, JSON.stringify(actualValue));\n                } else {\n                    console.log(`[verifyPropertyChange] No .value property found, using raw data`);\n                }\n                \n                // 修复验证逻辑：检查实际值是否匹配期望值\n                let verified = false;\n                \n                if (typeof expectedValue === 'object' && expectedValue !== null && 'uuid' in expectedValue) {\n                    // 对于引用类型（节点/组件/资源），比较UUID\n                    const actualUuid = actualValue && typeof actualValue === 'object' && 'uuid' in actualValue ? actualValue.uuid : '';\n                    const expectedUuid = expectedValue.uuid || '';\n                    verified = actualUuid === expectedUuid && expectedUuid !== '';\n                    \n                    console.log(`[verifyPropertyChange] Reference comparison:`);\n                    console.log(`  - Expected UUID: \"${expectedUuid}\"`);\n                    console.log(`  - Actual UUID: \"${actualUuid}\"`);\n                    console.log(`  - UUID match: ${actualUuid === expectedUuid}`);\n                    console.log(`  - UUID not empty: ${expectedUuid !== ''}`);\n                    console.log(`  - Final verified: ${verified}`);\n                } else {\n                    // 对于其他类型，直接比较值\n                    console.log(`[verifyPropertyChange] Value comparison:`);\n                    console.log(`  - Expected type: ${typeof expectedValue}`);\n                    console.log(`  - Actual type: ${typeof actualValue}`);\n                    \n                    if (typeof actualValue === typeof expectedValue) {\n                        if (typeof actualValue === 'object' && actualValue !== null && expectedValue !== null) {\n                            // 对象类型的深度比较\n                            verified = JSON.stringify(actualValue) === JSON.stringify(expectedValue);\n                            console.log(`  - Object comparison (JSON): ${verified}`);\n                        } else {\n                            // 基本类型的直接比较\n                            verified = actualValue === expectedValue;\n                            console.log(`  - Direct comparison: ${verified}`);\n                        }\n                    } else {\n                        // 类型不匹配时的特殊处理（如数字和字符串）\n                        const stringMatch = String(actualValue) === String(expectedValue);\n                        const numberMatch = Number(actualValue) === Number(expectedValue);\n                        verified = stringMatch || numberMatch;\n                        console.log(`  - String match: ${stringMatch}`);\n                        console.log(`  - Number match: ${numberMatch}`);\n                        console.log(`  - Type mismatch verified: ${verified}`);\n                    }\n                }\n                \n                console.log(`[verifyPropertyChange] Final verification result: ${verified}`);\n                console.log(`[verifyPropertyChange] Final actualValue:`, JSON.stringify(actualValue));\n                \n                const result = {\n                    verified,\n                    actualValue,\n                    fullData: {\n                        // 只返回修改的属性信息，不返回完整组件数据\n                        modifiedProperty: {\n                            name: property,\n                            before: originalValue,\n                            expected: expectedValue,\n                            actual: actualValue,\n                            verified,\n                            propertyMetadata: propertyData // 只包含这个属性的元数据\n                        },\n                        // 简化的组件信息\n                        componentSummary: {\n                            nodeUuid,\n                            componentType,\n                            totalProperties: Object.keys(componentInfo.data?.properties || {}).length\n                        }\n                    }\n                };\n                \n                console.log(`[verifyPropertyChange] Returning result:`, JSON.stringify(result, null, 2));\n                return result;\n            } else {\n                console.log(`[verifyPropertyChange] ComponentInfo failed or no data:`, componentInfo);\n            }\n        } catch (error) {\n            console.error('[verifyPropertyChange] Verification failed with error:', error);\n            console.error('[verifyPropertyChange] Error stack:', error instanceof Error ? error.stack : 'No stack trace');\n        }\n        \n        console.log(`[verifyPropertyChange] Returning fallback result`);\n        return {\n            verified: false,\n            actualValue: undefined,\n            fullData: null\n        };\n    }\n}"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-tools.js","sourceRoot":"","sources":["../../source/tools/component-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, ComponentInfo } from '../types';\n\nexport class ComponentTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'add_component',\n                description: 'Add a component to a specific node. IMPORTANT: You must provide the nodeUuid parameter to specify which node to add the component to.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Target node UUID. REQUIRED: You must specify the exact node to add the component to. Use get_all_nodes or find_node_by_name to get the UUID of the desired node.'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type (e.g., cc.Sprite, cc.Label, cc.Button)'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType']\n                }\n            },\n            {\n                name: 'remove_component',\n                description: 'Remove a component from a node. componentType must be the component\\'s classId (cid, i.e. the type field from getComponents), not the script name or class name. Use getComponents to get the correct cid.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component cid (type field from getComponents). Do NOT use script name or class name. Example: \"cc.Sprite\" or \"9b4a7ueT9xD6aRE+AlOusy1\"'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType']\n                }\n            },\n            {\n                name: 'get_components',\n                description: 'Get all components of a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        }\n                    },\n                    required: ['nodeUuid']\n                }\n            },\n            {\n                name: 'get_component_info',\n                description: 'Get specific component information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type to get info for'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType']\n                }\n            },\n            {\n                name: 'set_component_property',\n                description: 'Set component property values for UI components or custom script components. Supports setting properties of built-in UI components (e.g., cc.Label, cc.Sprite) and custom script components. Note: For node basic properties (name, active, layer, etc.), use set_node_property. For node transform properties (position, rotation, scale, etc.), use set_node_transform.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Target node UUID - Must specify the node to operate on'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type - Can be built-in components (e.g., cc.Label) or custom script components (e.g., MyScript). If unsure about component type, use get_components first to retrieve all components on the node.',\n                            // 移除enum限制，允许任意组件类型包括自定义脚本\n                        },\n                        property: {\n                            type: 'string',\n                            description: 'Property name - The property to set. Common properties include:\\n' +\n                                '• cc.Label: string (text content), fontSize (font size), color (text color)\\n' +\n                                '• cc.Sprite: spriteFrame (sprite frame), color (tint color), sizeMode (size mode)\\n' +\n                                '• cc.Button: normalColor (normal color), pressedColor (pressed color), target (target node)\\n' +\n                                '• cc.UITransform: contentSize (content size), anchorPoint (anchor point)\\n' +\n                                '• Custom Scripts: Based on properties defined in the script'\n                        },\n                        propertyType: {\n                            type: 'string',\n                            description: 'Property type - Must explicitly specify the property data type for correct value conversion and validation',\n                            enum: [\n                                'string', 'number', 'boolean', 'integer', 'float',\n                                'color', 'vec2', 'vec3', 'size',\n                                'node', 'component', 'spriteFrame', 'prefab', 'asset',\n                                'nodeArray', 'colorArray', 'numberArray', 'stringArray'\n                            ]\n                                                },\n\n                        value: {\n                            description: 'Property value - Use the corresponding data format based on propertyType:\\n\\n' +\n                                '📝 Basic Data Types:\\n' +\n                                '• string: \"Hello World\" (text string)\\n' +\n                                '• number/integer/float: 42 or 3.14 (numeric value)\\n' +\n                                '• boolean: true or false (boolean value)\\n\\n' +\n                                '🎨 Color Type:\\n' +\n                                '• color: {\"r\":255,\"g\":0,\"b\":0,\"a\":255} (RGBA values, range 0-255)\\n' +\n                                '  - Alternative: \"#FF0000\" (hexadecimal format)\\n' +\n                                '  - Transparency: a value controls opacity, 255 = fully opaque, 0 = fully transparent\\n\\n' +\n                                '📐 Vector and Size Types:\\n' +\n                                '• vec2: {\"x\":100,\"y\":50} (2D vector)\\n' +\n                                '• vec3: {\"x\":1,\"y\":2,\"z\":3} (3D vector)\\n' +\n                                '• size: {\"width\":100,\"height\":50} (size dimensions)\\n\\n' +\n                                '🔗 Reference Types (using UUID strings):\\n' +\n                                '• node: \"target-node-uuid\" (node reference)\\n' +\n                                '  How to get: Use get_all_nodes or find_node_by_name to get node UUIDs\\n' +\n                                '• component: \"target-node-uuid\" (component reference)\\n' +\n                                '  How it works: \\n' +\n                                '    1. Provide the UUID of the NODE that contains the target component\\n' +\n                                '    2. System auto-detects required component type from property metadata\\n' +\n                                '    3. Finds the component on target node and gets its scene __id__\\n' +\n                                '    4. Sets reference using the scene __id__ (not node UUID)\\n' +\n                                '  Example: value=\"label-node-uuid\" will find cc.Label and use its scene ID\\n' +\n                                '• spriteFrame: \"spriteframe-uuid\" (sprite frame asset)\\n' +\n                                '  How to get: Check asset database or use asset browser\\n' +\n                                '• prefab: \"prefab-uuid\" (prefab asset)\\n' +\n                                '  How to get: Check asset database or use asset browser\\n' +\n                                '• asset: \"asset-uuid\" (generic asset reference)\\n' +\n                                '  How to get: Check asset database or use asset browser\\n\\n' +\n                                '📋 Array Types:\\n' +\n                                '• nodeArray: [\"uuid1\",\"uuid2\"] (array of node UUIDs)\\n' +\n                                '• colorArray: [{\"r\":255,\"g\":0,\"b\":0,\"a\":255}] (array of colors)\\n' +\n                                '• numberArray: [1,2,3,4,5] (array of numbers)\\n' +\n                                '• stringArray: [\"item1\",\"item2\"] (array of strings)'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType', 'property', 'propertyType', 'value']\n                }\n            },\n            {\n                name: 'attach_script',\n                description: 'Attach a script component to a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        scriptPath: {\n                            type: 'string',\n                            description: 'Script asset path (e.g., db://assets/scripts/MyScript.ts)'\n                        }\n                    },\n                    required: ['nodeUuid', 'scriptPath']\n                }\n            },\n            {\n                name: 'get_available_components',\n                description: 'Get list of available component types',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        category: {\n                            type: 'string',\n                            description: 'Component category filter',\n                            enum: ['all', 'renderer', 'ui', 'physics', 'animation', 'audio'],\n                            default: 'all'\n                        }\n                    }\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'add_component':\n                return await this.addComponent(args.nodeUuid, args.componentType);\n            case 'remove_component':\n                return await this.removeComponent(args.nodeUuid, args.componentType);\n            case 'get_components':\n                return await this.getComponents(args.nodeUuid);\n            case 'get_component_info':\n                return await this.getComponentInfo(args.nodeUuid, args.componentType);\n            case 'set_component_property':\n                return await this.setComponentProperty(args);\n            case 'attach_script':\n                return await this.attachScript(args.nodeUuid, args.scriptPath);\n            case 'get_available_components':\n                return await this.getAvailableComponents(args.category);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async addComponent(nodeUuid: string, componentType: string): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            // 先查找节点上是否已存在该组件\n            const allComponentsInfo = await this.getComponents(nodeUuid);\n            if (allComponentsInfo.success && allComponentsInfo.data?.components) {\n                const existingComponent = allComponentsInfo.data.components.find((comp: any) => comp.type === componentType);\n                if (existingComponent) {\n                    resolve({\n                        success: true,\n                        message: `Component '${componentType}' already exists on node`,\n                        data: {\n                            nodeUuid: nodeUuid,\n                            componentType: componentType,\n                            componentVerified: true,\n                            existing: true\n                        }\n                    });\n                    return;\n                }\n            }\n            // 尝试直接使用 Editor API 添加组件\n            Editor.Message.request('scene', 'create-component', {\n                uuid: nodeUuid,\n                component: componentType\n            }).then(async (result: any) => {\n                // 等待一段时间让Editor完成组件添加\n                await new Promise(resolve => setTimeout(resolve, 100));\n                // 重新查询节点信息验证组件是否真的添加成功\n                try {\n                    const allComponentsInfo2 = await this.getComponents(nodeUuid);\n                    if (allComponentsInfo2.success && allComponentsInfo2.data?.components) {\n                        const addedComponent = allComponentsInfo2.data.components.find((comp: any) => comp.type === componentType);\n                        if (addedComponent) {\n                            resolve({\n                                success: true,\n                                message: `Component '${componentType}' added successfully`,\n                                data: {\n                                    nodeUuid: nodeUuid,\n                                    componentType: componentType,\n                                    componentVerified: true,\n                                    existing: false\n                                }\n                            });\n                        } else {\n                            resolve({\n                                success: false,\n                                error: `Component '${componentType}' was not found on node after addition. Available components: ${allComponentsInfo2.data.components.map((c: any) => c.type).join(', ')}`\n                            });\n                        }\n                    } else {\n                        resolve({\n                            success: false,\n                            error: `Failed to verify component addition: ${allComponentsInfo2.error || 'Unable to get node components'}`\n                        });\n                    }\n                } catch (verifyError: any) {\n                    resolve({\n                        success: false,\n                        error: `Failed to verify component addition: ${verifyError.message}`\n                    });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'addComponentToNode',\n                    args: [nodeUuid, componentType]\n                };\n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async removeComponent(nodeUuid: string, componentType: string): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            // 1. 查找节点上的所有组件\n            const allComponentsInfo = await this.getComponents(nodeUuid);\n            if (!allComponentsInfo.success || !allComponentsInfo.data?.components) {\n                resolve({ success: false, error: `Failed to get components for node '${nodeUuid}': ${allComponentsInfo.error}` });\n                return;\n            }\n            // 2. 只查找type字段等于componentType的组件（即cid）\n            const exists = allComponentsInfo.data.components.some((comp: any) => comp.type === componentType);\n            if (!exists) {\n                resolve({ success: false, error: `Component cid '${componentType}' not found on node '${nodeUuid}'. 请用getComponents获取type字段（cid）作为componentType。` });\n                return;\n            }\n            // 3. 官方API直接移除\n            try {\n                await Editor.Message.request('scene', 'remove-component', {\n                    uuid: nodeUuid,\n                    component: componentType\n                });\n                // 4. 再查一次确认是否移除\n                const afterRemoveInfo = await this.getComponents(nodeUuid);\n                const stillExists = afterRemoveInfo.success && afterRemoveInfo.data?.components?.some((comp: any) => comp.type === componentType);\n                if (stillExists) {\n                    resolve({ success: false, error: `Component cid '${componentType}' was not removed from node '${nodeUuid}'.` });\n                } else {\n                    resolve({\n                        success: true,\n                        message: `Component cid '${componentType}' removed successfully from node '${nodeUuid}'`,\n                        data: { nodeUuid, componentType }\n                    });\n                }\n            } catch (err: any) {\n                resolve({ success: false, error: `Failed to remove component: ${err.message}` });\n            }\n        });\n    }\n\n    private async getComponents(nodeUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试直接使用 Editor API 查询节点信息\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => {\n                if (nodeData && nodeData.__comps__) {\n                    const components = nodeData.__comps__.map((comp: any) => ({\n                        type: comp.__type__ || comp.cid || comp.type || 'Unknown',\n                        uuid: comp.uuid?.value || comp.uuid || null,\n                        enabled: comp.enabled !== undefined ? comp.enabled : true,\n                        properties: this.extractComponentProperties(comp)\n                    }));\n                    \n                    resolve({\n                        success: true,\n                        data: {\n                            nodeUuid: nodeUuid,\n                            components: components\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: 'Node not found or no components data' });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getNodeInfo',\n                    args: [nodeUuid]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    if (result.success) {\n                        resolve({\n                            success: true,\n                            data: result.data.components\n                        });\n                    } else {\n                        resolve(result);\n                    }\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async getComponentInfo(nodeUuid: string, componentType: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试直接使用 Editor API 查询节点信息\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => {\n                if (nodeData && nodeData.__comps__) {\n                    const component = nodeData.__comps__.find((comp: any) => {\n                        const compType = comp.__type__ || comp.cid || comp.type;\n                        return compType === componentType;\n                    });\n                    \n                    if (component) {\n                        resolve({\n                            success: true,\n                            data: {\n                                nodeUuid: nodeUuid,\n                                componentType: componentType,\n                                enabled: component.enabled !== undefined ? component.enabled : true,\n                                properties: this.extractComponentProperties(component)\n                            }\n                        });\n                    } else {\n                        resolve({ success: false, error: `Component '${componentType}' not found on node` });\n                    }\n                } else {\n                    resolve({ success: false, error: 'Node not found or no components data' });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getNodeInfo',\n                    args: [nodeUuid]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    if (result.success && result.data.components) {\n                        const component = result.data.components.find((comp: any) => comp.type === componentType);\n                        if (component) {\n                            resolve({\n                                success: true,\n                                data: {\n                                    nodeUuid: nodeUuid,\n                                    componentType: componentType,\n                                    ...component\n                                }\n                            });\n                        } else {\n                            resolve({ success: false, error: `Component '${componentType}' not found on node` });\n                        }\n                    } else {\n                        resolve({ success: false, error: result.error || 'Failed to get component info' });\n                    }\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private extractComponentProperties(component: any): Record<string, any> {\n        console.log(`[extractComponentProperties] Processing component:`, Object.keys(component));\n        \n        // 检查组件是否有 value 属性，这通常包含实际的组件属性\n        if (component.value && typeof component.value === 'object') {\n            console.log(`[extractComponentProperties] Found component.value with properties:`, Object.keys(component.value));\n            return component.value; // 直接返回 value 对象，它包含所有组件属性\n        }\n        \n        // 备用方案：从组件对象中直接提取属性\n        const properties: Record<string, any> = {};\n        const excludeKeys = ['__type__', 'enabled', 'node', '_id', '__scriptAsset', 'uuid', 'name', '_name', '_objFlags', '_enabled', 'type', 'readonly', 'visible', 'cid', 'editor', 'extends'];\n        \n        for (const key in component) {\n            if (!excludeKeys.includes(key) && !key.startsWith('_')) {\n                console.log(`[extractComponentProperties] Found direct property '${key}':`, typeof component[key]);\n                properties[key] = component[key];\n            }\n        }\n        \n        console.log(`[extractComponentProperties] Final extracted properties:`, Object.keys(properties));\n        return properties;\n    }\n\n    private async findComponentTypeByUuid(componentUuid: string): Promise<string | null> {\n        console.log(`[findComponentTypeByUuid] Searching for component type with UUID: ${componentUuid}`);\n        if (!componentUuid) {\n            return null;\n        }\n        try {\n            const nodeTree = await Editor.Message.request('scene', 'query-node-tree');\n            if (!nodeTree) {\n                console.warn('[findComponentTypeByUuid] Failed to query node tree.');\n                return null;\n            }\n\n            const queue: any[] = [nodeTree];\n            \n            while (queue.length > 0) {\n                const currentNodeInfo = queue.shift();\n                if (!currentNodeInfo || !currentNodeInfo.uuid) {\n                    continue;\n                }\n\n                try {\n                    const fullNodeData = await Editor.Message.request('scene', 'query-node', currentNodeInfo.uuid);\n                    if (fullNodeData && fullNodeData.__comps__) {\n                        for (const comp of fullNodeData.__comps__) {\n                            const compAny = comp as any; // Cast to any to access dynamic properties\n                            // The component UUID is nested in the 'value' property\n                            if (compAny.uuid && compAny.uuid.value === componentUuid) {\n                                const componentType = compAny.__type__;\n                                console.log(`[findComponentTypeByUuid] Found component type '${componentType}' for UUID ${componentUuid} on node ${fullNodeData.name?.value}`);\n                                return componentType;\n                            }\n                        }\n                    }\n                } catch (e) {\n                    console.warn(`[findComponentTypeByUuid] Could not query node ${currentNodeInfo.uuid}:`, e);\n                }\n\n                if (currentNodeInfo.children) {\n                    for (const child of currentNodeInfo.children) {\n                        queue.push(child);\n                    }\n                }\n            }\n\n            console.warn(`[findComponentTypeByUuid] Component with UUID ${componentUuid} not found in scene tree.`);\n            return null;\n        } catch (error) {\n            console.error(`[findComponentTypeByUuid] Error while searching for component type:`, error);\n            return null;\n        }\n    }\n\n    private async setComponentProperty(args: any): Promise<ToolResponse> {\n                        const { nodeUuid, componentType, property, propertyType, value } = args;\n        \n        return new Promise(async (resolve) => {\n            try {\n                console.log(`[ComponentTools] Setting ${componentType}.${property} (type: ${propertyType}) = ${JSON.stringify(value)} on node ${nodeUuid}`);\n                \n                // Step 0: 检测是否为节点属性，如果是则重定向到对应的节点方法\n                const nodeRedirectResult = await this.checkAndRedirectNodeProperties(args);\n                if (nodeRedirectResult) {\n                    resolve(nodeRedirectResult);\n                    return;\n                }\n                \n                // Step 1: 获取组件信息，使用与getComponents相同的方法\n                const componentsResponse = await this.getComponents(nodeUuid);\n                if (!componentsResponse.success || !componentsResponse.data) {\n                    resolve({\n                        success: false,\n                        error: `Failed to get components for node '${nodeUuid}': ${componentsResponse.error}`,\n                        instruction: `Please verify that node UUID '${nodeUuid}' is correct. Use get_all_nodes or find_node_by_name to get the correct node UUID.`\n                    });\n                    return;\n                }\n                \n                const allComponents = componentsResponse.data.components;\n                \n                // Step 2: 查找目标组件\n                let targetComponent = null;\n                const availableTypes: string[] = [];\n                \n                for (let i = 0; i < allComponents.length; i++) {\n                    const comp = allComponents[i];\n                    availableTypes.push(comp.type);\n                    \n                    if (comp.type === componentType) {\n                        targetComponent = comp;\n                        break;\n                    }\n                }\n                \n                if (!targetComponent) {\n                    // 提供更详细的错误信息和建议\n                    const instruction = this.generateComponentSuggestion(componentType, availableTypes, property);\n                    resolve({\n                        success: false,\n                        error: `Component '${componentType}' not found on node. Available components: ${availableTypes.join(', ')}`,\n                        instruction: instruction\n                    });\n                    return;\n                }\n                \n                // Step 3: 自动检测和转换属性值\n                let propertyInfo;\n                try {\n                    console.log(`[ComponentTools] Analyzing property: ${property}`);\n                    propertyInfo = this.analyzeProperty(targetComponent, property);\n                } catch (analyzeError: any) {\n                    console.error(`[ComponentTools] Error in analyzeProperty:`, analyzeError);\n                    resolve({\n                        success: false,\n                        error: `Failed to analyze property '${property}': ${analyzeError.message}`\n                    });\n                    return;\n                }\n                \n                if (!propertyInfo.exists) {\n                    resolve({\n                        success: false,\n                        error: `Property '${property}' not found on component '${componentType}'. Available properties: ${propertyInfo.availableProperties.join(', ')}`\n                    });\n                    return;\n                }\n                \n                // Step 4: 处理属性值和设置\n                const originalValue = propertyInfo.originalValue;\n                let processedValue: any;\n                \n                // 根据明确的propertyType处理属性值\n                switch (propertyType) {\n                    case 'string':\n                        processedValue = String(value);\n                        break;\n                    case 'number':\n                    case 'integer':\n                    case 'float':\n                        processedValue = Number(value);\n                        break;\n                    case 'boolean':\n                        processedValue = Boolean(value);\n                        break;\n                    case 'color':\n                        if (typeof value === 'string') {\n                            // 字符串格式：支持十六进制、颜色名称、rgb()/rgba()\n                            processedValue = this.parseColorString(value);\n                        } else if (typeof value === 'object' && value !== null) {\n                            // 对象格式：验证并转换RGBA值\n                            processedValue = {\n                                r: Math.min(255, Math.max(0, Number(value.r) || 0)),\n                                g: Math.min(255, Math.max(0, Number(value.g) || 0)),\n                                b: Math.min(255, Math.max(0, Number(value.b) || 0)),\n                                a: value.a !== undefined ? Math.min(255, Math.max(0, Number(value.a))) : 255\n                            };\n                        } else {\n                            throw new Error('Color value must be an object with r, g, b properties or a hexadecimal string (e.g., \"#FF0000\")');\n                        }\n                        break;\n                    case 'vec2':\n                        if (typeof value === 'object' && value !== null) {\n                            processedValue = {\n                                x: Number(value.x) || 0,\n                                y: Number(value.y) || 0\n                            };\n                        } else {\n                            throw new Error('Vec2 value must be an object with x, y properties');\n                        }\n                        break;\n                    case 'vec3':\n                        if (typeof value === 'object' && value !== null) {\n                            processedValue = {\n                                x: Number(value.x) || 0,\n                                y: Number(value.y) || 0,\n                                z: Number(value.z) || 0\n                            };\n                        } else {\n                            throw new Error('Vec3 value must be an object with x, y, z properties');\n                        }\n                        break;\n                    case 'size':\n                        if (typeof value === 'object' && value !== null) {\n                            processedValue = {\n                                width: Number(value.width) || 0,\n                                height: Number(value.height) || 0\n                            };\n                        } else {\n                            throw new Error('Size value must be an object with width, height properties');\n                        }\n                        break;\n                    case 'node':\n                        if (typeof value === 'string') {\n                            processedValue = { uuid: value };\n                        } else {\n                            throw new Error('Node reference value must be a string UUID');\n                        }\n                        break;\n                    case 'component':\n                        if (typeof value === 'string') {\n                            // 组件引用需要特殊处理：通过节点UUID找到组件的__id__\n                            processedValue = value; // 先保存节点UUID，后续会转换为__id__\n                        } else {\n                            throw new Error('Component reference value must be a string (node UUID containing the target component)');\n                        }\n                        break;\n                    case 'spriteFrame':\n                    case 'prefab':\n                    case 'asset':\n                        if (typeof value === 'string') {\n                            processedValue = { uuid: value };\n                        } else {\n                            throw new Error(`${propertyType} value must be a string UUID`);\n                        }\n                        break;\n                    case 'nodeArray':\n                        if (Array.isArray(value)) {\n                            processedValue = value.map((item: any) => {\n                                if (typeof item === 'string') {\n                                    return { uuid: item };\n                                } else {\n                                    throw new Error('NodeArray items must be string UUIDs');\n                                }\n                            });\n                        } else {\n                            throw new Error('NodeArray value must be an array');\n                        }\n                        break;\n                    case 'colorArray':\n                        if (Array.isArray(value)) {\n                            processedValue = value.map((item: any) => {\n                                if (typeof item === 'object' && item !== null && 'r' in item) {\n                                    return {\n                                        r: Math.min(255, Math.max(0, Number(item.r) || 0)),\n                                        g: Math.min(255, Math.max(0, Number(item.g) || 0)),\n                                        b: Math.min(255, Math.max(0, Number(item.b) || 0)),\n                                        a: item.a !== undefined ? Math.min(255, Math.max(0, Number(item.a))) : 255\n                                    };\n                                } else {\n                                    return { r: 255, g: 255, b: 255, a: 255 };\n                                }\n                            });\n                        } else {\n                            throw new Error('ColorArray value must be an array');\n                        }\n                        break;\n                    case 'numberArray':\n                        if (Array.isArray(value)) {\n                            processedValue = value.map((item: any) => Number(item));\n                        } else {\n                            throw new Error('NumberArray value must be an array');\n                        }\n                        break;\n                    case 'stringArray':\n                        if (Array.isArray(value)) {\n                            processedValue = value.map((item: any) => String(item));\n                        } else {\n                            throw new Error('StringArray value must be an array');\n                        }\n                        break;\n                    default:\n                        throw new Error(`Unsupported property type: ${propertyType}`);\n                }\n                \n                console.log(`[ComponentTools] Converting value: ${JSON.stringify(value)} -> ${JSON.stringify(processedValue)} (type: ${propertyType})`);\n                console.log(`[ComponentTools] Property analysis result: propertyInfo.type=\"${propertyInfo.type}\", propertyType=\"${propertyType}\"`);\n                console.log(`[ComponentTools] Will use color special handling: ${propertyType === 'color' && processedValue && typeof processedValue === 'object'}`);\n                \n                // 用于验证的实际期望值（对于组件引用需要特殊处理）\n                let actualExpectedValue = processedValue;\n                \n                // Step 5: 获取原始节点数据来构建正确的路径\n                const rawNodeData = await Editor.Message.request('scene', 'query-node', nodeUuid);\n                if (!rawNodeData || !rawNodeData.__comps__) {\n                    resolve({\n                        success: false,\n                        error: `Failed to get raw node data for property setting`\n                    });\n                    return;\n                }\n                \n                // 找到原始组件的索引\n                let rawComponentIndex = -1;\n                for (let i = 0; i < rawNodeData.__comps__.length; i++) {\n                    const comp = rawNodeData.__comps__[i] as any;\n                    const compType = comp.__type__ || comp.cid || comp.type || 'Unknown';\n                    if (compType === componentType) {\n                        rawComponentIndex = i;\n                        break;\n                    }\n                }\n                \n                if (rawComponentIndex === -1) {\n                    resolve({\n                        success: false,\n                        error: `Could not find component index for setting property`\n                    });\n                    return;\n                }\n                \n                // 构建正确的属性路径\n                let propertyPath = `__comps__.${rawComponentIndex}.${property}`;\n                \n                // 特殊处理资源类属性\n                if (propertyType === 'asset' || propertyType === 'spriteFrame' || propertyType === 'prefab' || \n                    (propertyInfo.type === 'asset' && propertyType === 'string')) {\n                    \n                    console.log(`[ComponentTools] Setting asset reference:`, {\n                        value: processedValue,\n                        property: property,\n                        propertyType: propertyType,\n                        path: propertyPath\n                    });\n                    \n                    // Determine asset type based on property name\n                    let assetType = 'cc.SpriteFrame'; // default\n                    if (property.toLowerCase().includes('texture')) {\n                        assetType = 'cc.Texture2D';\n                    } else if (property.toLowerCase().includes('material')) {\n                        assetType = 'cc.Material';\n                    } else if (property.toLowerCase().includes('font')) {\n                        assetType = 'cc.Font';\n                    } else if (property.toLowerCase().includes('clip')) {\n                        assetType = 'cc.AudioClip';\n                    } else if (propertyType === 'prefab') {\n                        assetType = 'cc.Prefab';\n                    }\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: processedValue,\n                            type: assetType\n                        }\n                    });\n                } else if (componentType === 'cc.UITransform' && (property === '_contentSize' || property === 'contentSize')) {\n                    // Special handling for UITransform contentSize - set width and height separately\n                    const width = Number(value.width) || 100;\n                    const height = Number(value.height) || 100;\n                    \n                    // Set width first\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: `__comps__.${rawComponentIndex}.width`,\n                        dump: { value: width }\n                    });\n                    \n                    // Then set height\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: `__comps__.${rawComponentIndex}.height`,\n                        dump: { value: height }\n                    });\n                } else if (componentType === 'cc.UITransform' && (property === '_anchorPoint' || property === 'anchorPoint')) {\n                    // Special handling for UITransform anchorPoint - set anchorX and anchorY separately\n                    const anchorX = Number(value.x) || 0.5;\n                    const anchorY = Number(value.y) || 0.5;\n                    \n                    // Set anchorX first\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: `__comps__.${rawComponentIndex}.anchorX`,\n                        dump: { value: anchorX }\n                    });\n                    \n                    // Then set anchorY  \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: `__comps__.${rawComponentIndex}.anchorY`,\n                        dump: { value: anchorY }\n                    });\n                } else if (propertyType === 'color' && processedValue && typeof processedValue === 'object') {\n                    // 特殊处理颜色属性，确保RGBA值正确\n                    // Cocos Creator颜色值范围是0-255\n                    const colorValue = {\n                        r: Math.min(255, Math.max(0, Number(processedValue.r) || 0)),\n                        g: Math.min(255, Math.max(0, Number(processedValue.g) || 0)),\n                        b: Math.min(255, Math.max(0, Number(processedValue.b) || 0)),\n                        a: processedValue.a !== undefined ? Math.min(255, Math.max(0, Number(processedValue.a))) : 255\n                    };\n                    \n                    console.log(`[ComponentTools] Setting color value:`, colorValue);\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: colorValue,\n                            type: 'cc.Color'\n                        }\n                    });\n                } else if (propertyType === 'vec3' && processedValue && typeof processedValue === 'object') {\n                    // 特殊处理Vec3属性\n                    const vec3Value = {\n                        x: Number(processedValue.x) || 0,\n                        y: Number(processedValue.y) || 0,\n                        z: Number(processedValue.z) || 0\n                    };\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: vec3Value,\n                            type: 'cc.Vec3'\n                        }\n                    });\n                } else if (propertyType === 'vec2' && processedValue && typeof processedValue === 'object') {\n                    // 特殊处理Vec2属性\n                    const vec2Value = {\n                        x: Number(processedValue.x) || 0,\n                        y: Number(processedValue.y) || 0\n                    };\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: vec2Value,\n                            type: 'cc.Vec2'\n                        }\n                    });\n                } else if (propertyType === 'size' && processedValue && typeof processedValue === 'object') {\n                    // 特殊处理Size属性\n                    const sizeValue = {\n                        width: Number(processedValue.width) || 0,\n                        height: Number(processedValue.height) || 0\n                    };\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: sizeValue,\n                            type: 'cc.Size'\n                        }\n                    });\n                } else if (propertyType === 'node' && processedValue && typeof processedValue === 'object' && 'uuid' in processedValue) {\n                    // 特殊处理节点引用\n                    console.log(`[ComponentTools] Setting node reference with UUID: ${processedValue.uuid}`);\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: processedValue,\n                            type: 'cc.Node'\n                        }\n                    });\n                } else if (propertyType === 'component' && typeof processedValue === 'string') {\n                    // 特殊处理组件引用：通过节点UUID找到组件的__id__\n                    const targetNodeUuid = processedValue;\n                    console.log(`[ComponentTools] Setting component reference - finding component on node: ${targetNodeUuid}`);\n                    \n                    // 从当前组件的属性元数据中获取期望的组件类型\n                    let expectedComponentType = '';\n                    \n                    // 获取当前组件的详细信息，包括属性元数据\n                    const currentComponentInfo = await this.getComponentInfo(nodeUuid, componentType);\n                    if (currentComponentInfo.success && currentComponentInfo.data?.properties?.[property]) {\n                        const propertyMeta = currentComponentInfo.data.properties[property];\n                        \n                        // 从属性元数据中提取组件类型信息\n                        if (propertyMeta && typeof propertyMeta === 'object') {\n                            // 检查是否有type字段指示组件类型\n                            if (propertyMeta.type) {\n                                expectedComponentType = propertyMeta.type;\n                            } else if (propertyMeta.ctor) {\n                                // 有些属性可能使用ctor字段\n                                expectedComponentType = propertyMeta.ctor;\n                            } else if (propertyMeta.extends && Array.isArray(propertyMeta.extends)) {\n                                // 检查extends数组，通常第一个是最具体的类型\n                                for (const extendType of propertyMeta.extends) {\n                                    if (extendType.startsWith('cc.') && extendType !== 'cc.Component' && extendType !== 'cc.Object') {\n                                        expectedComponentType = extendType;\n                                        break;\n                                    }\n                                }\n                            }\n                        }\n                    }\n                    \n                    if (!expectedComponentType) {\n                        throw new Error(`Unable to determine required component type for property '${property}' on component '${componentType}'. Property metadata may not contain type information.`);\n                    }\n                    \n                    console.log(`[ComponentTools] Detected required component type: ${expectedComponentType} for property: ${property}`);\n                    \n                    try {\n                        // 获取目标节点的组件信息\n                        const targetNodeData = await Editor.Message.request('scene', 'query-node', targetNodeUuid);\n                        if (!targetNodeData || !targetNodeData.__comps__) {\n                            throw new Error(`Target node ${targetNodeUuid} not found or has no components`);\n                        }\n                        \n                        // 打印目标节点的组件概览\n                        console.log(`[ComponentTools] Target node ${targetNodeUuid} has ${targetNodeData.__comps__.length} components:`);\n                        targetNodeData.__comps__.forEach((comp: any, index: number) => {\n                            const sceneId = comp.value && comp.value.uuid && comp.value.uuid.value ? comp.value.uuid.value : 'unknown';\n                            console.log(`[ComponentTools] Component ${index}: ${comp.type} (scene_id: ${sceneId})`);\n                        });\n                        \n                        // 查找对应的组件\n                        let targetComponent = null;\n                        let componentId: string | null = null;\n                        \n                        // 在目标节点的_components数组中查找指定类型的组件\n                        // 注意：__comps__和_components的索引是对应的\n                        console.log(`[ComponentTools] Searching for component type: ${expectedComponentType}`);\n                        \n                        for (let i = 0; i < targetNodeData.__comps__.length; i++) {\n                            const comp = targetNodeData.__comps__[i] as any;\n                            console.log(`[ComponentTools] Checking component ${i}: type=${comp.type}, target=${expectedComponentType}`);\n                            \n                            if (comp.type === expectedComponentType) {\n                                targetComponent = comp;\n                                console.log(`[ComponentTools] Found matching component at index ${i}: ${comp.type}`);\n                                \n                                // 从组件的value.uuid.value中获取组件在场景中的ID\n                                if (comp.value && comp.value.uuid && comp.value.uuid.value) {\n                                    componentId = comp.value.uuid.value;\n                                    console.log(`[ComponentTools] Got componentId from comp.value.uuid.value: ${componentId}`);\n                                } else {\n                                    console.log(`[ComponentTools] Component structure:`, {\n                                        hasValue: !!comp.value,\n                                        hasUuid: !!(comp.value && comp.value.uuid),\n                                        hasUuidValue: !!(comp.value && comp.value.uuid && comp.value.uuid.value),\n                                        uuidStructure: comp.value ? comp.value.uuid : 'No value'\n                                    });\n                                    throw new Error(`Unable to extract component ID from component structure`);\n                                }\n                                \n                                break;\n                            }\n                        }\n                        \n                        if (!targetComponent) {\n                            // 如果没找到，列出可用组件让用户了解，显示场景中的真实ID\n                            const availableComponents = targetNodeData.__comps__.map((comp: any, index: number) => {\n                                let sceneId = 'unknown';\n                                // 从组件的value.uuid.value获取场景ID\n                                if (comp.value && comp.value.uuid && comp.value.uuid.value) {\n                                    sceneId = comp.value.uuid.value;\n                                }\n                                return `${comp.type}(scene_id:${sceneId})`;\n                            });\n                            throw new Error(`Component type '${expectedComponentType}' not found on node ${targetNodeUuid}. Available components: ${availableComponents.join(', ')}`);\n                        }\n                        \n                        console.log(`[ComponentTools] Found component ${expectedComponentType} with scene ID: ${componentId} on node ${targetNodeUuid}`);\n                        \n                        // 更新期望值为实际的组件ID对象格式，用于后续验证\n                        if (componentId) {\n                            actualExpectedValue = { uuid: componentId };\n                        }\n                        \n                        // 尝试使用与节点/资源引用相同的格式：{uuid: componentId}\n                        // 测试看是否能正确设置组件引用\n                        await Editor.Message.request('scene', 'set-property', {\n                            uuid: nodeUuid,\n                            path: propertyPath,\n                            dump: { \n                                value: { uuid: componentId },  // 使用对象格式，像节点/资源引用一样\n                                type: expectedComponentType\n                            }\n                        });\n                        \n                    } catch (error) {\n                        console.error(`[ComponentTools] Error setting component reference:`, error);\n                        throw error;\n                    }\n                } else if (propertyType === 'nodeArray' && Array.isArray(processedValue)) {\n                    // 特殊处理节点数组 - 保持预处理的格式\n                    console.log(`[ComponentTools] Setting node array:`, processedValue);\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: processedValue  // 保持 [{uuid: \"...\"}, {uuid: \"...\"}] 格式\n                        }\n                    });\n                } else if (propertyType === 'colorArray' && Array.isArray(processedValue)) {\n                    // 特殊处理颜色数组\n                    const colorArrayValue = processedValue.map((item: any) => {\n                        if (item && typeof item === 'object' && 'r' in item) {\n                            return {\n                                r: Math.min(255, Math.max(0, Number(item.r) || 0)),\n                                g: Math.min(255, Math.max(0, Number(item.g) || 0)),\n                                b: Math.min(255, Math.max(0, Number(item.b) || 0)),\n                                a: item.a !== undefined ? Math.min(255, Math.max(0, Number(item.a))) : 255\n                            };\n                        } else {\n                            return { r: 255, g: 255, b: 255, a: 255 };\n                        }\n                    });\n                    \n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { \n                            value: colorArrayValue,\n                            type: 'cc.Color'\n                        }\n                    });\n                } else {\n                    // Normal property setting for non-asset properties\n                    await Editor.Message.request('scene', 'set-property', {\n                        uuid: nodeUuid,\n                        path: propertyPath,\n                        dump: { value: processedValue }\n                    });\n                }\n                \n                // Step 5: 等待Editor完成更新，然后验证设置结果\n                await new Promise(resolve => setTimeout(resolve, 200)); // 等待200ms让Editor完成更新\n                \n                const verification = await this.verifyPropertyChange(nodeUuid, componentType, property, originalValue, actualExpectedValue);\n                \n                resolve({\n                    success: true,\n                    message: `Successfully set ${componentType}.${property}`,\n                    data: {\n                        nodeUuid,\n                        componentType,\n                        property,\n                        actualValue: verification.actualValue,\n                        changeVerified: verification.verified\n                    }\n                });\n                \n            } catch (error: any) {\n                console.error(`[ComponentTools] Error setting property:`, error);\n                resolve({\n                    success: false,\n                    error: `Failed to set property: ${error.message}`\n                });\n            }\n        });\n    }\n\n\n    private async attachScript(nodeUuid: string, scriptPath: string): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            // 从脚本路径提取组件类名\n            const scriptName = scriptPath.split('/').pop()?.replace('.ts', '').replace('.js', '');\n            if (!scriptName) {\n                resolve({ success: false, error: 'Invalid script path' });\n                return;\n            }\n            // 先查找节点上是否已存在该脚本组件\n            const allComponentsInfo = await this.getComponents(nodeUuid);\n            if (allComponentsInfo.success && allComponentsInfo.data?.components) {\n                const existingScript = allComponentsInfo.data.components.find((comp: any) => comp.type === scriptName);\n                if (existingScript) {\n                    resolve({\n                        success: true,\n                        message: `Script '${scriptName}' already exists on node`,\n                        data: {\n                            nodeUuid: nodeUuid,\n                            componentName: scriptName,\n                            existing: true\n                        }\n                    });\n                    return;\n                }\n            }\n            // 首先尝试直接使用脚本名称作为组件类型\n            Editor.Message.request('scene', 'create-component', {\n                uuid: nodeUuid,\n                component: scriptName  // 使用脚本名称而非UUID\n            }).then(async (result: any) => {\n                // 等待一段时间让Editor完成组件添加\n                await new Promise(resolve => setTimeout(resolve, 100));\n                // 重新查询节点信息验证脚本是否真的添加成功\n                const allComponentsInfo2 = await this.getComponents(nodeUuid);\n                if (allComponentsInfo2.success && allComponentsInfo2.data?.components) {\n                    const addedScript = allComponentsInfo2.data.components.find((comp: any) => comp.type === scriptName);\n                    if (addedScript) {\n                        resolve({\n                            success: true,\n                            message: `Script '${scriptName}' attached successfully`,\n                            data: {\n                                nodeUuid: nodeUuid,\n                                componentName: scriptName,\n                                existing: false\n                            }\n                        });\n                    } else {\n                        resolve({\n                            success: false,\n                            error: `Script '${scriptName}' was not found on node after addition. Available components: ${allComponentsInfo2.data.components.map((c: any) => c.type).join(', ')}`\n                        });\n                    }\n                } else {\n                    resolve({\n                        success: false,\n                        error: `Failed to verify script addition: ${allComponentsInfo2.error || 'Unable to get node components'}`\n                    });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'attachScript',\n                    args: [nodeUuid, scriptPath]\n                };\n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch(() => {\n                    resolve({ \n                        success: false, \n                        error: `Failed to attach script '${scriptName}': ${err.message}`,\n                        instruction: 'Please ensure the script is properly compiled and exported as a Component class. You can also manually attach the script through the Properties panel in the editor.'\n                    });\n                });\n            });\n        });\n    }\n\n    private async getAvailableComponents(category: string = 'all'): Promise<ToolResponse> {\n        const componentCategories: Record<string, string[]> = {\n            renderer: ['cc.Sprite', 'cc.Label', 'cc.RichText', 'cc.Mask', 'cc.Graphics'],\n            ui: ['cc.Button', 'cc.Toggle', 'cc.Slider', 'cc.ScrollView', 'cc.EditBox', 'cc.ProgressBar'],\n            physics: ['cc.RigidBody2D', 'cc.BoxCollider2D', 'cc.CircleCollider2D', 'cc.PolygonCollider2D'],\n            animation: ['cc.Animation', 'cc.AnimationClip', 'cc.SkeletalAnimation'],\n            audio: ['cc.AudioSource'],\n            layout: ['cc.Layout', 'cc.Widget', 'cc.PageView', 'cc.PageViewIndicator'],\n            effects: ['cc.MotionStreak', 'cc.ParticleSystem2D'],\n            camera: ['cc.Camera'],\n            light: ['cc.Light', 'cc.DirectionalLight', 'cc.PointLight', 'cc.SpotLight']\n        };\n\n        let components: string[] = [];\n        \n        if (category === 'all') {\n            for (const cat in componentCategories) {\n                components = components.concat(componentCategories[cat]);\n            }\n        } else if (componentCategories[category]) {\n            components = componentCategories[category];\n        }\n\n        return {\n            success: true,\n            data: {\n                category: category,\n                components: components\n            }\n        };\n    }\n\n    private isValidPropertyDescriptor(propData: any): boolean {\n        // 检查是否是有效的属性描述对象\n        if (typeof propData !== 'object' || propData === null) {\n            return false;\n        }\n        \n        try {\n            const keys = Object.keys(propData);\n            \n            // 避免遍历简单的数值对象（如 {width: 200, height: 150}）\n            const isSimpleValueObject = keys.every(key => {\n                const value = propData[key];\n                return typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean';\n            });\n            \n            if (isSimpleValueObject) {\n                return false;\n            }\n            \n            // 检查是否包含属性描述符的特征字段，不使用'in'操作符\n            const hasName = keys.includes('name');\n            const hasValue = keys.includes('value');\n            const hasType = keys.includes('type');\n            const hasDisplayName = keys.includes('displayName');\n            const hasReadonly = keys.includes('readonly');\n            \n            // 必须包含name或value字段，且通常还有type字段\n            const hasValidStructure = (hasName || hasValue) && (hasType || hasDisplayName || hasReadonly);\n            \n            // 额外检查：如果有default字段且结构复杂，避免深度遍历\n            if (keys.includes('default') && propData.default && typeof propData.default === 'object') {\n                const defaultKeys = Object.keys(propData.default);\n                if (defaultKeys.includes('value') && typeof propData.default.value === 'object') {\n                    // 这种情况下，我们只返回顶层属性，不深入遍历default.value\n                    return hasValidStructure;\n                }\n            }\n            \n            return hasValidStructure;\n        } catch (error) {\n            console.warn(`[isValidPropertyDescriptor] Error checking property descriptor:`, error);\n            return false;\n        }\n    }\n\n    private analyzeProperty(component: any, propertyName: string): { exists: boolean; type: string; availableProperties: string[]; originalValue: any } {\n        // 从复杂的组件结构中提取可用属性\n        const availableProperties: string[] = [];\n        let propertyValue: any = undefined;\n        let propertyExists = false;\n        \n        // 尝试多种方式查找属性：\n        // 1. 直接属性访问\n        if (Object.prototype.hasOwnProperty.call(component, propertyName)) {\n            propertyValue = component[propertyName];\n            propertyExists = true;\n        }\n        \n        // 2. 从嵌套结构中查找 (如从测试数据看到的复杂结构)\n        if (!propertyExists && component.properties && typeof component.properties === 'object') {\n            // 首先检查properties.value是否存在（这是我们在getComponents中看到的结构）\n            if (component.properties.value && typeof component.properties.value === 'object') {\n                const valueObj = component.properties.value;\n                for (const [key, propData] of Object.entries(valueObj)) {\n                    // 检查propData是否是一个有效的属性描述对象\n                    // 确保propData是对象且包含预期的属性结构\n                    if (this.isValidPropertyDescriptor(propData)) {\n                        const propInfo = propData as any;\n                        availableProperties.push(key);\n                        if (key === propertyName) {\n                            // 优先使用value属性，如果没有则使用propData本身\n                            try {\n                                const propKeys = Object.keys(propInfo);\n                                propertyValue = propKeys.includes('value') ? propInfo.value : propInfo;\n                            } catch (error) {\n                                // 如果检查失败，直接使用propInfo\n                                propertyValue = propInfo;\n                            }\n                            propertyExists = true;\n                        }\n                    }\n                }\n            } else {\n                // 备用方案：直接从properties查找\n                for (const [key, propData] of Object.entries(component.properties)) {\n                    if (this.isValidPropertyDescriptor(propData)) {\n                        const propInfo = propData as any;\n                        availableProperties.push(key);\n                        if (key === propertyName) {\n                            // 优先使用value属性，如果没有则使用propData本身\n                            try {\n                                const propKeys = Object.keys(propInfo);\n                                propertyValue = propKeys.includes('value') ? propInfo.value : propInfo;\n                            } catch (error) {\n                                // 如果检查失败，直接使用propInfo\n                                propertyValue = propInfo;\n                            }\n                            propertyExists = true;\n                        }\n                    }\n                }\n            }\n        }\n        \n        // 3. 从直接属性中提取简单属性名\n        if (availableProperties.length === 0) {\n            for (const key of Object.keys(component)) {\n                if (!key.startsWith('_') && !['__type__', 'cid', 'node', 'uuid', 'name', 'enabled', 'type', 'readonly', 'visible'].includes(key)) {\n                    availableProperties.push(key);\n                }\n            }\n        }\n        \n        if (!propertyExists) {\n            return {\n                exists: false,\n                type: 'unknown',\n                availableProperties,\n                originalValue: undefined\n            };\n        }\n        \n        let type = 'unknown';\n        \n        // 智能类型检测\n        if (Array.isArray(propertyValue)) {\n            // 数组类型检测\n            if (propertyName.toLowerCase().includes('node')) {\n                type = 'nodeArray';\n            } else if (propertyName.toLowerCase().includes('color')) {\n                type = 'colorArray';\n            } else {\n                type = 'array';\n            }\n        } else if (typeof propertyValue === 'string') {\n            // Check if property name suggests it's an asset\n            if (['spriteFrame', 'texture', 'material', 'font', 'clip', 'prefab'].includes(propertyName.toLowerCase())) {\n                type = 'asset';\n            } else {\n                type = 'string';\n            }\n        } else if (typeof propertyValue === 'number') {\n            type = 'number';\n        } else if (typeof propertyValue === 'boolean') {\n            type = 'boolean';\n        } else if (propertyValue && typeof propertyValue === 'object') {\n            try {\n                const keys = Object.keys(propertyValue);\n                if (keys.includes('r') && keys.includes('g') && keys.includes('b')) {\n                    type = 'color';\n                } else if (keys.includes('x') && keys.includes('y')) {\n                    type = propertyValue.z !== undefined ? 'vec3' : 'vec2';\n                } else if (keys.includes('width') && keys.includes('height')) {\n                    type = 'size';\n                } else if (keys.includes('uuid') || keys.includes('__uuid__')) {\n                    // 检查是否是节点引用（通过属性名或__id__属性判断）\n                    if (propertyName.toLowerCase().includes('node') || \n                        propertyName.toLowerCase().includes('target') ||\n                        keys.includes('__id__')) {\n                        type = 'node';\n                    } else {\n                        type = 'asset';\n                    }\n                } else if (keys.includes('__id__')) {\n                    // 节点引用特征\n                    type = 'node';\n                } else {\n                    type = 'object';\n                }\n            } catch (error) {\n                console.warn(`[analyzeProperty] Error checking property type for: ${JSON.stringify(propertyValue)}`);\n                type = 'object';\n            }\n        } else if (propertyValue === null || propertyValue === undefined) {\n            // For null/undefined values, check property name to determine type\n            if (['spriteFrame', 'texture', 'material', 'font', 'clip', 'prefab'].includes(propertyName.toLowerCase())) {\n                type = 'asset';\n            } else if (propertyName.toLowerCase().includes('node') || \n                      propertyName.toLowerCase().includes('target')) {\n                type = 'node';\n            } else if (propertyName.toLowerCase().includes('component')) {\n                type = 'component';\n            } else {\n                type = 'unknown';\n            }\n        }\n        \n        return {\n            exists: true,\n            type,\n            availableProperties,\n            originalValue: propertyValue\n        };\n    }\n\n    private smartConvertValue(inputValue: any, propertyInfo: any): any {\n        const { type, originalValue } = propertyInfo;\n        \n        console.log(`[smartConvertValue] Converting ${JSON.stringify(inputValue)} to type: ${type}`);\n        \n        switch (type) {\n            case 'string':\n                return String(inputValue);\n                \n            case 'number':\n                return Number(inputValue);\n                \n            case 'boolean':\n                if (typeof inputValue === 'boolean') return inputValue;\n                if (typeof inputValue === 'string') {\n                    return inputValue.toLowerCase() === 'true' || inputValue === '1';\n                }\n                return Boolean(inputValue);\n                \n            case 'color':\n                // 优化的颜色处理，支持多种输入格式\n                if (typeof inputValue === 'string') {\n                    // 字符串格式：十六进制、颜色名称、rgb()/rgba()\n                    return this.parseColorString(inputValue);\n                } else if (typeof inputValue === 'object' && inputValue !== null) {\n                    try {\n                        const inputKeys = Object.keys(inputValue);\n                        // 如果输入是颜色对象，验证并转换\n                        if (inputKeys.includes('r') || inputKeys.includes('g') || inputKeys.includes('b')) {\n                            return {\n                                r: Math.min(255, Math.max(0, Number(inputValue.r) || 0)),\n                                g: Math.min(255, Math.max(0, Number(inputValue.g) || 0)),\n                                b: Math.min(255, Math.max(0, Number(inputValue.b) || 0)),\n                                a: inputValue.a !== undefined ? Math.min(255, Math.max(0, Number(inputValue.a))) : 255\n                            };\n                        }\n                    } catch (error) {\n                        console.warn(`[smartConvertValue] Invalid color object: ${JSON.stringify(inputValue)}`);\n                    }\n                }\n                // 如果有原值，保持原值结构并更新提供的值\n                if (originalValue && typeof originalValue === 'object') {\n                    try {\n                        const inputKeys = typeof inputValue === 'object' && inputValue ? Object.keys(inputValue) : [];\n                        return {\n                            r: inputKeys.includes('r') ? Math.min(255, Math.max(0, Number(inputValue.r))) : (originalValue.r || 255),\n                            g: inputKeys.includes('g') ? Math.min(255, Math.max(0, Number(inputValue.g))) : (originalValue.g || 255),\n                            b: inputKeys.includes('b') ? Math.min(255, Math.max(0, Number(inputValue.b))) : (originalValue.b || 255),\n                            a: inputKeys.includes('a') ? Math.min(255, Math.max(0, Number(inputValue.a))) : (originalValue.a || 255)\n                        };\n                    } catch (error) {\n                        console.warn(`[smartConvertValue] Error processing color with original value: ${error}`);\n                    }\n                }\n                // 默认返回白色\n                console.warn(`[smartConvertValue] Using default white color for invalid input: ${JSON.stringify(inputValue)}`);\n                return { r: 255, g: 255, b: 255, a: 255 };\n                \n            case 'vec2':\n                if (typeof inputValue === 'object' && inputValue !== null) {\n                    return {\n                        x: Number(inputValue.x) || originalValue.x || 0,\n                        y: Number(inputValue.y) || originalValue.y || 0\n                    };\n                }\n                return originalValue;\n                \n            case 'vec3':\n                if (typeof inputValue === 'object' && inputValue !== null) {\n                    return {\n                        x: Number(inputValue.x) || originalValue.x || 0,\n                        y: Number(inputValue.y) || originalValue.y || 0,\n                        z: Number(inputValue.z) || originalValue.z || 0\n                    };\n                }\n                return originalValue;\n                \n            case 'size':\n                if (typeof inputValue === 'object' && inputValue !== null) {\n                    return {\n                        width: Number(inputValue.width) || originalValue.width || 100,\n                        height: Number(inputValue.height) || originalValue.height || 100\n                    };\n                }\n                return originalValue;\n                \n            case 'node':\n                if (typeof inputValue === 'string') {\n                    // 节点引用需要特殊处理\n                    return inputValue;\n                } else if (typeof inputValue === 'object' && inputValue !== null) {\n                    // 如果已经是对象形式，返回UUID或完整对象\n                    return inputValue.uuid || inputValue;\n                }\n                return originalValue;\n                \n            case 'asset':\n                if (typeof inputValue === 'string') {\n                    // 如果输入是字符串路径，转换为asset对象\n                    return { uuid: inputValue };\n                } else if (typeof inputValue === 'object' && inputValue !== null) {\n                    return inputValue;\n                }\n                return originalValue;\n                \n            default:\n                // 对于未知类型，尽量保持原有结构\n                if (typeof inputValue === typeof originalValue) {\n                    return inputValue;\n                }\n                return originalValue;\n        }\n    }\n\n        private parseColorString(colorStr: string): { r: number; g: number; b: number; a: number } {\n        const str = colorStr.trim();\n        \n        // 只支持十六进制格式 #RRGGBB 或 #RRGGBBAA\n        if (str.startsWith('#')) {\n            if (str.length === 7) { // #RRGGBB\n                const r = parseInt(str.substring(1, 3), 16);\n                const g = parseInt(str.substring(3, 5), 16);\n                const b = parseInt(str.substring(5, 7), 16);\n                return { r, g, b, a: 255 };\n            } else if (str.length === 9) { // #RRGGBBAA\n                const r = parseInt(str.substring(1, 3), 16);\n                const g = parseInt(str.substring(3, 5), 16);\n                const b = parseInt(str.substring(5, 7), 16);\n                const a = parseInt(str.substring(7, 9), 16);\n                return { r, g, b, a };\n            }\n        }\n        \n        // 如果不是有效的十六进制格式，返回错误提示\n        throw new Error(`Invalid color format: \"${colorStr}\". Only hexadecimal format is supported (e.g., \"#FF0000\" or \"#FF0000FF\")`);\n    }\n\n    private async verifyPropertyChange(nodeUuid: string, componentType: string, property: string, originalValue: any, expectedValue: any): Promise<{ verified: boolean; actualValue: any; fullData: any }> {\n        console.log(`[verifyPropertyChange] Starting verification for ${componentType}.${property}`);\n        console.log(`[verifyPropertyChange] Expected value:`, JSON.stringify(expectedValue));\n        console.log(`[verifyPropertyChange] Original value:`, JSON.stringify(originalValue));\n        \n        try {\n            // 重新获取组件信息进行验证\n            console.log(`[verifyPropertyChange] Calling getComponentInfo...`);\n            const componentInfo = await this.getComponentInfo(nodeUuid, componentType);\n            console.log(`[verifyPropertyChange] getComponentInfo success:`, componentInfo.success);\n            \n            const allComponents = await this.getComponents(nodeUuid);\n            console.log(`[verifyPropertyChange] getComponents success:`, allComponents.success);\n            \n            if (componentInfo.success && componentInfo.data) {\n                console.log(`[verifyPropertyChange] Component data available, extracting property '${property}'`);\n                const allPropertyNames = Object.keys(componentInfo.data.properties || {});\n                console.log(`[verifyPropertyChange] Available properties:`, allPropertyNames);\n                const propertyData = componentInfo.data.properties?.[property];\n                console.log(`[verifyPropertyChange] Raw property data for '${property}':`, JSON.stringify(propertyData));\n                \n                // 从属性数据中提取实际值\n                let actualValue = propertyData;\n                console.log(`[verifyPropertyChange] Initial actualValue:`, JSON.stringify(actualValue));\n                \n                if (propertyData && typeof propertyData === 'object' && 'value' in propertyData) {\n                    actualValue = propertyData.value;\n                    console.log(`[verifyPropertyChange] Extracted actualValue from .value:`, JSON.stringify(actualValue));\n                } else {\n                    console.log(`[verifyPropertyChange] No .value property found, using raw data`);\n                }\n                \n                // 修复验证逻辑：检查实际值是否匹配期望值\n                let verified = false;\n                \n                if (typeof expectedValue === 'object' && expectedValue !== null && 'uuid' in expectedValue) {\n                    // 对于引用类型（节点/组件/资源），比较UUID\n                    const actualUuid = actualValue && typeof actualValue === 'object' && 'uuid' in actualValue ? actualValue.uuid : '';\n                    const expectedUuid = expectedValue.uuid || '';\n                    verified = actualUuid === expectedUuid && expectedUuid !== '';\n                    \n                    console.log(`[verifyPropertyChange] Reference comparison:`);\n                    console.log(`  - Expected UUID: \"${expectedUuid}\"`);\n                    console.log(`  - Actual UUID: \"${actualUuid}\"`);\n                    console.log(`  - UUID match: ${actualUuid === expectedUuid}`);\n                    console.log(`  - UUID not empty: ${expectedUuid !== ''}`);\n                    console.log(`  - Final verified: ${verified}`);\n                } else {\n                    // 对于其他类型，直接比较值\n                    console.log(`[verifyPropertyChange] Value comparison:`);\n                    console.log(`  - Expected type: ${typeof expectedValue}`);\n                    console.log(`  - Actual type: ${typeof actualValue}`);\n                    \n                    if (typeof actualValue === typeof expectedValue) {\n                        if (typeof actualValue === 'object' && actualValue !== null && expectedValue !== null) {\n                            // 对象类型的深度比较\n                            verified = JSON.stringify(actualValue) === JSON.stringify(expectedValue);\n                            console.log(`  - Object comparison (JSON): ${verified}`);\n                        } else {\n                            // 基本类型的直接比较\n                            verified = actualValue === expectedValue;\n                            console.log(`  - Direct comparison: ${verified}`);\n                        }\n                    } else {\n                        // 类型不匹配时的特殊处理（如数字和字符串）\n                        const stringMatch = String(actualValue) === String(expectedValue);\n                        const numberMatch = Number(actualValue) === Number(expectedValue);\n                        verified = stringMatch || numberMatch;\n                        console.log(`  - String match: ${stringMatch}`);\n                        console.log(`  - Number match: ${numberMatch}`);\n                        console.log(`  - Type mismatch verified: ${verified}`);\n                    }\n                }\n                \n                console.log(`[verifyPropertyChange] Final verification result: ${verified}`);\n                console.log(`[verifyPropertyChange] Final actualValue:`, JSON.stringify(actualValue));\n                \n                const result = {\n                    verified,\n                    actualValue,\n                    fullData: {\n                        // 只返回修改的属性信息，不返回完整组件数据\n                        modifiedProperty: {\n                            name: property,\n                            before: originalValue,\n                            expected: expectedValue,\n                            actual: actualValue,\n                            verified,\n                            propertyMetadata: propertyData // 只包含这个属性的元数据\n                        },\n                        // 简化的组件信息\n                        componentSummary: {\n                            nodeUuid,\n                            componentType,\n                            totalProperties: Object.keys(componentInfo.data?.properties || {}).length\n                        }\n                    }\n                };\n                \n                console.log(`[verifyPropertyChange] Returning result:`, JSON.stringify(result, null, 2));\n                return result;\n            } else {\n                console.log(`[verifyPropertyChange] ComponentInfo failed or no data:`, componentInfo);\n            }\n        } catch (error) {\n            console.error('[verifyPropertyChange] Verification failed with error:', error);\n            console.error('[verifyPropertyChange] Error stack:', error instanceof Error ? error.stack : 'No stack trace');\n        }\n        \n        console.log(`[verifyPropertyChange] Returning fallback result`);\n        return {\n            verified: false,\n            actualValue: undefined,\n            fullData: null\n        };\n    }\n\n    /**\n     * 检测是否为节点属性，如果是则重定向到对应的节点方法\n     */\n    private async checkAndRedirectNodeProperties(args: any): Promise<ToolResponse | null> {\n        const { nodeUuid, componentType, property, propertyType, value } = args;\n        \n        // 检测是否为节点基础属性（应该使用 set_node_property）\n        const nodeBasicProperties = [\n            'name', 'active', 'layer', 'mobility', 'parent', 'children', 'hideFlags'\n        ];\n        \n        // 检测是否为节点变换属性（应该使用 set_node_transform）\n        const nodeTransformProperties = [\n            'position', 'rotation', 'scale', 'eulerAngles', 'angle'\n        ];\n        \n        // Detect attempts to set cc.Node properties (common mistake)\n        if (componentType === 'cc.Node' || componentType === 'Node') {\n            if (nodeBasicProperties.includes(property)) {\n                return {\n                    success: false,\n                                          error: `Property '${property}' is a node basic property, not a component property`,\n                      instruction: `Please use set_node_property method to set node properties: set_node_property(uuid=\"${nodeUuid}\", property=\"${property}\", value=${JSON.stringify(value)})`\n                  };\n              } else if (nodeTransformProperties.includes(property)) {\n                  return {\n                      success: false,\n                      error: `Property '${property}' is a node transform property, not a component property`,\n                      instruction: `Please use set_node_transform method to set transform properties: set_node_transform(uuid=\"${nodeUuid}\", ${property}=${JSON.stringify(value)})`\n                  };\n              }\n          }\n          \n          // Detect common incorrect usage\n          if (nodeBasicProperties.includes(property) || nodeTransformProperties.includes(property)) {\n              const methodName = nodeTransformProperties.includes(property) ? 'set_node_transform' : 'set_node_property';\n              return {\n                  success: false,\n                  error: `Property '${property}' is a node property, not a component property`,\n                  instruction: `Property '${property}' should be set using ${methodName} method, not set_component_property. Please use: ${methodName}(uuid=\"${nodeUuid}\", ${nodeTransformProperties.includes(property) ? property : `property=\"${property}\"`}=${JSON.stringify(value)})`\n              };\n          }\n          \n          return null; // 不是节点属性，继续正常处理\n      }\n\n      /**\n       * 生成组件建议信息\n       */\n      private generateComponentSuggestion(requestedType: string, availableTypes: string[], property: string): string {\n          // 检查是否存在相似的组件类型\n          const similarTypes = availableTypes.filter(type => \n              type.toLowerCase().includes(requestedType.toLowerCase()) || \n              requestedType.toLowerCase().includes(type.toLowerCase())\n          );\n          \n          let instruction = '';\n          \n          if (similarTypes.length > 0) {\n              instruction += `\\n\\n🔍 Found similar components: ${similarTypes.join(', ')}`;\n              instruction += `\\n💡 Suggestion: Perhaps you meant to set the '${similarTypes[0]}' component?`;\n          }\n          \n          // Recommend possible components based on property name\n          const propertyToComponentMap: Record<string, string[]> = {\n              'string': ['cc.Label', 'cc.RichText', 'cc.EditBox'],\n              'text': ['cc.Label', 'cc.RichText'],\n              'fontSize': ['cc.Label', 'cc.RichText'],\n              'spriteFrame': ['cc.Sprite'],\n              'color': ['cc.Label', 'cc.Sprite', 'cc.Graphics'],\n              'normalColor': ['cc.Button'],\n              'pressedColor': ['cc.Button'],\n              'target': ['cc.Button'],\n              'contentSize': ['cc.UITransform'],\n              'anchorPoint': ['cc.UITransform']\n          };\n          \n          const recommendedComponents = propertyToComponentMap[property] || [];\n          const availableRecommended = recommendedComponents.filter(comp => availableTypes.includes(comp));\n          \n          if (availableRecommended.length > 0) {\n              instruction += `\\n\\n🎯 Based on property '${property}', recommended components: ${availableRecommended.join(', ')}`;\n          }\n          \n          // Provide operation suggestions\n          instruction += `\\n\\n📋 Suggested Actions:`;\n          instruction += `\\n1. Use get_components(nodeUuid=\"${requestedType.includes('uuid') ? 'YOUR_NODE_UUID' : 'nodeUuid'}\") to view all components on the node`;\n          instruction += `\\n2. If you need to add a component, use add_component(nodeUuid=\"...\", componentType=\"${requestedType}\")`;\n          instruction += `\\n3. Verify that the component type name is correct (case-sensitive)`;\n          \n                  return instruction;\n    }\n\n    /**\n     * 快速验证资源设置结果\n     */\n    private async quickVerifyAsset(nodeUuid: string, componentType: string, property: string): Promise<any> {\n        try {\n            const rawNodeData = await Editor.Message.request('scene', 'query-node', nodeUuid);\n            if (!rawNodeData || !rawNodeData.__comps__) {\n                return null;\n            }\n            \n            // 找到组件\n            const component = rawNodeData.__comps__.find((comp: any) => {\n                const compType = comp.__type__ || comp.cid || comp.type;\n                return compType === componentType;\n            });\n            \n            if (!component) {\n                return null;\n            }\n            \n            // 提取属性值\n            const properties = this.extractComponentProperties(component);\n            const propertyData = properties[property];\n            \n            if (propertyData && typeof propertyData === 'object' && 'value' in propertyData) {\n                return propertyData.value;\n            } else {\n                return propertyData;\n            }\n        } catch (error) {\n            console.error(`[quickVerifyAsset] Error:`, error);\n            return null;\n        }\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/node-tools.js b/dist/tools/node-tools.js index 9619529..243ab70 100644 --- a/dist/tools/node-tools.js +++ b/dist/tools/node-tools.js @@ -1,12 +1,16 @@ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.NodeTools = void 0; +const component_tools_1 = require("./component-tools"); class NodeTools { + constructor() { + this.componentTools = new component_tools_1.ComponentTools(); + } getTools() { return [ { name: 'create_node', - description: 'Create a new node in the scene. IMPORTANT: You should always provide parentUuid to specify where to create the node. If parentUuid is not provided, the node will be created at the scene root.', + description: 'Create a new node in the scene. Supports creating empty nodes, nodes with components, or instantiating from assets (prefabs, etc.). IMPORTANT: You should always provide parentUuid to specify where to create the node.', inputSchema: { type: 'object', properties: { @@ -28,6 +32,59 @@ class NodeTools { type: 'number', description: 'Sibling index for ordering (-1 means append at end)', default: -1 + }, + assetUuid: { + type: 'string', + description: 'Asset UUID to instantiate from (e.g., prefab UUID). When provided, creates a node instance from the asset instead of an empty node.' + }, + assetPath: { + type: 'string', + description: 'Asset path to instantiate from (e.g., "db://assets/prefabs/MyPrefab.prefab"). Alternative to assetUuid.' + }, + components: { + type: 'array', + items: { type: 'string' }, + description: 'Array of component type names to add to the new node (e.g., ["cc.Sprite", "cc.Button"])' + }, + unlinkPrefab: { + type: 'boolean', + description: 'If true and creating from prefab, unlink from prefab to create a regular node', + default: false + }, + keepWorldTransform: { + type: 'boolean', + description: 'Whether to keep world transform when creating the node', + default: false + }, + initialTransform: { + type: 'object', + properties: { + position: { + type: 'object', + properties: { + x: { type: 'number' }, + y: { type: 'number' }, + z: { type: 'number' } + } + }, + rotation: { + type: 'object', + properties: { + x: { type: 'number' }, + y: { type: 'number' }, + z: { type: 'number' } + } + }, + scale: { + type: 'object', + properties: { + x: { type: 'number' }, + y: { type: 'number' }, + z: { type: 'number' } + } + } + }, + description: 'Initial transform to apply to the created node' } }, required: ['name'] @@ -90,7 +147,7 @@ class NodeTools { }, { name: 'set_node_property', - description: 'Set node property value (prefer using set_node_transform for position/rotation/scale)', + description: 'Set node property value (prefer using set_node_transform for active/layer/mobility/position/rotation/scale)', inputSchema: { type: 'object', properties: { @@ -252,150 +309,186 @@ class NodeTools { } async createNode(args) { return new Promise(async (resolve) => { - let targetParentUuid = args.parentUuid; - // 如果没有提供父节点UUID，获取场景根节点 - if (!targetParentUuid) { - try { - const sceneInfo = await Editor.Message.request('scene', 'query-node-tree'); - if (sceneInfo && typeof sceneInfo === 'object' && !Array.isArray(sceneInfo) && Object.prototype.hasOwnProperty.call(sceneInfo, 'uuid')) { - targetParentUuid = sceneInfo.uuid; - console.log(`No parent specified, using scene root: ${targetParentUuid}`); - } - else if (Array.isArray(sceneInfo) && sceneInfo.length > 0 && sceneInfo[0].uuid) { - // 如果返回的是数组，使用第一个元素（通常是场景根节点） - targetParentUuid = sceneInfo[0].uuid; - console.log(`No parent specified, using scene root: ${targetParentUuid}`); - } - else { - // 备用方案：尝试获取当前场景 - const currentScene = await Editor.Message.request('scene', 'query-current-scene'); - if (currentScene && currentScene.uuid) { - targetParentUuid = currentScene.uuid; + try { + let targetParentUuid = args.parentUuid; + // 如果没有提供父节点UUID，获取场景根节点 + if (!targetParentUuid) { + try { + const sceneInfo = await Editor.Message.request('scene', 'query-node-tree'); + if (sceneInfo && typeof sceneInfo === 'object' && !Array.isArray(sceneInfo) && Object.prototype.hasOwnProperty.call(sceneInfo, 'uuid')) { + targetParentUuid = sceneInfo.uuid; + console.log(`No parent specified, using scene root: ${targetParentUuid}`); + } + else if (Array.isArray(sceneInfo) && sceneInfo.length > 0 && sceneInfo[0].uuid) { + targetParentUuid = sceneInfo[0].uuid; + console.log(`No parent specified, using scene root: ${targetParentUuid}`); + } + else { + const currentScene = await Editor.Message.request('scene', 'query-current-scene'); + if (currentScene && currentScene.uuid) { + targetParentUuid = currentScene.uuid; + } } } + catch (err) { + console.warn('Failed to get scene root, will use default behavior'); + } } - catch (err) { - console.warn('Failed to get scene root, will use default behavior'); - } - } - // 如果指定了父节点，先验证父节点是否存在 - if (targetParentUuid) { - try { - const parentNode = await Editor.Message.request('scene', 'query-node', targetParentUuid); - if (!parentNode) { + // 如果提供了assetPath，先解析为assetUuid + let finalAssetUuid = args.assetUuid; + if (args.assetPath && !finalAssetUuid) { + try { + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', args.assetPath); + if (assetInfo && assetInfo.uuid) { + finalAssetUuid = assetInfo.uuid; + console.log(`Asset path '${args.assetPath}' resolved to UUID: ${finalAssetUuid}`); + } + else { + resolve({ + success: false, + error: `Asset not found at path: ${args.assetPath}` + }); + return; + } + } + catch (err) { resolve({ success: false, - error: `Parent node with UUID '${targetParentUuid}' not found` + error: `Failed to resolve asset path '${args.assetPath}': ${err}` }); return; } } - catch (err) { - resolve({ - success: false, - error: `Failed to verify parent node: ${err}` - }); - return; - } - } - const nodeData = { - name: args.name, - type: args.nodeType || 'cc.Node' - }; - // 使用正确的create-node API参数结构 - if (targetParentUuid) { + // 构建create-node选项 const createNodeOptions = { - parent: targetParentUuid, - name: args.name, - components: args.nodeType && args.nodeType !== 'Node' ? [args.nodeType] : undefined + name: args.name }; - Editor.Message.request('scene', 'create-node', createNodeOptions).then((nodeUuid) => { - // 如果需要设置特定的兄弟索引，使用set-parent API - // 添加延迟以避免内部状态竞争 - if (args.siblingIndex !== undefined && args.siblingIndex >= 0 && nodeUuid) { - setTimeout(() => { - Editor.Message.request('scene', 'set-parent', { - parent: targetParentUuid, - uuids: [nodeUuid], - keepWorldTransform: false - }).then(() => { - resolve({ - success: true, - data: { - uuid: nodeUuid, - name: args.name, - parentUuid: targetParentUuid, - message: args.parentUuid - ? `Node '${args.name}' created under specified parent` - : `Node '${args.name}' created at scene root (no parent specified)` - } - }); - }).catch(() => { - // 即使移动失败，节点已创建，返回成功但带警告 - resolve({ - success: true, - data: { - uuid: nodeUuid, - name: args.name, - message: `Node '${args.name}' created but may not be under intended parent`, - warning: 'Failed to move node to specified parent' - } - }); - }); - }, 100); // 100ms延迟 + // 设置父节点 + if (targetParentUuid) { + createNodeOptions.parent = targetParentUuid; + } + // 从资源实例化 + if (finalAssetUuid) { + createNodeOptions.assetUuid = finalAssetUuid; + if (args.unlinkPrefab) { + createNodeOptions.unlinkPrefab = true; } - else { - // Get complete node info for verification - this.getNodeInfo(nodeUuid).then((nodeInfo) => { - resolve({ - success: true, - data: { - uuid: nodeUuid, - name: args.name, - message: `Node '${args.name}' created successfully` - }, - verificationData: { - nodeInfo: nodeInfo.data, - creationDetails: { - parentUuid: targetParentUuid, - nodeType: args.nodeType || 'Node', - timestamp: new Date().toISOString() - } - } - }); - }).catch(() => { - resolve({ - success: true, - data: { - uuid: nodeUuid, - name: args.name, - message: `Node '${args.name}' created successfully (verification failed)` - } - }); + } + // 添加组件 + if (args.components && args.components.length > 0) { + createNodeOptions.components = args.components; + } + else if (args.nodeType && args.nodeType !== 'Node' && !finalAssetUuid) { + // 只有在不从资源实例化时才添加nodeType组件 + createNodeOptions.components = [args.nodeType]; + } + // 保持世界变换 + if (args.keepWorldTransform) { + createNodeOptions.keepWorldTransform = true; + } + // 不使用dump参数处理初始变换，创建后使用set_node_transform设置 + console.log('Creating node with options:', createNodeOptions); + // 创建节点 + const nodeUuid = await Editor.Message.request('scene', 'create-node', createNodeOptions); + const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid; + // 处理兄弟索引 + if (args.siblingIndex !== undefined && args.siblingIndex >= 0 && uuid && targetParentUuid) { + try { + await new Promise(resolve => setTimeout(resolve, 100)); // 等待内部状态更新 + await Editor.Message.request('scene', 'set-parent', { + parent: targetParentUuid, + uuids: [uuid], + keepWorldTransform: args.keepWorldTransform || false }); } - }).catch((err) => { - resolve({ success: false, error: err.message }); + catch (err) { + console.warn('Failed to set sibling index:', err); + } + } + // 添加组件（如果提供的话） + if (args.components && args.components.length > 0 && uuid) { + try { + await new Promise(resolve => setTimeout(resolve, 100)); // 等待节点创建完成 + for (const componentType of args.components) { + try { + const result = await this.componentTools.execute('add_component', { + nodeUuid: uuid, + componentType: componentType + }); + if (result.success) { + console.log(`Component ${componentType} added successfully`); + } + else { + console.warn(`Failed to add component ${componentType}:`, result.error); + } + } + catch (err) { + console.warn(`Failed to add component ${componentType}:`, err); + } + } + } + catch (err) { + console.warn('Failed to add components:', err); + } + } + // 设置初始变换（如果提供的话） + if (args.initialTransform && uuid) { + try { + await new Promise(resolve => setTimeout(resolve, 150)); // 等待节点和组件创建完成 + await this.setNodeTransform({ + uuid: uuid, + position: args.initialTransform.position, + rotation: args.initialTransform.rotation, + scale: args.initialTransform.scale + }); + console.log('Initial transform applied successfully'); + } + catch (err) { + console.warn('Failed to set initial transform:', err); + } + } + // 获取创建后的节点信息进行验证 + let verificationData = null; + try { + const nodeInfo = await this.getNodeInfo(uuid); + if (nodeInfo.success) { + verificationData = { + nodeInfo: nodeInfo.data, + creationDetails: { + parentUuid: targetParentUuid, + nodeType: args.nodeType || 'Node', + fromAsset: !!finalAssetUuid, + assetUuid: finalAssetUuid, + assetPath: args.assetPath, + timestamp: new Date().toISOString() + } + }; + } + } + catch (err) { + console.warn('Failed to get verification data:', err); + } + const successMessage = finalAssetUuid + ? `Node '${args.name}' instantiated from asset successfully` + : `Node '${args.name}' created successfully`; + resolve({ + success: true, + data: { + uuid: uuid, + name: args.name, + parentUuid: targetParentUuid, + nodeType: args.nodeType || 'Node', + fromAsset: !!finalAssetUuid, + assetUuid: finalAssetUuid, + message: successMessage + }, + verificationData: verificationData }); } - else { - // 没有找到场景根节点，使用默认行为（创建在场景根节点） - const createNodeOptions = { - name: args.name, - components: args.nodeType && args.nodeType !== 'Node' ? [args.nodeType] : undefined - }; - Editor.Message.request('scene', 'create-node', createNodeOptions).then((result) => { - resolve({ - success: true, - data: { - uuid: result, - name: args.name, - message: `Node '${args.name}' created at default location (scene root not found)`, - warning: 'Could not determine scene root, node created at default location' - } - }); - }).catch((err) => { - resolve({ success: false, error: err.message }); + catch (err) { + resolve({ + success: false, + error: `Failed to create node: ${err.message}. Args: ${JSON.stringify(args)}` }); } }); @@ -935,4 +1028,4 @@ class NodeTools { } } exports.NodeTools = NodeTools; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-tools.js","sourceRoot":"","sources":["../../source/tools/node-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, NodeInfo } from '../types';\n\nexport class NodeTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'create_node',\n                description: 'Create a new node in the scene. IMPORTANT: You should always provide parentUuid to specify where to create the node. If parentUuid is not provided, the node will be created at the scene root.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        name: {\n                            type: 'string',\n                            description: 'Node name'\n                        },\n                        parentUuid: {\n                            type: 'string',\n                            description: 'Parent node UUID. STRONGLY RECOMMENDED: Always provide this parameter. Use get_current_scene or get_all_nodes to find parent UUIDs. If not provided, node will be created at scene root.'\n                        },\n                        nodeType: {\n                            type: 'string',\n                            description: 'Node type: Node, 2DNode, 3DNode',\n                            enum: ['Node', '2DNode', '3DNode'],\n                            default: 'Node'\n                        },\n                        siblingIndex: {\n                            type: 'number',\n                            description: 'Sibling index for ordering (-1 means append at end)',\n                            default: -1\n                        }\n                    },\n                    required: ['name']\n                }\n            },\n            {\n                name: 'get_node_info',\n                description: 'Get node information by UUID',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'find_nodes',\n                description: 'Find nodes by name pattern',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        pattern: {\n                            type: 'string',\n                            description: 'Name pattern to search'\n                        },\n                        exactMatch: {\n                            type: 'boolean',\n                            description: 'Exact match or partial match',\n                            default: false\n                        }\n                    },\n                    required: ['pattern']\n                }\n            },\n            {\n                name: 'find_node_by_name',\n                description: 'Find first node by exact name',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        name: {\n                            type: 'string',\n                            description: 'Node name to find'\n                        }\n                    },\n                    required: ['name']\n                }\n            },\n            {\n                name: 'get_all_nodes',\n                description: 'Get all nodes in the scene with their UUIDs',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'set_node_property',\n                description: 'Set node property value (prefer using set_node_transform for position/rotation/scale)',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        property: {\n                            type: 'string',\n                            description: 'Property name (e.g., active, name, layer)'\n                        },\n                        value: {\n                            description: 'Property value'\n                        }\n                    },\n                    required: ['uuid', 'property', 'value']\n                }\n            },\n            {\n                name: 'set_node_transform',\n                description: 'Set node transform properties (position, rotation, scale) with unified interface. Automatically handles 2D/3D node differences.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        position: {\n                            type: 'object',\n                            properties: {\n                                x: { type: 'number' },\n                                y: { type: 'number' },\n                                z: { type: 'number', description: 'Z coordinate (ignored for 2D nodes)' }\n                            },\n                            description: 'Node position. For 2D nodes, only x,y are used; z is ignored. For 3D nodes, all coordinates are used.'\n                        },\n                        rotation: {\n                            type: 'object',\n                            properties: {\n                                x: { type: 'number', description: 'X rotation (ignored for 2D nodes)' },\n                                y: { type: 'number', description: 'Y rotation (ignored for 2D nodes)' },\n                                z: { type: 'number', description: 'Z rotation (main rotation axis for 2D nodes)' }\n                            },\n                            description: 'Node rotation in euler angles. For 2D nodes, only z rotation is used. For 3D nodes, all axes are used.'\n                        },\n                        scale: {\n                            type: 'object',\n                            properties: {\n                                x: { type: 'number' },\n                                y: { type: 'number' },\n                                z: { type: 'number', description: 'Z scale (usually 1 for 2D nodes)' }\n                            },\n                            description: 'Node scale. For 2D nodes, z is typically 1. For 3D nodes, all axes are used.'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'delete_node',\n                description: 'Delete a node from scene',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID to delete'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'move_node',\n                description: 'Move node to new parent',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID to move'\n                        },\n                        newParentUuid: {\n                            type: 'string',\n                            description: 'New parent node UUID'\n                        },\n                        siblingIndex: {\n                            type: 'number',\n                            description: 'Sibling index in new parent',\n                            default: -1\n                        }\n                    },\n                    required: ['nodeUuid', 'newParentUuid']\n                }\n            },\n            {\n                name: 'duplicate_node',\n                description: 'Duplicate a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID to duplicate'\n                        },\n                        includeChildren: {\n                            type: 'boolean',\n                            description: 'Include children nodes',\n                            default: true\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'detect_node_type',\n                description: 'Detect if a node is 2D or 3D based on its components and properties',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID to analyze'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'create_node':\n                return await this.createNode(args);\n            case 'get_node_info':\n                return await this.getNodeInfo(args.uuid);\n            case 'find_nodes':\n                return await this.findNodes(args.pattern, args.exactMatch);\n            case 'find_node_by_name':\n                return await this.findNodeByName(args.name);\n            case 'get_all_nodes':\n                return await this.getAllNodes();\n            case 'set_node_property':\n                return await this.setNodeProperty(args.uuid, args.property, args.value);\n            case 'set_node_transform':\n                return await this.setNodeTransform(args);\n            case 'delete_node':\n                return await this.deleteNode(args.uuid);\n            case 'move_node':\n                return await this.moveNode(args.nodeUuid, args.newParentUuid, args.siblingIndex);\n            case 'duplicate_node':\n                return await this.duplicateNode(args.uuid, args.includeChildren);\n            case 'detect_node_type':\n                return await this.detectNodeType(args.uuid);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async createNode(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            let targetParentUuid = args.parentUuid;\n            \n            // 如果没有提供父节点UUID，获取场景根节点\n            if (!targetParentUuid) {\n                try {\n                    const sceneInfo = await Editor.Message.request('scene', 'query-node-tree');\n                    if (sceneInfo && typeof sceneInfo === 'object' && !Array.isArray(sceneInfo) && Object.prototype.hasOwnProperty.call(sceneInfo, 'uuid')) {\n                        targetParentUuid = (sceneInfo as any).uuid;\n                        console.log(`No parent specified, using scene root: ${targetParentUuid}`);\n                    } else if (Array.isArray(sceneInfo) && sceneInfo.length > 0 && sceneInfo[0].uuid) {\n                        // 如果返回的是数组，使用第一个元素（通常是场景根节点）\n                        targetParentUuid = sceneInfo[0].uuid;\n                        console.log(`No parent specified, using scene root: ${targetParentUuid}`);\n                    } else {\n                        // 备用方案：尝试获取当前场景\n                        const currentScene = await Editor.Message.request('scene', 'query-current-scene');\n                        if (currentScene && currentScene.uuid) {\n                            targetParentUuid = currentScene.uuid;\n                        }\n                    }\n                } catch (err) {\n                    console.warn('Failed to get scene root, will use default behavior');\n                }\n            }\n\n            // 如果指定了父节点，先验证父节点是否存在\n            if (targetParentUuid) {\n                try {\n                    const parentNode = await Editor.Message.request('scene', 'query-node', targetParentUuid);\n                    if (!parentNode) {\n                        resolve({\n                            success: false,\n                            error: `Parent node with UUID '${targetParentUuid}' not found`\n                        });\n                        return;\n                    }\n                } catch (err) {\n                    resolve({\n                        success: false,\n                        error: `Failed to verify parent node: ${err}`\n                    });\n                    return;\n                }\n            }\n\n            const nodeData: any = {\n                name: args.name,\n                type: args.nodeType || 'cc.Node'\n            };\n\n            // 使用正确的create-node API参数结构\n            if (targetParentUuid) {\n                const createNodeOptions = {\n                    parent: targetParentUuid,\n                    name: args.name,\n                    components: args.nodeType && args.nodeType !== 'Node' ? [args.nodeType] : undefined\n                };\n                \n                Editor.Message.request('scene', 'create-node', createNodeOptions).then((nodeUuid: any) => {\n                    // 如果需要设置特定的兄弟索引，使用set-parent API\n                    // 添加延迟以避免内部状态竞争\n                    if (args.siblingIndex !== undefined && args.siblingIndex >= 0 && nodeUuid) {\n                        setTimeout(() => {\n                            Editor.Message.request('scene', 'set-parent', {\n                                parent: targetParentUuid,\n                                uuids: [nodeUuid],\n                                keepWorldTransform: false\n                            }).then(() => {\n                                resolve({\n                                    success: true,\n                                    data: {\n                                        uuid: nodeUuid,\n                                        name: args.name,\n                                        parentUuid: targetParentUuid,\n                                        message: args.parentUuid \n                                            ? `Node '${args.name}' created under specified parent`\n                                            : `Node '${args.name}' created at scene root (no parent specified)`\n                                    }\n                                });\n                            }).catch(() => {\n                                // 即使移动失败，节点已创建，返回成功但带警告\n                                resolve({\n                                    success: true,\n                                    data: {\n                                        uuid: nodeUuid,\n                                        name: args.name,\n                                        message: `Node '${args.name}' created but may not be under intended parent`,\n                                        warning: 'Failed to move node to specified parent'\n                                    }\n                                });\n                            });\n                        }, 100); // 100ms延迟\n                    } else {\n                        // Get complete node info for verification\n                        this.getNodeInfo(nodeUuid).then((nodeInfo) => {\n                            resolve({\n                                success: true,\n                                data: {\n                                    uuid: nodeUuid,\n                                    name: args.name,\n                                    message: `Node '${args.name}' created successfully`\n                                },\n                                verificationData: {\n                                    nodeInfo: nodeInfo.data,\n                                    creationDetails: {\n                                        parentUuid: targetParentUuid,\n                                        nodeType: args.nodeType || 'Node',\n                                        timestamp: new Date().toISOString()\n                                    }\n                                }\n                            });\n                        }).catch(() => {\n                            resolve({\n                                success: true,\n                                data: {\n                                    uuid: nodeUuid,\n                                    name: args.name,\n                                    message: `Node '${args.name}' created successfully (verification failed)`\n                                }\n                            });\n                        });\n                    }\n                }).catch((err: Error) => {\n                    resolve({ success: false, error: err.message });\n                });\n            } else {\n                // 没有找到场景根节点，使用默认行为（创建在场景根节点）\n                const createNodeOptions = {\n                    name: args.name,\n                    components: args.nodeType && args.nodeType !== 'Node' ? [args.nodeType] : undefined\n                };\n                \n                Editor.Message.request('scene', 'create-node', createNodeOptions).then((result: any) => {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: result,\n                            name: args.name,\n                            message: `Node '${args.name}' created at default location (scene root not found)`,\n                            warning: 'Could not determine scene root, node created at default location'\n                        }\n                    });\n                }).catch((err: Error) => {\n                    resolve({ success: false, error: err.message });\n                });\n            }\n        });\n    }\n\n    private async getNodeInfo(uuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'query-node', uuid).then((nodeData: any) => {\n                if (!nodeData) {\n                    resolve({\n                        success: false,\n                        error: 'Node not found or invalid response'\n                    });\n                    return;\n                }\n                \n                // 根据实际返回的数据结构解析节点信息\n                const info: NodeInfo = {\n                    uuid: nodeData.uuid?.value || uuid,\n                    name: nodeData.name?.value || 'Unknown',\n                    active: nodeData.active?.value !== undefined ? nodeData.active.value : true,\n                    position: nodeData.position?.value || { x: 0, y: 0, z: 0 },\n                    rotation: nodeData.rotation?.value || { x: 0, y: 0, z: 0 },\n                    scale: nodeData.scale?.value || { x: 1, y: 1, z: 1 },\n                    parent: nodeData.parent?.value?.uuid || null,\n                    children: nodeData.children || [],\n                    components: (nodeData.__comps__ || []).map((comp: any) => ({\n                        type: comp.__type__ || 'Unknown',\n                        enabled: comp.enabled !== undefined ? comp.enabled : true\n                    })),\n                    layer: nodeData.layer?.value || 1073741824,\n                    mobility: nodeData.mobility?.value || 0\n                };\n                resolve({ success: true, data: info });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async findNodes(pattern: string, exactMatch: boolean = false): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // Note: 'query-nodes-by-name' API doesn't exist in official documentation\n            // Using tree traversal as primary approach\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                const nodes: any[] = [];\n                \n                const searchTree = (node: any, currentPath: string = '') => {\n                    const nodePath = currentPath ? `${currentPath}/${node.name}` : node.name;\n                    \n                    const matches = exactMatch ? \n                        node.name === pattern : \n                        node.name.toLowerCase().includes(pattern.toLowerCase());\n                    \n                    if (matches) {\n                        nodes.push({\n                            uuid: node.uuid,\n                            name: node.name,\n                            path: nodePath\n                        });\n                    }\n                    \n                    if (node.children) {\n                        for (const child of node.children) {\n                            searchTree(child, nodePath);\n                        }\n                    }\n                };\n                \n                if (tree) {\n                    searchTree(tree);\n                }\n                \n                resolve({ success: true, data: nodes });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'findNodes',\n                    args: [pattern, exactMatch]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Tree search failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async findNodeByName(name: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试使用 Editor API 查询节点树并搜索\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                const foundNode = this.searchNodeInTree(tree, name);\n                if (foundNode) {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: foundNode.uuid,\n                            name: foundNode.name,\n                            path: this.getNodePath(foundNode)\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: `Node '${name}' not found` });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'findNodeByName',\n                    args: [name]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private searchNodeInTree(node: any, targetName: string): any {\n        if (node.name === targetName) {\n            return node;\n        }\n        \n        if (node.children) {\n            for (const child of node.children) {\n                const found = this.searchNodeInTree(child, targetName);\n                if (found) {\n                    return found;\n                }\n            }\n        }\n        \n        return null;\n    }\n\n    private async getAllNodes(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试查询场景节点树\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                const nodes: any[] = [];\n                \n                const traverseTree = (node: any) => {\n                    nodes.push({\n                        uuid: node.uuid,\n                        name: node.name,\n                        type: node.type,\n                        active: node.active,\n                        path: this.getNodePath(node)\n                    });\n                    \n                    if (node.children) {\n                        for (const child of node.children) {\n                            traverseTree(child);\n                        }\n                    }\n                };\n                \n                if (tree && tree.children) {\n                    traverseTree(tree);\n                }\n                \n                resolve({\n                    success: true,\n                    data: {\n                        totalNodes: nodes.length,\n                        nodes: nodes\n                    }\n                });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getAllNodes',\n                    args: []\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private getNodePath(node: any): string {\n        const path = [node.name];\n        let current = node.parent;\n        while (current && current.name !== 'Canvas') {\n            path.unshift(current.name);\n            current = current.parent;\n        }\n        return path.join('/');\n    }\n\n    private async setNodeProperty(uuid: string, property: string, value: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试直接使用 Editor API 设置节点属性\n            Editor.Message.request('scene', 'set-property', {\n                uuid: uuid,\n                path: property,\n                dump: {\n                    value: value\n                }\n            }).then(() => {\n                // Get comprehensive verification data including updated node info\n                this.getNodeInfo(uuid).then((nodeInfo) => {\n                    resolve({\n                        success: true,\n                        message: `Property '${property}' updated successfully`,\n                        data: {\n                            nodeUuid: uuid,\n                            property: property,\n                            newValue: value\n                        },\n                        verificationData: {\n                            nodeInfo: nodeInfo.data,\n                            changeDetails: {\n                                property: property,\n                                value: value,\n                                timestamp: new Date().toISOString()\n                            }\n                        }\n                    });\n                }).catch(() => {\n                    resolve({\n                        success: true,\n                        message: `Property '${property}' updated successfully (verification failed)`\n                    });\n                });\n            }).catch((err: Error) => {\n                // 如果直接设置失败，尝试使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'setNodeProperty',\n                    args: [uuid, property, value]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async setNodeTransform(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            const { uuid, position, rotation, scale } = args;\n            const updatePromises: Promise<any>[] = [];\n            const updates: string[] = [];\n            const warnings: string[] = [];\n            \n            try {\n                // First get node info to determine if it's 2D or 3D\n                const nodeInfoResponse = await this.getNodeInfo(uuid);\n                if (!nodeInfoResponse.success || !nodeInfoResponse.data) {\n                    resolve({ success: false, error: 'Failed to get node information' });\n                    return;\n                }\n                \n                const nodeInfo = nodeInfoResponse.data;\n                const is2DNode = this.is2DNode(nodeInfo);\n                \n                if (position) {\n                    const normalizedPosition = this.normalizeTransformValue(position, 'position', is2DNode);\n                    if (normalizedPosition.warning) {\n                        warnings.push(normalizedPosition.warning);\n                    }\n                    \n                    updatePromises.push(\n                        Editor.Message.request('scene', 'set-property', {\n                            uuid: uuid,\n                            path: 'position',\n                            dump: { value: normalizedPosition.value }\n                        })\n                    );\n                    updates.push('position');\n                }\n                \n                if (rotation) {\n                    const normalizedRotation = this.normalizeTransformValue(rotation, 'rotation', is2DNode);\n                    if (normalizedRotation.warning) {\n                        warnings.push(normalizedRotation.warning);\n                    }\n                    \n                    updatePromises.push(\n                        Editor.Message.request('scene', 'set-property', {\n                            uuid: uuid,\n                            path: 'rotation',\n                            dump: { value: normalizedRotation.value }\n                        })\n                    );\n                    updates.push('rotation');\n                }\n                \n                if (scale) {\n                    const normalizedScale = this.normalizeTransformValue(scale, 'scale', is2DNode);\n                    if (normalizedScale.warning) {\n                        warnings.push(normalizedScale.warning);\n                    }\n                    \n                    updatePromises.push(\n                        Editor.Message.request('scene', 'set-property', {\n                            uuid: uuid,\n                            path: 'scale',\n                            dump: { value: normalizedScale.value }\n                        })\n                    );\n                    updates.push('scale');\n                }\n                \n                if (updatePromises.length === 0) {\n                    resolve({ success: false, error: 'No transform properties specified' });\n                    return;\n                }\n                \n                await Promise.all(updatePromises);\n                \n                // Verify the changes by getting updated node info\n                const updatedNodeInfo = await this.getNodeInfo(uuid);\n                const response: any = {\n                    success: true,\n                    message: `Transform properties updated: ${updates.join(', ')} ${is2DNode ? '(2D node)' : '(3D node)'}`,\n                    updatedProperties: updates,\n                    data: {\n                        nodeUuid: uuid,\n                        nodeType: is2DNode ? '2D' : '3D',\n                        appliedChanges: updates,\n                        transformConstraints: {\n                            position: is2DNode ? 'x, y only (z ignored)' : 'x, y, z all used',\n                            rotation: is2DNode ? 'z only (x, y ignored)' : 'x, y, z all used',\n                            scale: is2DNode ? 'x, y main, z typically 1' : 'x, y, z all used'\n                        }\n                    },\n                    verificationData: {\n                        nodeInfo: updatedNodeInfo.data,\n                        transformDetails: {\n                            originalNodeType: is2DNode ? '2D' : '3D',\n                            appliedTransforms: updates,\n                            timestamp: new Date().toISOString()\n                        },\n                        beforeAfterComparison: {\n                            before: nodeInfo,\n                            after: updatedNodeInfo.data\n                        }\n                    }\n                };\n                \n                if (warnings.length > 0) {\n                    response.warning = warnings.join('; ');\n                }\n                \n                resolve(response);\n                \n            } catch (err: any) {\n                resolve({ \n                    success: false, \n                    error: `Failed to update transform: ${err.message}` \n                });\n            }\n        });\n    }\n\n    private is2DNode(nodeInfo: any): boolean {\n        // Check if node has 2D-specific components or is under Canvas\n        const components = nodeInfo.components || [];\n        \n        // Check for common 2D components\n        const has2DComponents = components.some((comp: any) => \n            comp.type && (\n                comp.type.includes('cc.Sprite') ||\n                comp.type.includes('cc.Label') ||\n                comp.type.includes('cc.Button') ||\n                comp.type.includes('cc.Layout') ||\n                comp.type.includes('cc.Widget') ||\n                comp.type.includes('cc.Mask') ||\n                comp.type.includes('cc.Graphics')\n            )\n        );\n        \n        if (has2DComponents) {\n            return true;\n        }\n        \n        // Check for 3D-specific components  \n        const has3DComponents = components.some((comp: any) =>\n            comp.type && (\n                comp.type.includes('cc.MeshRenderer') ||\n                comp.type.includes('cc.Camera') ||\n                comp.type.includes('cc.Light') ||\n                comp.type.includes('cc.DirectionalLight') ||\n                comp.type.includes('cc.PointLight') ||\n                comp.type.includes('cc.SpotLight')\n            )\n        );\n        \n        if (has3DComponents) {\n            return false;\n        }\n        \n        // Default heuristic: if z position is 0 and hasn't been changed, likely 2D\n        const position = nodeInfo.position;\n        if (position && Math.abs(position.z) < 0.001) {\n            return true;\n        }\n        \n        // Default to 3D if uncertain\n        return false;\n    }\n\n    private normalizeTransformValue(value: any, type: 'position' | 'rotation' | 'scale', is2D: boolean): { value: any, warning?: string } {\n        const result = { ...value };\n        let warning: string | undefined;\n        \n        if (is2D) {\n            switch (type) {\n                case 'position':\n                    if (value.z !== undefined && Math.abs(value.z) > 0.001) {\n                        warning = `2D node: z position (${value.z}) ignored, set to 0`;\n                        result.z = 0;\n                    } else if (value.z === undefined) {\n                        result.z = 0;\n                    }\n                    break;\n                    \n                case 'rotation':\n                    if ((value.x !== undefined && Math.abs(value.x) > 0.001) || \n                        (value.y !== undefined && Math.abs(value.y) > 0.001)) {\n                        warning = `2D node: x,y rotations ignored, only z rotation applied`;\n                        result.x = 0;\n                        result.y = 0;\n                    } else {\n                        result.x = result.x || 0;\n                        result.y = result.y || 0;\n                    }\n                    result.z = result.z || 0;\n                    break;\n                    \n                case 'scale':\n                    if (value.z === undefined) {\n                        result.z = 1; // Default scale for 2D\n                    }\n                    break;\n            }\n        } else {\n            // 3D node - ensure all axes are defined\n            result.x = result.x !== undefined ? result.x : (type === 'scale' ? 1 : 0);\n            result.y = result.y !== undefined ? result.y : (type === 'scale' ? 1 : 0);\n            result.z = result.z !== undefined ? result.z : (type === 'scale' ? 1 : 0);\n        }\n        \n        return { value: result, warning };\n    }\n\n    private async deleteNode(uuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'remove-node', { uuid: uuid }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Node deleted successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async moveNode(nodeUuid: string, newParentUuid: string, siblingIndex: number = -1): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // Use correct set-parent API instead of move-node\n            Editor.Message.request('scene', 'set-parent', {\n                parent: newParentUuid,\n                uuids: [nodeUuid],\n                keepWorldTransform: false\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Node moved successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async duplicateNode(uuid: string, includeChildren: boolean = true): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // Note: includeChildren parameter is accepted for future use but not currently implemented\n            Editor.Message.request('scene', 'duplicate-node', uuid).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        newUuid: result.uuid,\n                        message: 'Node duplicated successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async detectNodeType(uuid: string): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                const nodeInfoResponse = await this.getNodeInfo(uuid);\n                if (!nodeInfoResponse.success || !nodeInfoResponse.data) {\n                    resolve({ success: false, error: 'Failed to get node information' });\n                    return;\n                }\n\n                const nodeInfo = nodeInfoResponse.data;\n                const is2D = this.is2DNode(nodeInfo);\n                const components = nodeInfo.components || [];\n                \n                // Collect detection reasons\n                const detectionReasons: string[] = [];\n                \n                // Check for 2D components\n                const twoDComponents = components.filter((comp: any) => \n                    comp.type && (\n                        comp.type.includes('cc.Sprite') ||\n                        comp.type.includes('cc.Label') ||\n                        comp.type.includes('cc.Button') ||\n                        comp.type.includes('cc.Layout') ||\n                        comp.type.includes('cc.Widget') ||\n                        comp.type.includes('cc.Mask') ||\n                        comp.type.includes('cc.Graphics')\n                    )\n                );\n                \n                // Check for 3D components\n                const threeDComponents = components.filter((comp: any) =>\n                    comp.type && (\n                        comp.type.includes('cc.MeshRenderer') ||\n                        comp.type.includes('cc.Camera') ||\n                        comp.type.includes('cc.Light') ||\n                        comp.type.includes('cc.DirectionalLight') ||\n                        comp.type.includes('cc.PointLight') ||\n                        comp.type.includes('cc.SpotLight')\n                    )\n                );\n\n                if (twoDComponents.length > 0) {\n                    detectionReasons.push(`Has 2D components: ${twoDComponents.map((c: any) => c.type).join(', ')}`);\n                }\n                \n                if (threeDComponents.length > 0) {\n                    detectionReasons.push(`Has 3D components: ${threeDComponents.map((c: any) => c.type).join(', ')}`);\n                }\n                \n                // Check position for heuristic\n                const position = nodeInfo.position;\n                if (position && Math.abs(position.z) < 0.001) {\n                    detectionReasons.push('Z position is ~0 (likely 2D)');\n                } else if (position && Math.abs(position.z) > 0.001) {\n                    detectionReasons.push(`Z position is ${position.z} (likely 3D)`);\n                }\n\n                if (detectionReasons.length === 0) {\n                    detectionReasons.push('No specific indicators found, defaulting based on heuristics');\n                }\n\n                resolve({\n                    success: true,\n                    data: {\n                        nodeUuid: uuid,\n                        nodeName: nodeInfo.name,\n                        nodeType: is2D ? '2D' : '3D',\n                        detectionReasons: detectionReasons,\n                        components: components.map((comp: any) => ({\n                            type: comp.type,\n                            category: this.getComponentCategory(comp.type)\n                        })),\n                        position: nodeInfo.position,\n                        transformConstraints: {\n                            position: is2D ? 'x, y only (z ignored)' : 'x, y, z all used',\n                            rotation: is2D ? 'z only (x, y ignored)' : 'x, y, z all used',\n                            scale: is2D ? 'x, y main, z typically 1' : 'x, y, z all used'\n                        }\n                    }\n                });\n                \n            } catch (err: any) {\n                resolve({ \n                    success: false, \n                    error: `Failed to detect node type: ${err.message}` \n                });\n            }\n        });\n    }\n\n    private getComponentCategory(componentType: string): string {\n        if (!componentType) return 'unknown';\n        \n        if (componentType.includes('cc.Sprite') || componentType.includes('cc.Label') || \n            componentType.includes('cc.Button') || componentType.includes('cc.Layout') ||\n            componentType.includes('cc.Widget') || componentType.includes('cc.Mask') ||\n            componentType.includes('cc.Graphics')) {\n            return '2D';\n        }\n        \n        if (componentType.includes('cc.MeshRenderer') || componentType.includes('cc.Camera') ||\n            componentType.includes('cc.Light') || componentType.includes('cc.DirectionalLight') ||\n            componentType.includes('cc.PointLight') || componentType.includes('cc.SpotLight')) {\n            return '3D';\n        }\n        \n        return 'generic';\n    }\n}"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-tools.js","sourceRoot":"","sources":["../../source/tools/node-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, NodeInfo } from '../types';\nimport { ComponentTools } from './component-tools';\n\nexport class NodeTools implements ToolExecutor {\n    private componentTools = new ComponentTools();\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'create_node',\n                description: 'Create a new node in the scene. Supports creating empty nodes, nodes with components, or instantiating from assets (prefabs, etc.). IMPORTANT: You should always provide parentUuid to specify where to create the node.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        name: {\n                            type: 'string',\n                            description: 'Node name'\n                        },\n                        parentUuid: {\n                            type: 'string',\n                            description: 'Parent node UUID. STRONGLY RECOMMENDED: Always provide this parameter. Use get_current_scene or get_all_nodes to find parent UUIDs. If not provided, node will be created at scene root.'\n                        },\n                        nodeType: {\n                            type: 'string',\n                            description: 'Node type: Node, 2DNode, 3DNode',\n                            enum: ['Node', '2DNode', '3DNode'],\n                            default: 'Node'\n                        },\n                        siblingIndex: {\n                            type: 'number',\n                            description: 'Sibling index for ordering (-1 means append at end)',\n                            default: -1\n                        },\n                        assetUuid: {\n                            type: 'string',\n                            description: 'Asset UUID to instantiate from (e.g., prefab UUID). When provided, creates a node instance from the asset instead of an empty node.'\n                        },\n                        assetPath: {\n                            type: 'string',\n                            description: 'Asset path to instantiate from (e.g., \"db://assets/prefabs/MyPrefab.prefab\"). Alternative to assetUuid.'\n                        },\n                        components: {\n                            type: 'array',\n                            items: { type: 'string' },\n                            description: 'Array of component type names to add to the new node (e.g., [\"cc.Sprite\", \"cc.Button\"])'\n                        },\n                        unlinkPrefab: {\n                            type: 'boolean',\n                            description: 'If true and creating from prefab, unlink from prefab to create a regular node',\n                            default: false\n                        },\n                        keepWorldTransform: {\n                            type: 'boolean',\n                            description: 'Whether to keep world transform when creating the node',\n                            default: false\n                        },\n                        initialTransform: {\n                            type: 'object',\n                            properties: {\n                                position: {\n                                    type: 'object',\n                                    properties: {\n                                        x: { type: 'number' },\n                                        y: { type: 'number' },\n                                        z: { type: 'number' }\n                                    }\n                                },\n                                rotation: {\n                                    type: 'object',\n                                    properties: {\n                                        x: { type: 'number' },\n                                        y: { type: 'number' },\n                                        z: { type: 'number' }\n                                    }\n                                },\n                                scale: {\n                                    type: 'object',\n                                    properties: {\n                                        x: { type: 'number' },\n                                        y: { type: 'number' },\n                                        z: { type: 'number' }\n                                    }\n                                }\n                            },\n                            description: 'Initial transform to apply to the created node'\n                        }\n                    },\n                    required: ['name']\n                }\n            },\n            {\n                name: 'get_node_info',\n                description: 'Get node information by UUID',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'find_nodes',\n                description: 'Find nodes by name pattern',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        pattern: {\n                            type: 'string',\n                            description: 'Name pattern to search'\n                        },\n                        exactMatch: {\n                            type: 'boolean',\n                            description: 'Exact match or partial match',\n                            default: false\n                        }\n                    },\n                    required: ['pattern']\n                }\n            },\n            {\n                name: 'find_node_by_name',\n                description: 'Find first node by exact name',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        name: {\n                            type: 'string',\n                            description: 'Node name to find'\n                        }\n                    },\n                    required: ['name']\n                }\n            },\n            {\n                name: 'get_all_nodes',\n                description: 'Get all nodes in the scene with their UUIDs',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'set_node_property',\n                description: 'Set node property value (prefer using set_node_transform for active/layer/mobility/position/rotation/scale)',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        property: {\n                            type: 'string',\n                            description: 'Property name (e.g., active, name, layer)'\n                        },\n                        value: {\n                            description: 'Property value'\n                        }\n                    },\n                    required: ['uuid', 'property', 'value']\n                }\n            },\n            {\n                name: 'set_node_transform',\n                description: 'Set node transform properties (position, rotation, scale) with unified interface. Automatically handles 2D/3D node differences.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        position: {\n                            type: 'object',\n                            properties: {\n                                x: { type: 'number' },\n                                y: { type: 'number' },\n                                z: { type: 'number', description: 'Z coordinate (ignored for 2D nodes)' }\n                            },\n                            description: 'Node position. For 2D nodes, only x,y are used; z is ignored. For 3D nodes, all coordinates are used.'\n                        },\n                        rotation: {\n                            type: 'object',\n                            properties: {\n                                x: { type: 'number', description: 'X rotation (ignored for 2D nodes)' },\n                                y: { type: 'number', description: 'Y rotation (ignored for 2D nodes)' },\n                                z: { type: 'number', description: 'Z rotation (main rotation axis for 2D nodes)' }\n                            },\n                            description: 'Node rotation in euler angles. For 2D nodes, only z rotation is used. For 3D nodes, all axes are used.'\n                        },\n                        scale: {\n                            type: 'object',\n                            properties: {\n                                x: { type: 'number' },\n                                y: { type: 'number' },\n                                z: { type: 'number', description: 'Z scale (usually 1 for 2D nodes)' }\n                            },\n                            description: 'Node scale. For 2D nodes, z is typically 1. For 3D nodes, all axes are used.'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'delete_node',\n                description: 'Delete a node from scene',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID to delete'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'move_node',\n                description: 'Move node to new parent',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID to move'\n                        },\n                        newParentUuid: {\n                            type: 'string',\n                            description: 'New parent node UUID'\n                        },\n                        siblingIndex: {\n                            type: 'number',\n                            description: 'Sibling index in new parent',\n                            default: -1\n                        }\n                    },\n                    required: ['nodeUuid', 'newParentUuid']\n                }\n            },\n            {\n                name: 'duplicate_node',\n                description: 'Duplicate a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID to duplicate'\n                        },\n                        includeChildren: {\n                            type: 'boolean',\n                            description: 'Include children nodes',\n                            default: true\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'detect_node_type',\n                description: 'Detect if a node is 2D or 3D based on its components and properties',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID to analyze'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'create_node':\n                return await this.createNode(args);\n            case 'get_node_info':\n                return await this.getNodeInfo(args.uuid);\n            case 'find_nodes':\n                return await this.findNodes(args.pattern, args.exactMatch);\n            case 'find_node_by_name':\n                return await this.findNodeByName(args.name);\n            case 'get_all_nodes':\n                return await this.getAllNodes();\n            case 'set_node_property':\n                return await this.setNodeProperty(args.uuid, args.property, args.value);\n            case 'set_node_transform':\n                return await this.setNodeTransform(args);\n            case 'delete_node':\n                return await this.deleteNode(args.uuid);\n            case 'move_node':\n                return await this.moveNode(args.nodeUuid, args.newParentUuid, args.siblingIndex);\n            case 'duplicate_node':\n                return await this.duplicateNode(args.uuid, args.includeChildren);\n            case 'detect_node_type':\n                return await this.detectNodeType(args.uuid);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async createNode(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                let targetParentUuid = args.parentUuid;\n                \n                // 如果没有提供父节点UUID，获取场景根节点\n                if (!targetParentUuid) {\n                    try {\n                        const sceneInfo = await Editor.Message.request('scene', 'query-node-tree');\n                        if (sceneInfo && typeof sceneInfo === 'object' && !Array.isArray(sceneInfo) && Object.prototype.hasOwnProperty.call(sceneInfo, 'uuid')) {\n                            targetParentUuid = (sceneInfo as any).uuid;\n                            console.log(`No parent specified, using scene root: ${targetParentUuid}`);\n                        } else if (Array.isArray(sceneInfo) && sceneInfo.length > 0 && sceneInfo[0].uuid) {\n                            targetParentUuid = sceneInfo[0].uuid;\n                            console.log(`No parent specified, using scene root: ${targetParentUuid}`);\n                        } else {\n                            const currentScene = await Editor.Message.request('scene', 'query-current-scene');\n                            if (currentScene && currentScene.uuid) {\n                                targetParentUuid = currentScene.uuid;\n                            }\n                        }\n                    } catch (err) {\n                        console.warn('Failed to get scene root, will use default behavior');\n                    }\n                }\n\n                // 如果提供了assetPath，先解析为assetUuid\n                let finalAssetUuid = args.assetUuid;\n                if (args.assetPath && !finalAssetUuid) {\n                    try {\n                        const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', args.assetPath);\n                        if (assetInfo && assetInfo.uuid) {\n                            finalAssetUuid = assetInfo.uuid;\n                            console.log(`Asset path '${args.assetPath}' resolved to UUID: ${finalAssetUuid}`);\n                        } else {\n                            resolve({\n                                success: false,\n                                error: `Asset not found at path: ${args.assetPath}`\n                            });\n                            return;\n                        }\n                    } catch (err) {\n                        resolve({\n                            success: false,\n                            error: `Failed to resolve asset path '${args.assetPath}': ${err}`\n                        });\n                        return;\n                    }\n                }\n\n                // 构建create-node选项\n                const createNodeOptions: any = {\n                    name: args.name\n                };\n\n                // 设置父节点\n                if (targetParentUuid) {\n                    createNodeOptions.parent = targetParentUuid;\n                }\n\n                // 从资源实例化\n                if (finalAssetUuid) {\n                    createNodeOptions.assetUuid = finalAssetUuid;\n                    if (args.unlinkPrefab) {\n                        createNodeOptions.unlinkPrefab = true;\n                    }\n                }\n\n                // 添加组件\n                if (args.components && args.components.length > 0) {\n                    createNodeOptions.components = args.components;\n                } else if (args.nodeType && args.nodeType !== 'Node' && !finalAssetUuid) {\n                    // 只有在不从资源实例化时才添加nodeType组件\n                    createNodeOptions.components = [args.nodeType];\n                }\n\n                // 保持世界变换\n                if (args.keepWorldTransform) {\n                    createNodeOptions.keepWorldTransform = true;\n                }\n\n                // 不使用dump参数处理初始变换，创建后使用set_node_transform设置\n\n                console.log('Creating node with options:', createNodeOptions);\n\n                // 创建节点\n                const nodeUuid = await Editor.Message.request('scene', 'create-node', createNodeOptions);\n                const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid;\n\n                // 处理兄弟索引\n                if (args.siblingIndex !== undefined && args.siblingIndex >= 0 && uuid && targetParentUuid) {\n                    try {\n                        await new Promise(resolve => setTimeout(resolve, 100)); // 等待内部状态更新\n                        await Editor.Message.request('scene', 'set-parent', {\n                            parent: targetParentUuid,\n                            uuids: [uuid],\n                            keepWorldTransform: args.keepWorldTransform || false\n                        });\n                    } catch (err) {\n                        console.warn('Failed to set sibling index:', err);\n                    }\n                }\n\n                // 添加组件（如果提供的话）\n                if (args.components && args.components.length > 0 && uuid) {\n                    try {\n                        await new Promise(resolve => setTimeout(resolve, 100)); // 等待节点创建完成\n                        for (const componentType of args.components) {\n                            try {\n                                const result = await this.componentTools.execute('add_component', {\n                                    nodeUuid: uuid,\n                                    componentType: componentType\n                                });\n                                if (result.success) {\n                                    console.log(`Component ${componentType} added successfully`);\n                                } else {\n                                    console.warn(`Failed to add component ${componentType}:`, result.error);\n                                }\n                            } catch (err) {\n                                console.warn(`Failed to add component ${componentType}:`, err);\n                            }\n                        }\n                    } catch (err) {\n                        console.warn('Failed to add components:', err);\n                    }\n                }\n\n                // 设置初始变换（如果提供的话）\n                if (args.initialTransform && uuid) {\n                    try {\n                        await new Promise(resolve => setTimeout(resolve, 150)); // 等待节点和组件创建完成\n                        await this.setNodeTransform({\n                            uuid: uuid,\n                            position: args.initialTransform.position,\n                            rotation: args.initialTransform.rotation,\n                            scale: args.initialTransform.scale\n                        });\n                        console.log('Initial transform applied successfully');\n                    } catch (err) {\n                        console.warn('Failed to set initial transform:', err);\n                    }\n                }\n\n                // 获取创建后的节点信息进行验证\n                let verificationData: any = null;\n                try {\n                    const nodeInfo = await this.getNodeInfo(uuid);\n                    if (nodeInfo.success) {\n                        verificationData = {\n                            nodeInfo: nodeInfo.data,\n                            creationDetails: {\n                                parentUuid: targetParentUuid,\n                                nodeType: args.nodeType || 'Node',\n                                fromAsset: !!finalAssetUuid,\n                                assetUuid: finalAssetUuid,\n                                assetPath: args.assetPath,\n                                timestamp: new Date().toISOString()\n                            }\n                        };\n                    }\n                } catch (err) {\n                    console.warn('Failed to get verification data:', err);\n                }\n\n                const successMessage = finalAssetUuid \n                    ? `Node '${args.name}' instantiated from asset successfully`\n                    : `Node '${args.name}' created successfully`;\n\n                resolve({\n                    success: true,\n                    data: {\n                        uuid: uuid,\n                        name: args.name,\n                        parentUuid: targetParentUuid,\n                        nodeType: args.nodeType || 'Node',\n                        fromAsset: !!finalAssetUuid,\n                        assetUuid: finalAssetUuid,\n                        message: successMessage\n                    },\n                    verificationData: verificationData\n                });\n\n            } catch (err: any) {\n                resolve({ \n                    success: false, \n                    error: `Failed to create node: ${err.message}. Args: ${JSON.stringify(args)}`\n                });\n            }\n        });\n    }\n\n    private async getNodeInfo(uuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'query-node', uuid).then((nodeData: any) => {\n                if (!nodeData) {\n                    resolve({\n                        success: false,\n                        error: 'Node not found or invalid response'\n                    });\n                    return;\n                }\n                \n                // 根据实际返回的数据结构解析节点信息\n                const info: NodeInfo = {\n                    uuid: nodeData.uuid?.value || uuid,\n                    name: nodeData.name?.value || 'Unknown',\n                    active: nodeData.active?.value !== undefined ? nodeData.active.value : true,\n                    position: nodeData.position?.value || { x: 0, y: 0, z: 0 },\n                    rotation: nodeData.rotation?.value || { x: 0, y: 0, z: 0 },\n                    scale: nodeData.scale?.value || { x: 1, y: 1, z: 1 },\n                    parent: nodeData.parent?.value?.uuid || null,\n                    children: nodeData.children || [],\n                    components: (nodeData.__comps__ || []).map((comp: any) => ({\n                        type: comp.__type__ || 'Unknown',\n                        enabled: comp.enabled !== undefined ? comp.enabled : true\n                    })),\n                    layer: nodeData.layer?.value || 1073741824,\n                    mobility: nodeData.mobility?.value || 0\n                };\n                resolve({ success: true, data: info });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async findNodes(pattern: string, exactMatch: boolean = false): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // Note: 'query-nodes-by-name' API doesn't exist in official documentation\n            // Using tree traversal as primary approach\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                const nodes: any[] = [];\n                \n                const searchTree = (node: any, currentPath: string = '') => {\n                    const nodePath = currentPath ? `${currentPath}/${node.name}` : node.name;\n                    \n                    const matches = exactMatch ? \n                        node.name === pattern : \n                        node.name.toLowerCase().includes(pattern.toLowerCase());\n                    \n                    if (matches) {\n                        nodes.push({\n                            uuid: node.uuid,\n                            name: node.name,\n                            path: nodePath\n                        });\n                    }\n                    \n                    if (node.children) {\n                        for (const child of node.children) {\n                            searchTree(child, nodePath);\n                        }\n                    }\n                };\n                \n                if (tree) {\n                    searchTree(tree);\n                }\n                \n                resolve({ success: true, data: nodes });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'findNodes',\n                    args: [pattern, exactMatch]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Tree search failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async findNodeByName(name: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试使用 Editor API 查询节点树并搜索\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                const foundNode = this.searchNodeInTree(tree, name);\n                if (foundNode) {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: foundNode.uuid,\n                            name: foundNode.name,\n                            path: this.getNodePath(foundNode)\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: `Node '${name}' not found` });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'findNodeByName',\n                    args: [name]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private searchNodeInTree(node: any, targetName: string): any {\n        if (node.name === targetName) {\n            return node;\n        }\n        \n        if (node.children) {\n            for (const child of node.children) {\n                const found = this.searchNodeInTree(child, targetName);\n                if (found) {\n                    return found;\n                }\n            }\n        }\n        \n        return null;\n    }\n\n    private async getAllNodes(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试查询场景节点树\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                const nodes: any[] = [];\n                \n                const traverseTree = (node: any) => {\n                    nodes.push({\n                        uuid: node.uuid,\n                        name: node.name,\n                        type: node.type,\n                        active: node.active,\n                        path: this.getNodePath(node)\n                    });\n                    \n                    if (node.children) {\n                        for (const child of node.children) {\n                            traverseTree(child);\n                        }\n                    }\n                };\n                \n                if (tree && tree.children) {\n                    traverseTree(tree);\n                }\n                \n                resolve({\n                    success: true,\n                    data: {\n                        totalNodes: nodes.length,\n                        nodes: nodes\n                    }\n                });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getAllNodes',\n                    args: []\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private getNodePath(node: any): string {\n        const path = [node.name];\n        let current = node.parent;\n        while (current && current.name !== 'Canvas') {\n            path.unshift(current.name);\n            current = current.parent;\n        }\n        return path.join('/');\n    }\n\n    private async setNodeProperty(uuid: string, property: string, value: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试直接使用 Editor API 设置节点属性\n            Editor.Message.request('scene', 'set-property', {\n                uuid: uuid,\n                path: property,\n                dump: {\n                    value: value\n                }\n            }).then(() => {\n                // Get comprehensive verification data including updated node info\n                this.getNodeInfo(uuid).then((nodeInfo) => {\n                    resolve({\n                        success: true,\n                        message: `Property '${property}' updated successfully`,\n                        data: {\n                            nodeUuid: uuid,\n                            property: property,\n                            newValue: value\n                        },\n                        verificationData: {\n                            nodeInfo: nodeInfo.data,\n                            changeDetails: {\n                                property: property,\n                                value: value,\n                                timestamp: new Date().toISOString()\n                            }\n                        }\n                    });\n                }).catch(() => {\n                    resolve({\n                        success: true,\n                        message: `Property '${property}' updated successfully (verification failed)`\n                    });\n                });\n            }).catch((err: Error) => {\n                // 如果直接设置失败，尝试使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'setNodeProperty',\n                    args: [uuid, property, value]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async setNodeTransform(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            const { uuid, position, rotation, scale } = args;\n            const updatePromises: Promise<any>[] = [];\n            const updates: string[] = [];\n            const warnings: string[] = [];\n            \n            try {\n                // First get node info to determine if it's 2D or 3D\n                const nodeInfoResponse = await this.getNodeInfo(uuid);\n                if (!nodeInfoResponse.success || !nodeInfoResponse.data) {\n                    resolve({ success: false, error: 'Failed to get node information' });\n                    return;\n                }\n                \n                const nodeInfo = nodeInfoResponse.data;\n                const is2DNode = this.is2DNode(nodeInfo);\n                \n                if (position) {\n                    const normalizedPosition = this.normalizeTransformValue(position, 'position', is2DNode);\n                    if (normalizedPosition.warning) {\n                        warnings.push(normalizedPosition.warning);\n                    }\n                    \n                    updatePromises.push(\n                        Editor.Message.request('scene', 'set-property', {\n                            uuid: uuid,\n                            path: 'position',\n                            dump: { value: normalizedPosition.value }\n                        })\n                    );\n                    updates.push('position');\n                }\n                \n                if (rotation) {\n                    const normalizedRotation = this.normalizeTransformValue(rotation, 'rotation', is2DNode);\n                    if (normalizedRotation.warning) {\n                        warnings.push(normalizedRotation.warning);\n                    }\n                    \n                    updatePromises.push(\n                        Editor.Message.request('scene', 'set-property', {\n                            uuid: uuid,\n                            path: 'rotation',\n                            dump: { value: normalizedRotation.value }\n                        })\n                    );\n                    updates.push('rotation');\n                }\n                \n                if (scale) {\n                    const normalizedScale = this.normalizeTransformValue(scale, 'scale', is2DNode);\n                    if (normalizedScale.warning) {\n                        warnings.push(normalizedScale.warning);\n                    }\n                    \n                    updatePromises.push(\n                        Editor.Message.request('scene', 'set-property', {\n                            uuid: uuid,\n                            path: 'scale',\n                            dump: { value: normalizedScale.value }\n                        })\n                    );\n                    updates.push('scale');\n                }\n                \n                if (updatePromises.length === 0) {\n                    resolve({ success: false, error: 'No transform properties specified' });\n                    return;\n                }\n                \n                await Promise.all(updatePromises);\n                \n                // Verify the changes by getting updated node info\n                const updatedNodeInfo = await this.getNodeInfo(uuid);\n                const response: any = {\n                    success: true,\n                    message: `Transform properties updated: ${updates.join(', ')} ${is2DNode ? '(2D node)' : '(3D node)'}`,\n                    updatedProperties: updates,\n                    data: {\n                        nodeUuid: uuid,\n                        nodeType: is2DNode ? '2D' : '3D',\n                        appliedChanges: updates,\n                        transformConstraints: {\n                            position: is2DNode ? 'x, y only (z ignored)' : 'x, y, z all used',\n                            rotation: is2DNode ? 'z only (x, y ignored)' : 'x, y, z all used',\n                            scale: is2DNode ? 'x, y main, z typically 1' : 'x, y, z all used'\n                        }\n                    },\n                    verificationData: {\n                        nodeInfo: updatedNodeInfo.data,\n                        transformDetails: {\n                            originalNodeType: is2DNode ? '2D' : '3D',\n                            appliedTransforms: updates,\n                            timestamp: new Date().toISOString()\n                        },\n                        beforeAfterComparison: {\n                            before: nodeInfo,\n                            after: updatedNodeInfo.data\n                        }\n                    }\n                };\n                \n                if (warnings.length > 0) {\n                    response.warning = warnings.join('; ');\n                }\n                \n                resolve(response);\n                \n            } catch (err: any) {\n                resolve({ \n                    success: false, \n                    error: `Failed to update transform: ${err.message}` \n                });\n            }\n        });\n    }\n\n    private is2DNode(nodeInfo: any): boolean {\n        // Check if node has 2D-specific components or is under Canvas\n        const components = nodeInfo.components || [];\n        \n        // Check for common 2D components\n        const has2DComponents = components.some((comp: any) => \n            comp.type && (\n                comp.type.includes('cc.Sprite') ||\n                comp.type.includes('cc.Label') ||\n                comp.type.includes('cc.Button') ||\n                comp.type.includes('cc.Layout') ||\n                comp.type.includes('cc.Widget') ||\n                comp.type.includes('cc.Mask') ||\n                comp.type.includes('cc.Graphics')\n            )\n        );\n        \n        if (has2DComponents) {\n            return true;\n        }\n        \n        // Check for 3D-specific components  \n        const has3DComponents = components.some((comp: any) =>\n            comp.type && (\n                comp.type.includes('cc.MeshRenderer') ||\n                comp.type.includes('cc.Camera') ||\n                comp.type.includes('cc.Light') ||\n                comp.type.includes('cc.DirectionalLight') ||\n                comp.type.includes('cc.PointLight') ||\n                comp.type.includes('cc.SpotLight')\n            )\n        );\n        \n        if (has3DComponents) {\n            return false;\n        }\n        \n        // Default heuristic: if z position is 0 and hasn't been changed, likely 2D\n        const position = nodeInfo.position;\n        if (position && Math.abs(position.z) < 0.001) {\n            return true;\n        }\n        \n        // Default to 3D if uncertain\n        return false;\n    }\n\n    private normalizeTransformValue(value: any, type: 'position' | 'rotation' | 'scale', is2D: boolean): { value: any, warning?: string } {\n        const result = { ...value };\n        let warning: string | undefined;\n        \n        if (is2D) {\n            switch (type) {\n                case 'position':\n                    if (value.z !== undefined && Math.abs(value.z) > 0.001) {\n                        warning = `2D node: z position (${value.z}) ignored, set to 0`;\n                        result.z = 0;\n                    } else if (value.z === undefined) {\n                        result.z = 0;\n                    }\n                    break;\n                    \n                case 'rotation':\n                    if ((value.x !== undefined && Math.abs(value.x) > 0.001) || \n                        (value.y !== undefined && Math.abs(value.y) > 0.001)) {\n                        warning = `2D node: x,y rotations ignored, only z rotation applied`;\n                        result.x = 0;\n                        result.y = 0;\n                    } else {\n                        result.x = result.x || 0;\n                        result.y = result.y || 0;\n                    }\n                    result.z = result.z || 0;\n                    break;\n                    \n                case 'scale':\n                    if (value.z === undefined) {\n                        result.z = 1; // Default scale for 2D\n                    }\n                    break;\n            }\n        } else {\n            // 3D node - ensure all axes are defined\n            result.x = result.x !== undefined ? result.x : (type === 'scale' ? 1 : 0);\n            result.y = result.y !== undefined ? result.y : (type === 'scale' ? 1 : 0);\n            result.z = result.z !== undefined ? result.z : (type === 'scale' ? 1 : 0);\n        }\n        \n        return { value: result, warning };\n    }\n\n    private async deleteNode(uuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'remove-node', { uuid: uuid }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Node deleted successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async moveNode(nodeUuid: string, newParentUuid: string, siblingIndex: number = -1): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // Use correct set-parent API instead of move-node\n            Editor.Message.request('scene', 'set-parent', {\n                parent: newParentUuid,\n                uuids: [nodeUuid],\n                keepWorldTransform: false\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Node moved successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async duplicateNode(uuid: string, includeChildren: boolean = true): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // Note: includeChildren parameter is accepted for future use but not currently implemented\n            Editor.Message.request('scene', 'duplicate-node', uuid).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        newUuid: result.uuid,\n                        message: 'Node duplicated successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async detectNodeType(uuid: string): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                const nodeInfoResponse = await this.getNodeInfo(uuid);\n                if (!nodeInfoResponse.success || !nodeInfoResponse.data) {\n                    resolve({ success: false, error: 'Failed to get node information' });\n                    return;\n                }\n\n                const nodeInfo = nodeInfoResponse.data;\n                const is2D = this.is2DNode(nodeInfo);\n                const components = nodeInfo.components || [];\n                \n                // Collect detection reasons\n                const detectionReasons: string[] = [];\n                \n                // Check for 2D components\n                const twoDComponents = components.filter((comp: any) => \n                    comp.type && (\n                        comp.type.includes('cc.Sprite') ||\n                        comp.type.includes('cc.Label') ||\n                        comp.type.includes('cc.Button') ||\n                        comp.type.includes('cc.Layout') ||\n                        comp.type.includes('cc.Widget') ||\n                        comp.type.includes('cc.Mask') ||\n                        comp.type.includes('cc.Graphics')\n                    )\n                );\n                \n                // Check for 3D components\n                const threeDComponents = components.filter((comp: any) =>\n                    comp.type && (\n                        comp.type.includes('cc.MeshRenderer') ||\n                        comp.type.includes('cc.Camera') ||\n                        comp.type.includes('cc.Light') ||\n                        comp.type.includes('cc.DirectionalLight') ||\n                        comp.type.includes('cc.PointLight') ||\n                        comp.type.includes('cc.SpotLight')\n                    )\n                );\n\n                if (twoDComponents.length > 0) {\n                    detectionReasons.push(`Has 2D components: ${twoDComponents.map((c: any) => c.type).join(', ')}`);\n                }\n                \n                if (threeDComponents.length > 0) {\n                    detectionReasons.push(`Has 3D components: ${threeDComponents.map((c: any) => c.type).join(', ')}`);\n                }\n                \n                // Check position for heuristic\n                const position = nodeInfo.position;\n                if (position && Math.abs(position.z) < 0.001) {\n                    detectionReasons.push('Z position is ~0 (likely 2D)');\n                } else if (position && Math.abs(position.z) > 0.001) {\n                    detectionReasons.push(`Z position is ${position.z} (likely 3D)`);\n                }\n\n                if (detectionReasons.length === 0) {\n                    detectionReasons.push('No specific indicators found, defaulting based on heuristics');\n                }\n\n                resolve({\n                    success: true,\n                    data: {\n                        nodeUuid: uuid,\n                        nodeName: nodeInfo.name,\n                        nodeType: is2D ? '2D' : '3D',\n                        detectionReasons: detectionReasons,\n                        components: components.map((comp: any) => ({\n                            type: comp.type,\n                            category: this.getComponentCategory(comp.type)\n                        })),\n                        position: nodeInfo.position,\n                        transformConstraints: {\n                            position: is2D ? 'x, y only (z ignored)' : 'x, y, z all used',\n                            rotation: is2D ? 'z only (x, y ignored)' : 'x, y, z all used',\n                            scale: is2D ? 'x, y main, z typically 1' : 'x, y, z all used'\n                        }\n                    }\n                });\n                \n            } catch (err: any) {\n                resolve({ \n                    success: false, \n                    error: `Failed to detect node type: ${err.message}` \n                });\n            }\n        });\n    }\n\n    private getComponentCategory(componentType: string): string {\n        if (!componentType) return 'unknown';\n        \n        if (componentType.includes('cc.Sprite') || componentType.includes('cc.Label') || \n            componentType.includes('cc.Button') || componentType.includes('cc.Layout') ||\n            componentType.includes('cc.Widget') || componentType.includes('cc.Mask') ||\n            componentType.includes('cc.Graphics')) {\n            return '2D';\n        }\n        \n        if (componentType.includes('cc.MeshRenderer') || componentType.includes('cc.Camera') ||\n            componentType.includes('cc.Light') || componentType.includes('cc.DirectionalLight') ||\n            componentType.includes('cc.PointLight') || componentType.includes('cc.SpotLight')) {\n            return '3D';\n        }\n        \n        return 'generic';\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/prefab-tools.js b/dist/tools/prefab-tools.js index a1eb637..0f55844 100644 --- a/dist/tools/prefab-tools.js +++ b/dist/tools/prefab-tools.js @@ -61,7 +61,7 @@ class PrefabTools { }, { name: 'create_prefab', - description: 'Create a prefab from a node', + description: 'Create a prefab from a node with all children and components', inputSchema: { type: 'object', properties: { @@ -71,44 +71,16 @@ class PrefabTools { }, savePath: { type: 'string', - description: 'Path to save the prefab' + description: 'Path to save the prefab (e.g., db://assets/prefabs/MyPrefab.prefab)' }, prefabName: { type: 'string', description: 'Prefab name' - }, - includeChildren: { - type: 'boolean', - description: 'Whether to include child nodes', - default: true - }, - includeComponents: { - type: 'boolean', - description: 'Whether to include components', - default: true } }, required: ['nodeUuid', 'savePath', 'prefabName'] } }, - { - name: 'create_prefab_from_node', - description: 'Create a prefab from a node (alias for create_prefab)', - inputSchema: { - type: 'object', - properties: { - nodeUuid: { - type: 'string', - description: 'Source node UUID' - }, - prefabPath: { - type: 'string', - description: 'Path to save the prefab' - } - }, - required: ['nodeUuid', 'prefabPath'] - } - }, { name: 'update_prefab', description: 'Update an existing prefab', @@ -221,8 +193,6 @@ class PrefabTools { return await this.instantiatePrefab(args); case 'create_prefab': return await this.createPrefab(args); - case 'create_prefab_from_node': - return await this.createPrefabFromNode(args); case 'update_prefab': return await this.updatePrefab(args.prefabPath, args.nodeUuid); case 'revert_prefab': @@ -282,8 +252,10 @@ class PrefabTools { }); } async instantiatePrefab(args) { - return new Promise((resolve) => { - Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo) => { + return new Promise(async (resolve) => { + try { + // 获取预制体资源信息 + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath); if (!assetInfo) { throw new Error('预制体未找到'); } @@ -310,10 +282,15 @@ class PrefabTools { } }; } - return Editor.Message.request('scene', 'create-node', createNodeOptions); - }).then((nodeUuid) => { - // 获取实际的节点UUID + // 创建节点 + const nodeUuid = await Editor.Message.request('scene', 'create-node', createNodeOptions); const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid; + // 注意：create-node API从预制体资源创建时应该自动建立预制体关联 + console.log('预制体节点创建成功:', { + nodeUuid: uuid, + prefabUuid: assetInfo.uuid, + prefabPath: args.prefabPath + }); resolve({ success: true, data: { @@ -321,18 +298,172 @@ class PrefabTools { prefabPath: args.prefabPath, parentUuid: args.parentUuid, position: args.position, - message: '预制体实例化成功' + message: '预制体实例化成功，已建立预制体关联' } }); - }).catch((err) => { + } + catch (err) { resolve({ success: false, error: `预制体实例化失败: ${err.message}`, instruction: '请检查预制体路径是否正确，确保预制体文件格式正确' }); - }); + } }); } + /** + * 建立节点与预制体的关联关系 + * 这个方法创建必要的PrefabInfo和PrefabInstance结构 + */ + async establishPrefabConnection(nodeUuid, prefabUuid, prefabPath) { + try { + // 读取预制体文件获取根节点的fileId + const prefabContent = await this.readPrefabFile(prefabPath); + if (!prefabContent || !prefabContent.data || !prefabContent.data.length) { + throw new Error('无法读取预制体文件内容'); + } + // 找到预制体根节点的fileId (通常是第二个对象，即索引1) + const rootNode = prefabContent.data.find((item) => item.__type === 'cc.Node' && item._parent === null); + if (!rootNode || !rootNode._prefab) { + throw new Error('无法找到预制体根节点或其预制体信息'); + } + // 获取根节点的PrefabInfo + const rootPrefabInfo = prefabContent.data[rootNode._prefab.__id__]; + if (!rootPrefabInfo || rootPrefabInfo.__type !== 'cc.PrefabInfo') { + throw new Error('无法找到预制体根节点的PrefabInfo'); + } + const rootFileId = rootPrefabInfo.fileId; + // 使用scene API建立预制体连接 + const prefabConnectionData = { + node: nodeUuid, + prefab: prefabUuid, + fileId: rootFileId + }; + // 尝试使用多种API方法建立预制体连接 + const connectionMethods = [ + () => Editor.Message.request('scene', 'connect-prefab-instance', prefabConnectionData), + () => Editor.Message.request('scene', 'set-prefab-connection', prefabConnectionData), + () => Editor.Message.request('scene', 'apply-prefab-link', prefabConnectionData) + ]; + let connected = false; + for (const method of connectionMethods) { + try { + await method(); + connected = true; + break; + } + catch (error) { + console.warn('预制体连接方法失败，尝试下一个方法:', error); + } + } + if (!connected) { + // 如果所有API方法都失败，尝试手动修改场景数据 + console.warn('所有预制体连接API都失败，尝试手动建立连接'); + await this.manuallyEstablishPrefabConnection(nodeUuid, prefabUuid, rootFileId); + } + } + catch (error) { + console.error('建立预制体连接失败:', error); + throw error; + } + } + /** + * 手动建立预制体连接（当API方法失败时的备用方案） + */ + async manuallyEstablishPrefabConnection(nodeUuid, prefabUuid, rootFileId) { + try { + // 尝试使用dump API修改节点的_prefab属性 + const prefabConnectionData = { + [nodeUuid]: { + '_prefab': { + '__uuid__': prefabUuid, + '__expectedType__': 'cc.Prefab', + 'fileId': rootFileId + } + } + }; + await Editor.Message.request('scene', 'set-property', { + uuid: nodeUuid, + path: '_prefab', + dump: { + value: { + '__uuid__': prefabUuid, + '__expectedType__': 'cc.Prefab' + } + } + }); + } + catch (error) { + console.error('手动建立预制体连接也失败:', error); + // 不抛出错误，因为基本的节点创建已经成功 + } + } + /** + * 读取预制体文件内容 + */ + async readPrefabFile(prefabPath) { + try { + // 尝试使用asset-db API读取文件内容 + let assetContent; + try { + assetContent = await Editor.Message.request('asset-db', 'query-asset-info', prefabPath); + if (assetContent && assetContent.source) { + // 如果有source路径，直接读取文件 + const fs = require('fs'); + const path = require('path'); + const fullPath = path.resolve(assetContent.source); + const fileContent = fs.readFileSync(fullPath, 'utf8'); + return JSON.parse(fileContent); + } + } + catch (error) { + console.warn('使用asset-db读取失败，尝试其他方法:', error); + } + // 备用方法：转换db://路径为实际文件路径 + const fsPath = prefabPath.replace('db://assets/', 'assets/').replace('db://assets', 'assets'); + const fs = require('fs'); + const path = require('path'); + // 尝试多个可能的项目根路径 + const possiblePaths = [ + path.resolve(process.cwd(), '../../NewProject_3', fsPath), + path.resolve('/Users/lizhiyong/NewProject_3', fsPath), + path.resolve(fsPath), + // 如果是根目录下的文件，也尝试直接路径 + path.resolve('/Users/lizhiyong/NewProject_3/assets', path.basename(fsPath)) + ]; + console.log('尝试读取预制体文件，路径转换:', { + originalPath: prefabPath, + fsPath: fsPath, + possiblePaths: possiblePaths + }); + for (const fullPath of possiblePaths) { + try { + console.log(`检查路径: ${fullPath}`); + if (fs.existsSync(fullPath)) { + console.log(`找到文件: ${fullPath}`); + const fileContent = fs.readFileSync(fullPath, 'utf8'); + const parsed = JSON.parse(fileContent); + console.log('文件解析成功，数据结构:', { + hasData: !!parsed.data, + dataLength: parsed.data ? parsed.data.length : 0 + }); + return parsed; + } + else { + console.log(`文件不存在: ${fullPath}`); + } + } + catch (readError) { + console.warn(`读取文件失败 ${fullPath}:`, readError); + } + } + throw new Error('无法找到或读取预制体文件'); + } + catch (error) { + console.error('读取预制体文件失败:', error); + throw error; + } + } async tryCreateNodeWithPrefab(args) { return new Promise((resolve) => { Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo) => { @@ -498,6 +629,88 @@ class PrefabTools { tryMethod(0); }); } + /** + * 使用 asset-db API 创建预制体的新方法 + * 深度整合引擎的资源管理系统，实现完整的预制体创建流程 + */ + async createPrefabWithAssetDB(nodeUuid, savePath, prefabName, includeChildren, includeComponents) { + return new Promise(async (resolve) => { + var _a; + try { + console.log('=== 使用 Asset-DB API 创建预制体 ==='); + console.log(`节点UUID: ${nodeUuid}`); + console.log(`保存路径: ${savePath}`); + console.log(`预制体名称: ${prefabName}`); + // 第一步：获取节点数据（包括变换属性） + const nodeData = await this.getNodeData(nodeUuid); + if (!nodeData) { + resolve({ + success: false, + error: '无法获取节点数据' + }); + return; + } + console.log('获取到节点数据，子节点数量:', nodeData.children ? nodeData.children.length : 0); + // 第二步：先创建资源文件以获取引擎分配的UUID + console.log('创建预制体资源文件...'); + const tempPrefabContent = JSON.stringify([{ "__type__": "cc.Prefab", "_name": prefabName }], null, 2); + const createResult = await this.createAssetWithAssetDB(savePath, tempPrefabContent); + if (!createResult.success) { + resolve(createResult); + return; + } + // 获取引擎分配的实际UUID + const actualPrefabUuid = (_a = createResult.data) === null || _a === void 0 ? void 0 : _a.uuid; + if (!actualPrefabUuid) { + resolve({ + success: false, + error: '无法获取引擎分配的预制体UUID' + }); + return; + } + console.log('引擎分配的UUID:', actualPrefabUuid); + // 第三步：使用实际UUID重新生成预制体内容 + const prefabContent = await this.createStandardPrefabContent(nodeData, prefabName, actualPrefabUuid, includeChildren, includeComponents); + const prefabContentString = JSON.stringify(prefabContent, null, 2); + // 第四步：更新预制体文件内容 + console.log('更新预制体文件内容...'); + const updateResult = await this.updateAssetWithAssetDB(savePath, prefabContentString); + // 第五步：创建对应的meta文件（使用实际UUID） + console.log('创建预制体meta文件...'); + const metaContent = this.createStandardMetaContent(prefabName, actualPrefabUuid); + const metaResult = await this.createMetaWithAssetDB(savePath, metaContent); + // 第六步：重新导入资源以更新引用 + console.log('重新导入预制体资源...'); + const reimportResult = await this.reimportAssetWithAssetDB(savePath); + // 第七步：尝试将原始节点转换为预制体实例 + console.log('尝试将原始节点转换为预制体实例...'); + const convertResult = await this.convertNodeToPrefabInstance(nodeUuid, actualPrefabUuid, savePath); + resolve({ + success: true, + data: { + prefabUuid: actualPrefabUuid, + prefabPath: savePath, + nodeUuid: nodeUuid, + prefabName: prefabName, + convertedToPrefabInstance: convertResult.success, + createAssetResult: createResult, + updateResult: updateResult, + metaResult: metaResult, + reimportResult: reimportResult, + convertResult: convertResult, + message: convertResult.success ? '预制体创建并成功转换原始节点' : '预制体创建成功，但节点转换失败' + } + }); + } + catch (error) { + console.error('创建预制体时发生错误:', error); + resolve({ + success: false, + error: `创建预制体失败: ${error}` + }); + } + }); + } async createPrefab(args) { return new Promise(async (resolve) => { try { @@ -513,13 +726,24 @@ class PrefabTools { const prefabName = args.prefabName || 'NewPrefab'; const fullPath = pathParam.endsWith('.prefab') ? pathParam : `${pathParam}/${prefabName}.prefab`; - // 尝试使用Cocos Creator的原生预制体创建API + const includeChildren = args.includeChildren !== false; // 默认为 true + const includeComponents = args.includeComponents !== false; // 默认为 true + // 优先使用新的 asset-db 方法创建预制体 + console.log('使用新的 asset-db 方法创建预制体...'); + const assetDbResult = await this.createPrefabWithAssetDB(args.nodeUuid, fullPath, prefabName, includeChildren, includeComponents); + if (assetDbResult.success) { + resolve(assetDbResult); + return; + } + // 如果 asset-db 方法失败，尝试使用Cocos Creator的原生预制体创建API + console.log('asset-db 方法失败，尝试原生API...'); const nativeResult = await this.createPrefabNative(args.nodeUuid, fullPath); if (nativeResult.success) { resolve(nativeResult); return; } // 如果原生API失败，使用自定义实现 + console.log('原生API失败，使用自定义实现...'); const customResult = await this.createPrefabCustom(args.nodeUuid, fullPath, prefabName); resolve(customResult); } @@ -565,12 +789,14 @@ class PrefabTools { console.log('节点UUID:', ((_b = nodeData.uuid) === null || _b === void 0 ? void 0 : _b.value) || '未知'); console.log('预制体保存路径:', prefabPath); console.log(`开始创建预制体，节点数据:`, nodeData); - const prefabJsonData = await this.createStandardPrefabData(nodeData, prefabName, prefabUuid); + const prefabJsonData = await this.createStandardPrefabContent(nodeData, prefabName, prefabUuid, true, true); // 5. 创建标准meta文件数据 const standardMetaData = this.createStandardMetaData(prefabName, prefabUuid); // 6. 保存预制体和meta文件 const saveResult = await this.savePrefabWithMeta(prefabPath, prefabJsonData, standardMetaData); if (saveResult.success) { + // 保存成功后，将原始节点转换为预制体实例 + const convertResult = await this.convertNodeToPrefabInstance(nodeUuid, prefabPath, prefabUuid); resolve({ success: true, data: { @@ -578,7 +804,10 @@ class PrefabTools { prefabPath: prefabPath, nodeUuid: nodeUuid, prefabName: prefabName, - message: '自定义预制体创建成功' + convertedToPrefabInstance: convertResult.success, + message: convertResult.success ? + '自定义预制体创建成功，原始节点已转换为预制体实例' : + '预制体创建成功，但节点转换失败' } }); } @@ -598,51 +827,121 @@ class PrefabTools { }); } async getNodeData(nodeUuid) { - return new Promise((resolve) => { - Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeInfo) => { + return new Promise(async (resolve) => { + try { + // 首先获取基本节点信息 + const nodeInfo = await Editor.Message.request('scene', 'query-node', nodeUuid); if (!nodeInfo) { resolve(null); return; } - // 尝试获取节点的完整序列化数据 - Editor.Message.request('scene', 'serialize-node', { - node: nodeUuid, - includeChildren: true - }).then((serializedData) => { - resolve(serializedData); - }).catch(() => { - // 如果序列化失败，尝试获取节点的详细信息 - this.getNodeDetailedInfo(nodeUuid).then((detailedInfo) => { - resolve(detailedInfo || nodeInfo); - }).catch(() => { - resolve(nodeInfo); - }); - }); - }).catch(() => { - resolve(null); - }); - }); - } - async getNodeDetailedInfo(nodeUuid) { - return new Promise((resolve) => { - // 获取节点的详细信息，包括组件和子节点 - Editor.Message.request('scene', 'query-node-detail', nodeUuid).then((detailInfo) => { - if (detailInfo) { - resolve(detailInfo); + console.log(`获取节点 ${nodeUuid} 的基本信息成功`); + // 使用query-node-tree获取包含子节点的完整结构 + const nodeTree = await this.getNodeWithChildren(nodeUuid); + if (nodeTree) { + console.log(`获取节点 ${nodeUuid} 的完整树结构成功`); + resolve(nodeTree); } else { - // 如果无法获取详细信息，构建基本节点信息 - this.buildBasicNodeInfo(nodeUuid).then((basicInfo) => { - resolve(basicInfo); - }).catch(() => { - resolve(null); - }); + console.log(`使用基本节点信息`); + resolve(nodeInfo); } - }).catch(() => { + } + catch (error) { + console.warn(`获取节点数据失败 ${nodeUuid}:`, error); resolve(null); - }); + } }); } + // 使用query-node-tree获取包含子节点的完整节点结构 + async getNodeWithChildren(nodeUuid) { + try { + // 获取整个场景树 + const tree = await Editor.Message.request('scene', 'query-node-tree'); + if (!tree) { + return null; + } + // 在树中查找指定的节点 + const targetNode = this.findNodeInTree(tree, nodeUuid); + if (targetNode) { + console.log(`在场景树中找到节点 ${nodeUuid}，子节点数量: ${targetNode.children ? targetNode.children.length : 0}`); + // 增强节点树，获取每个节点的正确组件信息 + const enhancedTree = await this.enhanceTreeWithMCPComponents(targetNode); + return enhancedTree; + } + return null; + } + catch (error) { + console.warn(`获取节点树结构失败 ${nodeUuid}:`, error); + return null; + } + } + // 在节点树中递归查找指定UUID的节点 + findNodeInTree(node, targetUuid) { + var _a; + if (!node) + return null; + // 检查当前节点 + if (node.uuid === targetUuid || ((_a = node.value) === null || _a === void 0 ? void 0 : _a.uuid) === targetUuid) { + return node; + } + // 递归检查子节点 + if (node.children && Array.isArray(node.children)) { + for (const child of node.children) { + const found = this.findNodeInTree(child, targetUuid); + if (found) { + return found; + } + } + } + return null; + } + /** + * 使用MCP接口增强节点树，获取正确的组件信息 + */ + async enhanceTreeWithMCPComponents(node) { + var _a, _b, _c; + if (!node || !node.uuid) { + return node; + } + try { + // 使用MCP接口获取节点的组件信息 + const response = await fetch('http://localhost:8585/mcp', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + "jsonrpc": "2.0", + "method": "tools/call", + "params": { + "name": "component_get_components", + "arguments": { + "nodeUuid": node.uuid + } + }, + "id": Date.now() + }) + }); + const mcpResult = await response.json(); + if ((_c = (_b = (_a = mcpResult.result) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.text) { + const componentData = JSON.parse(mcpResult.result.content[0].text); + if (componentData.success && componentData.data.components) { + // 更新节点的组件信息为MCP返回的正确数据 + node.components = componentData.data.components; + console.log(`节点 ${node.uuid} 获取到 ${componentData.data.components.length} 个组件，包含脚本组件的正确类型`); + } + } + } + catch (error) { + console.warn(`获取节点 ${node.uuid} 的MCP组件信息失败:`, error); + } + // 递归处理子节点 + if (node.children && Array.isArray(node.children)) { + for (let i = 0; i < node.children.length; i++) { + node.children[i] = await this.enhanceTreeWithMCPComponents(node.children[i]); + } + } + return node; + } async buildBasicNodeInfo(nodeUuid) { return new Promise((resolve) => { // 构建基本的节点信息 @@ -660,6 +959,71 @@ class PrefabTools { }); }); } + // 验证节点数据是否有效 + isValidNodeData(nodeData) { + if (!nodeData) + return false; + if (typeof nodeData !== 'object') + return false; + // 检查基本属性 - 适配query-node-tree的数据格式 + return nodeData.hasOwnProperty('uuid') || + nodeData.hasOwnProperty('name') || + nodeData.hasOwnProperty('__type__') || + (nodeData.value && (nodeData.value.hasOwnProperty('uuid') || + nodeData.value.hasOwnProperty('name') || + nodeData.value.hasOwnProperty('__type__'))); + } + // 提取子节点UUID的统一方法 + extractChildUuid(childRef) { + if (!childRef) + return null; + // 方法1: 直接字符串 + if (typeof childRef === 'string') { + return childRef; + } + // 方法2: value属性包含字符串 + if (childRef.value && typeof childRef.value === 'string') { + return childRef.value; + } + // 方法3: value.uuid属性 + if (childRef.value && childRef.value.uuid) { + return childRef.value.uuid; + } + // 方法4: 直接uuid属性 + if (childRef.uuid) { + return childRef.uuid; + } + // 方法5: __id__引用 - 这种情况需要特殊处理 + if (childRef.__id__ !== undefined) { + console.log(`发现__id__引用: ${childRef.__id__}，可能需要从数据结构中查找`); + return null; // 暂时返回null，后续可以添加引用解析逻辑 + } + console.warn('无法提取子节点UUID:', JSON.stringify(childRef)); + return null; + } + // 获取需要处理的子节点数据 + getChildrenToProcess(nodeData) { + var _a; + const children = []; + // 方法1: 直接从children数组获取（从query-node-tree返回的数据） + if (nodeData.children && Array.isArray(nodeData.children)) { + console.log(`从children数组获取子节点，数量: ${nodeData.children.length}`); + for (const child of nodeData.children) { + // query-node-tree返回的子节点通常已经是完整的数据结构 + if (this.isValidNodeData(child)) { + children.push(child); + console.log(`添加子节点: ${child.name || ((_a = child.value) === null || _a === void 0 ? void 0 : _a.name) || '未知'}`); + } + else { + console.log('子节点数据无效:', JSON.stringify(child, null, 2)); + } + } + } + else { + console.log('节点没有子节点或children数组为空'); + } + return children; + } generateUUID() { // 生成符合Cocos Creator格式的UUID const chars = '0123456789abcdef'; @@ -696,7 +1060,6 @@ class PrefabTools { let idCounter = 1; // 递归处理节点和组件 const processNode = (node, parentId = 0) => { - var _a, _b, _c, _d, _e, _f; const nodeId = idCounter++; // 创建节点对象 const processedNode = { @@ -713,9 +1076,9 @@ class PrefabTools { }, "_lpos": { "__type__": "cc.Vec3", - "x": ((_a = node.position) === null || _a === void 0 ? void 0 : _a.x) || 0, - "y": ((_b = node.position) === null || _b === void 0 ? void 0 : _b.y) || 0, - "z": ((_c = node.position) === null || _c === void 0 ? void 0 : _c.z) || 0 + "x": 0, + "y": 0, + "z": 0 }, "_lrot": { "__type__": "cc.Quat", @@ -726,9 +1089,9 @@ class PrefabTools { }, "_lscale": { "__type__": "cc.Vec3", - "x": ((_d = node.scale) === null || _d === void 0 ? void 0 : _d.x) || 1, - "y": ((_e = node.scale) === null || _e === void 0 ? void 0 : _e.y) || 1, - "z": ((_f = node.scale) === null || _f === void 0 ? void 0 : _f.z) || 1 + "x": 1, + "y": 1, + "z": 1 }, "_mobility": 0, "_layer": 1073741824, @@ -1073,6 +1436,688 @@ class PrefabTools { // 在实际应用中，可能需要更复杂的UUID映射处理 return modifiedData; } + /** + * 使用 asset-db API 创建资源文件 + */ + async createAssetWithAssetDB(assetPath, content) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'create-asset', assetPath, content, { + overwrite: true, + rename: false + }).then((assetInfo) => { + console.log('创建资源文件成功:', assetInfo); + resolve({ success: true, data: assetInfo }); + }).catch((error) => { + console.error('创建资源文件失败:', error); + resolve({ success: false, error: error.message || '创建资源文件失败' }); + }); + }); + } + /** + * 使用 asset-db API 创建 meta 文件 + */ + async createMetaWithAssetDB(assetPath, metaContent) { + return new Promise((resolve) => { + const metaContentString = JSON.stringify(metaContent, null, 2); + Editor.Message.request('asset-db', 'save-asset-meta', assetPath, metaContentString).then((assetInfo) => { + console.log('创建meta文件成功:', assetInfo); + resolve({ success: true, data: assetInfo }); + }).catch((error) => { + console.error('创建meta文件失败:', error); + resolve({ success: false, error: error.message || '创建meta文件失败' }); + }); + }); + } + /** + * 使用 asset-db API 重新导入资源 + */ + async reimportAssetWithAssetDB(assetPath) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'reimport-asset', assetPath).then((result) => { + console.log('重新导入资源成功:', result); + resolve({ success: true, data: result }); + }).catch((error) => { + console.error('重新导入资源失败:', error); + resolve({ success: false, error: error.message || '重新导入资源失败' }); + }); + }); + } + /** + * 使用 asset-db API 更新资源文件内容 + */ + async updateAssetWithAssetDB(assetPath, content) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'save-asset', assetPath, content).then((result) => { + console.log('更新资源文件成功:', result); + resolve({ success: true, data: result }); + }).catch((error) => { + console.error('更新资源文件失败:', error); + resolve({ success: false, error: error.message || '更新资源文件失败' }); + }); + }); + } + /** + * 创建符合 Cocos Creator 标准的预制体内容 + * 完整实现递归节点树处理，匹配引擎标准格式 + */ + async createStandardPrefabContent(nodeData, prefabName, prefabUuid, includeChildren, includeComponents) { + console.log('开始创建引擎标准预制体内容...'); + const prefabData = []; + let currentId = 0; + // 1. 创建预制体资产对象 (index 0) + const prefabAsset = { + "__type__": "cc.Prefab", + "_name": prefabName || "", // 确保预制体名称不为空 + "_objFlags": 0, + "__editorExtras__": {}, + "_native": "", + "data": { + "__id__": 1 + }, + "optimizationPolicy": 0, + "persistent": false + }; + prefabData.push(prefabAsset); + currentId++; + // 2. 递归创建完整的节点树结构 + const context = { + prefabData, + currentId: currentId + 1, // 根节点占用索引1，子节点从索引2开始 + prefabAssetIndex: 0, + nodeFileIds: new Map(), // 存储节点ID到fileId的映射 + nodeUuidToIndex: new Map(), // 存储节点UUID到索引的映射 + componentUuidToIndex: new Map() // 存储组件UUID到索引的映射 + }; + // 创建根节点和整个节点树 - 注意：根节点的父节点应该是null，不是预制体对象 + await this.createCompleteNodeTree(nodeData, null, 1, context, includeChildren, includeComponents, prefabName); + console.log(`预制体内容创建完成，总共 ${prefabData.length} 个对象`); + console.log('节点fileId映射:', Array.from(context.nodeFileIds.entries())); + return prefabData; + } + /** + * 递归创建完整的节点树，包括所有子节点和对应的PrefabInfo + */ + async createCompleteNodeTree(nodeData, parentNodeIndex, nodeIndex, context, includeChildren, includeComponents, nodeName) { + const { prefabData } = context; + // 创建节点对象 + const node = this.createEngineStandardNode(nodeData, parentNodeIndex, nodeName); + // 确保节点在指定的索引位置 + while (prefabData.length <= nodeIndex) { + prefabData.push(null); + } + console.log(`设置节点到索引 ${nodeIndex}: ${node._name}, _parent:`, node._parent, `_children count: ${node._children.length}`); + prefabData[nodeIndex] = node; + // 为当前节点生成fileId并记录UUID到索引的映射 + const nodeUuid = this.extractNodeUuid(nodeData); + const fileId = nodeUuid || this.generateFileId(); + context.nodeFileIds.set(nodeIndex.toString(), fileId); + // 记录节点UUID到索引的映射 + if (nodeUuid) { + context.nodeUuidToIndex.set(nodeUuid, nodeIndex); + console.log(`记录节点UUID映射: ${nodeUuid} -> ${nodeIndex}`); + } + // 先处理子节点（保持与手动创建的索引顺序一致） + const childrenToProcess = this.getChildrenToProcess(nodeData); + if (includeChildren && childrenToProcess.length > 0) { + console.log(`处理节点 ${node._name} 的 ${childrenToProcess.length} 个子节点`); + // 为每个子节点分配索引 + const childIndices = []; + console.log(`准备为 ${childrenToProcess.length} 个子节点分配索引，当前ID: ${context.currentId}`); + for (let i = 0; i < childrenToProcess.length; i++) { + console.log(`处理第 ${i + 1} 个子节点，当前currentId: ${context.currentId}`); + const childIndex = context.currentId++; + childIndices.push(childIndex); + node._children.push({ "__id__": childIndex }); + console.log(`✅ 添加子节点引用到 ${node._name}: {__id__: ${childIndex}}`); + } + console.log(`✅ 节点 ${node._name} 最终的子节点数组:`, node._children); + // 递归创建子节点 + for (let i = 0; i < childrenToProcess.length; i++) { + const childData = childrenToProcess[i]; + const childIndex = childIndices[i]; + await this.createCompleteNodeTree(childData, nodeIndex, childIndex, context, includeChildren, includeComponents, childData.name || `Child${i + 1}`); + } + } + // 然后处理组件 + if (includeComponents && nodeData.components && Array.isArray(nodeData.components)) { + console.log(`处理节点 ${node._name} 的 ${nodeData.components.length} 个组件`); + const componentIndices = []; + for (const component of nodeData.components) { + const componentIndex = context.currentId++; + componentIndices.push(componentIndex); + node._components.push({ "__id__": componentIndex }); + // 记录组件UUID到索引的映射 + const componentUuid = component.uuid || (component.value && component.value.uuid); + if (componentUuid) { + context.componentUuidToIndex.set(componentUuid, componentIndex); + console.log(`记录组件UUID映射: ${componentUuid} -> ${componentIndex}`); + } + // 创建组件对象，传入context以处理引用 + const componentObj = this.createComponentObject(component, nodeIndex, context); + prefabData[componentIndex] = componentObj; + // 为组件创建 CompPrefabInfo + const compPrefabInfoIndex = context.currentId++; + prefabData[compPrefabInfoIndex] = { + "__type__": "cc.CompPrefabInfo", + "fileId": this.generateFileId() + }; + // 如果组件对象有 __prefab 属性，设置引用 + if (componentObj && typeof componentObj === 'object') { + componentObj.__prefab = { "__id__": compPrefabInfoIndex }; + } + } + console.log(`✅ 节点 ${node._name} 添加了 ${componentIndices.length} 个组件`); + } + // 为当前节点创建PrefabInfo + const prefabInfoIndex = context.currentId++; + node._prefab = { "__id__": prefabInfoIndex }; + const prefabInfo = { + "__type__": "cc.PrefabInfo", + "root": { "__id__": 1 }, + "asset": { "__id__": context.prefabAssetIndex }, + "fileId": fileId, + "targetOverrides": null, + "nestedPrefabInstanceRoots": null + }; + // 根节点的特殊处理 + if (nodeIndex === 1) { + // 根节点没有instance，但可能有targetOverrides + prefabInfo.instance = null; + } + else { + // 子节点通常有instance为null + prefabInfo.instance = null; + } + prefabData[prefabInfoIndex] = prefabInfo; + context.currentId = prefabInfoIndex + 1; + } + /** + * 将UUID转换为Cocos Creator的压缩格式 + * 基于真实Cocos Creator编辑器的压缩算法实现 + * 前5个hex字符保持不变，剩余27个字符压缩成18个字符 + */ + uuidToCompressedId(uuid) { + const BASE64_KEYS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; + // 移除连字符并转为小写 + const cleanUuid = uuid.replace(/-/g, '').toLowerCase(); + // 确保UUID有效 + if (cleanUuid.length !== 32) { + return uuid; // 如果不是有效的UUID，返回原始值 + } + // Cocos Creator的压缩算法：前5个字符保持不变，剩余27个字符压缩成18个字符 + let result = cleanUuid.substring(0, 5); + // 剩余27个字符需要压缩成18个字符 + const remainder = cleanUuid.substring(5); + // 每3个hex字符压缩成2个字符 + for (let i = 0; i < remainder.length; i += 3) { + const hex1 = remainder[i] || '0'; + const hex2 = remainder[i + 1] || '0'; + const hex3 = remainder[i + 2] || '0'; + // 将3个hex字符(12位)转换为2个base64字符 + const value = parseInt(hex1 + hex2 + hex3, 16); + // 12位分成两个6位 + const high6 = (value >> 6) & 63; + const low6 = value & 63; + result += BASE64_KEYS[high6] + BASE64_KEYS[low6]; + } + return result; + } + /** + * 创建组件对象 + */ + createComponentObject(componentData, nodeIndex, context) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6; + let componentType = componentData.type || componentData.__type__ || 'cc.Component'; + const enabled = componentData.enabled !== undefined ? componentData.enabled : true; + // console.log(`创建组件对象 - 原始类型: ${componentType}`); + // console.log('组件完整数据:', JSON.stringify(componentData, null, 2)); + // 处理脚本组件 - MCP接口已经返回正确的压缩UUID格式 + if (componentType && !componentType.startsWith('cc.')) { + console.log(`使用脚本组件压缩UUID类型: ${componentType}`); + } + // 基础组件结构 + const component = { + "__type__": componentType, + "_name": "", + "_objFlags": 0, + "__editorExtras__": {}, + "node": { "__id__": nodeIndex }, + "_enabled": enabled + }; + // 提前设置 __prefab 属性占位符，后续会被正确设置 + component.__prefab = null; + // 根据组件类型添加特定属性 + if (componentType === 'cc.UITransform') { + const contentSize = ((_b = (_a = componentData.properties) === null || _a === void 0 ? void 0 : _a.contentSize) === null || _b === void 0 ? void 0 : _b.value) || { width: 100, height: 100 }; + const anchorPoint = ((_d = (_c = componentData.properties) === null || _c === void 0 ? void 0 : _c.anchorPoint) === null || _d === void 0 ? void 0 : _d.value) || { x: 0.5, y: 0.5 }; + component._contentSize = { + "__type__": "cc.Size", + "width": contentSize.width, + "height": contentSize.height + }; + component._anchorPoint = { + "__type__": "cc.Vec2", + "x": anchorPoint.x, + "y": anchorPoint.y + }; + } + else if (componentType === 'cc.Sprite') { + // 处理Sprite组件的spriteFrame引用 + const spriteFrameProp = ((_e = componentData.properties) === null || _e === void 0 ? void 0 : _e._spriteFrame) || ((_f = componentData.properties) === null || _f === void 0 ? void 0 : _f.spriteFrame); + if (spriteFrameProp) { + component._spriteFrame = this.processComponentProperty(spriteFrameProp, context); + } + else { + component._spriteFrame = null; + } + component._type = (_j = (_h = (_g = componentData.properties) === null || _g === void 0 ? void 0 : _g._type) === null || _h === void 0 ? void 0 : _h.value) !== null && _j !== void 0 ? _j : 0; + component._fillType = (_m = (_l = (_k = componentData.properties) === null || _k === void 0 ? void 0 : _k._fillType) === null || _l === void 0 ? void 0 : _l.value) !== null && _m !== void 0 ? _m : 0; + component._sizeMode = (_q = (_p = (_o = componentData.properties) === null || _o === void 0 ? void 0 : _o._sizeMode) === null || _p === void 0 ? void 0 : _p.value) !== null && _q !== void 0 ? _q : 1; + component._fillCenter = { "__type__": "cc.Vec2", "x": 0, "y": 0 }; + component._fillStart = (_t = (_s = (_r = componentData.properties) === null || _r === void 0 ? void 0 : _r._fillStart) === null || _s === void 0 ? void 0 : _s.value) !== null && _t !== void 0 ? _t : 0; + component._fillRange = (_w = (_v = (_u = componentData.properties) === null || _u === void 0 ? void 0 : _u._fillRange) === null || _v === void 0 ? void 0 : _v.value) !== null && _w !== void 0 ? _w : 0; + component._isTrimmedMode = (_z = (_y = (_x = componentData.properties) === null || _x === void 0 ? void 0 : _x._isTrimmedMode) === null || _y === void 0 ? void 0 : _y.value) !== null && _z !== void 0 ? _z : true; + component._useGrayscale = (_2 = (_1 = (_0 = componentData.properties) === null || _0 === void 0 ? void 0 : _0._useGrayscale) === null || _1 === void 0 ? void 0 : _1.value) !== null && _2 !== void 0 ? _2 : false; + // 调试：打印Sprite组件的所有属性（已注释） + // console.log('Sprite组件属性:', JSON.stringify(componentData.properties, null, 2)); + component._atlas = null; + component._id = ""; + } + else if (componentType === 'cc.Button') { + component._interactable = true; + component._transition = 3; + component._normalColor = { "__type__": "cc.Color", "r": 255, "g": 255, "b": 255, "a": 255 }; + component._hoverColor = { "__type__": "cc.Color", "r": 211, "g": 211, "b": 211, "a": 255 }; + component._pressedColor = { "__type__": "cc.Color", "r": 255, "g": 255, "b": 255, "a": 255 }; + component._disabledColor = { "__type__": "cc.Color", "r": 124, "g": 124, "b": 124, "a": 255 }; + component._normalSprite = null; + component._hoverSprite = null; + component._pressedSprite = null; + component._disabledSprite = null; + component._duration = 0.1; + component._zoomScale = 1.2; + // 处理Button的target引用 + const targetProp = ((_3 = componentData.properties) === null || _3 === void 0 ? void 0 : _3._target) || ((_4 = componentData.properties) === null || _4 === void 0 ? void 0 : _4.target); + if (targetProp) { + component._target = this.processComponentProperty(targetProp, context); + } + else { + component._target = { "__id__": nodeIndex }; // 默认指向自身节点 + } + component._clickEvents = []; + component._id = ""; + } + else if (componentType === 'cc.Label') { + component._string = ((_6 = (_5 = componentData.properties) === null || _5 === void 0 ? void 0 : _5._string) === null || _6 === void 0 ? void 0 : _6.value) || "Label"; + component._horizontalAlign = 1; + component._verticalAlign = 1; + component._actualFontSize = 20; + component._fontSize = 20; + component._fontFamily = "Arial"; + component._lineHeight = 25; + component._overflow = 0; + component._enableWrapText = true; + component._font = null; + component._isSystemFontUsed = true; + component._spacingX = 0; + component._isItalic = false; + component._isBold = false; + component._isUnderline = false; + component._underlineHeight = 2; + component._cacheMode = 0; + component._id = ""; + } + else if (componentData.properties) { + // 处理所有组件的属性（包括内置组件和自定义脚本组件） + for (const [key, value] of Object.entries(componentData.properties)) { + if (key === 'node' || key === 'enabled' || key === '__type__' || + key === 'uuid' || key === 'name' || key === '__scriptAsset' || key === '_objFlags') { + continue; // 跳过这些特殊属性，包括_objFlags + } + // 对于以下划线开头的属性，需要特殊处理 + if (key.startsWith('_')) { + // 确保属性名保持原样（包括下划线） + const propValue = this.processComponentProperty(value, context); + if (propValue !== undefined) { + component[key] = propValue; + } + } + else { + // 非下划线开头的属性正常处理 + const propValue = this.processComponentProperty(value, context); + if (propValue !== undefined) { + component[key] = propValue; + } + } + } + } + // 确保 _id 在最后位置 + const _id = component._id || ""; + delete component._id; + component._id = _id; + return component; + } + /** + * 处理组件属性值，确保格式与手动创建的预制体一致 + */ + processComponentProperty(propData, context) { + var _a, _b; + if (!propData || typeof propData !== 'object') { + return propData; + } + const value = propData.value; + const type = propData.type; + // 处理null值 + if (value === null || value === undefined) { + return null; + } + // 处理空UUID对象，转换为null + if (value && typeof value === 'object' && value.uuid === '') { + return null; + } + // 处理节点引用 + if (type === 'cc.Node' && (value === null || value === void 0 ? void 0 : value.uuid)) { + // 在预制体中，节点引用需要转换为 __id__ 形式 + if ((context === null || context === void 0 ? void 0 : context.nodeUuidToIndex) && context.nodeUuidToIndex.has(value.uuid)) { + // 内部引用：转换为__id__格式 + return { + "__id__": context.nodeUuidToIndex.get(value.uuid) + }; + } + // 外部引用：设置为null，因为外部节点不属于预制体结构 + console.warn(`Node reference UUID ${value.uuid} not found in prefab context, setting to null (external reference)`); + return null; + } + // 处理资源引用（预制体、纹理、精灵帧等） + if ((value === null || value === void 0 ? void 0 : value.uuid) && (type === 'cc.Prefab' || + type === 'cc.Texture2D' || + type === 'cc.SpriteFrame' || + type === 'cc.Material' || + type === 'cc.AnimationClip' || + type === 'cc.AudioClip' || + type === 'cc.Font' || + type === 'cc.Asset')) { + // 对于预制体引用，保持原始UUID格式 + const uuidToUse = type === 'cc.Prefab' ? value.uuid : this.uuidToCompressedId(value.uuid); + return { + "__uuid__": uuidToUse, + "__expectedType__": type + }; + } + // 处理组件引用（包括具体的组件类型如cc.Label, cc.Button等） + if ((value === null || value === void 0 ? void 0 : value.uuid) && (type === 'cc.Component' || + type === 'cc.Label' || type === 'cc.Button' || type === 'cc.Sprite' || + type === 'cc.UITransform' || type === 'cc.RigidBody2D' || + type === 'cc.BoxCollider2D' || type === 'cc.Animation' || + type === 'cc.AudioSource' || ((type === null || type === void 0 ? void 0 : type.startsWith('cc.')) && !type.includes('@')))) { + // 在预制体中，组件引用也需要转换为 __id__ 形式 + if ((context === null || context === void 0 ? void 0 : context.componentUuidToIndex) && context.componentUuidToIndex.has(value.uuid)) { + // 内部引用：转换为__id__格式 + console.log(`Component reference ${type} UUID ${value.uuid} found in prefab context, converting to __id__`); + return { + "__id__": context.componentUuidToIndex.get(value.uuid) + }; + } + // 外部引用：设置为null，因为外部组件不属于预制体结构 + console.warn(`Component reference ${type} UUID ${value.uuid} not found in prefab context, setting to null (external reference)`); + return null; + } + // 处理复杂类型，添加__type__标记 + if (value && typeof value === 'object') { + if (type === 'cc.Color') { + return { + "__type__": "cc.Color", + "r": Math.min(255, Math.max(0, Number(value.r) || 0)), + "g": Math.min(255, Math.max(0, Number(value.g) || 0)), + "b": Math.min(255, Math.max(0, Number(value.b) || 0)), + "a": value.a !== undefined ? Math.min(255, Math.max(0, Number(value.a))) : 255 + }; + } + else if (type === 'cc.Vec3') { + return { + "__type__": "cc.Vec3", + "x": Number(value.x) || 0, + "y": Number(value.y) || 0, + "z": Number(value.z) || 0 + }; + } + else if (type === 'cc.Vec2') { + return { + "__type__": "cc.Vec2", + "x": Number(value.x) || 0, + "y": Number(value.y) || 0 + }; + } + else if (type === 'cc.Size') { + return { + "__type__": "cc.Size", + "width": Number(value.width) || 0, + "height": Number(value.height) || 0 + }; + } + else if (type === 'cc.Quat') { + return { + "__type__": "cc.Quat", + "x": Number(value.x) || 0, + "y": Number(value.y) || 0, + "z": Number(value.z) || 0, + "w": value.w !== undefined ? Number(value.w) : 1 + }; + } + } + // 处理数组类型 + if (Array.isArray(value)) { + // 节点数组 + if (((_a = propData.elementTypeData) === null || _a === void 0 ? void 0 : _a.type) === 'cc.Node') { + return value.map(item => { + var _a; + if ((item === null || item === void 0 ? void 0 : item.uuid) && ((_a = context === null || context === void 0 ? void 0 : context.nodeUuidToIndex) === null || _a === void 0 ? void 0 : _a.has(item.uuid))) { + return { "__id__": context.nodeUuidToIndex.get(item.uuid) }; + } + return null; + }).filter(item => item !== null); + } + // 资源数组 + if (((_b = propData.elementTypeData) === null || _b === void 0 ? void 0 : _b.type) && propData.elementTypeData.type.startsWith('cc.')) { + return value.map(item => { + if (item === null || item === void 0 ? void 0 : item.uuid) { + return { + "__uuid__": this.uuidToCompressedId(item.uuid), + "__expectedType__": propData.elementTypeData.type + }; + } + return null; + }).filter(item => item !== null); + } + // 基础类型数组 + return value.map(item => (item === null || item === void 0 ? void 0 : item.value) !== undefined ? item.value : item); + } + // 其他复杂对象类型，保持原样但确保有__type__标记 + if (value && typeof value === 'object' && type && type.startsWith('cc.')) { + return Object.assign({ "__type__": type }, value); + } + return value; + } + /** + * 创建符合引擎标准的节点对象 + */ + createEngineStandardNode(nodeData, parentNodeIndex, nodeName) { + // 调试：打印原始节点数据（已注释） + // console.log('原始节点数据:', JSON.stringify(nodeData, null, 2)); + var _a, _b, _c, _d, _e, _f, _g, _h; + // 提取节点的基本属性 + const getValue = (prop) => { + if ((prop === null || prop === void 0 ? void 0 : prop.value) !== undefined) + return prop.value; + if (prop !== undefined) + return prop; + return null; + }; + const position = getValue(nodeData.position) || getValue((_a = nodeData.value) === null || _a === void 0 ? void 0 : _a.position) || { x: 0, y: 0, z: 0 }; + const rotation = getValue(nodeData.rotation) || getValue((_b = nodeData.value) === null || _b === void 0 ? void 0 : _b.rotation) || { x: 0, y: 0, z: 0, w: 1 }; + const scale = getValue(nodeData.scale) || getValue((_c = nodeData.value) === null || _c === void 0 ? void 0 : _c.scale) || { x: 1, y: 1, z: 1 }; + const active = (_f = (_d = getValue(nodeData.active)) !== null && _d !== void 0 ? _d : getValue((_e = nodeData.value) === null || _e === void 0 ? void 0 : _e.active)) !== null && _f !== void 0 ? _f : true; + const name = nodeName || getValue(nodeData.name) || getValue((_g = nodeData.value) === null || _g === void 0 ? void 0 : _g.name) || 'Node'; + const layer = getValue(nodeData.layer) || getValue((_h = nodeData.value) === null || _h === void 0 ? void 0 : _h.layer) || 1073741824; + // 调试输出 + console.log(`创建节点: ${name}, parentNodeIndex: ${parentNodeIndex}`); + const parentRef = parentNodeIndex !== null ? { "__id__": parentNodeIndex } : null; + console.log(`节点 ${name} 的父节点引用:`, parentRef); + return { + "__type__": "cc.Node", + "_name": name, + "_objFlags": 0, + "__editorExtras__": {}, + "_parent": parentRef, + "_children": [], // 子节点引用将在递归过程中动态添加 + "_active": active, + "_components": [], // 组件引用将在处理组件时动态添加 + "_prefab": { "__id__": 0 }, // 临时值，后续会被正确设置 + "_lpos": { + "__type__": "cc.Vec3", + "x": position.x, + "y": position.y, + "z": position.z + }, + "_lrot": { + "__type__": "cc.Quat", + "x": rotation.x, + "y": rotation.y, + "z": rotation.z, + "w": rotation.w + }, + "_lscale": { + "__type__": "cc.Vec3", + "x": scale.x, + "y": scale.y, + "z": scale.z + }, + "_mobility": 0, + "_layer": layer, + "_euler": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "_id": "" + }; + } + /** + * 从节点数据中提取UUID + */ + extractNodeUuid(nodeData) { + var _a, _b, _c; + if (!nodeData) + return null; + // 尝试多种方式获取UUID + const sources = [ + nodeData.uuid, + (_a = nodeData.value) === null || _a === void 0 ? void 0 : _a.uuid, + nodeData.__uuid__, + (_b = nodeData.value) === null || _b === void 0 ? void 0 : _b.__uuid__, + nodeData.id, + (_c = nodeData.value) === null || _c === void 0 ? void 0 : _c.id + ]; + for (const source of sources) { + if (typeof source === 'string' && source.length > 0) { + return source; + } + } + return null; + } + /** + * 创建最小化的节点对象，不包含任何组件以避免依赖问题 + */ + createMinimalNode(nodeData, nodeName) { + var _a, _b, _c, _d, _e, _f, _g, _h; + // 提取节点的基本属性 + const getValue = (prop) => { + if ((prop === null || prop === void 0 ? void 0 : prop.value) !== undefined) + return prop.value; + if (prop !== undefined) + return prop; + return null; + }; + const position = getValue(nodeData.position) || getValue((_a = nodeData.value) === null || _a === void 0 ? void 0 : _a.position) || { x: 0, y: 0, z: 0 }; + const rotation = getValue(nodeData.rotation) || getValue((_b = nodeData.value) === null || _b === void 0 ? void 0 : _b.rotation) || { x: 0, y: 0, z: 0, w: 1 }; + const scale = getValue(nodeData.scale) || getValue((_c = nodeData.value) === null || _c === void 0 ? void 0 : _c.scale) || { x: 1, y: 1, z: 1 }; + const active = (_f = (_d = getValue(nodeData.active)) !== null && _d !== void 0 ? _d : getValue((_e = nodeData.value) === null || _e === void 0 ? void 0 : _e.active)) !== null && _f !== void 0 ? _f : true; + const name = nodeName || getValue(nodeData.name) || getValue((_g = nodeData.value) === null || _g === void 0 ? void 0 : _g.name) || 'Node'; + const layer = getValue(nodeData.layer) || getValue((_h = nodeData.value) === null || _h === void 0 ? void 0 : _h.layer) || 33554432; + return { + "__type__": "cc.Node", + "_name": name, + "_objFlags": 0, + "_parent": null, + "_children": [], + "_active": active, + "_components": [], // 空的组件数组，避免组件依赖问题 + "_prefab": { + "__id__": 2 + }, + "_lpos": { + "__type__": "cc.Vec3", + "x": position.x, + "y": position.y, + "z": position.z + }, + "_lrot": { + "__type__": "cc.Quat", + "x": rotation.x, + "y": rotation.y, + "z": rotation.z, + "w": rotation.w + }, + "_lscale": { + "__type__": "cc.Vec3", + "x": scale.x, + "y": scale.y, + "z": scale.z + }, + "_layer": layer, + "_euler": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "_id": "" + }; + } + /** + * 创建标准的 meta 文件内容 + */ + createStandardMetaContent(prefabName, prefabUuid) { + return { + "ver": "2.0.3", + "importer": "prefab", + "imported": true, + "uuid": prefabUuid, + "files": [ + ".json" + ], + "subMetas": {}, + "userData": { + "syncNodeName": prefabName, + "hasIcon": false + } + }; + } + /** + * 尝试将原始节点转换为预制体实例 + */ + async convertNodeToPrefabInstance(nodeUuid, prefabUuid, prefabPath) { + return new Promise((resolve) => { + // 这个功能需要深入的场景编辑器集成，暂时返回失败 + // 在实际的引擎中，这涉及到复杂的预制体实例化和节点替换逻辑 + console.log('节点转换为预制体实例的功能需要更深入的引擎集成'); + resolve({ + success: false, + error: '节点转换为预制体实例需要更深入的引擎集成支持' + }); + }); + } async restorePrefabNode(nodeUuid, assetUuid) { return new Promise((resolve) => { // 使用官方API restore-prefab 还原预制体节点 @@ -1130,31 +2175,40 @@ class PrefabTools { const rootNode = await this.createNodeObject(nodeData, null, prefabData, currentId); prefabData.push(rootNode.node); currentId = rootNode.nextId; - // 添加根节点的 PrefabInfo + // 添加根节点的 PrefabInfo - 修复asset引用使用UUID const rootPrefabInfo = { "__type__": "cc.PrefabInfo", "root": { "__id__": 1 }, "asset": { - "__id__": 0 + "__uuid__": prefabUuid }, "fileId": this.generateFileId(), - "targetOverrides": null + "instance": null, + "targetOverrides": [], + "nestedPrefabInstanceRoots": [] }; prefabData.push(rootPrefabInfo); return prefabData; } async createNodeObject(nodeData, parentId, prefabData, currentId) { - var _a, _b, _c, _d, _e, _f, _g; + var _a, _b, _c, _d, _e, _f, _g, _h, _j; const nodeId = currentId++; - // 提取节点的基本属性 - const position = ((_a = nodeData.position) === null || _a === void 0 ? void 0 : _a.value) || { x: 0, y: 0, z: 0 }; - const rotation = ((_b = nodeData.rotation) === null || _b === void 0 ? void 0 : _b.value) || { x: 0, y: 0, z: 0, w: 1 }; - const scale = ((_c = nodeData.scale) === null || _c === void 0 ? void 0 : _c.value) || { x: 1, y: 1, z: 1 }; - const active = ((_d = nodeData.active) === null || _d === void 0 ? void 0 : _d.value) !== undefined ? nodeData.active.value : true; - const name = ((_e = nodeData.name) === null || _e === void 0 ? void 0 : _e.value) || 'Node'; - const layer = ((_f = nodeData.layer) === null || _f === void 0 ? void 0 : _f.value) || 33554432; + // 提取节点的基本属性 - 适配query-node-tree的数据格式 + const getValue = (prop) => { + if ((prop === null || prop === void 0 ? void 0 : prop.value) !== undefined) + return prop.value; + if (prop !== undefined) + return prop; + return null; + }; + const position = getValue(nodeData.position) || getValue((_a = nodeData.value) === null || _a === void 0 ? void 0 : _a.position) || { x: 0, y: 0, z: 0 }; + const rotation = getValue(nodeData.rotation) || getValue((_b = nodeData.value) === null || _b === void 0 ? void 0 : _b.rotation) || { x: 0, y: 0, z: 0, w: 1 }; + const scale = getValue(nodeData.scale) || getValue((_c = nodeData.value) === null || _c === void 0 ? void 0 : _c.scale) || { x: 1, y: 1, z: 1 }; + const active = (_f = (_d = getValue(nodeData.active)) !== null && _d !== void 0 ? _d : getValue((_e = nodeData.value) === null || _e === void 0 ? void 0 : _e.active)) !== null && _f !== void 0 ? _f : true; + const name = getValue(nodeData.name) || getValue((_g = nodeData.value) === null || _g === void 0 ? void 0 : _g.name) || 'Node'; + const layer = getValue(nodeData.layer) || getValue((_h = nodeData.value) === null || _h === void 0 ? void 0 : _h.layer) || 33554432; const node = { "__type__": "cc.Node", "_name": name, @@ -1164,9 +2218,9 @@ class PrefabTools { "_children": [], "_active": active, "_components": [], - "_prefab": { + "_prefab": parentId === null ? { "__id__": currentId++ - }, + } : null, "_lpos": { "__type__": "cc.Vec3", "x": position.x, @@ -1196,127 +2250,259 @@ class PrefabTools { }, "_id": "" }; - // 添加组件 - if (nodeData.__comps__ && nodeData.__comps__.length > 0) { - for (const comp of nodeData.__comps__) { - const componentId = currentId++; - node._components.push({ "__id__": componentId }); - // 创建组件对象 - const componentObj = this.createComponentObject(comp, nodeId, currentId++); - prefabData.push(componentObj); - // 添加组件的 CompPrefabInfo - const compPrefabInfo = { - "__type__": "cc.CompPrefabInfo", - "fileId": this.generateFileId() - }; - prefabData.push(compPrefabInfo); - currentId++; - } + // 暂时跳过UITransform组件以避免_getDependComponent错误 + // 后续通过Engine API动态添加 + console.log(`节点 ${name} 暂时跳过UITransform组件，避免引擎依赖错误`); + // 处理其他组件（暂时跳过，专注于修复UITransform问题） + const components = this.extractComponentsFromNode(nodeData); + if (components.length > 0) { + console.log(`节点 ${name} 包含 ${components.length} 个其他组件，暂时跳过以专注于UITransform修复`); } - // 处理子节点 - if (nodeData.children && Array.isArray(nodeData.children) && nodeData.children.length > 0) { + // 处理子节点 - 使用query-node-tree获取的完整结构 + const childrenToProcess = this.getChildrenToProcess(nodeData); + if (childrenToProcess.length > 0) { console.log(`=== 处理子节点 ===`); - console.log(`节点 ${name} 包含 ${nodeData.children.length} 个子节点`); - console.log('完整子节点数据:', JSON.stringify(nodeData.children, null, 2)); - for (let i = 0; i < nodeData.children.length; i++) { - const childRef = nodeData.children[i]; - console.log(`第${i}个子节点的完整数据:`, JSON.stringify(childRef, null, 2)); - // 尝试多种可能的UUID提取方式 - let childUuid = null; - if (typeof childRef === 'string') { - childUuid = childRef; - console.log(`方法1 - 直接字符串: ${childUuid}`); + console.log(`节点 ${name} 包含 ${childrenToProcess.length} 个子节点`); + for (let i = 0; i < childrenToProcess.length; i++) { + const childData = childrenToProcess[i]; + const childName = childData.name || ((_j = childData.value) === null || _j === void 0 ? void 0 : _j.name) || '未知'; + console.log(`处理第${i + 1}个子节点: ${childName}`); + try { + const childId = currentId; + node._children.push({ "__id__": childId }); + // 递归创建子节点 + const childResult = await this.createNodeObject(childData, nodeId, prefabData, currentId); + prefabData.push(childResult.node); + currentId = childResult.nextId; + // 子节点不需要PrefabInfo，只有根节点需要 + // 子节点的_prefab应该设置为null + childResult.node._prefab = null; + console.log(`✅ 成功添加子节点: ${childName}`); } - else if (childRef && childRef.value) { - if (typeof childRef.value === 'string') { - childUuid = childRef.value; - console.log(`方法2 - value是字符串: ${childUuid}`); - } - else if (childRef.value.uuid) { - childUuid = childRef.value.uuid; - console.log(`方法3 - value.uuid: ${childUuid}`); - } - else if (childRef.value.__id__) { - console.log(`方法4 - 发现__id__引用: ${childRef.value.__id__}`); - // 这可能是一个内部引用，我们需要不同的处理方式 - continue; - } - else { - console.log('方法4 - value不是字符串，内容:', JSON.stringify(childRef.value)); - } - } - else if (childRef && childRef.uuid) { - childUuid = childRef.uuid; - console.log(`方法5 - 直接uuid属性: ${childUuid}`); - } - else { - console.log('方法6 - 无法识别的子节点格式:', JSON.stringify(childRef)); - } - if (childUuid && childUuid !== '[object Object]') { - try { - // 获取子节点数据 - const childNodeData = await this.getNodeData(childUuid); - if (childNodeData) { - const childId = currentId; - node._children.push({ "__id__": childId }); - // 递归创建子节点 - const childResult = await this.createNodeObject(childNodeData, nodeId, prefabData, currentId); - prefabData.push(childResult.node); - currentId = childResult.nextId; - // 为子节点添加PrefabInfo - const childPrefabInfo = { - "__type__": "cc.PrefabInfo", - "root": { - "__id__": 1 // 指向根节点 - }, - "asset": { - "__id__": 0 // 指向Prefab资源 - }, - "fileId": this.generateFileId(), - "instance": null, - "targetOverrides": null, - "nestedPrefabInstanceRoots": null - }; - prefabData.push(childPrefabInfo); - currentId++; - console.log(`✅ 已添加子节点: ${((_g = childNodeData.name) === null || _g === void 0 ? void 0 : _g.value) || '未知'}`); - console.log(`子节点在预制体数组中的索引: ${currentId}`); - } - else { - console.warn(`无法获取子节点数据: ${childUuid}`); - } - } - catch (error) { - console.error(`处理子节点 ${childUuid} 时出错:`, error); - } + catch (error) { + console.error(`处理子节点 ${childName} 时出错:`, error); } } } return { node, nextId: currentId }; } - createComponentObject(componentData, nodeId, prefabInfoId) { - const componentType = componentData.__type__ || 'cc.Component'; + // 从节点数据中提取组件信息 + extractComponentsFromNode(nodeData) { + var _a, _b; + const components = []; + // 从不同位置尝试获取组件数据 + const componentSources = [ + nodeData.__comps__, + nodeData.components, + (_a = nodeData.value) === null || _a === void 0 ? void 0 : _a.__comps__, + (_b = nodeData.value) === null || _b === void 0 ? void 0 : _b.components + ]; + for (const source of componentSources) { + if (Array.isArray(source)) { + components.push(...source.filter(comp => comp && (comp.__type__ || comp.type))); + break; // 找到有效的组件数组就退出 + } + } + return components; + } + // 创建标准的组件对象 + createStandardComponentObject(componentData, nodeId, prefabInfoId) { + const componentType = componentData.__type__ || componentData.type; + if (!componentType) { + console.warn('组件缺少类型信息:', componentData); + return null; + } + // 基础组件结构 - 基于官方预制体格式 const component = { "__type__": componentType, "_name": "", "_objFlags": 0, - "__editorExtras__": {}, "node": { "__id__": nodeId }, - "_enabled": componentData.enabled !== undefined ? componentData.enabled : true, + "_enabled": this.getComponentPropertyValue(componentData, 'enabled', true), "__prefab": { "__id__": prefabInfoId - }, - "_id": "" + } }; - // 复制组件的其他属性 - for (const key in componentData) { - if (!key.startsWith('_') && key !== '__type__' && key !== 'enabled' && key !== 'node') { - component[key] = componentData[key]; + // 根据组件类型添加特定属性 + this.addComponentSpecificProperties(component, componentData, componentType); + // 添加_id属性 + component._id = ""; + return component; + } + // 添加组件特定的属性 + addComponentSpecificProperties(component, componentData, componentType) { + switch (componentType) { + case 'cc.UITransform': + this.addUITransformProperties(component, componentData); + break; + case 'cc.Sprite': + this.addSpriteProperties(component, componentData); + break; + case 'cc.Label': + this.addLabelProperties(component, componentData); + break; + case 'cc.Button': + this.addButtonProperties(component, componentData); + break; + default: + // 对于未知类型的组件，复制所有安全的属性 + this.addGenericProperties(component, componentData); + break; + } + } + // UITransform组件属性 + addUITransformProperties(component, componentData) { + component._contentSize = this.createSizeObject(this.getComponentPropertyValue(componentData, 'contentSize', { width: 100, height: 100 })); + component._anchorPoint = this.createVec2Object(this.getComponentPropertyValue(componentData, 'anchorPoint', { x: 0.5, y: 0.5 })); + } + // Sprite组件属性 + addSpriteProperties(component, componentData) { + component._visFlags = 0; + component._customMaterial = null; + component._srcBlendFactor = 2; + component._dstBlendFactor = 4; + component._color = this.createColorObject(this.getComponentPropertyValue(componentData, 'color', { r: 255, g: 255, b: 255, a: 255 })); + component._spriteFrame = this.getComponentPropertyValue(componentData, 'spriteFrame', null); + component._type = this.getComponentPropertyValue(componentData, 'type', 0); + component._fillType = 0; + component._sizeMode = this.getComponentPropertyValue(componentData, 'sizeMode', 1); + component._fillCenter = this.createVec2Object({ x: 0, y: 0 }); + component._fillStart = 0; + component._fillRange = 0; + component._isTrimmedMode = true; + component._useGrayscale = false; + component._atlas = null; + } + // Label组件属性 + addLabelProperties(component, componentData) { + component._visFlags = 0; + component._customMaterial = null; + component._srcBlendFactor = 2; + component._dstBlendFactor = 4; + component._color = this.createColorObject(this.getComponentPropertyValue(componentData, 'color', { r: 0, g: 0, b: 0, a: 255 })); + component._string = this.getComponentPropertyValue(componentData, 'string', 'Label'); + component._horizontalAlign = 1; + component._verticalAlign = 1; + component._actualFontSize = 20; + component._fontSize = this.getComponentPropertyValue(componentData, 'fontSize', 20); + component._fontFamily = 'Arial'; + component._lineHeight = 40; + component._overflow = 1; + component._enableWrapText = false; + component._font = null; + component._isSystemFontUsed = true; + component._isItalic = false; + component._isBold = false; + component._isUnderline = false; + component._underlineHeight = 2; + component._cacheMode = 0; + } + // Button组件属性 + addButtonProperties(component, componentData) { + component.clickEvents = []; + component._interactable = true; + component._transition = 2; + component._normalColor = this.createColorObject({ r: 214, g: 214, b: 214, a: 255 }); + component._hoverColor = this.createColorObject({ r: 211, g: 211, b: 211, a: 255 }); + component._pressedColor = this.createColorObject({ r: 255, g: 255, b: 255, a: 255 }); + component._disabledColor = this.createColorObject({ r: 124, g: 124, b: 124, a: 255 }); + component._duration = 0.1; + component._zoomScale = 1.2; + } + // 添加通用属性 + addGenericProperties(component, componentData) { + // 只复制安全的、已知的属性 + const safeProperties = ['enabled', 'color', 'string', 'fontSize', 'spriteFrame', 'type', 'sizeMode']; + for (const prop of safeProperties) { + if (componentData.hasOwnProperty(prop)) { + const value = this.getComponentPropertyValue(componentData, prop); + if (value !== undefined) { + component[`_${prop}`] = value; + } } } - return component; + } + // 创建Vec2对象 + createVec2Object(data) { + return { + "__type__": "cc.Vec2", + "x": (data === null || data === void 0 ? void 0 : data.x) || 0, + "y": (data === null || data === void 0 ? void 0 : data.y) || 0 + }; + } + // 创建Vec3对象 + createVec3Object(data) { + return { + "__type__": "cc.Vec3", + "x": (data === null || data === void 0 ? void 0 : data.x) || 0, + "y": (data === null || data === void 0 ? void 0 : data.y) || 0, + "z": (data === null || data === void 0 ? void 0 : data.z) || 0 + }; + } + // 创建Size对象 + createSizeObject(data) { + return { + "__type__": "cc.Size", + "width": (data === null || data === void 0 ? void 0 : data.width) || 100, + "height": (data === null || data === void 0 ? void 0 : data.height) || 100 + }; + } + // 创建Color对象 + createColorObject(data) { + var _a, _b, _c, _d; + return { + "__type__": "cc.Color", + "r": (_a = data === null || data === void 0 ? void 0 : data.r) !== null && _a !== void 0 ? _a : 255, + "g": (_b = data === null || data === void 0 ? void 0 : data.g) !== null && _b !== void 0 ? _b : 255, + "b": (_c = data === null || data === void 0 ? void 0 : data.b) !== null && _c !== void 0 ? _c : 255, + "a": (_d = data === null || data === void 0 ? void 0 : data.a) !== null && _d !== void 0 ? _d : 255 + }; + } + // 判断是否应该复制组件属性 + shouldCopyComponentProperty(key, value) { + // 跳过内部属性和已处理的属性 + if (key.startsWith('__') || key === '_enabled' || key === 'node' || key === 'enabled') { + return false; + } + // 跳过函数和undefined值 + if (typeof value === 'function' || value === undefined) { + return false; + } + return true; + } + // 获取组件属性值 - 重命名以避免冲突 + getComponentPropertyValue(componentData, propertyName, defaultValue) { + // 尝试直接获取属性 + if (componentData[propertyName] !== undefined) { + return this.extractValue(componentData[propertyName]); + } + // 尝试从value属性中获取 + if (componentData.value && componentData.value[propertyName] !== undefined) { + return this.extractValue(componentData.value[propertyName]); + } + // 尝试带下划线前缀的属性名 + const prefixedName = `_${propertyName}`; + if (componentData[prefixedName] !== undefined) { + return this.extractValue(componentData[prefixedName]); + } + return defaultValue; + } + // 提取属性值 + extractValue(data) { + if (data === null || data === undefined) { + return data; + } + // 如果有value属性，优先使用value + if (typeof data === 'object' && data.hasOwnProperty('value')) { + return data.value; + } + // 如果是引用对象，保持原样 + if (typeof data === 'object' && (data.__id__ !== undefined || data.__uuid__ !== undefined)) { + return data; + } + return data; } createStandardMetaData(prefabName, prefabUuid) { return { @@ -1370,4 +2556,4 @@ class PrefabTools { } } exports.PrefabTools = PrefabTools; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prefab-tools.js","sourceRoot":"","sources":["../../source/tools/prefab-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, PrefabInfo } from '../types';\n\nexport class PrefabTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'get_prefab_list',\n                description: 'Get all prefabs in the project',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        folder: {\n                            type: 'string',\n                            description: 'Folder path to search (optional)',\n                            default: 'db://assets'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'load_prefab',\n                description: 'Load a prefab by path',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'instantiate_prefab',\n                description: 'Instantiate a prefab in the scene',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        },\n                        parentUuid: {\n                            type: 'string',\n                            description: 'Parent node UUID (optional)'\n                        },\n                        position: {\n                            type: 'object',\n                            description: 'Initial position',\n                            properties: {\n                                x: { type: 'number' },\n                                y: { type: 'number' },\n                                z: { type: 'number' }\n                            }\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'create_prefab',\n                description: 'Create a prefab from a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Source node UUID'\n                        },\n                        savePath: {\n                            type: 'string',\n                            description: 'Path to save the prefab'\n                        },\n                        prefabName: {\n                            type: 'string',\n                            description: 'Prefab name'\n                        },\n                        includeChildren: {\n                            type: 'boolean',\n                            description: 'Whether to include child nodes',\n                            default: true\n                        },\n                        includeComponents: {\n                            type: 'boolean',\n                            description: 'Whether to include components',\n                            default: true\n                        }\n                    },\n                    required: ['nodeUuid', 'savePath', 'prefabName']\n                }\n            },\n            {\n                name: 'create_prefab_from_node',\n                description: 'Create a prefab from a node (alias for create_prefab)',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Source node UUID'\n                        },\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Path to save the prefab'\n                        }\n                    },\n                    required: ['nodeUuid', 'prefabPath']\n                }\n            },\n            {\n                name: 'update_prefab',\n                description: 'Update an existing prefab',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        },\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID with changes'\n                        }\n                    },\n                    required: ['prefabPath', 'nodeUuid']\n                }\n            },\n            {\n                name: 'revert_prefab',\n                description: 'Revert prefab instance to original',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Prefab instance node UUID'\n                        }\n                    },\n                    required: ['nodeUuid']\n                }\n            },\n            {\n                name: 'get_prefab_info',\n                description: 'Get detailed prefab information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'validate_prefab',\n                description: 'Validate a prefab file format',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'duplicate_prefab',\n                description: 'Duplicate an existing prefab',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        sourcePrefabPath: {\n                            type: 'string',\n                            description: 'Source prefab path'\n                        },\n                        targetPrefabPath: {\n                            type: 'string',\n                            description: 'Target prefab path'\n                        },\n                        newPrefabName: {\n                            type: 'string',\n                            description: 'New prefab name'\n                        }\n                    },\n                    required: ['sourcePrefabPath', 'targetPrefabPath']\n                }\n            },\n            {\n                name: 'restore_prefab_node',\n                description: 'Restore prefab node using prefab asset (built-in undo record)',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Prefab instance node UUID'\n                        },\n                        assetUuid: {\n                            type: 'string',\n                            description: 'Prefab asset UUID'\n                        }\n                    },\n                    required: ['nodeUuid', 'assetUuid']\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'get_prefab_list':\n                return await this.getPrefabList(args.folder);\n            case 'load_prefab':\n                return await this.loadPrefab(args.prefabPath);\n            case 'instantiate_prefab':\n                return await this.instantiatePrefab(args);\n            case 'create_prefab':\n                return await this.createPrefab(args);\n            case 'create_prefab_from_node':\n                return await this.createPrefabFromNode(args);\n            case 'update_prefab':\n                return await this.updatePrefab(args.prefabPath, args.nodeUuid);\n            case 'revert_prefab':\n                return await this.revertPrefab(args.nodeUuid);\n            case 'get_prefab_info':\n                return await this.getPrefabInfo(args.prefabPath);\n            case 'validate_prefab':\n                return await this.validatePrefab(args.prefabPath);\n            case 'duplicate_prefab':\n                return await this.duplicatePrefab(args);\n            case 'restore_prefab_node':\n                return await this.restorePrefabNode(args.nodeUuid, args.assetUuid);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async getPrefabList(folder: string = 'db://assets'): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const pattern = folder.endsWith('/') ? \n                `${folder}**/*.prefab` : `${folder}/**/*.prefab`;\n            \n            Editor.Message.request('asset-db', 'query-assets', {\n                pattern: pattern\n            }).then((results: any[]) => {\n                const prefabs: PrefabInfo[] = results.map(asset => ({\n                    name: asset.name,\n                    path: asset.url,\n                    uuid: asset.uuid,\n                    folder: asset.url.substring(0, asset.url.lastIndexOf('/'))\n                }));\n                resolve({ success: true, data: prefabs });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async loadPrefab(prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n                \n                return Editor.Message.request('scene', 'load-asset', {\n                    uuid: assetInfo.uuid\n                });\n            }).then((prefabData: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        uuid: prefabData.uuid,\n                        name: prefabData.name,\n                        message: 'Prefab loaded successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async instantiatePrefab(args: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('预制体未找到');\n                }\n\n                // 使用正确的 create-node API 从预制体资源实例化\n                const createNodeOptions: any = {\n                    assetUuid: assetInfo.uuid\n                };\n\n                // 设置父节点\n                if (args.parentUuid) {\n                    createNodeOptions.parent = args.parentUuid;\n                }\n\n                // 设置节点名称\n                if (args.name) {\n                    createNodeOptions.name = args.name;\n                } else if (assetInfo.name) {\n                    createNodeOptions.name = assetInfo.name;\n                }\n\n                // 设置初始属性（如位置）\n                if (args.position) {\n                    createNodeOptions.dump = {\n                        position: {\n                            value: args.position\n                        }\n                    };\n                }\n\n                return Editor.Message.request('scene', 'create-node', createNodeOptions);\n            }).then((nodeUuid: string | string[]) => {\n                // 获取实际的节点UUID\n                const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid;\n                \n                resolve({\n                    success: true,\n                    data: {\n                        nodeUuid: uuid,\n                        prefabPath: args.prefabPath,\n                        parentUuid: args.parentUuid,\n                        position: args.position,\n                        message: '预制体实例化成功'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ \n                    success: false, \n                    error: `预制体实例化失败: ${err.message}`,\n                    instruction: '请检查预制体路径是否正确，确保预制体文件格式正确'\n                });\n            });\n        });\n    }\n\n    private async tryCreateNodeWithPrefab(args: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('预制体未找到');\n                }\n\n                // 方法2: 使用 create-node 指定预制体资源\n                const createNodeOptions: any = {\n                    assetUuid: assetInfo.uuid\n                };\n\n                // 设置父节点\n                if (args.parentUuid) {\n                    createNodeOptions.parent = args.parentUuid;\n                }\n\n                return Editor.Message.request('scene', 'create-node', createNodeOptions);\n            }).then((nodeUuid: string | string[]) => {\n                const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid;\n                \n                // 如果指定了位置，设置节点位置\n                if (args.position && uuid) {\n                    Editor.Message.request('scene', 'set-property', {\n                        uuid: uuid,\n                        path: 'position',\n                        dump: { value: args.position }\n                    }).then(() => {\n                        resolve({\n                            success: true,\n                            data: {\n                                nodeUuid: uuid,\n                                prefabPath: args.prefabPath,\n                                position: args.position,\n                                message: '预制体实例化成功（备用方法）并设置了位置'\n                            }\n                        });\n                    }).catch(() => {\n                        resolve({\n                            success: true,\n                            data: {\n                                nodeUuid: uuid,\n                                prefabPath: args.prefabPath,\n                                message: '预制体实例化成功（备用方法）但位置设置失败'\n                            }\n                        });\n                    });\n                } else {\n                    resolve({\n                        success: true,\n                        data: {\n                            nodeUuid: uuid,\n                            prefabPath: args.prefabPath,\n                            message: '预制体实例化成功（备用方法）'\n                        }\n                    });\n                }\n            }).catch((err: Error) => {\n                resolve({\n                    success: false,\n                    error: `备用预制体实例化方法也失败: ${err.message}`\n                });\n            });\n        });\n    }\n\n    private async tryAlternativeInstantiateMethods(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                // 方法1: 尝试使用 create-node 然后设置预制体\n                const assetInfo = await this.getAssetInfo(args.prefabPath);\n                if (!assetInfo) {\n                    resolve({ success: false, error: '无法获取预制体信息' });\n                    return;\n                }\n\n                // 创建空节点\n                const createResult = await this.createNode(args.parentUuid, args.position);\n                if (!createResult.success) {\n                    resolve(createResult);\n                    return;\n                }\n\n                // 尝试将预制体应用到节点\n                const applyResult = await this.applyPrefabToNode(createResult.data.nodeUuid, assetInfo.uuid);\n                if (applyResult.success) {\n                    resolve({\n                        success: true,\n                        data: {\n                            nodeUuid: createResult.data.nodeUuid,\n                            name: createResult.data.name,\n                            message: '预制体实例化成功（使用备选方法）'\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: false,\n                        error: '无法将预制体应用到节点',\n                        data: {\n                            nodeUuid: createResult.data.nodeUuid,\n                            message: '已创建节点，但无法应用预制体数据'\n                        }\n                    });\n                }\n\n            } catch (error) {\n                resolve({ success: false, error: `备选实例化方法失败: ${error}` });\n            }\n        });\n    }\n\n    private async getAssetInfo(prefabPath: string): Promise<any> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                resolve(assetInfo);\n            }).catch(() => {\n                resolve(null);\n            });\n        });\n    }\n\n    private async createNode(parentUuid?: string, position?: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const createNodeOptions: any = {\n                name: 'PrefabInstance'\n            };\n\n            // 设置父节点\n            if (parentUuid) {\n                createNodeOptions.parent = parentUuid;\n            }\n\n            // 设置位置\n            if (position) {\n                createNodeOptions.dump = {\n                    position: position\n                };\n            }\n\n            Editor.Message.request('scene', 'create-node', createNodeOptions).then((nodeUuid: string | string[]) => {\n                const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid;\n                resolve({\n                    success: true,\n                    data: {\n                        nodeUuid: uuid,\n                        name: 'PrefabInstance'\n                    }\n                });\n            }).catch((error: any) => {\n                resolve({ success: false, error: error.message || '创建节点失败' });\n            });\n        });\n    }\n\n    private async applyPrefabToNode(nodeUuid: string, prefabUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试多种方法来应用预制体数据\n            const methods = [\n                () => Editor.Message.request('scene', 'apply-prefab', { node: nodeUuid, prefab: prefabUuid }),\n                () => Editor.Message.request('scene', 'set-prefab', { node: nodeUuid, prefab: prefabUuid }),\n                () => Editor.Message.request('scene', 'load-prefab-to-node', { node: nodeUuid, prefab: prefabUuid })\n            ];\n\n            const tryMethod = (index: number) => {\n                if (index >= methods.length) {\n                    resolve({ success: false, error: '无法应用预制体数据' });\n                    return;\n                }\n\n                methods[index]().then(() => {\n                    resolve({ success: true });\n                }).catch(() => {\n                    tryMethod(index + 1);\n                });\n            };\n\n            tryMethod(0);\n        });\n    }\n\n    private async createPrefab(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                // 支持 prefabPath 和 savePath 两种参数名\n                const pathParam = args.prefabPath || args.savePath;\n                if (!pathParam) {\n                    resolve({\n                        success: false,\n                        error: '缺少预制体路径参数。请提供 prefabPath 或 savePath。'\n                    });\n                    return;\n                }\n\n                const prefabName = args.prefabName || 'NewPrefab';\n                const fullPath = pathParam.endsWith('.prefab') ? \n                    pathParam : `${pathParam}/${prefabName}.prefab`;\n\n                // 尝试使用Cocos Creator的原生预制体创建API\n                const nativeResult = await this.createPrefabNative(args.nodeUuid, fullPath);\n                if (nativeResult.success) {\n                    resolve(nativeResult);\n                    return;\n                }\n\n                // 如果原生API失败，使用自定义实现\n                const customResult = await this.createPrefabCustom(args.nodeUuid, fullPath, prefabName);\n                resolve(customResult);\n\n            } catch (error) {\n                resolve({\n                    success: false,\n                    error: `创建预制体时发生错误: ${error}`\n                });\n            }\n        });\n    }\n\n    private async createPrefabNative(nodeUuid: string, prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 根据官方API文档，不存在直接的预制体创建API\n            // 预制体创建需要手动在编辑器中完成\n            resolve({\n                success: false,\n                error: '原生预制体创建API不存在',\n                instruction: '根据Cocos Creator官方API文档，预制体创建需要手动操作：\\n1. 在场景中选择节点\\n2. 将节点拖拽到资源管理器中\\n3. 或右键节点选择\"生成预制体\"'\n            });\n        });\n    }\n\n    private async createPrefabCustom(nodeUuid: string, prefabPath: string, prefabName: string): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                // 1. 获取源节点的完整数据\n                const nodeData = await this.getNodeData(nodeUuid);\n                if (!nodeData) {\n                    resolve({\n                        success: false,\n                        error: `无法找到节点: ${nodeUuid}`\n                    });\n                    return;\n                }\n\n                // 2. 生成预制体UUID\n                const prefabUuid = this.generateUUID();\n\n                // 3. 创建预制体数据结构\n                const prefabData = this.createPrefabData(nodeData, prefabName, prefabUuid);\n\n                // 4. 基于官方格式创建预制体数据结构\n                console.log('=== 开始创建预制体 ===');\n                console.log('节点名称:', nodeData.name?.value || '未知');\n                console.log('节点UUID:', nodeData.uuid?.value || '未知');\n                console.log('预制体保存路径:', prefabPath);\n                console.log(`开始创建预制体，节点数据:`, nodeData);\n                const prefabJsonData = await this.createStandardPrefabData(nodeData, prefabName, prefabUuid);\n\n                // 5. 创建标准meta文件数据\n                const standardMetaData = this.createStandardMetaData(prefabName, prefabUuid);\n\n                // 6. 保存预制体和meta文件\n                const saveResult = await this.savePrefabWithMeta(prefabPath, prefabJsonData, standardMetaData);\n\n                if (saveResult.success) {\n                    resolve({\n                        success: true,\n                        data: {\n                            prefabUuid: prefabUuid,\n                            prefabPath: prefabPath,\n                            nodeUuid: nodeUuid,\n                            prefabName: prefabName,\n                            message: '自定义预制体创建成功'\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: false,\n                        error: saveResult.error || '保存预制体文件失败'\n                    });\n                }\n\n            } catch (error) {\n                resolve({\n                    success: false,\n                    error: `创建预制体时发生错误: ${error}`\n                });\n            }\n        });\n    }\n\n    private async getNodeData(nodeUuid: string): Promise<any> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeInfo: any) => {\n                if (!nodeInfo) {\n                    resolve(null);\n                    return;\n                }\n\n                // 尝试获取节点的完整序列化数据\n                Editor.Message.request('scene', 'serialize-node', {\n                    node: nodeUuid,\n                    includeChildren: true\n                }).then((serializedData: any) => {\n                    resolve(serializedData);\n                }).catch(() => {\n                    // 如果序列化失败，尝试获取节点的详细信息\n                    this.getNodeDetailedInfo(nodeUuid).then((detailedInfo: any) => {\n                        resolve(detailedInfo || nodeInfo);\n                    }).catch(() => {\n                        resolve(nodeInfo);\n                    });\n                });\n            }).catch(() => {\n                resolve(null);\n            });\n        });\n    }\n\n    private async getNodeDetailedInfo(nodeUuid: string): Promise<any> {\n        return new Promise((resolve) => {\n            // 获取节点的详细信息，包括组件和子节点\n            Editor.Message.request('scene', 'query-node-detail', nodeUuid).then((detailInfo: any) => {\n                if (detailInfo) {\n                    resolve(detailInfo);\n                } else {\n                    // 如果无法获取详细信息，构建基本节点信息\n                    this.buildBasicNodeInfo(nodeUuid).then((basicInfo: any) => {\n                        resolve(basicInfo);\n                    }).catch(() => {\n                        resolve(null);\n                    });\n                }\n            }).catch(() => {\n                resolve(null);\n            });\n        });\n    }\n\n    private async buildBasicNodeInfo(nodeUuid: string): Promise<any> {\n        return new Promise((resolve) => {\n            // 构建基本的节点信息\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeInfo: any) => {\n                if (!nodeInfo) {\n                    resolve(null);\n                    return;\n                }\n\n                // 简化版本：只返回基本节点信息，不获取子节点和组件\n                // 这些信息将在后续的预制体处理中根据需要添加\n                const basicInfo = {\n                    ...nodeInfo,\n                    children: [],\n                    components: []\n                };\n                resolve(basicInfo);\n            }).catch(() => {\n                resolve(null);\n            });\n        });\n    }\n\n    private generateUUID(): string {\n        // 生成符合Cocos Creator格式的UUID\n        const chars = '0123456789abcdef';\n        let uuid = '';\n        for (let i = 0; i < 32; i++) {\n            if (i === 8 || i === 12 || i === 16 || i === 20) {\n                uuid += '-';\n            }\n            uuid += chars[Math.floor(Math.random() * chars.length)];\n        }\n        return uuid;\n    }\n\n    private createPrefabData(nodeData: any, prefabName: string, prefabUuid: string): any[] {\n        // 创建标准的预制体数据结构\n        const prefabAsset = {\n            \"__type__\": \"cc.Prefab\",\n            \"_name\": prefabName,\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"_native\": \"\",\n            \"data\": {\n                \"__id__\": 1\n            },\n            \"optimizationPolicy\": 0,\n            \"persistent\": false\n        };\n\n        // 处理节点数据，确保符合预制体格式\n        const processedNodeData = this.processNodeForPrefab(nodeData, prefabUuid);\n\n        return [prefabAsset, ...processedNodeData];\n    }\n\n    private processNodeForPrefab(nodeData: any, prefabUuid: string): any[] {\n        // 处理节点数据以符合预制体格式\n        const processedData: any[] = [];\n        let idCounter = 1;\n\n        // 递归处理节点和组件\n        const processNode = (node: any, parentId: number = 0): number => {\n            const nodeId = idCounter++;\n            \n            // 创建节点对象\n            const processedNode = {\n                \"__type__\": \"cc.Node\",\n                \"_name\": node.name || \"Node\",\n                \"_objFlags\": 0,\n                \"__editorExtras__\": {},\n                \"_parent\": parentId > 0 ? { \"__id__\": parentId } : null,\n                \"_children\": node.children ? node.children.map(() => ({ \"__id__\": idCounter++ })) : [],\n                \"_active\": node.active !== false,\n                \"_components\": node.components ? node.components.map(() => ({ \"__id__\": idCounter++ })) : [],\n                \"_prefab\": {\n                    \"__id__\": idCounter++\n                },\n                \"_lpos\": {\n                    \"__type__\": \"cc.Vec3\",\n                    \"x\": node.position?.x || 0,\n                    \"y\": node.position?.y || 0,\n                    \"z\": node.position?.z || 0\n                },\n                \"_lrot\": {\n                    \"__type__\": \"cc.Quat\",\n                    \"x\": 0,\n                    \"y\": 0,\n                    \"z\": 0,\n                    \"w\": 1\n                },\n                \"_lscale\": {\n                    \"__type__\": \"cc.Vec3\",\n                    \"x\": node.scale?.x || 1,\n                    \"y\": node.scale?.y || 1,\n                    \"z\": node.scale?.z || 1\n                },\n                \"_mobility\": 0,\n                \"_layer\": 1073741824,\n                \"_euler\": {\n                    \"__type__\": \"cc.Vec3\",\n                    \"x\": 0,\n                    \"y\": 0,\n                    \"z\": 0\n                },\n                \"_id\": \"\"\n            };\n\n            processedData.push(processedNode);\n\n            // 处理组件\n            if (node.components) {\n                node.components.forEach((component: any) => {\n                    const componentId = idCounter++;\n                    const processedComponents = this.processComponentForPrefab(component, componentId);\n                    processedData.push(...processedComponents);\n                });\n            }\n\n            // 处理子节点\n            if (node.children) {\n                node.children.forEach((child: any) => {\n                    processNode(child, nodeId);\n                });\n            }\n\n            return nodeId;\n        };\n\n        processNode(nodeData);\n        return processedData;\n    }\n\n    private processComponentForPrefab(component: any, componentId: number): any[] {\n        // 处理组件数据以符合预制体格式\n        const processedComponent = {\n            \"__type__\": component.type || \"cc.Component\",\n            \"_name\": \"\",\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"node\": {\n                \"__id__\": componentId - 1\n            },\n            \"_enabled\": component.enabled !== false,\n            \"__prefab\": {\n                \"__id__\": componentId + 1\n            },\n            ...component.properties\n        };\n\n        // 添加组件特定的预制体信息\n        const compPrefabInfo = {\n            \"__type__\": \"cc.CompPrefabInfo\",\n            \"fileId\": this.generateFileId()\n        };\n\n        return [processedComponent, compPrefabInfo];\n    }\n\n    private generateFileId(): string {\n        // 生成文件ID（简化版本）\n        const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/';\n        let fileId = '';\n        for (let i = 0; i < 22; i++) {\n            fileId += chars[Math.floor(Math.random() * chars.length)];\n        }\n        return fileId;\n    }\n\n    private createMetaData(prefabName: string, prefabUuid: string): any {\n        return {\n            \"ver\": \"1.1.50\",\n            \"importer\": \"prefab\",\n            \"imported\": true,\n            \"uuid\": prefabUuid,\n            \"files\": [\n                \".json\"\n            ],\n            \"subMetas\": {},\n            \"userData\": {\n                \"syncNodeName\": prefabName\n            }\n        };\n    }\n\n    private async savePrefabFiles(prefabPath: string, prefabData: any[], metaData: any): Promise<{ success: boolean; error?: string }> {\n        return new Promise((resolve) => {\n            try {\n                // 使用Editor API保存预制体文件\n                const prefabContent = JSON.stringify(prefabData, null, 2);\n                const metaContent = JSON.stringify(metaData, null, 2);\n                \n                // 尝试使用更可靠的保存方法\n                this.saveAssetFile(prefabPath, prefabContent).then(() => {\n                    // 再创建meta文件\n                    const metaPath = `${prefabPath}.meta`;\n                    return this.saveAssetFile(metaPath, metaContent);\n                }).then(() => {\n                    resolve({ success: true });\n                }).catch((error: any) => {\n                    resolve({ success: false, error: error.message || '保存预制体文件失败' });\n                });\n            } catch (error) {\n                resolve({ success: false, error: `保存文件时发生错误: ${error}` });\n            }\n        });\n    }\n\n    private async saveAssetFile(filePath: string, content: string): Promise<void> {\n        return new Promise((resolve, reject) => {\n            // 尝试多种保存方法\n            const saveMethods = [\n                () => Editor.Message.request('asset-db', 'create-asset', filePath, content),\n                () => Editor.Message.request('asset-db', 'save-asset', filePath, content),\n                () => Editor.Message.request('asset-db', 'write-asset', filePath, content)\n            ];\n\n            const trySave = (index: number) => {\n                if (index >= saveMethods.length) {\n                    reject(new Error('所有保存方法都失败了'));\n                    return;\n                }\n\n                saveMethods[index]().then(() => {\n                    resolve();\n                }).catch(() => {\n                    trySave(index + 1);\n                });\n            };\n\n            trySave(0);\n        });\n    }\n\n    private async updatePrefab(prefabPath: string, nodeUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n\n                return Editor.Message.request('scene', 'apply-prefab', {\n                    node: nodeUuid,\n                    prefab: assetInfo.uuid\n                });\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Prefab updated successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async revertPrefab(nodeUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'revert-prefab', {\n                node: nodeUuid\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Prefab instance reverted successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getPrefabInfo(prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n\n                return Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n            }).then((metaInfo: any) => {\n                const info: PrefabInfo = {\n                    name: metaInfo.name,\n                    uuid: metaInfo.uuid,\n                    path: prefabPath,\n                    folder: prefabPath.substring(0, prefabPath.lastIndexOf('/')),\n                    createTime: metaInfo.createTime,\n                    modifyTime: metaInfo.modifyTime,\n                    dependencies: metaInfo.depends || []\n                };\n                resolve({ success: true, data: info });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async createPrefabFromNode(args: any): Promise<ToolResponse> {\n        // 从 prefabPath 提取名称\n        const prefabPath = args.prefabPath;\n        const prefabName = prefabPath.split('/').pop()?.replace('.prefab', '') || 'NewPrefab';\n        \n        // 调用原来的 createPrefab 方法\n        return await this.createPrefab({\n            nodeUuid: args.nodeUuid,\n            savePath: prefabPath,\n            prefabName: prefabName\n        });\n    }\n\n    private async validatePrefab(prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                // 读取预制体文件内容\n                Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                    if (!assetInfo) {\n                        resolve({\n                            success: false,\n                            error: '预制体文件不存在'\n                        });\n                        return;\n                    }\n\n                    // 验证预制体格式\n                    Editor.Message.request('asset-db', 'read-asset', prefabPath).then((content: string) => {\n                        try {\n                            const prefabData = JSON.parse(content);\n                            const validationResult = this.validatePrefabFormat(prefabData);\n                            \n                            resolve({\n                                success: true,\n                                data: {\n                                    isValid: validationResult.isValid,\n                                    issues: validationResult.issues,\n                                    nodeCount: validationResult.nodeCount,\n                                    componentCount: validationResult.componentCount,\n                                    message: validationResult.isValid ? '预制体格式有效' : '预制体格式存在问题'\n                                }\n                            });\n                        } catch (parseError) {\n                            resolve({\n                                success: false,\n                                error: '预制体文件格式错误，无法解析JSON'\n                            });\n                        }\n                    }).catch((error: any) => {\n                        resolve({\n                            success: false,\n                            error: `读取预制体文件失败: ${error.message}`\n                        });\n                    });\n                }).catch((error: any) => {\n                    resolve({\n                        success: false,\n                        error: `查询预制体信息失败: ${error.message}`\n                    });\n                });\n            } catch (error) {\n                resolve({\n                    success: false,\n                    error: `验证预制体时发生错误: ${error}`\n                });\n            }\n        });\n    }\n\n    private validatePrefabFormat(prefabData: any): { isValid: boolean; issues: string[]; nodeCount: number; componentCount: number } {\n        const issues: string[] = [];\n        let nodeCount = 0;\n        let componentCount = 0;\n\n        // 检查基本结构\n        if (!Array.isArray(prefabData)) {\n            issues.push('预制体数据必须是数组格式');\n            return { isValid: false, issues, nodeCount, componentCount };\n        }\n\n        if (prefabData.length === 0) {\n            issues.push('预制体数据为空');\n            return { isValid: false, issues, nodeCount, componentCount };\n        }\n\n        // 检查第一个元素是否为预制体资产\n        const firstElement = prefabData[0];\n        if (!firstElement || firstElement.__type__ !== 'cc.Prefab') {\n            issues.push('第一个元素必须是cc.Prefab类型');\n        }\n\n        // 统计节点和组件\n        prefabData.forEach((item: any, index: number) => {\n            if (item.__type__ === 'cc.Node') {\n                nodeCount++;\n            } else if (item.__type__ && item.__type__.includes('cc.')) {\n                componentCount++;\n            }\n        });\n\n        // 检查必要的字段\n        if (nodeCount === 0) {\n            issues.push('预制体必须包含至少一个节点');\n        }\n\n        return {\n            isValid: issues.length === 0,\n            issues,\n            nodeCount,\n            componentCount\n        };\n    }\n\n    private async duplicatePrefab(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                const { sourcePrefabPath, targetPrefabPath, newPrefabName } = args;\n                \n                // 读取源预制体\n                const sourceInfo = await this.getPrefabInfo(sourcePrefabPath);\n                if (!sourceInfo.success) {\n                    resolve({\n                        success: false,\n                        error: `无法读取源预制体: ${sourceInfo.error}`\n                    });\n                    return;\n                }\n\n                // 读取源预制体内容\n                const sourceContent = await this.readPrefabContent(sourcePrefabPath);\n                if (!sourceContent.success) {\n                    resolve({\n                        success: false,\n                        error: `无法读取源预制体内容: ${sourceContent.error}`\n                    });\n                    return;\n                }\n\n                // 生成新的UUID\n                const newUuid = this.generateUUID();\n                \n                // 修改预制体数据\n                const modifiedData = this.modifyPrefabForDuplication(sourceContent.data, newPrefabName, newUuid);\n                \n                // 创建新的meta数据\n                const newMetaData = this.createMetaData(newPrefabName || 'DuplicatedPrefab', newUuid);\n                \n                // 预制体复制功能暂时禁用，因为涉及复杂的序列化格式\n                resolve({\n                    success: false,\n                    error: '预制体复制功能暂时不可用',\n                    instruction: '请在 Cocos Creator 编辑器中手动复制预制体：\\n1. 在资源管理器中选择要复制的预制体\\n2. 右键选择复制\\n3. 在目标位置粘贴'\n                });\n\n            } catch (error) {\n                resolve({\n                    success: false,\n                    error: `复制预制体时发生错误: ${error}`\n                });\n            }\n        });\n    }\n\n    private async readPrefabContent(prefabPath: string): Promise<{ success: boolean; data?: any; error?: string }> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'read-asset', prefabPath).then((content: string) => {\n                try {\n                    const prefabData = JSON.parse(content);\n                    resolve({ success: true, data: prefabData });\n                } catch (parseError) {\n                    resolve({ success: false, error: '预制体文件格式错误' });\n                }\n            }).catch((error: any) => {\n                resolve({ success: false, error: error.message || '读取预制体文件失败' });\n            });\n        });\n    }\n\n    private modifyPrefabForDuplication(prefabData: any[], newName: string, newUuid: string): any[] {\n        // 修改预制体数据以创建副本\n        const modifiedData = [...prefabData];\n        \n        // 修改第一个元素（预制体资产）\n        if (modifiedData[0] && modifiedData[0].__type__ === 'cc.Prefab') {\n            modifiedData[0]._name = newName || 'DuplicatedPrefab';\n        }\n\n        // 更新所有UUID引用（简化版本）\n        // 在实际应用中，可能需要更复杂的UUID映射处理\n        \n        return modifiedData;\n    }\n\n    private async restorePrefabNode(nodeUuid: string, assetUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 使用官方API restore-prefab 还原预制体节点\n            (Editor.Message.request as any)('scene', 'restore-prefab', nodeUuid, assetUuid).then(() => {\n                resolve({\n                    success: true,\n                    data: {\n                        nodeUuid: nodeUuid,\n                        assetUuid: assetUuid,\n                        message: '预制体节点还原成功'\n                    }\n                });\n            }).catch((error: any) => {\n                resolve({\n                    success: false,\n                    error: `预制体节点还原失败: ${error.message}`\n                });\n            });\n        });\n    }\n\n    // 基于官方预制体格式的新实现方法\n    private async getNodeDataForPrefab(nodeUuid: string): Promise<{ success: boolean; data?: any; error?: string }> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => {\n                if (!nodeData) {\n                    resolve({ success: false, error: '节点不存在' });\n                    return;\n                }\n                resolve({ success: true, data: nodeData });\n            }).catch((error: any) => {\n                resolve({ success: false, error: error.message });\n            });\n        });\n    }\n\n    private async createStandardPrefabData(nodeData: any, prefabName: string, prefabUuid: string): Promise<any[]> {\n        // 基于官方Canvas.prefab格式创建预制体数据结构\n        const prefabData: any[] = [];\n        let currentId = 0;\n\n        // 第一个元素：cc.Prefab 资源对象\n        const prefabAsset = {\n            \"__type__\": \"cc.Prefab\",\n            \"_name\": prefabName,\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"_native\": \"\",\n            \"data\": {\n                \"__id__\": 1\n            },\n            \"optimizationPolicy\": 0,\n            \"persistent\": false\n        };\n        prefabData.push(prefabAsset);\n        currentId++;\n\n        // 第二个元素：根节点\n        const rootNode = await this.createNodeObject(nodeData, null, prefabData, currentId);\n        prefabData.push(rootNode.node);\n        currentId = rootNode.nextId;\n\n        // 添加根节点的 PrefabInfo\n        const rootPrefabInfo = {\n            \"__type__\": \"cc.PrefabInfo\",\n            \"root\": {\n                \"__id__\": 1\n            },\n            \"asset\": {\n                \"__id__\": 0\n            },\n            \"fileId\": this.generateFileId(),\n            \"targetOverrides\": null\n        };\n        prefabData.push(rootPrefabInfo);\n\n        return prefabData;\n    }\n\n    private async createNodeObject(nodeData: any, parentId: number | null, prefabData: any[], currentId: number): Promise<{ node: any; nextId: number }> {\n        const nodeId = currentId++;\n        \n        // 提取节点的基本属性\n        const position = nodeData.position?.value || { x: 0, y: 0, z: 0 };\n        const rotation = nodeData.rotation?.value || { x: 0, y: 0, z: 0, w: 1 };\n        const scale = nodeData.scale?.value || { x: 1, y: 1, z: 1 };\n        const active = nodeData.active?.value !== undefined ? nodeData.active.value : true;\n        const name = nodeData.name?.value || 'Node';\n        const layer = nodeData.layer?.value || 33554432;\n\n        const node: any = {\n            \"__type__\": \"cc.Node\",\n            \"_name\": name,\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"_parent\": parentId !== null ? { \"__id__\": parentId } : null,\n            \"_children\": [],\n            \"_active\": active,\n            \"_components\": [],\n            \"_prefab\": {\n                \"__id__\": currentId++\n            },\n            \"_lpos\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": position.x,\n                \"y\": position.y,\n                \"z\": position.z\n            },\n            \"_lrot\": {\n                \"__type__\": \"cc.Quat\",\n                \"x\": rotation.x,\n                \"y\": rotation.y,\n                \"z\": rotation.z,\n                \"w\": rotation.w\n            },\n            \"_lscale\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": scale.x,\n                \"y\": scale.y,\n                \"z\": scale.z\n            },\n            \"_mobility\": 0,\n            \"_layer\": layer,\n            \"_euler\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": 0,\n                \"y\": 0,\n                \"z\": 0\n            },\n            \"_id\": \"\"\n        };\n\n        // 添加组件\n        if (nodeData.__comps__ && nodeData.__comps__.length > 0) {\n            for (const comp of nodeData.__comps__) {\n                const componentId = currentId++;\n                node._components.push({ \"__id__\": componentId });\n                \n                // 创建组件对象\n                const componentObj = this.createComponentObject(comp, nodeId, currentId++);\n                prefabData.push(componentObj);\n                \n                // 添加组件的 CompPrefabInfo\n                const compPrefabInfo = {\n                    \"__type__\": \"cc.CompPrefabInfo\",\n                    \"fileId\": this.generateFileId()\n                };\n                prefabData.push(compPrefabInfo);\n                currentId++;\n            }\n        }\n\n        // 处理子节点\n        if (nodeData.children && Array.isArray(nodeData.children) && nodeData.children.length > 0) {\n            console.log(`=== 处理子节点 ===`);\n            console.log(`节点 ${name} 包含 ${nodeData.children.length} 个子节点`);\n            console.log('完整子节点数据:', JSON.stringify(nodeData.children, null, 2));\n            \n            for (let i = 0; i < nodeData.children.length; i++) {\n                const childRef = nodeData.children[i];\n                console.log(`第${i}个子节点的完整数据:`, JSON.stringify(childRef, null, 2));\n                \n                // 尝试多种可能的UUID提取方式\n                let childUuid = null;\n                if (typeof childRef === 'string') {\n                    childUuid = childRef;\n                    console.log(`方法1 - 直接字符串: ${childUuid}`);\n                } else if (childRef && childRef.value) {\n                    if (typeof childRef.value === 'string') {\n                        childUuid = childRef.value;\n                        console.log(`方法2 - value是字符串: ${childUuid}`);\n                    } else if (childRef.value.uuid) {\n                        childUuid = childRef.value.uuid;\n                        console.log(`方法3 - value.uuid: ${childUuid}`);\n                    } else if (childRef.value.__id__) {\n                        console.log(`方法4 - 发现__id__引用: ${childRef.value.__id__}`);\n                        // 这可能是一个内部引用，我们需要不同的处理方式\n                        continue;\n                    } else {\n                        console.log('方法4 - value不是字符串，内容:', JSON.stringify(childRef.value));\n                    }\n                } else if (childRef && childRef.uuid) {\n                    childUuid = childRef.uuid;\n                    console.log(`方法5 - 直接uuid属性: ${childUuid}`);\n                } else {\n                    console.log('方法6 - 无法识别的子节点格式:', JSON.stringify(childRef));\n                }\n                \n                if (childUuid && childUuid !== '[object Object]') {\n                    try {\n                        // 获取子节点数据\n                        const childNodeData = await this.getNodeData(childUuid);\n                        if (childNodeData) {\n                            const childId = currentId;\n                            node._children.push({ \"__id__\": childId });\n                            \n                            // 递归创建子节点\n                            const childResult = await this.createNodeObject(childNodeData, nodeId, prefabData, currentId);\n                            prefabData.push(childResult.node);\n                            currentId = childResult.nextId;\n                            \n                            // 为子节点添加PrefabInfo\n                            const childPrefabInfo = {\n                                \"__type__\": \"cc.PrefabInfo\",\n                                \"root\": {\n                                    \"__id__\": 1  // 指向根节点\n                                },\n                                \"asset\": {\n                                    \"__id__\": 0  // 指向Prefab资源\n                                },\n                                \"fileId\": this.generateFileId(),\n                                \"instance\": null,\n                                \"targetOverrides\": null,\n                                \"nestedPrefabInstanceRoots\": null\n                            };\n                            prefabData.push(childPrefabInfo);\n                            currentId++;\n                            \n                            console.log(`✅ 已添加子节点: ${childNodeData.name?.value || '未知'}`);\n                            console.log(`子节点在预制体数组中的索引: ${currentId}`);\n                        } else {\n                            console.warn(`无法获取子节点数据: ${childUuid}`);\n                        }\n                    } catch (error) {\n                        console.error(`处理子节点 ${childUuid} 时出错:`, error);\n                    }\n                }\n            }\n        }\n\n        return { node, nextId: currentId };\n    }\n\n    private createComponentObject(componentData: any, nodeId: number, prefabInfoId: number): any {\n        const componentType = componentData.__type__ || 'cc.Component';\n        \n        const component: any = {\n            \"__type__\": componentType,\n            \"_name\": \"\",\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"node\": {\n                \"__id__\": nodeId\n            },\n            \"_enabled\": componentData.enabled !== undefined ? componentData.enabled : true,\n            \"__prefab\": {\n                \"__id__\": prefabInfoId\n            },\n            \"_id\": \"\"\n        };\n\n        // 复制组件的其他属性\n        for (const key in componentData) {\n            if (!key.startsWith('_') && key !== '__type__' && key !== 'enabled' && key !== 'node') {\n                component[key] = componentData[key];\n            }\n        }\n\n        return component;\n    }\n\n    private createStandardMetaData(prefabName: string, prefabUuid: string): any {\n        return {\n            \"ver\": \"1.1.50\",\n            \"importer\": \"prefab\",\n            \"imported\": true,\n            \"uuid\": prefabUuid,\n            \"files\": [\n                \".json\"\n            ],\n            \"subMetas\": {},\n            \"userData\": {\n                \"syncNodeName\": prefabName\n            }\n        };\n    }\n\n    private async savePrefabWithMeta(prefabPath: string, prefabData: any[], metaData: any): Promise<{ success: boolean; error?: string }> {\n        try {\n            const prefabContent = JSON.stringify(prefabData, null, 2);\n            const metaContent = JSON.stringify(metaData, null, 2);\n\n            // 确保路径以.prefab结尾\n            const finalPrefabPath = prefabPath.endsWith('.prefab') ? prefabPath : `${prefabPath}.prefab`;\n            const metaPath = `${finalPrefabPath}.meta`;\n\n            // 使用asset-db API创建预制体文件\n            await new Promise((resolve, reject) => {\n                Editor.Message.request('asset-db', 'create-asset', finalPrefabPath, prefabContent).then(() => {\n                    resolve(true);\n                }).catch((error: any) => {\n                    reject(error);\n                });\n            });\n\n            // 创建meta文件\n            await new Promise((resolve, reject) => {\n                Editor.Message.request('asset-db', 'create-asset', metaPath, metaContent).then(() => {\n                    resolve(true);\n                }).catch((error: any) => {\n                    reject(error);\n                });\n            });\n\n            console.log(`=== 预制体保存完成 ===`);\n            console.log(`预制体文件已保存: ${finalPrefabPath}`);\n            console.log(`Meta文件已保存: ${metaPath}`);\n            console.log(`预制体数组总长度: ${prefabData.length}`);\n            console.log(`预制体根节点索引: ${prefabData.length - 1}`);\n\n            return { success: true };\n        } catch (error: any) {\n            console.error('保存预制体文件时出错:', error);\n            return { success: false, error: error.message };\n        }\n    }\n\n}"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prefab-tools.js","sourceRoot":"","sources":["../../source/tools/prefab-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, PrefabInfo } from '../types';\n\nexport class PrefabTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'get_prefab_list',\n                description: 'Get all prefabs in the project',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        folder: {\n                            type: 'string',\n                            description: 'Folder path to search (optional)',\n                            default: 'db://assets'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'load_prefab',\n                description: 'Load a prefab by path',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'instantiate_prefab',\n                description: 'Instantiate a prefab in the scene',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        },\n                        parentUuid: {\n                            type: 'string',\n                            description: 'Parent node UUID (optional)'\n                        },\n                        position: {\n                            type: 'object',\n                            description: 'Initial position',\n                            properties: {\n                                x: { type: 'number' },\n                                y: { type: 'number' },\n                                z: { type: 'number' }\n                            }\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'create_prefab',\n                description: 'Create a prefab from a node with all children and components',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Source node UUID'\n                        },\n                        savePath: {\n                            type: 'string',\n                            description: 'Path to save the prefab (e.g., db://assets/prefabs/MyPrefab.prefab)'\n                        },\n                        prefabName: {\n                            type: 'string',\n                            description: 'Prefab name'\n                        }\n                    },\n                    required: ['nodeUuid', 'savePath', 'prefabName']\n                }\n            },\n            {\n                name: 'update_prefab',\n                description: 'Update an existing prefab',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        },\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID with changes'\n                        }\n                    },\n                    required: ['prefabPath', 'nodeUuid']\n                }\n            },\n            {\n                name: 'revert_prefab',\n                description: 'Revert prefab instance to original',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Prefab instance node UUID'\n                        }\n                    },\n                    required: ['nodeUuid']\n                }\n            },\n            {\n                name: 'get_prefab_info',\n                description: 'Get detailed prefab information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'validate_prefab',\n                description: 'Validate a prefab file format',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'duplicate_prefab',\n                description: 'Duplicate an existing prefab',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        sourcePrefabPath: {\n                            type: 'string',\n                            description: 'Source prefab path'\n                        },\n                        targetPrefabPath: {\n                            type: 'string',\n                            description: 'Target prefab path'\n                        },\n                        newPrefabName: {\n                            type: 'string',\n                            description: 'New prefab name'\n                        }\n                    },\n                    required: ['sourcePrefabPath', 'targetPrefabPath']\n                }\n            },\n            {\n                name: 'restore_prefab_node',\n                description: 'Restore prefab node using prefab asset (built-in undo record)',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Prefab instance node UUID'\n                        },\n                        assetUuid: {\n                            type: 'string',\n                            description: 'Prefab asset UUID'\n                        }\n                    },\n                    required: ['nodeUuid', 'assetUuid']\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'get_prefab_list':\n                return await this.getPrefabList(args.folder);\n            case 'load_prefab':\n                return await this.loadPrefab(args.prefabPath);\n            case 'instantiate_prefab':\n                return await this.instantiatePrefab(args);\n            case 'create_prefab':\n                return await this.createPrefab(args);\n            case 'update_prefab':\n                return await this.updatePrefab(args.prefabPath, args.nodeUuid);\n            case 'revert_prefab':\n                return await this.revertPrefab(args.nodeUuid);\n            case 'get_prefab_info':\n                return await this.getPrefabInfo(args.prefabPath);\n            case 'validate_prefab':\n                return await this.validatePrefab(args.prefabPath);\n            case 'duplicate_prefab':\n                return await this.duplicatePrefab(args);\n            case 'restore_prefab_node':\n                return await this.restorePrefabNode(args.nodeUuid, args.assetUuid);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async getPrefabList(folder: string = 'db://assets'): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const pattern = folder.endsWith('/') ? \n                `${folder}**/*.prefab` : `${folder}/**/*.prefab`;\n            \n            Editor.Message.request('asset-db', 'query-assets', {\n                pattern: pattern\n            }).then((results: any[]) => {\n                const prefabs: PrefabInfo[] = results.map(asset => ({\n                    name: asset.name,\n                    path: asset.url,\n                    uuid: asset.uuid,\n                    folder: asset.url.substring(0, asset.url.lastIndexOf('/'))\n                }));\n                resolve({ success: true, data: prefabs });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async loadPrefab(prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n                \n                return Editor.Message.request('scene', 'load-asset', {\n                    uuid: assetInfo.uuid\n                });\n            }).then((prefabData: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        uuid: prefabData.uuid,\n                        name: prefabData.name,\n                        message: 'Prefab loaded successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async instantiatePrefab(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                // 获取预制体资源信息\n                const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath);\n                if (!assetInfo) {\n                    throw new Error('预制体未找到');\n                }\n\n                // 使用正确的 create-node API 从预制体资源实例化\n                const createNodeOptions: any = {\n                    assetUuid: assetInfo.uuid\n                };\n\n                // 设置父节点\n                if (args.parentUuid) {\n                    createNodeOptions.parent = args.parentUuid;\n                }\n\n                // 设置节点名称\n                if (args.name) {\n                    createNodeOptions.name = args.name;\n                } else if (assetInfo.name) {\n                    createNodeOptions.name = assetInfo.name;\n                }\n\n                // 设置初始属性（如位置）\n                if (args.position) {\n                    createNodeOptions.dump = {\n                        position: {\n                            value: args.position\n                        }\n                    };\n                }\n\n                // 创建节点\n                const nodeUuid = await Editor.Message.request('scene', 'create-node', createNodeOptions);\n                const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid;\n\n                // 注意：create-node API从预制体资源创建时应该自动建立预制体关联\n                console.log('预制体节点创建成功:', {\n                    nodeUuid: uuid,\n                    prefabUuid: assetInfo.uuid,\n                    prefabPath: args.prefabPath\n                });\n                \n                resolve({\n                    success: true,\n                    data: {\n                        nodeUuid: uuid,\n                        prefabPath: args.prefabPath,\n                        parentUuid: args.parentUuid,\n                        position: args.position,\n                        message: '预制体实例化成功，已建立预制体关联'\n                    }\n                });\n            } catch (err: any) {\n                resolve({ \n                    success: false, \n                    error: `预制体实例化失败: ${err.message}`,\n                    instruction: '请检查预制体路径是否正确，确保预制体文件格式正确'\n                });\n            }\n        });\n    }\n\n    /**\n     * 建立节点与预制体的关联关系\n     * 这个方法创建必要的PrefabInfo和PrefabInstance结构\n     */\n    private async establishPrefabConnection(nodeUuid: string, prefabUuid: string, prefabPath: string): Promise<void> {\n        try {\n            // 读取预制体文件获取根节点的fileId\n            const prefabContent = await this.readPrefabFile(prefabPath);\n            if (!prefabContent || !prefabContent.data || !prefabContent.data.length) {\n                throw new Error('无法读取预制体文件内容');\n            }\n\n            // 找到预制体根节点的fileId (通常是第二个对象，即索引1)\n            const rootNode = prefabContent.data.find((item: any) => item.__type === 'cc.Node' && item._parent === null);\n            if (!rootNode || !rootNode._prefab) {\n                throw new Error('无法找到预制体根节点或其预制体信息');\n            }\n\n            // 获取根节点的PrefabInfo\n            const rootPrefabInfo = prefabContent.data[rootNode._prefab.__id__];\n            if (!rootPrefabInfo || rootPrefabInfo.__type !== 'cc.PrefabInfo') {\n                throw new Error('无法找到预制体根节点的PrefabInfo');\n            }\n\n            const rootFileId = rootPrefabInfo.fileId;\n\n            // 使用scene API建立预制体连接\n            const prefabConnectionData = {\n                node: nodeUuid,\n                prefab: prefabUuid,\n                fileId: rootFileId\n            };\n\n            // 尝试使用多种API方法建立预制体连接\n            const connectionMethods = [\n                () => Editor.Message.request('scene', 'connect-prefab-instance', prefabConnectionData),\n                () => Editor.Message.request('scene', 'set-prefab-connection', prefabConnectionData),\n                () => Editor.Message.request('scene', 'apply-prefab-link', prefabConnectionData)\n            ];\n\n            let connected = false;\n            for (const method of connectionMethods) {\n                try {\n                    await method();\n                    connected = true;\n                    break;\n                } catch (error) {\n                    console.warn('预制体连接方法失败，尝试下一个方法:', error);\n                }\n            }\n\n            if (!connected) {\n                // 如果所有API方法都失败，尝试手动修改场景数据\n                console.warn('所有预制体连接API都失败，尝试手动建立连接');\n                await this.manuallyEstablishPrefabConnection(nodeUuid, prefabUuid, rootFileId);\n            }\n\n        } catch (error) {\n            console.error('建立预制体连接失败:', error);\n            throw error;\n        }\n    }\n\n    /**\n     * 手动建立预制体连接（当API方法失败时的备用方案）\n     */\n    private async manuallyEstablishPrefabConnection(nodeUuid: string, prefabUuid: string, rootFileId: string): Promise<void> {\n        try {\n            // 尝试使用dump API修改节点的_prefab属性\n            const prefabConnectionData = {\n                [nodeUuid]: {\n                    '_prefab': {\n                        '__uuid__': prefabUuid,\n                        '__expectedType__': 'cc.Prefab',\n                        'fileId': rootFileId\n                    }\n                }\n            };\n\n            await Editor.Message.request('scene', 'set-property', {\n                uuid: nodeUuid,\n                path: '_prefab',\n                dump: {\n                    value: {\n                        '__uuid__': prefabUuid,\n                        '__expectedType__': 'cc.Prefab'\n                    }\n                }\n            });\n\n        } catch (error) {\n            console.error('手动建立预制体连接也失败:', error);\n            // 不抛出错误，因为基本的节点创建已经成功\n        }\n    }\n\n    /**\n     * 读取预制体文件内容\n     */\n    private async readPrefabFile(prefabPath: string): Promise<any> {\n        try {\n            // 尝试使用asset-db API读取文件内容\n            let assetContent: any;\n            try {\n                assetContent = await Editor.Message.request('asset-db', 'query-asset-info', prefabPath);\n                if (assetContent && assetContent.source) {\n                    // 如果有source路径，直接读取文件\n                    const fs = require('fs');\n                    const path = require('path');\n                    const fullPath = path.resolve(assetContent.source);\n                    const fileContent = fs.readFileSync(fullPath, 'utf8');\n                    return JSON.parse(fileContent);\n                }\n            } catch (error) {\n                console.warn('使用asset-db读取失败，尝试其他方法:', error);\n            }\n\n            // 备用方法：转换db://路径为实际文件路径\n            const fsPath = prefabPath.replace('db://assets/', 'assets/').replace('db://assets', 'assets');\n            const fs = require('fs');\n            const path = require('path');\n            \n            // 尝试多个可能的项目根路径\n            const possiblePaths = [\n                path.resolve(process.cwd(), '../../NewProject_3', fsPath),\n                path.resolve('/Users/lizhiyong/NewProject_3', fsPath),\n                path.resolve(fsPath),\n                // 如果是根目录下的文件，也尝试直接路径\n                path.resolve('/Users/lizhiyong/NewProject_3/assets', path.basename(fsPath))\n            ];\n\n            console.log('尝试读取预制体文件，路径转换:', {\n                originalPath: prefabPath,\n                fsPath: fsPath,\n                possiblePaths: possiblePaths\n            });\n\n            for (const fullPath of possiblePaths) {\n                try {\n                    console.log(`检查路径: ${fullPath}`);\n                    if (fs.existsSync(fullPath)) {\n                        console.log(`找到文件: ${fullPath}`);\n                        const fileContent = fs.readFileSync(fullPath, 'utf8');\n                        const parsed = JSON.parse(fileContent);\n                        console.log('文件解析成功，数据结构:', {\n                            hasData: !!parsed.data,\n                            dataLength: parsed.data ? parsed.data.length : 0\n                        });\n                        return parsed;\n                    } else {\n                        console.log(`文件不存在: ${fullPath}`);\n                    }\n                } catch (readError) {\n                    console.warn(`读取文件失败 ${fullPath}:`, readError);\n                }\n            }\n\n            throw new Error('无法找到或读取预制体文件');\n        } catch (error) {\n            console.error('读取预制体文件失败:', error);\n            throw error;\n        }\n    }\n\n    private async tryCreateNodeWithPrefab(args: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('预制体未找到');\n                }\n\n                // 方法2: 使用 create-node 指定预制体资源\n                const createNodeOptions: any = {\n                    assetUuid: assetInfo.uuid\n                };\n\n                // 设置父节点\n                if (args.parentUuid) {\n                    createNodeOptions.parent = args.parentUuid;\n                }\n\n                return Editor.Message.request('scene', 'create-node', createNodeOptions);\n            }).then((nodeUuid: string | string[]) => {\n                const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid;\n                \n                // 如果指定了位置，设置节点位置\n                if (args.position && uuid) {\n                    Editor.Message.request('scene', 'set-property', {\n                        uuid: uuid,\n                        path: 'position',\n                        dump: { value: args.position }\n                    }).then(() => {\n                        resolve({\n                            success: true,\n                            data: {\n                                nodeUuid: uuid,\n                                prefabPath: args.prefabPath,\n                                position: args.position,\n                                message: '预制体实例化成功（备用方法）并设置了位置'\n                            }\n                        });\n                    }).catch(() => {\n                        resolve({\n                            success: true,\n                            data: {\n                                nodeUuid: uuid,\n                                prefabPath: args.prefabPath,\n                                message: '预制体实例化成功（备用方法）但位置设置失败'\n                            }\n                        });\n                    });\n                } else {\n                    resolve({\n                        success: true,\n                        data: {\n                            nodeUuid: uuid,\n                            prefabPath: args.prefabPath,\n                            message: '预制体实例化成功（备用方法）'\n                        }\n                    });\n                }\n            }).catch((err: Error) => {\n                resolve({\n                    success: false,\n                    error: `备用预制体实例化方法也失败: ${err.message}`\n                });\n            });\n        });\n    }\n\n    private async tryAlternativeInstantiateMethods(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                // 方法1: 尝试使用 create-node 然后设置预制体\n                const assetInfo = await this.getAssetInfo(args.prefabPath);\n                if (!assetInfo) {\n                    resolve({ success: false, error: '无法获取预制体信息' });\n                    return;\n                }\n\n                // 创建空节点\n                const createResult = await this.createNode(args.parentUuid, args.position);\n                if (!createResult.success) {\n                    resolve(createResult);\n                    return;\n                }\n\n                // 尝试将预制体应用到节点\n                const applyResult = await this.applyPrefabToNode(createResult.data.nodeUuid, assetInfo.uuid);\n                if (applyResult.success) {\n                    resolve({\n                        success: true,\n                        data: {\n                            nodeUuid: createResult.data.nodeUuid,\n                            name: createResult.data.name,\n                            message: '预制体实例化成功（使用备选方法）'\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: false,\n                        error: '无法将预制体应用到节点',\n                        data: {\n                            nodeUuid: createResult.data.nodeUuid,\n                            message: '已创建节点，但无法应用预制体数据'\n                        }\n                    });\n                }\n\n            } catch (error) {\n                resolve({ success: false, error: `备选实例化方法失败: ${error}` });\n            }\n        });\n    }\n\n    private async getAssetInfo(prefabPath: string): Promise<any> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                resolve(assetInfo);\n            }).catch(() => {\n                resolve(null);\n            });\n        });\n    }\n\n    private async createNode(parentUuid?: string, position?: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const createNodeOptions: any = {\n                name: 'PrefabInstance'\n            };\n\n            // 设置父节点\n            if (parentUuid) {\n                createNodeOptions.parent = parentUuid;\n            }\n\n            // 设置位置\n            if (position) {\n                createNodeOptions.dump = {\n                    position: position\n                };\n            }\n\n            Editor.Message.request('scene', 'create-node', createNodeOptions).then((nodeUuid: string | string[]) => {\n                const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid;\n                resolve({\n                    success: true,\n                    data: {\n                        nodeUuid: uuid,\n                        name: 'PrefabInstance'\n                    }\n                });\n            }).catch((error: any) => {\n                resolve({ success: false, error: error.message || '创建节点失败' });\n            });\n        });\n    }\n\n    private async applyPrefabToNode(nodeUuid: string, prefabUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试多种方法来应用预制体数据\n            const methods = [\n                () => Editor.Message.request('scene', 'apply-prefab', { node: nodeUuid, prefab: prefabUuid }),\n                () => Editor.Message.request('scene', 'set-prefab', { node: nodeUuid, prefab: prefabUuid }),\n                () => Editor.Message.request('scene', 'load-prefab-to-node', { node: nodeUuid, prefab: prefabUuid })\n            ];\n\n            const tryMethod = (index: number) => {\n                if (index >= methods.length) {\n                    resolve({ success: false, error: '无法应用预制体数据' });\n                    return;\n                }\n\n                methods[index]().then(() => {\n                    resolve({ success: true });\n                }).catch(() => {\n                    tryMethod(index + 1);\n                });\n            };\n\n            tryMethod(0);\n        });\n    }\n\n    /**\n     * 使用 asset-db API 创建预制体的新方法\n     * 深度整合引擎的资源管理系统，实现完整的预制体创建流程\n     */\n    private async createPrefabWithAssetDB(nodeUuid: string, savePath: string, prefabName: string, includeChildren: boolean, includeComponents: boolean): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                console.log('=== 使用 Asset-DB API 创建预制体 ===');\n                console.log(`节点UUID: ${nodeUuid}`);\n                console.log(`保存路径: ${savePath}`);\n                console.log(`预制体名称: ${prefabName}`);\n\n                // 第一步：获取节点数据（包括变换属性）\n                const nodeData = await this.getNodeData(nodeUuid);\n                if (!nodeData) {\n                    resolve({\n                        success: false,\n                        error: '无法获取节点数据'\n                    });\n                    return;\n                }\n\n                console.log('获取到节点数据，子节点数量:', nodeData.children ? nodeData.children.length : 0);\n\n                // 第二步：先创建资源文件以获取引擎分配的UUID\n                console.log('创建预制体资源文件...');\n                const tempPrefabContent = JSON.stringify([{\"__type__\": \"cc.Prefab\", \"_name\": prefabName}], null, 2);\n                const createResult = await this.createAssetWithAssetDB(savePath, tempPrefabContent);\n                if (!createResult.success) {\n                    resolve(createResult);\n                    return;\n                }\n\n                // 获取引擎分配的实际UUID\n                const actualPrefabUuid = createResult.data?.uuid;\n                if (!actualPrefabUuid) {\n                    resolve({\n                        success: false,\n                        error: '无法获取引擎分配的预制体UUID'\n                    });\n                    return;\n                }\n                console.log('引擎分配的UUID:', actualPrefabUuid);\n\n                // 第三步：使用实际UUID重新生成预制体内容\n                const prefabContent = await this.createStandardPrefabContent(nodeData, prefabName, actualPrefabUuid, includeChildren, includeComponents);\n                const prefabContentString = JSON.stringify(prefabContent, null, 2);\n\n                // 第四步：更新预制体文件内容\n                console.log('更新预制体文件内容...');\n                const updateResult = await this.updateAssetWithAssetDB(savePath, prefabContentString);\n                \n                // 第五步：创建对应的meta文件（使用实际UUID）\n                console.log('创建预制体meta文件...');\n                const metaContent = this.createStandardMetaContent(prefabName, actualPrefabUuid);\n                const metaResult = await this.createMetaWithAssetDB(savePath, metaContent);\n                \n                // 第六步：重新导入资源以更新引用\n                console.log('重新导入预制体资源...');\n                const reimportResult = await this.reimportAssetWithAssetDB(savePath);\n\n                // 第七步：尝试将原始节点转换为预制体实例\n                console.log('尝试将原始节点转换为预制体实例...');\n                const convertResult = await this.convertNodeToPrefabInstance(nodeUuid, actualPrefabUuid, savePath);\n                \n                resolve({\n                    success: true,\n                    data: {\n                        prefabUuid: actualPrefabUuid,\n                        prefabPath: savePath,\n                        nodeUuid: nodeUuid,\n                        prefabName: prefabName,\n                        convertedToPrefabInstance: convertResult.success,\n                        createAssetResult: createResult,\n                        updateResult: updateResult,\n                        metaResult: metaResult,\n                        reimportResult: reimportResult,\n                        convertResult: convertResult,\n                        message: convertResult.success ? '预制体创建并成功转换原始节点' : '预制体创建成功，但节点转换失败'\n                    }\n                });\n\n            } catch (error) {\n                console.error('创建预制体时发生错误:', error);\n                resolve({\n                    success: false,\n                    error: `创建预制体失败: ${error}`\n                });\n            }\n        });\n    }\n\n    private async createPrefab(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                // 支持 prefabPath 和 savePath 两种参数名\n                const pathParam = args.prefabPath || args.savePath;\n                if (!pathParam) {\n                    resolve({\n                        success: false,\n                        error: '缺少预制体路径参数。请提供 prefabPath 或 savePath。'\n                    });\n                    return;\n                }\n\n                const prefabName = args.prefabName || 'NewPrefab';\n                const fullPath = pathParam.endsWith('.prefab') ? \n                    pathParam : `${pathParam}/${prefabName}.prefab`;\n\n                const includeChildren = args.includeChildren !== false; // 默认为 true\n                const includeComponents = args.includeComponents !== false; // 默认为 true\n\n                // 优先使用新的 asset-db 方法创建预制体\n                console.log('使用新的 asset-db 方法创建预制体...');\n                const assetDbResult = await this.createPrefabWithAssetDB(\n                    args.nodeUuid,\n                    fullPath,\n                    prefabName,\n                    includeChildren,\n                    includeComponents\n                );\n\n                if (assetDbResult.success) {\n                    resolve(assetDbResult);\n                    return;\n                }\n\n                // 如果 asset-db 方法失败，尝试使用Cocos Creator的原生预制体创建API\n                console.log('asset-db 方法失败，尝试原生API...');\n                const nativeResult = await this.createPrefabNative(args.nodeUuid, fullPath);\n                if (nativeResult.success) {\n                    resolve(nativeResult);\n                    return;\n                }\n\n                // 如果原生API失败，使用自定义实现\n                console.log('原生API失败，使用自定义实现...');\n                const customResult = await this.createPrefabCustom(args.nodeUuid, fullPath, prefabName);\n                resolve(customResult);\n\n            } catch (error) {\n                resolve({\n                    success: false,\n                    error: `创建预制体时发生错误: ${error}`\n                });\n            }\n        });\n    }\n\n    private async createPrefabNative(nodeUuid: string, prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 根据官方API文档，不存在直接的预制体创建API\n            // 预制体创建需要手动在编辑器中完成\n            resolve({\n                success: false,\n                error: '原生预制体创建API不存在',\n                instruction: '根据Cocos Creator官方API文档，预制体创建需要手动操作：\\n1. 在场景中选择节点\\n2. 将节点拖拽到资源管理器中\\n3. 或右键节点选择\"生成预制体\"'\n            });\n        });\n    }\n\n    private async createPrefabCustom(nodeUuid: string, prefabPath: string, prefabName: string): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                // 1. 获取源节点的完整数据\n                const nodeData = await this.getNodeData(nodeUuid);\n                if (!nodeData) {\n                    resolve({\n                        success: false,\n                        error: `无法找到节点: ${nodeUuid}`\n                    });\n                    return;\n                }\n\n                // 2. 生成预制体UUID\n                const prefabUuid = this.generateUUID();\n\n                // 3. 创建预制体数据结构\n                const prefabData = this.createPrefabData(nodeData, prefabName, prefabUuid);\n\n                // 4. 基于官方格式创建预制体数据结构\n                console.log('=== 开始创建预制体 ===');\n                console.log('节点名称:', nodeData.name?.value || '未知');\n                console.log('节点UUID:', nodeData.uuid?.value || '未知');\n                console.log('预制体保存路径:', prefabPath);\n                console.log(`开始创建预制体，节点数据:`, nodeData);\n                const prefabJsonData = await this.createStandardPrefabContent(nodeData, prefabName, prefabUuid, true, true);\n\n                // 5. 创建标准meta文件数据\n                const standardMetaData = this.createStandardMetaData(prefabName, prefabUuid);\n\n                // 6. 保存预制体和meta文件\n                const saveResult = await this.savePrefabWithMeta(prefabPath, prefabJsonData, standardMetaData);\n\n                if (saveResult.success) {\n                    // 保存成功后，将原始节点转换为预制体实例\n                    const convertResult = await this.convertNodeToPrefabInstance(nodeUuid, prefabPath, prefabUuid);\n                    \n                    resolve({\n                        success: true,\n                        data: {\n                            prefabUuid: prefabUuid,\n                            prefabPath: prefabPath,\n                            nodeUuid: nodeUuid,\n                            prefabName: prefabName,\n                            convertedToPrefabInstance: convertResult.success,\n                            message: convertResult.success ? \n                                '自定义预制体创建成功，原始节点已转换为预制体实例' : \n                                '预制体创建成功，但节点转换失败'\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: false,\n                        error: saveResult.error || '保存预制体文件失败'\n                    });\n                }\n\n            } catch (error) {\n                resolve({\n                    success: false,\n                    error: `创建预制体时发生错误: ${error}`\n                });\n            }\n        });\n    }\n\n    private async getNodeData(nodeUuid: string): Promise<any> {\n        return new Promise(async (resolve) => {\n            try {\n                // 首先获取基本节点信息\n                const nodeInfo = await Editor.Message.request('scene', 'query-node', nodeUuid);\n                if (!nodeInfo) {\n                    resolve(null);\n                    return;\n                }\n\n                console.log(`获取节点 ${nodeUuid} 的基本信息成功`);\n                \n                // 使用query-node-tree获取包含子节点的完整结构\n                const nodeTree = await this.getNodeWithChildren(nodeUuid);\n                if (nodeTree) {\n                    console.log(`获取节点 ${nodeUuid} 的完整树结构成功`);\n                    resolve(nodeTree);\n                } else {\n                    console.log(`使用基本节点信息`);\n                    resolve(nodeInfo);\n                }\n            } catch (error) {\n                console.warn(`获取节点数据失败 ${nodeUuid}:`, error);\n                resolve(null);\n            }\n        });\n    }\n\n    // 使用query-node-tree获取包含子节点的完整节点结构\n    private async getNodeWithChildren(nodeUuid: string): Promise<any> {\n        try {\n            // 获取整个场景树\n            const tree = await Editor.Message.request('scene', 'query-node-tree');\n            if (!tree) {\n                return null;\n            }\n\n            // 在树中查找指定的节点\n            const targetNode = this.findNodeInTree(tree, nodeUuid);\n            if (targetNode) {\n                console.log(`在场景树中找到节点 ${nodeUuid}，子节点数量: ${targetNode.children ? targetNode.children.length : 0}`);\n                \n                // 增强节点树，获取每个节点的正确组件信息\n                const enhancedTree = await this.enhanceTreeWithMCPComponents(targetNode);\n                return enhancedTree;\n            }\n\n            return null;\n        } catch (error) {\n            console.warn(`获取节点树结构失败 ${nodeUuid}:`, error);\n            return null;\n        }\n    }\n\n    // 在节点树中递归查找指定UUID的节点\n    private findNodeInTree(node: any, targetUuid: string): any {\n        if (!node) return null;\n        \n        // 检查当前节点\n        if (node.uuid === targetUuid || node.value?.uuid === targetUuid) {\n            return node;\n        }\n\n        // 递归检查子节点\n        if (node.children && Array.isArray(node.children)) {\n            for (const child of node.children) {\n                const found = this.findNodeInTree(child, targetUuid);\n                if (found) {\n                    return found;\n                }\n            }\n        }\n\n        return null;\n    }\n\n    /**\n     * 使用MCP接口增强节点树，获取正确的组件信息\n     */\n    private async enhanceTreeWithMCPComponents(node: any): Promise<any> {\n        if (!node || !node.uuid) {\n            return node;\n        }\n\n        try {\n            // 使用MCP接口获取节点的组件信息\n            const response = await fetch('http://localhost:8585/mcp', {\n                method: 'POST',\n                headers: { 'Content-Type': 'application/json' },\n                body: JSON.stringify({\n                    \"jsonrpc\": \"2.0\",\n                    \"method\": \"tools/call\",\n                    \"params\": {\n                        \"name\": \"component_get_components\",\n                        \"arguments\": {\n                            \"nodeUuid\": node.uuid\n                        }\n                    },\n                    \"id\": Date.now()\n                })\n            });\n            \n            const mcpResult = await response.json();\n            if (mcpResult.result?.content?.[0]?.text) {\n                const componentData = JSON.parse(mcpResult.result.content[0].text);\n                if (componentData.success && componentData.data.components) {\n                    // 更新节点的组件信息为MCP返回的正确数据\n                    node.components = componentData.data.components;\n                    console.log(`节点 ${node.uuid} 获取到 ${componentData.data.components.length} 个组件，包含脚本组件的正确类型`);\n                }\n            }\n        } catch (error) {\n            console.warn(`获取节点 ${node.uuid} 的MCP组件信息失败:`, error);\n        }\n\n        // 递归处理子节点\n        if (node.children && Array.isArray(node.children)) {\n            for (let i = 0; i < node.children.length; i++) {\n                node.children[i] = await this.enhanceTreeWithMCPComponents(node.children[i]);\n            }\n        }\n\n        return node;\n    }\n\n    private async buildBasicNodeInfo(nodeUuid: string): Promise<any> {\n        return new Promise((resolve) => {\n            // 构建基本的节点信息\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeInfo: any) => {\n                if (!nodeInfo) {\n                    resolve(null);\n                    return;\n                }\n\n                // 简化版本：只返回基本节点信息，不获取子节点和组件\n                // 这些信息将在后续的预制体处理中根据需要添加\n                const basicInfo = {\n                    ...nodeInfo,\n                    children: [],\n                    components: []\n                };\n                resolve(basicInfo);\n            }).catch(() => {\n                resolve(null);\n            });\n        });\n    }\n\n    // 验证节点数据是否有效\n    private isValidNodeData(nodeData: any): boolean {\n        if (!nodeData) return false;\n        if (typeof nodeData !== 'object') return false;\n        \n        // 检查基本属性 - 适配query-node-tree的数据格式\n        return nodeData.hasOwnProperty('uuid') || \n               nodeData.hasOwnProperty('name') || \n               nodeData.hasOwnProperty('__type__') ||\n               (nodeData.value && (\n                   nodeData.value.hasOwnProperty('uuid') ||\n                   nodeData.value.hasOwnProperty('name') ||\n                   nodeData.value.hasOwnProperty('__type__')\n               ));\n    }\n\n    // 提取子节点UUID的统一方法\n    private extractChildUuid(childRef: any): string | null {\n        if (!childRef) return null;\n        \n        // 方法1: 直接字符串\n        if (typeof childRef === 'string') {\n            return childRef;\n        }\n        \n        // 方法2: value属性包含字符串\n        if (childRef.value && typeof childRef.value === 'string') {\n            return childRef.value;\n        }\n        \n        // 方法3: value.uuid属性\n        if (childRef.value && childRef.value.uuid) {\n            return childRef.value.uuid;\n        }\n        \n        // 方法4: 直接uuid属性\n        if (childRef.uuid) {\n            return childRef.uuid;\n        }\n        \n        // 方法5: __id__引用 - 这种情况需要特殊处理\n        if (childRef.__id__ !== undefined) {\n            console.log(`发现__id__引用: ${childRef.__id__}，可能需要从数据结构中查找`);\n            return null; // 暂时返回null，后续可以添加引用解析逻辑\n        }\n        \n        console.warn('无法提取子节点UUID:', JSON.stringify(childRef));\n        return null;\n    }\n\n    // 获取需要处理的子节点数据\n    private getChildrenToProcess(nodeData: any): any[] {\n        const children: any[] = [];\n        \n        // 方法1: 直接从children数组获取（从query-node-tree返回的数据）\n        if (nodeData.children && Array.isArray(nodeData.children)) {\n            console.log(`从children数组获取子节点，数量: ${nodeData.children.length}`);\n            for (const child of nodeData.children) {\n                // query-node-tree返回的子节点通常已经是完整的数据结构\n                if (this.isValidNodeData(child)) {\n                    children.push(child);\n                    console.log(`添加子节点: ${child.name || child.value?.name || '未知'}`);\n                } else {\n                    console.log('子节点数据无效:', JSON.stringify(child, null, 2));\n                }\n            }\n        } else {\n            console.log('节点没有子节点或children数组为空');\n        }\n        \n        return children;\n    }\n\n    private generateUUID(): string {\n        // 生成符合Cocos Creator格式的UUID\n        const chars = '0123456789abcdef';\n        let uuid = '';\n        for (let i = 0; i < 32; i++) {\n            if (i === 8 || i === 12 || i === 16 || i === 20) {\n                uuid += '-';\n            }\n            uuid += chars[Math.floor(Math.random() * chars.length)];\n        }\n        return uuid;\n    }\n\n    private createPrefabData(nodeData: any, prefabName: string, prefabUuid: string): any[] {\n        // 创建标准的预制体数据结构\n        const prefabAsset = {\n            \"__type__\": \"cc.Prefab\",\n            \"_name\": prefabName,\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"_native\": \"\",\n            \"data\": {\n                \"__id__\": 1\n            },\n            \"optimizationPolicy\": 0,\n            \"persistent\": false\n        };\n\n        // 处理节点数据，确保符合预制体格式\n        const processedNodeData = this.processNodeForPrefab(nodeData, prefabUuid);\n\n        return [prefabAsset, ...processedNodeData];\n    }\n\n    private processNodeForPrefab(nodeData: any, prefabUuid: string): any[] {\n        // 处理节点数据以符合预制体格式\n        const processedData: any[] = [];\n        let idCounter = 1;\n\n        // 递归处理节点和组件\n        const processNode = (node: any, parentId: number = 0): number => {\n            const nodeId = idCounter++;\n            \n            // 创建节点对象\n            const processedNode = {\n                \"__type__\": \"cc.Node\",\n                \"_name\": node.name || \"Node\",\n                \"_objFlags\": 0,\n                \"__editorExtras__\": {},\n                \"_parent\": parentId > 0 ? { \"__id__\": parentId } : null,\n                \"_children\": node.children ? node.children.map(() => ({ \"__id__\": idCounter++ })) : [],\n                \"_active\": node.active !== false,\n                \"_components\": node.components ? node.components.map(() => ({ \"__id__\": idCounter++ })) : [],\n                \"_prefab\": {\n                    \"__id__\": idCounter++\n                },\n                \"_lpos\": {\n                    \"__type__\": \"cc.Vec3\",\n                    \"x\": 0,\n                    \"y\": 0,\n                    \"z\": 0\n                },\n                \"_lrot\": {\n                    \"__type__\": \"cc.Quat\",\n                    \"x\": 0,\n                    \"y\": 0,\n                    \"z\": 0,\n                    \"w\": 1\n                },\n                \"_lscale\": {\n                    \"__type__\": \"cc.Vec3\",\n                    \"x\": 1,\n                    \"y\": 1,\n                    \"z\": 1\n                },\n                \"_mobility\": 0,\n                \"_layer\": 1073741824,\n                \"_euler\": {\n                    \"__type__\": \"cc.Vec3\",\n                    \"x\": 0,\n                    \"y\": 0,\n                    \"z\": 0\n                },\n                \"_id\": \"\"\n            };\n\n            processedData.push(processedNode);\n\n            // 处理组件\n            if (node.components) {\n                node.components.forEach((component: any) => {\n                    const componentId = idCounter++;\n                    const processedComponents = this.processComponentForPrefab(component, componentId);\n                    processedData.push(...processedComponents);\n                });\n            }\n\n            // 处理子节点\n            if (node.children) {\n                node.children.forEach((child: any) => {\n                    processNode(child, nodeId);\n                });\n            }\n\n            return nodeId;\n        };\n\n        processNode(nodeData);\n        return processedData;\n    }\n\n    private processComponentForPrefab(component: any, componentId: number): any[] {\n        // 处理组件数据以符合预制体格式\n        const processedComponent = {\n            \"__type__\": component.type || \"cc.Component\",\n            \"_name\": \"\",\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"node\": {\n                \"__id__\": componentId - 1\n            },\n            \"_enabled\": component.enabled !== false,\n            \"__prefab\": {\n                \"__id__\": componentId + 1\n            },\n            ...component.properties\n        };\n\n        // 添加组件特定的预制体信息\n        const compPrefabInfo = {\n            \"__type__\": \"cc.CompPrefabInfo\",\n            \"fileId\": this.generateFileId()\n        };\n\n        return [processedComponent, compPrefabInfo];\n    }\n\n    private generateFileId(): string {\n        // 生成文件ID（简化版本）\n        const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/';\n        let fileId = '';\n        for (let i = 0; i < 22; i++) {\n            fileId += chars[Math.floor(Math.random() * chars.length)];\n        }\n        return fileId;\n    }\n\n    private createMetaData(prefabName: string, prefabUuid: string): any {\n        return {\n            \"ver\": \"1.1.50\",\n            \"importer\": \"prefab\",\n            \"imported\": true,\n            \"uuid\": prefabUuid,\n            \"files\": [\n                \".json\"\n            ],\n            \"subMetas\": {},\n            \"userData\": {\n                \"syncNodeName\": prefabName\n            }\n        };\n    }\n\n    private async savePrefabFiles(prefabPath: string, prefabData: any[], metaData: any): Promise<{ success: boolean; error?: string }> {\n        return new Promise((resolve) => {\n            try {\n                // 使用Editor API保存预制体文件\n                const prefabContent = JSON.stringify(prefabData, null, 2);\n                const metaContent = JSON.stringify(metaData, null, 2);\n                \n                // 尝试使用更可靠的保存方法\n                this.saveAssetFile(prefabPath, prefabContent).then(() => {\n                    // 再创建meta文件\n                    const metaPath = `${prefabPath}.meta`;\n                    return this.saveAssetFile(metaPath, metaContent);\n                }).then(() => {\n                    resolve({ success: true });\n                }).catch((error: any) => {\n                    resolve({ success: false, error: error.message || '保存预制体文件失败' });\n                });\n            } catch (error) {\n                resolve({ success: false, error: `保存文件时发生错误: ${error}` });\n            }\n        });\n    }\n\n    private async saveAssetFile(filePath: string, content: string): Promise<void> {\n        return new Promise((resolve, reject) => {\n            // 尝试多种保存方法\n            const saveMethods = [\n                () => Editor.Message.request('asset-db', 'create-asset', filePath, content),\n                () => Editor.Message.request('asset-db', 'save-asset', filePath, content),\n                () => Editor.Message.request('asset-db', 'write-asset', filePath, content)\n            ];\n\n            const trySave = (index: number) => {\n                if (index >= saveMethods.length) {\n                    reject(new Error('所有保存方法都失败了'));\n                    return;\n                }\n\n                saveMethods[index]().then(() => {\n                    resolve();\n                }).catch(() => {\n                    trySave(index + 1);\n                });\n            };\n\n            trySave(0);\n        });\n    }\n\n    private async updatePrefab(prefabPath: string, nodeUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n\n                return Editor.Message.request('scene', 'apply-prefab', {\n                    node: nodeUuid,\n                    prefab: assetInfo.uuid\n                });\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Prefab updated successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async revertPrefab(nodeUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'revert-prefab', {\n                node: nodeUuid\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Prefab instance reverted successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getPrefabInfo(prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n\n                return Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n            }).then((metaInfo: any) => {\n                const info: PrefabInfo = {\n                    name: metaInfo.name,\n                    uuid: metaInfo.uuid,\n                    path: prefabPath,\n                    folder: prefabPath.substring(0, prefabPath.lastIndexOf('/')),\n                    createTime: metaInfo.createTime,\n                    modifyTime: metaInfo.modifyTime,\n                    dependencies: metaInfo.depends || []\n                };\n                resolve({ success: true, data: info });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async createPrefabFromNode(args: any): Promise<ToolResponse> {\n        // 从 prefabPath 提取名称\n        const prefabPath = args.prefabPath;\n        const prefabName = prefabPath.split('/').pop()?.replace('.prefab', '') || 'NewPrefab';\n        \n        // 调用原来的 createPrefab 方法\n        return await this.createPrefab({\n            nodeUuid: args.nodeUuid,\n            savePath: prefabPath,\n            prefabName: prefabName\n        });\n    }\n\n    private async validatePrefab(prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                // 读取预制体文件内容\n                Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                    if (!assetInfo) {\n                        resolve({\n                            success: false,\n                            error: '预制体文件不存在'\n                        });\n                        return;\n                    }\n\n                    // 验证预制体格式\n                    Editor.Message.request('asset-db', 'read-asset', prefabPath).then((content: string) => {\n                        try {\n                            const prefabData = JSON.parse(content);\n                            const validationResult = this.validatePrefabFormat(prefabData);\n                            \n                            resolve({\n                                success: true,\n                                data: {\n                                    isValid: validationResult.isValid,\n                                    issues: validationResult.issues,\n                                    nodeCount: validationResult.nodeCount,\n                                    componentCount: validationResult.componentCount,\n                                    message: validationResult.isValid ? '预制体格式有效' : '预制体格式存在问题'\n                                }\n                            });\n                        } catch (parseError) {\n                            resolve({\n                                success: false,\n                                error: '预制体文件格式错误，无法解析JSON'\n                            });\n                        }\n                    }).catch((error: any) => {\n                        resolve({\n                            success: false,\n                            error: `读取预制体文件失败: ${error.message}`\n                        });\n                    });\n                }).catch((error: any) => {\n                    resolve({\n                        success: false,\n                        error: `查询预制体信息失败: ${error.message}`\n                    });\n                });\n            } catch (error) {\n                resolve({\n                    success: false,\n                    error: `验证预制体时发生错误: ${error}`\n                });\n            }\n        });\n    }\n\n    private validatePrefabFormat(prefabData: any): { isValid: boolean; issues: string[]; nodeCount: number; componentCount: number } {\n        const issues: string[] = [];\n        let nodeCount = 0;\n        let componentCount = 0;\n\n        // 检查基本结构\n        if (!Array.isArray(prefabData)) {\n            issues.push('预制体数据必须是数组格式');\n            return { isValid: false, issues, nodeCount, componentCount };\n        }\n\n        if (prefabData.length === 0) {\n            issues.push('预制体数据为空');\n            return { isValid: false, issues, nodeCount, componentCount };\n        }\n\n        // 检查第一个元素是否为预制体资产\n        const firstElement = prefabData[0];\n        if (!firstElement || firstElement.__type__ !== 'cc.Prefab') {\n            issues.push('第一个元素必须是cc.Prefab类型');\n        }\n\n        // 统计节点和组件\n        prefabData.forEach((item: any, index: number) => {\n            if (item.__type__ === 'cc.Node') {\n                nodeCount++;\n            } else if (item.__type__ && item.__type__.includes('cc.')) {\n                componentCount++;\n            }\n        });\n\n        // 检查必要的字段\n        if (nodeCount === 0) {\n            issues.push('预制体必须包含至少一个节点');\n        }\n\n        return {\n            isValid: issues.length === 0,\n            issues,\n            nodeCount,\n            componentCount\n        };\n    }\n\n    private async duplicatePrefab(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            try {\n                const { sourcePrefabPath, targetPrefabPath, newPrefabName } = args;\n                \n                // 读取源预制体\n                const sourceInfo = await this.getPrefabInfo(sourcePrefabPath);\n                if (!sourceInfo.success) {\n                    resolve({\n                        success: false,\n                        error: `无法读取源预制体: ${sourceInfo.error}`\n                    });\n                    return;\n                }\n\n                // 读取源预制体内容\n                const sourceContent = await this.readPrefabContent(sourcePrefabPath);\n                if (!sourceContent.success) {\n                    resolve({\n                        success: false,\n                        error: `无法读取源预制体内容: ${sourceContent.error}`\n                    });\n                    return;\n                }\n\n                // 生成新的UUID\n                const newUuid = this.generateUUID();\n                \n                // 修改预制体数据\n                const modifiedData = this.modifyPrefabForDuplication(sourceContent.data, newPrefabName, newUuid);\n                \n                // 创建新的meta数据\n                const newMetaData = this.createMetaData(newPrefabName || 'DuplicatedPrefab', newUuid);\n                \n                // 预制体复制功能暂时禁用，因为涉及复杂的序列化格式\n                resolve({\n                    success: false,\n                    error: '预制体复制功能暂时不可用',\n                    instruction: '请在 Cocos Creator 编辑器中手动复制预制体：\\n1. 在资源管理器中选择要复制的预制体\\n2. 右键选择复制\\n3. 在目标位置粘贴'\n                });\n\n            } catch (error) {\n                resolve({\n                    success: false,\n                    error: `复制预制体时发生错误: ${error}`\n                });\n            }\n        });\n    }\n\n    private async readPrefabContent(prefabPath: string): Promise<{ success: boolean; data?: any; error?: string }> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'read-asset', prefabPath).then((content: string) => {\n                try {\n                    const prefabData = JSON.parse(content);\n                    resolve({ success: true, data: prefabData });\n                } catch (parseError) {\n                    resolve({ success: false, error: '预制体文件格式错误' });\n                }\n            }).catch((error: any) => {\n                resolve({ success: false, error: error.message || '读取预制体文件失败' });\n            });\n        });\n    }\n\n    private modifyPrefabForDuplication(prefabData: any[], newName: string, newUuid: string): any[] {\n        // 修改预制体数据以创建副本\n        const modifiedData = [...prefabData];\n        \n        // 修改第一个元素（预制体资产）\n        if (modifiedData[0] && modifiedData[0].__type__ === 'cc.Prefab') {\n            modifiedData[0]._name = newName || 'DuplicatedPrefab';\n        }\n\n        // 更新所有UUID引用（简化版本）\n        // 在实际应用中，可能需要更复杂的UUID映射处理\n        \n        return modifiedData;\n    }\n\n    /**\n     * 使用 asset-db API 创建资源文件\n     */\n    private async createAssetWithAssetDB(assetPath: string, content: string): Promise<{ success: boolean; data?: any; error?: string }> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'create-asset', assetPath, content, {\n                overwrite: true,\n                rename: false\n            }).then((assetInfo: any) => {\n                console.log('创建资源文件成功:', assetInfo);\n                resolve({ success: true, data: assetInfo });\n            }).catch((error: any) => {\n                console.error('创建资源文件失败:', error);\n                resolve({ success: false, error: error.message || '创建资源文件失败' });\n            });\n        });\n    }\n\n    /**\n     * 使用 asset-db API 创建 meta 文件\n     */\n    private async createMetaWithAssetDB(assetPath: string, metaContent: any): Promise<{ success: boolean; data?: any; error?: string }> {\n        return new Promise((resolve) => {\n            const metaContentString = JSON.stringify(metaContent, null, 2);\n            Editor.Message.request('asset-db', 'save-asset-meta', assetPath, metaContentString).then((assetInfo: any) => {\n                console.log('创建meta文件成功:', assetInfo);\n                resolve({ success: true, data: assetInfo });\n            }).catch((error: any) => {\n                console.error('创建meta文件失败:', error);\n                resolve({ success: false, error: error.message || '创建meta文件失败' });\n            });\n        });\n    }\n\n    /**\n     * 使用 asset-db API 重新导入资源\n     */\n    private async reimportAssetWithAssetDB(assetPath: string): Promise<{ success: boolean; data?: any; error?: string }> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'reimport-asset', assetPath).then((result: any) => {\n                console.log('重新导入资源成功:', result);\n                resolve({ success: true, data: result });\n            }).catch((error: any) => {\n                console.error('重新导入资源失败:', error);\n                resolve({ success: false, error: error.message || '重新导入资源失败' });\n            });\n        });\n    }\n\n    /**\n     * 使用 asset-db API 更新资源文件内容\n     */\n    private async updateAssetWithAssetDB(assetPath: string, content: string): Promise<{ success: boolean; data?: any; error?: string }> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'save-asset', assetPath, content).then((result: any) => {\n                console.log('更新资源文件成功:', result);\n                resolve({ success: true, data: result });\n            }).catch((error: any) => {\n                console.error('更新资源文件失败:', error);\n                resolve({ success: false, error: error.message || '更新资源文件失败' });\n            });\n        });\n    }\n\n    /**\n     * 创建符合 Cocos Creator 标准的预制体内容\n     * 完整实现递归节点树处理，匹配引擎标准格式\n     */\n    private async createStandardPrefabContent(nodeData: any, prefabName: string, prefabUuid: string, includeChildren: boolean, includeComponents: boolean): Promise<any[]> {\n        console.log('开始创建引擎标准预制体内容...');\n        \n        const prefabData: any[] = [];\n        let currentId = 0;\n\n        // 1. 创建预制体资产对象 (index 0)\n        const prefabAsset = {\n            \"__type__\": \"cc.Prefab\",\n            \"_name\": prefabName || \"\", // 确保预制体名称不为空\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"_native\": \"\",\n            \"data\": {\n                \"__id__\": 1\n            },\n            \"optimizationPolicy\": 0,\n            \"persistent\": false\n        };\n        prefabData.push(prefabAsset);\n        currentId++;\n\n        // 2. 递归创建完整的节点树结构\n        const context = {\n            prefabData,\n            currentId: currentId + 1, // 根节点占用索引1，子节点从索引2开始\n            prefabAssetIndex: 0,\n            nodeFileIds: new Map<string, string>(), // 存储节点ID到fileId的映射\n            nodeUuidToIndex: new Map<string, number>(), // 存储节点UUID到索引的映射\n            componentUuidToIndex: new Map<string, number>() // 存储组件UUID到索引的映射\n        };\n\n        // 创建根节点和整个节点树 - 注意：根节点的父节点应该是null，不是预制体对象\n        await this.createCompleteNodeTree(nodeData, null, 1, context, includeChildren, includeComponents, prefabName);\n\n        console.log(`预制体内容创建完成，总共 ${prefabData.length} 个对象`);\n        console.log('节点fileId映射:', Array.from(context.nodeFileIds.entries()));\n        \n        return prefabData;\n    }\n\n    /**\n     * 递归创建完整的节点树，包括所有子节点和对应的PrefabInfo\n     */\n    private async createCompleteNodeTree(\n        nodeData: any, \n        parentNodeIndex: number | null, \n        nodeIndex: number,\n        context: { \n            prefabData: any[], \n            currentId: number, \n            prefabAssetIndex: number, \n            nodeFileIds: Map<string, string>,\n            nodeUuidToIndex: Map<string, number>,\n            componentUuidToIndex: Map<string, number>\n        },\n        includeChildren: boolean,\n        includeComponents: boolean,\n        nodeName?: string\n    ): Promise<void> {\n        const { prefabData } = context;\n        \n        // 创建节点对象\n        const node = this.createEngineStandardNode(nodeData, parentNodeIndex, nodeName);\n        \n        // 确保节点在指定的索引位置\n        while (prefabData.length <= nodeIndex) {\n            prefabData.push(null);\n        }\n        console.log(`设置节点到索引 ${nodeIndex}: ${node._name}, _parent:`, node._parent, `_children count: ${node._children.length}`);\n        prefabData[nodeIndex] = node;\n        \n        // 为当前节点生成fileId并记录UUID到索引的映射\n        const nodeUuid = this.extractNodeUuid(nodeData);\n        const fileId = nodeUuid || this.generateFileId();\n        context.nodeFileIds.set(nodeIndex.toString(), fileId);\n        \n        // 记录节点UUID到索引的映射\n        if (nodeUuid) {\n            context.nodeUuidToIndex.set(nodeUuid, nodeIndex);\n            console.log(`记录节点UUID映射: ${nodeUuid} -> ${nodeIndex}`);\n        }\n\n        // 先处理子节点（保持与手动创建的索引顺序一致）\n        const childrenToProcess = this.getChildrenToProcess(nodeData);\n        if (includeChildren && childrenToProcess.length > 0) {\n            console.log(`处理节点 ${node._name} 的 ${childrenToProcess.length} 个子节点`);\n            \n            // 为每个子节点分配索引\n            const childIndices: number[] = [];\n            console.log(`准备为 ${childrenToProcess.length} 个子节点分配索引，当前ID: ${context.currentId}`);\n            for (let i = 0; i < childrenToProcess.length; i++) {\n                console.log(`处理第 ${i+1} 个子节点，当前currentId: ${context.currentId}`);\n                const childIndex = context.currentId++;\n                childIndices.push(childIndex);\n                node._children.push({ \"__id__\": childIndex });\n                console.log(`✅ 添加子节点引用到 ${node._name}: {__id__: ${childIndex}}`);\n            }\n            console.log(`✅ 节点 ${node._name} 最终的子节点数组:`, node._children);\n\n            // 递归创建子节点\n            for (let i = 0; i < childrenToProcess.length; i++) {\n                const childData = childrenToProcess[i];\n                const childIndex = childIndices[i];\n                await this.createCompleteNodeTree(\n                    childData, \n                    nodeIndex, \n                    childIndex, \n                    context,\n                    includeChildren,\n                    includeComponents,\n                    childData.name || `Child${i+1}`\n                );\n            }\n        }\n\n        // 然后处理组件\n        if (includeComponents && nodeData.components && Array.isArray(nodeData.components)) {\n            console.log(`处理节点 ${node._name} 的 ${nodeData.components.length} 个组件`);\n            \n            const componentIndices: number[] = [];\n            for (const component of nodeData.components) {\n                const componentIndex = context.currentId++;\n                componentIndices.push(componentIndex);\n                node._components.push({ \"__id__\": componentIndex });\n                \n                // 记录组件UUID到索引的映射\n                const componentUuid = component.uuid || (component.value && component.value.uuid);\n                if (componentUuid) {\n                    context.componentUuidToIndex.set(componentUuid, componentIndex);\n                    console.log(`记录组件UUID映射: ${componentUuid} -> ${componentIndex}`);\n                }\n                \n                // 创建组件对象，传入context以处理引用\n                const componentObj = this.createComponentObject(component, nodeIndex, context);\n                prefabData[componentIndex] = componentObj;\n                \n                // 为组件创建 CompPrefabInfo\n                const compPrefabInfoIndex = context.currentId++;\n                prefabData[compPrefabInfoIndex] = {\n                    \"__type__\": \"cc.CompPrefabInfo\",\n                    \"fileId\": this.generateFileId()\n                };\n                \n                // 如果组件对象有 __prefab 属性，设置引用\n                if (componentObj && typeof componentObj === 'object') {\n                    componentObj.__prefab = { \"__id__\": compPrefabInfoIndex };\n                }\n            }\n            \n            console.log(`✅ 节点 ${node._name} 添加了 ${componentIndices.length} 个组件`);\n        }\n\n\n        // 为当前节点创建PrefabInfo\n        const prefabInfoIndex = context.currentId++;\n        node._prefab = { \"__id__\": prefabInfoIndex };\n        \n        const prefabInfo: any = {\n            \"__type__\": \"cc.PrefabInfo\",\n            \"root\": { \"__id__\": 1 },\n            \"asset\": { \"__id__\": context.prefabAssetIndex },\n            \"fileId\": fileId,\n            \"targetOverrides\": null,\n            \"nestedPrefabInstanceRoots\": null\n        };\n        \n        // 根节点的特殊处理\n        if (nodeIndex === 1) {\n            // 根节点没有instance，但可能有targetOverrides\n            prefabInfo.instance = null;\n        } else {\n            // 子节点通常有instance为null\n            prefabInfo.instance = null;\n        }\n        \n        prefabData[prefabInfoIndex] = prefabInfo;\n        context.currentId = prefabInfoIndex + 1;\n    }\n\n    /**\n     * 将UUID转换为Cocos Creator的压缩格式\n     * 基于真实Cocos Creator编辑器的压缩算法实现\n     * 前5个hex字符保持不变，剩余27个字符压缩成18个字符\n     */\n    private uuidToCompressedId(uuid: string): string {\n        const BASE64_KEYS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n        \n        // 移除连字符并转为小写\n        const cleanUuid = uuid.replace(/-/g, '').toLowerCase();\n        \n        // 确保UUID有效\n        if (cleanUuid.length !== 32) {\n            return uuid; // 如果不是有效的UUID，返回原始值\n        }\n        \n        // Cocos Creator的压缩算法：前5个字符保持不变，剩余27个字符压缩成18个字符\n        let result = cleanUuid.substring(0, 5);\n        \n        // 剩余27个字符需要压缩成18个字符\n        const remainder = cleanUuid.substring(5);\n        \n        // 每3个hex字符压缩成2个字符\n        for (let i = 0; i < remainder.length; i += 3) {\n            const hex1 = remainder[i] || '0';\n            const hex2 = remainder[i + 1] || '0';\n            const hex3 = remainder[i + 2] || '0';\n            \n            // 将3个hex字符(12位)转换为2个base64字符\n            const value = parseInt(hex1 + hex2 + hex3, 16);\n            \n            // 12位分成两个6位\n            const high6 = (value >> 6) & 63;\n            const low6 = value & 63;\n            \n            result += BASE64_KEYS[high6] + BASE64_KEYS[low6];\n        }\n        \n        return result;\n    }\n\n    /**\n     * 创建组件对象\n     */\n    private createComponentObject(componentData: any, nodeIndex: number, context?: { \n        nodeUuidToIndex?: Map<string, number>,\n        componentUuidToIndex?: Map<string, number>\n    }): any {\n        let componentType = componentData.type || componentData.__type__ || 'cc.Component';\n        const enabled = componentData.enabled !== undefined ? componentData.enabled : true;\n        \n        // console.log(`创建组件对象 - 原始类型: ${componentType}`);\n        // console.log('组件完整数据:', JSON.stringify(componentData, null, 2));\n        \n        // 处理脚本组件 - MCP接口已经返回正确的压缩UUID格式\n        if (componentType && !componentType.startsWith('cc.')) {\n            console.log(`使用脚本组件压缩UUID类型: ${componentType}`);\n        }\n        \n        // 基础组件结构\n        const component: any = {\n            \"__type__\": componentType,\n            \"_name\": \"\",\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"node\": { \"__id__\": nodeIndex },\n            \"_enabled\": enabled\n        };\n        \n        // 提前设置 __prefab 属性占位符，后续会被正确设置\n        component.__prefab = null;\n        \n        // 根据组件类型添加特定属性\n        if (componentType === 'cc.UITransform') {\n            const contentSize = componentData.properties?.contentSize?.value || { width: 100, height: 100 };\n            const anchorPoint = componentData.properties?.anchorPoint?.value || { x: 0.5, y: 0.5 };\n            \n            component._contentSize = {\n                \"__type__\": \"cc.Size\",\n                \"width\": contentSize.width,\n                \"height\": contentSize.height\n            };\n            component._anchorPoint = {\n                \"__type__\": \"cc.Vec2\",\n                \"x\": anchorPoint.x,\n                \"y\": anchorPoint.y\n            };\n        } else if (componentType === 'cc.Sprite') {\n            // 处理Sprite组件的spriteFrame引用\n            const spriteFrameProp = componentData.properties?._spriteFrame || componentData.properties?.spriteFrame;\n            if (spriteFrameProp) {\n                component._spriteFrame = this.processComponentProperty(spriteFrameProp, context);\n            } else {\n                component._spriteFrame = null;\n            }\n            \n            component._type = componentData.properties?._type?.value ?? 0;\n            component._fillType = componentData.properties?._fillType?.value ?? 0;\n            component._sizeMode = componentData.properties?._sizeMode?.value ?? 1;\n            component._fillCenter = { \"__type__\": \"cc.Vec2\", \"x\": 0, \"y\": 0 };\n            component._fillStart = componentData.properties?._fillStart?.value ?? 0;\n            component._fillRange = componentData.properties?._fillRange?.value ?? 0;\n            component._isTrimmedMode = componentData.properties?._isTrimmedMode?.value ?? true;\n            component._useGrayscale = componentData.properties?._useGrayscale?.value ?? false;\n            \n            // 调试：打印Sprite组件的所有属性（已注释）\n            // console.log('Sprite组件属性:', JSON.stringify(componentData.properties, null, 2));\n            component._atlas = null;\n            component._id = \"\";\n        } else if (componentType === 'cc.Button') {\n            component._interactable = true;\n            component._transition = 3;\n            component._normalColor = { \"__type__\": \"cc.Color\", \"r\": 255, \"g\": 255, \"b\": 255, \"a\": 255 };\n            component._hoverColor = { \"__type__\": \"cc.Color\", \"r\": 211, \"g\": 211, \"b\": 211, \"a\": 255 };\n            component._pressedColor = { \"__type__\": \"cc.Color\", \"r\": 255, \"g\": 255, \"b\": 255, \"a\": 255 };\n            component._disabledColor = { \"__type__\": \"cc.Color\", \"r\": 124, \"g\": 124, \"b\": 124, \"a\": 255 };\n            component._normalSprite = null;\n            component._hoverSprite = null;\n            component._pressedSprite = null;\n            component._disabledSprite = null;\n            component._duration = 0.1;\n            component._zoomScale = 1.2;\n            // 处理Button的target引用\n            const targetProp = componentData.properties?._target || componentData.properties?.target;\n            if (targetProp) {\n                component._target = this.processComponentProperty(targetProp, context);\n            } else {\n                component._target = { \"__id__\": nodeIndex }; // 默认指向自身节点\n            }\n            component._clickEvents = [];\n            component._id = \"\";\n        } else if (componentType === 'cc.Label') {\n            component._string = componentData.properties?._string?.value || \"Label\";\n            component._horizontalAlign = 1;\n            component._verticalAlign = 1;\n            component._actualFontSize = 20;\n            component._fontSize = 20;\n            component._fontFamily = \"Arial\";\n            component._lineHeight = 25;\n            component._overflow = 0;\n            component._enableWrapText = true;\n            component._font = null;\n            component._isSystemFontUsed = true;\n            component._spacingX = 0;\n            component._isItalic = false;\n            component._isBold = false;\n            component._isUnderline = false;\n            component._underlineHeight = 2;\n            component._cacheMode = 0;\n            component._id = \"\";\n        } else if (componentData.properties) {\n            // 处理所有组件的属性（包括内置组件和自定义脚本组件）\n            for (const [key, value] of Object.entries(componentData.properties)) {\n                if (key === 'node' || key === 'enabled' || key === '__type__' || \n                    key === 'uuid' || key === 'name' || key === '__scriptAsset' || key === '_objFlags') {\n                    continue; // 跳过这些特殊属性，包括_objFlags\n                }\n                \n                // 对于以下划线开头的属性，需要特殊处理\n                if (key.startsWith('_')) {\n                    // 确保属性名保持原样（包括下划线）\n                    const propValue = this.processComponentProperty(value, context);\n                    if (propValue !== undefined) {\n                        component[key] = propValue;\n                    }\n                } else {\n                    // 非下划线开头的属性正常处理\n                    const propValue = this.processComponentProperty(value, context);\n                    if (propValue !== undefined) {\n                        component[key] = propValue;\n                    }\n                }\n            }\n        }\n        \n        // 确保 _id 在最后位置\n        const _id = component._id || \"\";\n        delete component._id;\n        component._id = _id;\n        \n        return component;\n    }\n\n    /**\n     * 处理组件属性值，确保格式与手动创建的预制体一致\n     */\n    private processComponentProperty(propData: any, context?: { \n        nodeUuidToIndex?: Map<string, number>,\n        componentUuidToIndex?: Map<string, number>\n    }): any {\n        if (!propData || typeof propData !== 'object') {\n            return propData;\n        }\n\n        const value = propData.value;\n        const type = propData.type;\n\n        // 处理null值\n        if (value === null || value === undefined) {\n            return null;\n        }\n\n        // 处理空UUID对象，转换为null\n        if (value && typeof value === 'object' && value.uuid === '') {\n            return null;\n        }\n\n        // 处理节点引用\n        if (type === 'cc.Node' && value?.uuid) {\n            // 在预制体中，节点引用需要转换为 __id__ 形式\n            if (context?.nodeUuidToIndex && context.nodeUuidToIndex.has(value.uuid)) {\n                // 内部引用：转换为__id__格式\n                return {\n                    \"__id__\": context.nodeUuidToIndex.get(value.uuid)\n                };\n            }\n            // 外部引用：设置为null，因为外部节点不属于预制体结构\n            console.warn(`Node reference UUID ${value.uuid} not found in prefab context, setting to null (external reference)`);\n            return null;\n        }\n\n        // 处理资源引用（预制体、纹理、精灵帧等）\n        if (value?.uuid && (\n            type === 'cc.Prefab' || \n            type === 'cc.Texture2D' || \n            type === 'cc.SpriteFrame' ||\n            type === 'cc.Material' ||\n            type === 'cc.AnimationClip' ||\n            type === 'cc.AudioClip' ||\n            type === 'cc.Font' ||\n            type === 'cc.Asset'\n        )) {\n            // 对于预制体引用，保持原始UUID格式\n            const uuidToUse = type === 'cc.Prefab' ? value.uuid : this.uuidToCompressedId(value.uuid);\n            return {\n                \"__uuid__\": uuidToUse,\n                \"__expectedType__\": type\n            };\n        }\n\n        // 处理组件引用（包括具体的组件类型如cc.Label, cc.Button等）\n        if (value?.uuid && (type === 'cc.Component' || \n            type === 'cc.Label' || type === 'cc.Button' || type === 'cc.Sprite' || \n            type === 'cc.UITransform' || type === 'cc.RigidBody2D' || \n            type === 'cc.BoxCollider2D' || type === 'cc.Animation' || \n            type === 'cc.AudioSource' || (type?.startsWith('cc.') && !type.includes('@')))) {\n            // 在预制体中，组件引用也需要转换为 __id__ 形式\n            if (context?.componentUuidToIndex && context.componentUuidToIndex.has(value.uuid)) {\n                // 内部引用：转换为__id__格式\n                console.log(`Component reference ${type} UUID ${value.uuid} found in prefab context, converting to __id__`);\n                return {\n                    \"__id__\": context.componentUuidToIndex.get(value.uuid)\n                };\n            }\n            // 外部引用：设置为null，因为外部组件不属于预制体结构\n            console.warn(`Component reference ${type} UUID ${value.uuid} not found in prefab context, setting to null (external reference)`);\n            return null;\n        }\n\n        // 处理复杂类型，添加__type__标记\n        if (value && typeof value === 'object') {\n            if (type === 'cc.Color') {\n                return {\n                    \"__type__\": \"cc.Color\",\n                    \"r\": Math.min(255, Math.max(0, Number(value.r) || 0)),\n                    \"g\": Math.min(255, Math.max(0, Number(value.g) || 0)),\n                    \"b\": Math.min(255, Math.max(0, Number(value.b) || 0)),\n                    \"a\": value.a !== undefined ? Math.min(255, Math.max(0, Number(value.a))) : 255\n                };\n            } else if (type === 'cc.Vec3') {\n                return {\n                    \"__type__\": \"cc.Vec3\",\n                    \"x\": Number(value.x) || 0,\n                    \"y\": Number(value.y) || 0,\n                    \"z\": Number(value.z) || 0\n                };\n            } else if (type === 'cc.Vec2') {\n                return {\n                    \"__type__\": \"cc.Vec2\", \n                    \"x\": Number(value.x) || 0,\n                    \"y\": Number(value.y) || 0\n                };\n            } else if (type === 'cc.Size') {\n                return {\n                    \"__type__\": \"cc.Size\",\n                    \"width\": Number(value.width) || 0,\n                    \"height\": Number(value.height) || 0\n                };\n            } else if (type === 'cc.Quat') {\n                return {\n                    \"__type__\": \"cc.Quat\",\n                    \"x\": Number(value.x) || 0,\n                    \"y\": Number(value.y) || 0,\n                    \"z\": Number(value.z) || 0,\n                    \"w\": value.w !== undefined ? Number(value.w) : 1\n                };\n            }\n        }\n\n        // 处理数组类型\n        if (Array.isArray(value)) {\n            // 节点数组\n            if (propData.elementTypeData?.type === 'cc.Node') {\n                return value.map(item => {\n                    if (item?.uuid && context?.nodeUuidToIndex?.has(item.uuid)) {\n                        return { \"__id__\": context.nodeUuidToIndex.get(item.uuid) };\n                    }\n                    return null;\n                }).filter(item => item !== null);\n            }\n            \n            // 资源数组\n            if (propData.elementTypeData?.type && propData.elementTypeData.type.startsWith('cc.')) {\n                return value.map(item => {\n                    if (item?.uuid) {\n                        return {\n                            \"__uuid__\": this.uuidToCompressedId(item.uuid),\n                            \"__expectedType__\": propData.elementTypeData.type\n                        };\n                    }\n                    return null;\n                }).filter(item => item !== null);\n            }\n\n            // 基础类型数组\n            return value.map(item => item?.value !== undefined ? item.value : item);\n        }\n\n        // 其他复杂对象类型，保持原样但确保有__type__标记\n        if (value && typeof value === 'object' && type && type.startsWith('cc.')) {\n            return {\n                \"__type__\": type,\n                ...value\n            };\n        }\n\n        return value;\n    }\n\n    /**\n     * 创建符合引擎标准的节点对象\n     */\n    private createEngineStandardNode(nodeData: any, parentNodeIndex: number | null, nodeName?: string): any {\n        // 调试：打印原始节点数据（已注释）\n        // console.log('原始节点数据:', JSON.stringify(nodeData, null, 2));\n        \n        // 提取节点的基本属性\n        const getValue = (prop: any) => {\n            if (prop?.value !== undefined) return prop.value;\n            if (prop !== undefined) return prop;\n            return null;\n        };\n        \n        const position = getValue(nodeData.position) || getValue(nodeData.value?.position) || { x: 0, y: 0, z: 0 };\n        const rotation = getValue(nodeData.rotation) || getValue(nodeData.value?.rotation) || { x: 0, y: 0, z: 0, w: 1 };\n        const scale = getValue(nodeData.scale) || getValue(nodeData.value?.scale) || { x: 1, y: 1, z: 1 };\n        const active = getValue(nodeData.active) ?? getValue(nodeData.value?.active) ?? true;\n        const name = nodeName || getValue(nodeData.name) || getValue(nodeData.value?.name) || 'Node';\n        const layer = getValue(nodeData.layer) || getValue(nodeData.value?.layer) || 1073741824;\n\n        // 调试输出\n        console.log(`创建节点: ${name}, parentNodeIndex: ${parentNodeIndex}`);\n\n        const parentRef = parentNodeIndex !== null ? { \"__id__\": parentNodeIndex } : null;\n        console.log(`节点 ${name} 的父节点引用:`, parentRef);\n\n        return {\n            \"__type__\": \"cc.Node\",\n            \"_name\": name,\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"_parent\": parentRef,\n            \"_children\": [], // 子节点引用将在递归过程中动态添加\n            \"_active\": active,\n            \"_components\": [], // 组件引用将在处理组件时动态添加\n            \"_prefab\": { \"__id__\": 0 }, // 临时值，后续会被正确设置\n            \"_lpos\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": position.x,\n                \"y\": position.y,\n                \"z\": position.z\n            },\n            \"_lrot\": {\n                \"__type__\": \"cc.Quat\",\n                \"x\": rotation.x,\n                \"y\": rotation.y,\n                \"z\": rotation.z,\n                \"w\": rotation.w\n            },\n            \"_lscale\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": scale.x,\n                \"y\": scale.y,\n                \"z\": scale.z\n            },\n            \"_mobility\": 0,\n            \"_layer\": layer,\n            \"_euler\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": 0,\n                \"y\": 0,\n                \"z\": 0\n            },\n            \"_id\": \"\"\n        };\n    }\n\n    /**\n     * 从节点数据中提取UUID\n     */\n    private extractNodeUuid(nodeData: any): string | null {\n        if (!nodeData) return null;\n        \n        // 尝试多种方式获取UUID\n        const sources = [\n            nodeData.uuid,\n            nodeData.value?.uuid,\n            nodeData.__uuid__,\n            nodeData.value?.__uuid__,\n            nodeData.id,\n            nodeData.value?.id\n        ];\n        \n        for (const source of sources) {\n            if (typeof source === 'string' && source.length > 0) {\n                return source;\n            }\n        }\n        \n        return null;\n    }\n\n    /**\n     * 创建最小化的节点对象，不包含任何组件以避免依赖问题\n     */\n    private createMinimalNode(nodeData: any, nodeName?: string): any {\n        // 提取节点的基本属性\n        const getValue = (prop: any) => {\n            if (prop?.value !== undefined) return prop.value;\n            if (prop !== undefined) return prop;\n            return null;\n        };\n        \n        const position = getValue(nodeData.position) || getValue(nodeData.value?.position) || { x: 0, y: 0, z: 0 };\n        const rotation = getValue(nodeData.rotation) || getValue(nodeData.value?.rotation) || { x: 0, y: 0, z: 0, w: 1 };\n        const scale = getValue(nodeData.scale) || getValue(nodeData.value?.scale) || { x: 1, y: 1, z: 1 };\n        const active = getValue(nodeData.active) ?? getValue(nodeData.value?.active) ?? true;\n        const name = nodeName || getValue(nodeData.name) || getValue(nodeData.value?.name) || 'Node';\n        const layer = getValue(nodeData.layer) || getValue(nodeData.value?.layer) || 33554432;\n\n        return {\n            \"__type__\": \"cc.Node\",\n            \"_name\": name,\n            \"_objFlags\": 0,\n            \"_parent\": null,\n            \"_children\": [],\n            \"_active\": active,\n            \"_components\": [], // 空的组件数组，避免组件依赖问题\n            \"_prefab\": {\n                \"__id__\": 2\n            },\n            \"_lpos\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": position.x,\n                \"y\": position.y,\n                \"z\": position.z\n            },\n            \"_lrot\": {\n                \"__type__\": \"cc.Quat\",\n                \"x\": rotation.x,\n                \"y\": rotation.y,\n                \"z\": rotation.z,\n                \"w\": rotation.w\n            },\n            \"_lscale\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": scale.x,\n                \"y\": scale.y,\n                \"z\": scale.z\n            },\n            \"_layer\": layer,\n            \"_euler\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": 0,\n                \"y\": 0,\n                \"z\": 0\n            },\n            \"_id\": \"\"\n        };\n    }\n\n    /**\n     * 创建标准的 meta 文件内容\n     */\n    private createStandardMetaContent(prefabName: string, prefabUuid: string): any {\n        return {\n            \"ver\": \"2.0.3\",\n            \"importer\": \"prefab\",\n            \"imported\": true,\n            \"uuid\": prefabUuid,\n            \"files\": [\n                \".json\"\n            ],\n            \"subMetas\": {},\n            \"userData\": {\n                \"syncNodeName\": prefabName,\n                \"hasIcon\": false\n            }\n        };\n    }\n\n    /**\n     * 尝试将原始节点转换为预制体实例\n     */\n    private async convertNodeToPrefabInstance(nodeUuid: string, prefabUuid: string, prefabPath: string): Promise<{ success: boolean; error?: string }> {\n        return new Promise((resolve) => {\n            // 这个功能需要深入的场景编辑器集成，暂时返回失败\n            // 在实际的引擎中，这涉及到复杂的预制体实例化和节点替换逻辑\n            console.log('节点转换为预制体实例的功能需要更深入的引擎集成');\n            resolve({\n                success: false,\n                error: '节点转换为预制体实例需要更深入的引擎集成支持'\n            });\n        });\n    }\n\n    private async restorePrefabNode(nodeUuid: string, assetUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 使用官方API restore-prefab 还原预制体节点\n            (Editor.Message.request as any)('scene', 'restore-prefab', nodeUuid, assetUuid).then(() => {\n                resolve({\n                    success: true,\n                    data: {\n                        nodeUuid: nodeUuid,\n                        assetUuid: assetUuid,\n                        message: '预制体节点还原成功'\n                    }\n                });\n            }).catch((error: any) => {\n                resolve({\n                    success: false,\n                    error: `预制体节点还原失败: ${error.message}`\n                });\n            });\n        });\n    }\n\n    // 基于官方预制体格式的新实现方法\n    private async getNodeDataForPrefab(nodeUuid: string): Promise<{ success: boolean; data?: any; error?: string }> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => {\n                if (!nodeData) {\n                    resolve({ success: false, error: '节点不存在' });\n                    return;\n                }\n                resolve({ success: true, data: nodeData });\n            }).catch((error: any) => {\n                resolve({ success: false, error: error.message });\n            });\n        });\n    }\n\n    private async createStandardPrefabData(nodeData: any, prefabName: string, prefabUuid: string): Promise<any[]> {\n        // 基于官方Canvas.prefab格式创建预制体数据结构\n        const prefabData: any[] = [];\n        let currentId = 0;\n\n        // 第一个元素：cc.Prefab 资源对象\n        const prefabAsset = {\n            \"__type__\": \"cc.Prefab\",\n            \"_name\": prefabName,\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"_native\": \"\",\n            \"data\": {\n                \"__id__\": 1\n            },\n            \"optimizationPolicy\": 0,\n            \"persistent\": false\n        };\n        prefabData.push(prefabAsset);\n        currentId++;\n\n        // 第二个元素：根节点\n        const rootNode = await this.createNodeObject(nodeData, null, prefabData, currentId);\n        prefabData.push(rootNode.node);\n        currentId = rootNode.nextId;\n\n        // 添加根节点的 PrefabInfo - 修复asset引用使用UUID\n        const rootPrefabInfo = {\n            \"__type__\": \"cc.PrefabInfo\",\n            \"root\": {\n                \"__id__\": 1\n            },\n            \"asset\": {\n                \"__uuid__\": prefabUuid\n            },\n            \"fileId\": this.generateFileId(),\n            \"instance\": null,\n            \"targetOverrides\": [],\n            \"nestedPrefabInstanceRoots\": []\n        };\n        prefabData.push(rootPrefabInfo);\n\n        return prefabData;\n    }\n\n\n    private async createNodeObject(nodeData: any, parentId: number | null, prefabData: any[], currentId: number): Promise<{ node: any; nextId: number }> {\n        const nodeId = currentId++;\n        \n        // 提取节点的基本属性 - 适配query-node-tree的数据格式\n        const getValue = (prop: any) => {\n            if (prop?.value !== undefined) return prop.value;\n            if (prop !== undefined) return prop;\n            return null;\n        };\n        \n        const position = getValue(nodeData.position) || getValue(nodeData.value?.position) || { x: 0, y: 0, z: 0 };\n        const rotation = getValue(nodeData.rotation) || getValue(nodeData.value?.rotation) || { x: 0, y: 0, z: 0, w: 1 };\n        const scale = getValue(nodeData.scale) || getValue(nodeData.value?.scale) || { x: 1, y: 1, z: 1 };\n        const active = getValue(nodeData.active) ?? getValue(nodeData.value?.active) ?? true;\n        const name = getValue(nodeData.name) || getValue(nodeData.value?.name) || 'Node';\n        const layer = getValue(nodeData.layer) || getValue(nodeData.value?.layer) || 33554432;\n\n        const node: any = {\n            \"__type__\": \"cc.Node\",\n            \"_name\": name,\n            \"_objFlags\": 0,\n            \"__editorExtras__\": {},\n            \"_parent\": parentId !== null ? { \"__id__\": parentId } : null,\n            \"_children\": [],\n            \"_active\": active,\n            \"_components\": [],\n            \"_prefab\": parentId === null ? {\n                \"__id__\": currentId++\n            } : null,\n            \"_lpos\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": position.x,\n                \"y\": position.y,\n                \"z\": position.z\n            },\n            \"_lrot\": {\n                \"__type__\": \"cc.Quat\",\n                \"x\": rotation.x,\n                \"y\": rotation.y,\n                \"z\": rotation.z,\n                \"w\": rotation.w\n            },\n            \"_lscale\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": scale.x,\n                \"y\": scale.y,\n                \"z\": scale.z\n            },\n            \"_mobility\": 0,\n            \"_layer\": layer,\n            \"_euler\": {\n                \"__type__\": \"cc.Vec3\",\n                \"x\": 0,\n                \"y\": 0,\n                \"z\": 0\n            },\n            \"_id\": \"\"\n        };\n\n        // 暂时跳过UITransform组件以避免_getDependComponent错误\n        // 后续通过Engine API动态添加\n        console.log(`节点 ${name} 暂时跳过UITransform组件，避免引擎依赖错误`);\n        \n        // 处理其他组件（暂时跳过，专注于修复UITransform问题）\n        const components = this.extractComponentsFromNode(nodeData);\n        if (components.length > 0) {\n            console.log(`节点 ${name} 包含 ${components.length} 个其他组件，暂时跳过以专注于UITransform修复`);\n        }\n\n        // 处理子节点 - 使用query-node-tree获取的完整结构\n        const childrenToProcess = this.getChildrenToProcess(nodeData);\n        if (childrenToProcess.length > 0) {\n            console.log(`=== 处理子节点 ===`);\n            console.log(`节点 ${name} 包含 ${childrenToProcess.length} 个子节点`);\n            \n            for (let i = 0; i < childrenToProcess.length; i++) {\n                const childData = childrenToProcess[i];\n                const childName = childData.name || childData.value?.name || '未知';\n                console.log(`处理第${i + 1}个子节点: ${childName}`);\n                \n                try {\n                    const childId = currentId;\n                    node._children.push({ \"__id__\": childId });\n                    \n                    // 递归创建子节点\n                    const childResult = await this.createNodeObject(childData, nodeId, prefabData, currentId);\n                    prefabData.push(childResult.node);\n                    currentId = childResult.nextId;\n                    \n                    // 子节点不需要PrefabInfo，只有根节点需要\n                    // 子节点的_prefab应该设置为null\n                    childResult.node._prefab = null;\n                    \n                    console.log(`✅ 成功添加子节点: ${childName}`);\n                } catch (error) {\n                    console.error(`处理子节点 ${childName} 时出错:`, error);\n                }\n            }\n        }\n\n        return { node, nextId: currentId };\n    }\n\n    // 从节点数据中提取组件信息\n    private extractComponentsFromNode(nodeData: any): any[] {\n        const components: any[] = [];\n        \n        // 从不同位置尝试获取组件数据\n        const componentSources = [\n            nodeData.__comps__,\n            nodeData.components,\n            nodeData.value?.__comps__,\n            nodeData.value?.components\n        ];\n        \n        for (const source of componentSources) {\n            if (Array.isArray(source)) {\n                components.push(...source.filter(comp => comp && (comp.__type__ || comp.type)));\n                break; // 找到有效的组件数组就退出\n            }\n        }\n        \n        return components;\n    }\n    \n    // 创建标准的组件对象\n    private createStandardComponentObject(componentData: any, nodeId: number, prefabInfoId: number): any {\n        const componentType = componentData.__type__ || componentData.type;\n        \n        if (!componentType) {\n            console.warn('组件缺少类型信息:', componentData);\n            return null;\n        }\n        \n        // 基础组件结构 - 基于官方预制体格式\n        const component: any = {\n            \"__type__\": componentType,\n            \"_name\": \"\",\n            \"_objFlags\": 0,\n            \"node\": {\n                \"__id__\": nodeId\n            },\n            \"_enabled\": this.getComponentPropertyValue(componentData, 'enabled', true),\n            \"__prefab\": {\n                \"__id__\": prefabInfoId\n            }\n        };\n        \n        // 根据组件类型添加特定属性\n        this.addComponentSpecificProperties(component, componentData, componentType);\n        \n        // 添加_id属性\n        component._id = \"\";\n        \n        return component;\n    }\n    \n    // 添加组件特定的属性\n    private addComponentSpecificProperties(component: any, componentData: any, componentType: string): void {\n        switch (componentType) {\n            case 'cc.UITransform':\n                this.addUITransformProperties(component, componentData);\n                break;\n            case 'cc.Sprite':\n                this.addSpriteProperties(component, componentData);\n                break;\n            case 'cc.Label':\n                this.addLabelProperties(component, componentData);\n                break;\n            case 'cc.Button':\n                this.addButtonProperties(component, componentData);\n                break;\n            default:\n                // 对于未知类型的组件，复制所有安全的属性\n                this.addGenericProperties(component, componentData);\n                break;\n        }\n    }\n    \n    // UITransform组件属性\n    private addUITransformProperties(component: any, componentData: any): void {\n        component._contentSize = this.createSizeObject(\n            this.getComponentPropertyValue(componentData, 'contentSize', { width: 100, height: 100 })\n        );\n        component._anchorPoint = this.createVec2Object(\n            this.getComponentPropertyValue(componentData, 'anchorPoint', { x: 0.5, y: 0.5 })\n        );\n    }\n    \n    // Sprite组件属性\n    private addSpriteProperties(component: any, componentData: any): void {\n        component._visFlags = 0;\n        component._customMaterial = null;\n        component._srcBlendFactor = 2;\n        component._dstBlendFactor = 4;\n        component._color = this.createColorObject(\n            this.getComponentPropertyValue(componentData, 'color', { r: 255, g: 255, b: 255, a: 255 })\n        );\n        component._spriteFrame = this.getComponentPropertyValue(componentData, 'spriteFrame', null);\n        component._type = this.getComponentPropertyValue(componentData, 'type', 0);\n        component._fillType = 0;\n        component._sizeMode = this.getComponentPropertyValue(componentData, 'sizeMode', 1);\n        component._fillCenter = this.createVec2Object({ x: 0, y: 0 });\n        component._fillStart = 0;\n        component._fillRange = 0;\n        component._isTrimmedMode = true;\n        component._useGrayscale = false;\n        component._atlas = null;\n    }\n    \n    // Label组件属性\n    private addLabelProperties(component: any, componentData: any): void {\n        component._visFlags = 0;\n        component._customMaterial = null;\n        component._srcBlendFactor = 2;\n        component._dstBlendFactor = 4;\n        component._color = this.createColorObject(\n            this.getComponentPropertyValue(componentData, 'color', { r: 0, g: 0, b: 0, a: 255 })\n        );\n        component._string = this.getComponentPropertyValue(componentData, 'string', 'Label');\n        component._horizontalAlign = 1;\n        component._verticalAlign = 1;\n        component._actualFontSize = 20;\n        component._fontSize = this.getComponentPropertyValue(componentData, 'fontSize', 20);\n        component._fontFamily = 'Arial';\n        component._lineHeight = 40;\n        component._overflow = 1;\n        component._enableWrapText = false;\n        component._font = null;\n        component._isSystemFontUsed = true;\n        component._isItalic = false;\n        component._isBold = false;\n        component._isUnderline = false;\n        component._underlineHeight = 2;\n        component._cacheMode = 0;\n    }\n    \n    // Button组件属性\n    private addButtonProperties(component: any, componentData: any): void {\n        component.clickEvents = [];\n        component._interactable = true;\n        component._transition = 2;\n        component._normalColor = this.createColorObject({ r: 214, g: 214, b: 214, a: 255 });\n        component._hoverColor = this.createColorObject({ r: 211, g: 211, b: 211, a: 255 });\n        component._pressedColor = this.createColorObject({ r: 255, g: 255, b: 255, a: 255 });\n        component._disabledColor = this.createColorObject({ r: 124, g: 124, b: 124, a: 255 });\n        component._duration = 0.1;\n        component._zoomScale = 1.2;\n    }\n    \n    // 添加通用属性\n    private addGenericProperties(component: any, componentData: any): void {\n        // 只复制安全的、已知的属性\n        const safeProperties = ['enabled', 'color', 'string', 'fontSize', 'spriteFrame', 'type', 'sizeMode'];\n        \n        for (const prop of safeProperties) {\n            if (componentData.hasOwnProperty(prop)) {\n                const value = this.getComponentPropertyValue(componentData, prop);\n                if (value !== undefined) {\n                    component[`_${prop}`] = value;\n                }\n            }\n        }\n    }\n    \n    // 创建Vec2对象\n    private createVec2Object(data: any): any {\n        return {\n            \"__type__\": \"cc.Vec2\",\n            \"x\": data?.x || 0,\n            \"y\": data?.y || 0\n        };\n    }\n    \n    // 创建Vec3对象\n    private createVec3Object(data: any): any {\n        return {\n            \"__type__\": \"cc.Vec3\",\n            \"x\": data?.x || 0,\n            \"y\": data?.y || 0,\n            \"z\": data?.z || 0\n        };\n    }\n    \n    // 创建Size对象\n    private createSizeObject(data: any): any {\n        return {\n            \"__type__\": \"cc.Size\",\n            \"width\": data?.width || 100,\n            \"height\": data?.height || 100\n        };\n    }\n    \n    // 创建Color对象\n    private createColorObject(data: any): any {\n        return {\n            \"__type__\": \"cc.Color\",\n            \"r\": data?.r ?? 255,\n            \"g\": data?.g ?? 255,\n            \"b\": data?.b ?? 255,\n            \"a\": data?.a ?? 255\n        };\n    }\n\n    // 判断是否应该复制组件属性\n    private shouldCopyComponentProperty(key: string, value: any): boolean {\n        // 跳过内部属性和已处理的属性\n        if (key.startsWith('__') || key === '_enabled' || key === 'node' || key === 'enabled') {\n            return false;\n        }\n        \n        // 跳过函数和undefined值\n        if (typeof value === 'function' || value === undefined) {\n            return false;\n        }\n        \n        return true;\n    }\n\n\n    // 获取组件属性值 - 重命名以避免冲突\n    private getComponentPropertyValue(componentData: any, propertyName: string, defaultValue?: any): any {\n        // 尝试直接获取属性\n        if (componentData[propertyName] !== undefined) {\n            return this.extractValue(componentData[propertyName]);\n        }\n        \n        // 尝试从value属性中获取\n        if (componentData.value && componentData.value[propertyName] !== undefined) {\n            return this.extractValue(componentData.value[propertyName]);\n        }\n        \n        // 尝试带下划线前缀的属性名\n        const prefixedName = `_${propertyName}`;\n        if (componentData[prefixedName] !== undefined) {\n            return this.extractValue(componentData[prefixedName]);\n        }\n        \n        return defaultValue;\n    }\n    \n    // 提取属性值\n    private extractValue(data: any): any {\n        if (data === null || data === undefined) {\n            return data;\n        }\n        \n        // 如果有value属性，优先使用value\n        if (typeof data === 'object' && data.hasOwnProperty('value')) {\n            return data.value;\n        }\n        \n        // 如果是引用对象，保持原样\n        if (typeof data === 'object' && (data.__id__ !== undefined || data.__uuid__ !== undefined)) {\n            return data;\n        }\n        \n        return data;\n    }\n\n    private createStandardMetaData(prefabName: string, prefabUuid: string): any {\n        return {\n            \"ver\": \"1.1.50\",\n            \"importer\": \"prefab\",\n            \"imported\": true,\n            \"uuid\": prefabUuid,\n            \"files\": [\n                \".json\"\n            ],\n            \"subMetas\": {},\n            \"userData\": {\n                \"syncNodeName\": prefabName\n            }\n        };\n    }\n\n    private async savePrefabWithMeta(prefabPath: string, prefabData: any[], metaData: any): Promise<{ success: boolean; error?: string }> {\n        try {\n            const prefabContent = JSON.stringify(prefabData, null, 2);\n            const metaContent = JSON.stringify(metaData, null, 2);\n\n            // 确保路径以.prefab结尾\n            const finalPrefabPath = prefabPath.endsWith('.prefab') ? prefabPath : `${prefabPath}.prefab`;\n            const metaPath = `${finalPrefabPath}.meta`;\n\n            // 使用asset-db API创建预制体文件\n            await new Promise((resolve, reject) => {\n                Editor.Message.request('asset-db', 'create-asset', finalPrefabPath, prefabContent).then(() => {\n                    resolve(true);\n                }).catch((error: any) => {\n                    reject(error);\n                });\n            });\n\n            // 创建meta文件\n            await new Promise((resolve, reject) => {\n                Editor.Message.request('asset-db', 'create-asset', metaPath, metaContent).then(() => {\n                    resolve(true);\n                }).catch((error: any) => {\n                    reject(error);\n                });\n            });\n\n            console.log(`=== 预制体保存完成 ===`);\n            console.log(`预制体文件已保存: ${finalPrefabPath}`);\n            console.log(`Meta文件已保存: ${metaPath}`);\n            console.log(`预制体数组总长度: ${prefabData.length}`);\n            console.log(`预制体根节点索引: ${prefabData.length - 1}`);\n\n            return { success: true };\n        } catch (error: any) {\n            console.error('保存预制体文件时出错:', error);\n            return { success: false, error: error.message };\n        }\n    }\n\n}"]} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 4a34f21..6898f32 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "cocos-mcp-server", - "version": "1.0.0", + "version": "1.4.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "cocos-mcp-server", - "version": "1.0.0", + "version": "1.4.0", "hasInstallScript": true, "dependencies": { "fs-extra": "^11.3.0", diff --git a/package.json b/package.json index 7a8ccaa..b025c8d 100755 --- a/package.json +++ b/package.json @@ -2,8 +2,8 @@ "$schema": "./@types/schema/package/index.json", "package_version": 2, "name": "cocos-mcp-server", - "version": "1.0.0", - "author": "Cocos Creator", + "version": "1.4.0", + "author": "LiDaxian", "editor": ">=3.8.6", "scripts": { "preinstall": "node ./scripts/preinstall.js", diff --git a/source/examples/prefab-instantiation-example.ts b/source/examples/prefab-instantiation-example.ts deleted file mode 100644 index 6f9b8fa..0000000 --- a/source/examples/prefab-instantiation-example.ts +++ /dev/null @@ -1,308 +0,0 @@ -import { PrefabTools } from '../tools/prefab-tools'; - -/** - * 预制体实例化使用示例 - * 展示如何在实际项目中使用预制体工具 - */ -export class PrefabInstantiationExample { - private prefabTools: PrefabTools; - - constructor() { - this.prefabTools = new PrefabTools(); - } - - /** - * 示例1: 基本预制体实例化 - */ - async basicInstantiationExample() { - console.log('=== 基本预制体实例化示例 ==='); - - try { - const result = await this.prefabTools.execute('instantiate_prefab', { - prefabPath: 'db://assets/prefabs/Player.prefab', - position: { x: 0, y: 0, z: 0 } - }); - - if (result.success) { - console.log('✅ 预制体实例化成功'); - console.log(`节点UUID: ${result.data.nodeUuid}`); - console.log(`节点名称: ${result.data.name}`); - console.log('使用的API: create-node with assetUuid'); - } else { - console.log('❌ 预制体实例化失败'); - console.log(`错误: ${result.error}`); - if (result.instruction) { - console.log(`建议: ${result.instruction}`); - } - } - } catch (error) { - console.error('实例化过程中发生错误:', error); - } - } - - /** - * 示例2: 在指定父节点下实例化预制体 - */ - async instantiateWithParentExample() { - console.log('=== 在父节点下实例化预制体示例 ==='); - - try { - const result = await this.prefabTools.execute('instantiate_prefab', { - prefabPath: 'db://assets/prefabs/Enemy.prefab', - parentUuid: 'canvas-uuid-here', - position: { x: 100, y: 200, z: 0 } - }); - - if (result.success) { - console.log('✅ 在父节点下实例化成功'); - console.log(`节点UUID: ${result.data.nodeUuid}`); - } else { - console.log('❌ 实例化失败'); - console.log(`错误: ${result.error}`); - } - } catch (error) { - console.error('实例化过程中发生错误:', error); - } - } - - /** - * 示例3: 批量实例化预制体 - */ - async batchInstantiationExample() { - console.log('=== 批量实例化预制体示例 ==='); - - const prefabPaths = [ - 'db://assets/prefabs/Item1.prefab', - 'db://assets/prefabs/Item2.prefab', - 'db://assets/prefabs/Item3.prefab' - ]; - - const positions = [ - { x: 0, y: 0, z: 0 }, - { x: 100, y: 0, z: 0 }, - { x: 200, y: 0, z: 0 } - ]; - - const results = []; - - for (let i = 0; i < prefabPaths.length; i++) { - try { - const result = await this.prefabTools.execute('instantiate_prefab', { - prefabPath: prefabPaths[i], - position: positions[i] - }); - - results.push({ - index: i, - prefabPath: prefabPaths[i], - success: result.success, - data: result.data, - error: result.error - }); - - if (result.success) { - console.log(`✅ 预制体 ${i + 1} 实例化成功`); - } else { - console.log(`❌ 预制体 ${i + 1} 实例化失败: ${result.error}`); - } - } catch (error) { - console.error(`预制体 ${i + 1} 实例化时发生错误:`, error); - results.push({ - index: i, - prefabPath: prefabPaths[i], - success: false, - error: error instanceof Error ? error.message : String(error) - }); - } - } - - const successCount = results.filter(r => r.success).length; - console.log(`批量实例化完成: ${successCount}/${results.length} 成功`); - - return results; - } - - /** - * 示例4: 错误处理和重试机制 - */ - async instantiationWithRetryExample() { - console.log('=== 带重试机制的实例化示例 ==='); - - const maxRetries = 3; - let attempt = 0; - - while (attempt < maxRetries) { - try { - const result = await this.prefabTools.execute('instantiate_prefab', { - prefabPath: 'db://assets/prefabs/ComplexPrefab.prefab', - position: { x: 0, y: 0, z: 0 } - }); - - if (result.success) { - console.log(`✅ 预制体实例化成功 (尝试 ${attempt + 1})`); - return result; - } else { - console.log(`❌ 尝试 ${attempt + 1} 失败: ${result.error}`); - attempt++; - - if (attempt < maxRetries) { - console.log(`等待 1 秒后重试...`); - await this.delay(1000); - } - } - } catch (error) { - console.error(`尝试 ${attempt + 1} 时发生错误:`, error); - attempt++; - - if (attempt < maxRetries) { - console.log(`等待 1 秒后重试...`); - await this.delay(1000); - } - } - } - - console.log('❌ 所有重试都失败了'); - return { success: false, error: '达到最大重试次数' }; - } - - /** - * 示例5: 预制体实例化前的验证 - */ - async instantiationWithValidationExample() { - console.log('=== 带验证的实例化示例 ==='); - - const prefabPath = 'db://assets/prefabs/ValidatedPrefab.prefab'; - - try { - // 首先验证预制体 - const validationResult = await this.prefabTools.execute('validate_prefab', { - prefabPath: prefabPath - }); - - if (validationResult.success && validationResult.data.isValid) { - console.log('✅ 预制体验证通过'); - console.log(`节点数量: ${validationResult.data.nodeCount}`); - console.log(`组件数量: ${validationResult.data.componentCount}`); - - // 验证通过后实例化 - const instantiationResult = await this.prefabTools.execute('instantiate_prefab', { - prefabPath: prefabPath, - position: { x: 0, y: 0, z: 0 } - }); - - if (instantiationResult.success) { - console.log('✅ 预制体实例化成功'); - return instantiationResult; - } else { - console.log('❌ 预制体实例化失败:', instantiationResult.error); - return instantiationResult; - } - } else { - console.log('❌ 预制体验证失败'); - if (validationResult.data && validationResult.data.issues) { - console.log('问题列表:'); - validationResult.data.issues.forEach((issue: string, index: number) => { - console.log(` ${index + 1}. ${issue}`); - }); - } - return validationResult; - } - } catch (error) { - console.error('验证和实例化过程中发生错误:', error); - return { success: false, error: error instanceof Error ? error.message : String(error) }; - } - } - - /** - * 示例6: API参数构建示例 - */ - demonstrateAPIParameters() { - console.log('=== API参数构建示例 ==='); - - // 模拟从asset-db获取的预制体信息 - const assetInfo = { - uuid: 'prefab-uuid-123', - name: 'PlayerCharacter' - }; - - // 基本实例化参数 - const basicOptions = { - assetUuid: assetInfo.uuid, - name: assetInfo.name - }; - console.log('基本实例化参数:', JSON.stringify(basicOptions, null, 2)); - - // 带父节点的实例化参数 - const withParentOptions = { - assetUuid: assetInfo.uuid, - name: assetInfo.name, - parent: 'canvas-uuid-456' - }; - console.log('带父节点参数:', JSON.stringify(withParentOptions, null, 2)); - - // 带位置设置的实例化参数 - const withPositionOptions = { - assetUuid: assetInfo.uuid, - name: assetInfo.name, - dump: { - position: { x: 100, y: 200, z: 0 } - } - }; - console.log('带位置参数:', JSON.stringify(withPositionOptions, null, 2)); - - // 完整实例化参数 - const fullOptions = { - assetUuid: assetInfo.uuid, - name: assetInfo.name, - parent: 'canvas-uuid-456', - dump: { - position: { x: 100, y: 200, z: 0 } - }, - keepWorldTransform: false, - unlinkPrefab: false - }; - console.log('完整参数:', JSON.stringify(fullOptions, null, 2)); - - console.log('这些参数将传递给 Editor.Message.request("scene", "create-node", options)'); - } - - /** - * 延迟函数 - */ - private delay(ms: number): Promise { - return new Promise(resolve => setTimeout(resolve, ms)); - } - - /** - * 运行所有示例 - */ - async runAllExamples() { - console.log('🚀 开始运行预制体实例化示例...\n'); - - await this.basicInstantiationExample(); - console.log(''); - - await this.instantiateWithParentExample(); - console.log(''); - - await this.batchInstantiationExample(); - console.log(''); - - await this.instantiationWithRetryExample(); - console.log(''); - - await this.instantiationWithValidationExample(); - console.log(''); - - this.demonstrateAPIParameters(); - console.log(''); - - console.log('🎉 所有示例运行完成！'); - } -} - -// 如果直接运行此文件 -if (typeof module !== 'undefined' && module.exports) { - const example = new PrefabInstantiationExample(); - example.runAllExamples(); -} \ No newline at end of file diff --git a/source/tools/component-tools.ts b/source/tools/component-tools.ts index 18a23fd..76f890a 100644 --- a/source/tools/component-tools.ts +++ b/source/tools/component-tools.ts @@ -23,7 +23,7 @@ export class ComponentTools implements ToolExecutor { }, { name: 'remove_component', - description: 'Remove a component from a node', + description: 'Remove a component from a node. componentType must be the component\'s classId (cid, i.e. the type field from getComponents), not the script name or class name. Use getComponents to get the correct cid.', inputSchema: { type: 'object', properties: { @@ -33,7 +33,7 @@ export class ComponentTools implements ToolExecutor { }, componentType: { type: 'string', - description: 'Component type to remove' + description: 'Component cid (type field from getComponents). Do NOT use script name or class name. Example: "cc.Sprite" or "9b4a7ueT9xD6aRE+AlOusy1"' } }, required: ['nodeUuid', 'componentType'] @@ -73,56 +73,74 @@ export class ComponentTools implements ToolExecutor { }, { name: 'set_component_property', - description: 'Set component property value - AI必须提供5个参数：节点UUID、组件名称、属性名称、属性类型、属性值\n' + - '重要：对于引用类型属性：\n' + - '• 节点引用(propertyType: "node"): value传入目标节点的UUID字符串\n' + - '• 组件引用(propertyType: "component"): value传入目标组件的UUID字符串\n' + - '• 资源引用(propertyType: "spriteFrame/prefab/asset"): value传入资源UUID字符串', + description: 'Set component property values for UI components or custom script components. Supports setting properties of built-in UI components (e.g., cc.Label, cc.Sprite) and custom script components. Note: For node basic properties (name, active, layer, etc.), use set_node_property. For node transform properties (position, rotation, scale, etc.), use set_node_transform.', inputSchema: { type: 'object', properties: { nodeUuid: { type: 'string', - description: 'Node UUID - 节点的UUID' + description: 'Target node UUID - Must specify the node to operate on' }, componentType: { type: 'string', - description: 'Component type - 组件类型', - enum: ['cc.Label', 'cc.Sprite', 'cc.Button', 'cc.Toggle', 'cc.Slider', 'cc.ScrollView', 'cc.EditBox', 'cc.ProgressBar', 'cc.RichText', 'cc.Mask', 'cc.Graphics', 'cc.Layout', 'cc.Widget', 'cc.UITransform', 'TestMCPScript'] + description: 'Component type - Can be built-in components (e.g., cc.Label) or custom script components (e.g., MyScript). If unsure about component type, use get_components first to retrieve all components on the node.', + // 移除enum限制，允许任意组件类型包括自定义脚本 }, property: { type: 'string', - description: 'Property name - 属性名称' + description: 'Property name - The property to set. Common properties include:\n' + + '• cc.Label: string (text content), fontSize (font size), color (text color)\n' + + '• cc.Sprite: spriteFrame (sprite frame), color (tint color), sizeMode (size mode)\n' + + '• cc.Button: normalColor (normal color), pressedColor (pressed color), target (target node)\n' + + '• cc.UITransform: contentSize (content size), anchorPoint (anchor point)\n' + + '• Custom Scripts: Based on properties defined in the script' }, propertyType: { type: 'string', - description: 'Property type - 属性类型（必须明确指定）', + description: 'Property type - Must explicitly specify the property data type for correct value conversion and validation', enum: [ 'string', 'number', 'boolean', 'integer', 'float', 'color', 'vec2', 'vec3', 'size', 'node', 'component', 'spriteFrame', 'prefab', 'asset', 'nodeArray', 'colorArray', 'numberArray', 'stringArray' ] - }, + }, + value: { - description: 'Property value - 属性值，根据propertyType使用不同格式:\n' + - '基础类型：\n' + - '• string: "Hello World"\n' + - '• number/integer/float: 42 或 3.14\n' + - '• boolean: true 或 false\n' + - '• color: {"r":255,"g":0,"b":0,"a":255}\n' + - '• vec2: {"x":100,"y":50}\n' + - '• vec3: {"x":1,"y":2,"z":3}\n' + - '• size: {"width":100,"height":50}\n' + - '引用类型（重要）：\n' + - '• node: "target-node-uuid-string" （目标节点的UUID字符串）\n' + - '• component: "target-component-uuid-string" （目标组件的UUID字符串）\n' + - '• spriteFrame/prefab/asset: "asset-uuid-string" （资源UUID字符串）\n' + - '数组类型：\n' + - '• nodeArray: ["uuid1","uuid2","uuid3"]\n' + - '• colorArray: [{"r":255,"g":0,"b":0,"a":255},{"r":0,"g":255,"b":0,"a":255}]\n' + - '• numberArray: [1,2,3,4,5]\n' + - '• stringArray: ["item1","item2","item3"]' + description: 'Property value - Use the corresponding data format based on propertyType:\n\n' + + '📝 Basic Data Types:\n' + + '• string: "Hello World" (text string)\n' + + '• number/integer/float: 42 or 3.14 (numeric value)\n' + + '• boolean: true or false (boolean value)\n\n' + + '🎨 Color Type:\n' + + '• color: {"r":255,"g":0,"b":0,"a":255} (RGBA values, range 0-255)\n' + + ' - Alternative: "#FF0000" (hexadecimal format)\n' + + ' - Transparency: a value controls opacity, 255 = fully opaque, 0 = fully transparent\n\n' + + '📐 Vector and Size Types:\n' + + '• vec2: {"x":100,"y":50} (2D vector)\n' + + '• vec3: {"x":1,"y":2,"z":3} (3D vector)\n' + + '• size: {"width":100,"height":50} (size dimensions)\n\n' + + '🔗 Reference Types (using UUID strings):\n' + + '• node: "target-node-uuid" (node reference)\n' + + ' How to get: Use get_all_nodes or find_node_by_name to get node UUIDs\n' + + '• component: "target-node-uuid" (component reference)\n' + + ' How it works: \n' + + ' 1. Provide the UUID of the NODE that contains the target component\n' + + ' 2. System auto-detects required component type from property metadata\n' + + ' 3. Finds the component on target node and gets its scene __id__\n' + + ' 4. Sets reference using the scene __id__ (not node UUID)\n' + + ' Example: value="label-node-uuid" will find cc.Label and use its scene ID\n' + + '• spriteFrame: "spriteframe-uuid" (sprite frame asset)\n' + + ' How to get: Check asset database or use asset browser\n' + + '• prefab: "prefab-uuid" (prefab asset)\n' + + ' How to get: Check asset database or use asset browser\n' + + '• asset: "asset-uuid" (generic asset reference)\n' + + ' How to get: Check asset database or use asset browser\n\n' + + '📋 Array Types:\n' + + '• nodeArray: ["uuid1","uuid2"] (array of node UUIDs)\n' + + '• colorArray: [{"r":255,"g":0,"b":0,"a":255}] (array of colors)\n' + + '• numberArray: [1,2,3,4,5] (array of numbers)\n' + + '• stringArray: ["item1","item2"] (array of strings)' } }, required: ['nodeUuid', 'componentType', 'property', 'propertyType', 'value'] @@ -186,48 +204,66 @@ export class ComponentTools implements ToolExecutor { } private async addComponent(nodeUuid: string, componentType: string): Promise { - return new Promise((resolve) => { + return new Promise(async (resolve) => { + // 先查找节点上是否已存在该组件 + const allComponentsInfo = await this.getComponents(nodeUuid); + if (allComponentsInfo.success && allComponentsInfo.data?.components) { + const existingComponent = allComponentsInfo.data.components.find((comp: any) => comp.type === componentType); + if (existingComponent) { + resolve({ + success: true, + message: `Component '${componentType}' already exists on node`, + data: { + nodeUuid: nodeUuid, + componentType: componentType, + componentVerified: true, + existing: true + } + }); + return; + } + } // 尝试直接使用 Editor API 添加组件 Editor.Message.request('scene', 'create-component', { uuid: nodeUuid, component: componentType - }).then((result: any) => { - // Get comprehensive verification data including node info and all components - Promise.all([ - this.getComponents(nodeUuid), - this.getComponentInfo(nodeUuid, componentType) - ]).then(([allComponentsInfo, newComponentInfo]) => { - const addedComponent = allComponentsInfo.data?.components?.find((comp: any) => comp.type === componentType); - resolve({ - success: true, - data: { - componentId: result, - nodeUuid: nodeUuid, - componentType: componentType, - message: `Component '${componentType}' added successfully`, - componentVerified: !!addedComponent - }, - verificationData: { - addedComponent: newComponentInfo.data, - allNodeComponents: allComponentsInfo.data, - componentCount: allComponentsInfo.data?.components?.length || 0, - verificationStatus: { - componentExists: !!addedComponent, - componentDetails: addedComponent || null - } + }).then(async (result: any) => { + // 等待一段时间让Editor完成组件添加 + await new Promise(resolve => setTimeout(resolve, 100)); + // 重新查询节点信息验证组件是否真的添加成功 + try { + const allComponentsInfo2 = await this.getComponents(nodeUuid); + if (allComponentsInfo2.success && allComponentsInfo2.data?.components) { + const addedComponent = allComponentsInfo2.data.components.find((comp: any) => comp.type === componentType); + if (addedComponent) { + resolve({ + success: true, + message: `Component '${componentType}' added successfully`, + data: { + nodeUuid: nodeUuid, + componentType: componentType, + componentVerified: true, + existing: false + } + }); + } else { + resolve({ + success: false, + error: `Component '${componentType}' was not found on node after addition. Available components: ${allComponentsInfo2.data.components.map((c: any) => c.type).join(', ')}` + }); } - }); - }).catch(() => { + } else { + resolve({ + success: false, + error: `Failed to verify component addition: ${allComponentsInfo2.error || 'Unable to get node components'}` + }); + } + } catch (verifyError: any) { resolve({ - success: true, - data: { - componentId: result, - nodeUuid: nodeUuid, - componentType: componentType, - message: `Component '${componentType}' added successfully (verification failed)` - } + success: false, + error: `Failed to verify component addition: ${verifyError.message}` }); - }); + } }).catch((err: Error) => { // 备用方案：使用场景脚本 const options = { @@ -235,7 +271,6 @@ export class ComponentTools implements ToolExecutor { method: 'addComponentToNode', args: [nodeUuid, componentType] }; - Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { resolve(result); }).catch((err2: Error) => { @@ -246,18 +281,40 @@ export class ComponentTools implements ToolExecutor { } private async removeComponent(nodeUuid: string, componentType: string): Promise { - return new Promise((resolve) => { - const options = { - name: 'cocos-mcp-server', - method: 'removeComponentFromNode', - args: [nodeUuid, componentType] - }; - - Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { - resolve(result); - }).catch((err: Error) => { - resolve({ success: false, error: err.message }); - }); + return new Promise(async (resolve) => { + // 1. 查找节点上的所有组件 + const allComponentsInfo = await this.getComponents(nodeUuid); + if (!allComponentsInfo.success || !allComponentsInfo.data?.components) { + resolve({ success: false, error: `Failed to get components for node '${nodeUuid}': ${allComponentsInfo.error}` }); + return; + } + // 2. 只查找type字段等于componentType的组件（即cid） + const exists = allComponentsInfo.data.components.some((comp: any) => comp.type === componentType); + if (!exists) { + resolve({ success: false, error: `Component cid '${componentType}' not found on node '${nodeUuid}'. 请用getComponents获取type字段（cid）作为componentType。` }); + return; + } + // 3. 官方API直接移除 + try { + await Editor.Message.request('scene', 'remove-component', { + uuid: nodeUuid, + component: componentType + }); + // 4. 再查一次确认是否移除 + const afterRemoveInfo = await this.getComponents(nodeUuid); + const stillExists = afterRemoveInfo.success && afterRemoveInfo.data?.components?.some((comp: any) => comp.type === componentType); + if (stillExists) { + resolve({ success: false, error: `Component cid '${componentType}' was not removed from node '${nodeUuid}'.` }); + } else { + resolve({ + success: true, + message: `Component cid '${componentType}' removed successfully from node '${nodeUuid}'`, + data: { nodeUuid, componentType } + }); + } + } catch (err: any) { + resolve({ success: false, error: `Failed to remove component: ${err.message}` }); + } }); } @@ -268,6 +325,7 @@ export class ComponentTools implements ToolExecutor { if (nodeData && nodeData.__comps__) { const components = nodeData.__comps__.map((comp: any) => ({ type: comp.__type__ || comp.cid || comp.type || 'Unknown', + uuid: comp.uuid?.value || comp.uuid || null, enabled: comp.enabled !== undefined ? comp.enabled : true, properties: this.extractComponentProperties(comp) })); @@ -389,19 +447,79 @@ export class ComponentTools implements ToolExecutor { return properties; } + private async findComponentTypeByUuid(componentUuid: string): Promise { + console.log(`[findComponentTypeByUuid] Searching for component type with UUID: ${componentUuid}`); + if (!componentUuid) { + return null; + } + try { + const nodeTree = await Editor.Message.request('scene', 'query-node-tree'); + if (!nodeTree) { + console.warn('[findComponentTypeByUuid] Failed to query node tree.'); + return null; + } + + const queue: any[] = [nodeTree]; + + while (queue.length > 0) { + const currentNodeInfo = queue.shift(); + if (!currentNodeInfo || !currentNodeInfo.uuid) { + continue; + } + + try { + const fullNodeData = await Editor.Message.request('scene', 'query-node', currentNodeInfo.uuid); + if (fullNodeData && fullNodeData.__comps__) { + for (const comp of fullNodeData.__comps__) { + const compAny = comp as any; // Cast to any to access dynamic properties + // The component UUID is nested in the 'value' property + if (compAny.uuid && compAny.uuid.value === componentUuid) { + const componentType = compAny.__type__; + console.log(`[findComponentTypeByUuid] Found component type '${componentType}' for UUID ${componentUuid} on node ${fullNodeData.name?.value}`); + return componentType; + } + } + } + } catch (e) { + console.warn(`[findComponentTypeByUuid] Could not query node ${currentNodeInfo.uuid}:`, e); + } + + if (currentNodeInfo.children) { + for (const child of currentNodeInfo.children) { + queue.push(child); + } + } + } + + console.warn(`[findComponentTypeByUuid] Component with UUID ${componentUuid} not found in scene tree.`); + return null; + } catch (error) { + console.error(`[findComponentTypeByUuid] Error while searching for component type:`, error); + return null; + } + } + private async setComponentProperty(args: any): Promise { - const { nodeUuid, componentType, property, propertyType, value } = args; + const { nodeUuid, componentType, property, propertyType, value } = args; return new Promise(async (resolve) => { try { console.log(`[ComponentTools] Setting ${componentType}.${property} (type: ${propertyType}) = ${JSON.stringify(value)} on node ${nodeUuid}`); + // Step 0: 检测是否为节点属性，如果是则重定向到对应的节点方法 + const nodeRedirectResult = await this.checkAndRedirectNodeProperties(args); + if (nodeRedirectResult) { + resolve(nodeRedirectResult); + return; + } + // Step 1: 获取组件信息，使用与getComponents相同的方法 const componentsResponse = await this.getComponents(nodeUuid); if (!componentsResponse.success || !componentsResponse.data) { resolve({ success: false, - error: `Failed to get components for node '${nodeUuid}': ${componentsResponse.error}` + error: `Failed to get components for node '${nodeUuid}': ${componentsResponse.error}`, + instruction: `Please verify that node UUID '${nodeUuid}' is correct. Use get_all_nodes or find_node_by_name to get the correct node UUID.` }); return; } @@ -423,9 +541,12 @@ export class ComponentTools implements ToolExecutor { } if (!targetComponent) { + // 提供更详细的错误信息和建议 + const instruction = this.generateComponentSuggestion(componentType, availableTypes, property); resolve({ success: false, - error: `Component '${componentType}' not found on node. Available components: ${availableTypes.join(', ')}` + error: `Component '${componentType}' not found on node. Available components: ${availableTypes.join(', ')}`, + instruction: instruction }); return; } @@ -470,7 +591,11 @@ export class ComponentTools implements ToolExecutor { processedValue = Boolean(value); break; case 'color': - if (typeof value === 'object' && value !== null) { + if (typeof value === 'string') { + // 字符串格式：支持十六进制、颜色名称、rgb()/rgba() + processedValue = this.parseColorString(value); + } else if (typeof value === 'object' && value !== null) { + // 对象格式：验证并转换RGBA值 processedValue = { r: Math.min(255, Math.max(0, Number(value.r) || 0)), g: Math.min(255, Math.max(0, Number(value.g) || 0)), @@ -478,7 +603,7 @@ export class ComponentTools implements ToolExecutor { a: value.a !== undefined ? Math.min(255, Math.max(0, Number(value.a))) : 255 }; } else { - throw new Error('Color value must be an object with r, g, b properties'); + throw new Error('Color value must be an object with r, g, b properties or a hexadecimal string (e.g., "#FF0000")'); } break; case 'vec2': @@ -521,66 +646,10 @@ export class ComponentTools implements ToolExecutor { break; case 'component': if (typeof value === 'string') { - // 组件引用：需要验证节点上是否有对应组件类型 - // 推断组件类型从属性名称（例如：labelComponent -> Label, buttonComponent -> Button） - let expectedComponentType = ''; - const propertyLower = property.toLowerCase(); - if (propertyLower.includes('label')) { - expectedComponentType = 'cc.Label'; - } else if (propertyLower.includes('button')) { - expectedComponentType = 'cc.Button'; - } else if (propertyLower.includes('sprite')) { - expectedComponentType = 'cc.Sprite'; - } else if (propertyLower.includes('canvas')) { - expectedComponentType = 'cc.Canvas'; - } else if (propertyLower.includes('camera')) { - expectedComponentType = 'cc.Camera'; - } - - // 验证目标节点是否存在指定组件 - try { - const nodeData = await Editor.Message.request('scene', 'query-node', value); - if (nodeData && nodeData.__comps__ && expectedComponentType) { - const targetComponent = nodeData.__comps__.find((comp: any) => - comp.__type__ === expectedComponentType - ); - if (targetComponent) { - // 找到匹配组件，使用组件的UUID - processedValue = { uuid: (targetComponent as any).uuid || value }; - } else { - console.warn(`[setComponentProperty] Node ${value} does not have component ${expectedComponentType}`); - processedValue = { uuid: value }; // 仍然设置，让Editor处理 - } - } else { - // 无法推断组件类型或节点不存在，直接使用UUID - processedValue = { uuid: value }; - } - } catch (error) { - console.warn(`[setComponentProperty] Failed to verify component on node ${value}: ${error}`); - processedValue = { uuid: value }; // 仍然设置，让Editor处理 - } - } else if (typeof value === 'object' && value !== null && value.node && value.component) { - // 查找具体的组件UUID - try { - const nodeData = await Editor.Message.request('scene', 'query-node', value.node); - if (nodeData && nodeData.__comps__) { - const targetComponent = nodeData.__comps__.find((comp: any) => - comp.__type__ === value.component - ); - if (targetComponent) { - processedValue = { uuid: (targetComponent as any).uuid || "" }; - } else { - processedValue = { uuid: "" }; - } - } else { - processedValue = { uuid: "" }; - } - } catch (error) { - console.warn(`[setComponentProperty] Failed to find component: ${error}`); - processedValue = { uuid: "" }; - } + // 组件引用需要特殊处理：通过节点UUID找到组件的__id__ + processedValue = value; // 先保存节点UUID，后续会转换为__id__ } else { - throw new Error('Component reference value must be a string UUID or object with node and component properties'); + throw new Error('Component reference value must be a string (node UUID containing the target component)'); } break; case 'spriteFrame': @@ -616,7 +685,7 @@ export class ComponentTools implements ToolExecutor { a: item.a !== undefined ? Math.min(255, Math.max(0, Number(item.a))) : 255 }; } else { - throw new Error('ColorArray items must be objects with r, g, b properties'); + return { r: 255, g: 255, b: 255, a: 255 }; } }); } else { @@ -642,6 +711,11 @@ export class ComponentTools implements ToolExecutor { } console.log(`[ComponentTools] Converting value: ${JSON.stringify(value)} -> ${JSON.stringify(processedValue)} (type: ${propertyType})`); + console.log(`[ComponentTools] Property analysis result: propertyInfo.type="${propertyInfo.type}", propertyType="${propertyType}"`); + console.log(`[ComponentTools] Will use color special handling: ${propertyType === 'color' && processedValue && typeof processedValue === 'object'}`); + + // 用于验证的实际期望值（对于组件引用需要特殊处理） + let actualExpectedValue = processedValue; // Step 5: 获取原始节点数据来构建正确的路径 const rawNodeData = await Editor.Message.request('scene', 'query-node', nodeUuid); @@ -676,10 +750,15 @@ export class ComponentTools implements ToolExecutor { let propertyPath = `__comps__.${rawComponentIndex}.${property}`; // 特殊处理资源类属性 - if (propertyInfo.type === 'asset') { - // 对于资源类属性，需要特殊处理 - const assetValue = typeof processedValue === 'string' ? - { uuid: processedValue } : processedValue; + if (propertyType === 'asset' || propertyType === 'spriteFrame' || propertyType === 'prefab' || + (propertyInfo.type === 'asset' && propertyType === 'string')) { + + console.log(`[ComponentTools] Setting asset reference:`, { + value: processedValue, + property: property, + propertyType: propertyType, + path: propertyPath + }); // Determine asset type based on property name let assetType = 'cc.SpriteFrame'; // default @@ -691,40 +770,18 @@ export class ComponentTools implements ToolExecutor { assetType = 'cc.Font'; } else if (property.toLowerCase().includes('clip')) { assetType = 'cc.AudioClip'; + } else if (propertyType === 'prefab') { + assetType = 'cc.Prefab'; } - // Try multiple approaches for setting asset properties - try { - // Approach 1: Direct property setting with asset structure - await Editor.Message.request('scene', 'set-property', { - uuid: nodeUuid, - path: propertyPath, - dump: { - value: assetValue, - type: assetType - } - }); - } catch (error1) { - try { - // Approach 2: Try with different structure - await Editor.Message.request('scene', 'set-property', { - uuid: nodeUuid, - path: propertyPath, - dump: { - value: { - __uuid__: assetValue.uuid || assetValue - } - } - }); - } catch (error2) { - // Approach 3: Try direct UUID assignment - await Editor.Message.request('scene', 'set-property', { - uuid: nodeUuid, - path: propertyPath, - dump: { value: assetValue.uuid || assetValue } - }); + await Editor.Message.request('scene', 'set-property', { + uuid: nodeUuid, + path: propertyPath, + dump: { + value: processedValue, + type: assetType } - } + }); } else if (componentType === 'cc.UITransform' && (property === '_contentSize' || property === 'contentSize')) { // Special handling for UITransform contentSize - set width and height separately const width = Number(value.width) || 100; @@ -761,7 +818,7 @@ export class ComponentTools implements ToolExecutor { path: `__comps__.${rawComponentIndex}.anchorY`, dump: { value: anchorY } }); - } else if (propertyInfo.type === 'color' && processedValue && typeof processedValue === 'object') { + } else if (propertyType === 'color' && processedValue && typeof processedValue === 'object') { // 特殊处理颜色属性，确保RGBA值正确 // Cocos Creator颜色值范围是0-255 const colorValue = { @@ -771,6 +828,8 @@ export class ComponentTools implements ToolExecutor { a: processedValue.a !== undefined ? Math.min(255, Math.max(0, Number(processedValue.a))) : 255 }; + console.log(`[ComponentTools] Setting color value:`, colorValue); + await Editor.Message.request('scene', 'set-property', { uuid: nodeUuid, path: propertyPath, @@ -779,7 +838,7 @@ export class ComponentTools implements ToolExecutor { type: 'cc.Color' } }); - } else if (propertyInfo.type === 'vec3' && processedValue && typeof processedValue === 'object') { + } else if (propertyType === 'vec3' && processedValue && typeof processedValue === 'object') { // 特殊处理Vec3属性 const vec3Value = { x: Number(processedValue.x) || 0, @@ -795,7 +854,7 @@ export class ComponentTools implements ToolExecutor { type: 'cc.Vec3' } }); - } else if (propertyInfo.type === 'vec2' && processedValue && typeof processedValue === 'object') { + } else if (propertyType === 'vec2' && processedValue && typeof processedValue === 'object') { // 特殊处理Vec2属性 const vec2Value = { x: Number(processedValue.x) || 0, @@ -810,7 +869,7 @@ export class ComponentTools implements ToolExecutor { type: 'cc.Vec2' } }); - } else if (propertyInfo.type === 'size' && processedValue && typeof processedValue === 'object') { + } else if (propertyType === 'size' && processedValue && typeof processedValue === 'object') { // 特殊处理Size属性 const sizeValue = { width: Number(processedValue.width) || 0, @@ -825,7 +884,7 @@ export class ComponentTools implements ToolExecutor { type: 'cc.Size' } }); - } else if ((propertyInfo.type === 'node' || propertyInfo.type === 'cc.Node') && processedValue && typeof processedValue === 'object' && 'uuid' in processedValue) { + } else if (propertyType === 'node' && processedValue && typeof processedValue === 'object' && 'uuid' in processedValue) { // 特殊处理节点引用 console.log(`[ComponentTools] Setting node reference with UUID: ${processedValue.uuid}`); await Editor.Message.request('scene', 'set-property', { @@ -836,92 +895,140 @@ export class ComponentTools implements ToolExecutor { type: 'cc.Node' } }); - } else if (propertyInfo.type === 'component') { - // 特殊处理组件引用 - 方案B：使用完整的属性描述符 - let componentValue; - let originalPropertyDescriptor: any = {}; + } else if (propertyType === 'component' && typeof processedValue === 'string') { + // 特殊处理组件引用：通过节点UUID找到组件的__id__ + const targetNodeUuid = processedValue; + console.log(`[ComponentTools] Setting component reference - finding component on node: ${targetNodeUuid}`); - // 关键优化：获取完整的原始属性描述符 - try { - const tempResult = await this.getComponentInfo(nodeUuid, componentType); - if (tempResult.success && tempResult.data?.properties?.[property]) { - const propertyMeta = tempResult.data.properties[property]; - if (propertyMeta && typeof propertyMeta === 'object') { - // 保存完整的属性描述符（除了value之外的所有信息） - originalPropertyDescriptor = { ...propertyMeta }; - delete originalPropertyDescriptor.value; // 移除旧的value，我们会设置新的 - console.log(`[setComponentProperty] Preserving original property descriptor for ${property}:`, Object.keys(originalPropertyDescriptor)); - } - } - } catch (error) { - console.warn(`[setComponentProperty] Failed to get original property descriptor: ${error}`); - } + // 从当前组件的属性元数据中获取期望的组件类型 + let expectedComponentType = ''; - if (typeof processedValue === 'string') { - // 如果是字符串，假设是组件的UUID - componentValue = { uuid: processedValue }; - } else if (processedValue && typeof processedValue === 'object') { - if (processedValue.node && processedValue.component) { - // 如果提供了节点和组件类型，需要查找具体的组件UUID - try { - const nodeData = await Editor.Message.request('scene', 'query-node', processedValue.node); - if (nodeData && nodeData.__comps__) { - const targetComponent = nodeData.__comps__.find((comp: any) => - comp.__type__ === processedValue.component - ); - if (targetComponent) { - componentValue = { uuid: (targetComponent as any).uuid || "" }; - } else { - componentValue = { uuid: "" }; + // 获取当前组件的详细信息，包括属性元数据 + const currentComponentInfo = await this.getComponentInfo(nodeUuid, componentType); + if (currentComponentInfo.success && currentComponentInfo.data?.properties?.[property]) { + const propertyMeta = currentComponentInfo.data.properties[property]; + + // 从属性元数据中提取组件类型信息 + if (propertyMeta && typeof propertyMeta === 'object') { + // 检查是否有type字段指示组件类型 + if (propertyMeta.type) { + expectedComponentType = propertyMeta.type; + } else if (propertyMeta.ctor) { + // 有些属性可能使用ctor字段 + expectedComponentType = propertyMeta.ctor; + } else if (propertyMeta.extends && Array.isArray(propertyMeta.extends)) { + // 检查extends数组，通常第一个是最具体的类型 + for (const extendType of propertyMeta.extends) { + if (extendType.startsWith('cc.') && extendType !== 'cc.Component' && extendType !== 'cc.Object') { + expectedComponentType = extendType; + break; } - } else { - componentValue = { uuid: "" }; } - } catch (error) { - console.warn(`[setComponentProperty] Failed to find component: ${error}`); - componentValue = { uuid: "" }; } - } else { - componentValue = processedValue; } - } else { - componentValue = { uuid: "" }; } - // 方案B：使用完整的属性描述符，保持所有原始元数据 - const dumpData = { - value: componentValue, - ...originalPropertyDescriptor // 保持完整的属性描述符 - }; + if (!expectedComponentType) { + throw new Error(`Unable to determine required component type for property '${property}' on component '${componentType}'. Property metadata may not contain type information.`); + } - console.log(`[setComponentProperty] Setting with complete descriptor:`, Object.keys(dumpData)); + console.log(`[ComponentTools] Detected required component type: ${expectedComponentType} for property: ${property}`); - await Editor.Message.request('scene', 'set-property', { - uuid: nodeUuid, - path: propertyPath, - dump: dumpData - }); - } else if (propertyInfo.type === 'nodeArray' && Array.isArray(processedValue)) { - // 特殊处理节点数组 - const nodeArrayValue = processedValue.map((item: any) => { - if (typeof item === 'string') { - return { __uuid__: item }; - } else if (item && typeof item === 'object' && (item.uuid || item.__uuid__)) { - return { __uuid__: item.uuid || item.__uuid__ }; - } else { - return { __uuid__: "" }; + try { + // 获取目标节点的组件信息 + const targetNodeData = await Editor.Message.request('scene', 'query-node', targetNodeUuid); + if (!targetNodeData || !targetNodeData.__comps__) { + throw new Error(`Target node ${targetNodeUuid} not found or has no components`); } - }); + + // 打印目标节点的组件概览 + console.log(`[ComponentTools] Target node ${targetNodeUuid} has ${targetNodeData.__comps__.length} components:`); + targetNodeData.__comps__.forEach((comp: any, index: number) => { + const sceneId = comp.value && comp.value.uuid && comp.value.uuid.value ? comp.value.uuid.value : 'unknown'; + console.log(`[ComponentTools] Component ${index}: ${comp.type} (scene_id: ${sceneId})`); + }); + + // 查找对应的组件 + let targetComponent = null; + let componentId: string | null = null; + + // 在目标节点的_components数组中查找指定类型的组件 + // 注意：__comps__和_components的索引是对应的 + console.log(`[ComponentTools] Searching for component type: ${expectedComponentType}`); + + for (let i = 0; i < targetNodeData.__comps__.length; i++) { + const comp = targetNodeData.__comps__[i] as any; + console.log(`[ComponentTools] Checking component ${i}: type=${comp.type}, target=${expectedComponentType}`); + + if (comp.type === expectedComponentType) { + targetComponent = comp; + console.log(`[ComponentTools] Found matching component at index ${i}: ${comp.type}`); + + // 从组件的value.uuid.value中获取组件在场景中的ID + if (comp.value && comp.value.uuid && comp.value.uuid.value) { + componentId = comp.value.uuid.value; + console.log(`[ComponentTools] Got componentId from comp.value.uuid.value: ${componentId}`); + } else { + console.log(`[ComponentTools] Component structure:`, { + hasValue: !!comp.value, + hasUuid: !!(comp.value && comp.value.uuid), + hasUuidValue: !!(comp.value && comp.value.uuid && comp.value.uuid.value), + uuidStructure: comp.value ? comp.value.uuid : 'No value' + }); + throw new Error(`Unable to extract component ID from component structure`); + } + + break; + } + } + + if (!targetComponent) { + // 如果没找到，列出可用组件让用户了解，显示场景中的真实ID + const availableComponents = targetNodeData.__comps__.map((comp: any, index: number) => { + let sceneId = 'unknown'; + // 从组件的value.uuid.value获取场景ID + if (comp.value && comp.value.uuid && comp.value.uuid.value) { + sceneId = comp.value.uuid.value; + } + return `${comp.type}(scene_id:${sceneId})`; + }); + throw new Error(`Component type '${expectedComponentType}' not found on node ${targetNodeUuid}. Available components: ${availableComponents.join(', ')}`); + } + + console.log(`[ComponentTools] Found component ${expectedComponentType} with scene ID: ${componentId} on node ${targetNodeUuid}`); + + // 更新期望值为实际的组件ID对象格式，用于后续验证 + if (componentId) { + actualExpectedValue = { uuid: componentId }; + } + + // 尝试使用与节点/资源引用相同的格式：{uuid: componentId} + // 测试看是否能正确设置组件引用 + await Editor.Message.request('scene', 'set-property', { + uuid: nodeUuid, + path: propertyPath, + dump: { + value: { uuid: componentId }, // 使用对象格式，像节点/资源引用一样 + type: expectedComponentType + } + }); + + } catch (error) { + console.error(`[ComponentTools] Error setting component reference:`, error); + throw error; + } + } else if (propertyType === 'nodeArray' && Array.isArray(processedValue)) { + // 特殊处理节点数组 - 保持预处理的格式 + console.log(`[ComponentTools] Setting node array:`, processedValue); await Editor.Message.request('scene', 'set-property', { uuid: nodeUuid, path: propertyPath, dump: { - value: nodeArrayValue, - type: 'cc.Node' + value: processedValue // 保持 [{uuid: "..."}, {uuid: "..."}] 格式 } }); - } else if (propertyInfo.type === 'colorArray' && Array.isArray(processedValue)) { + } else if (propertyType === 'colorArray' && Array.isArray(processedValue)) { // 特殊处理颜色数组 const colorArrayValue = processedValue.map((item: any) => { if (item && typeof item === 'object' && 'r' in item) { @@ -955,21 +1062,19 @@ export class ComponentTools implements ToolExecutor { // Step 5: 等待Editor完成更新，然后验证设置结果 await new Promise(resolve => setTimeout(resolve, 200)); // 等待200ms让Editor完成更新 - const verification = await this.verifyPropertyChange(nodeUuid, componentType, property, originalValue, processedValue); + + const verification = await this.verifyPropertyChange(nodeUuid, componentType, property, originalValue, actualExpectedValue); resolve({ success: true, - message: `Successfully set ${componentType}.${property} = ${JSON.stringify(processedValue)}`, + message: `Successfully set ${componentType}.${property}`, data: { nodeUuid, componentType, property, - originalValue, - newValue: processedValue, actualValue: verification.actualValue, changeVerified: verification.verified - }, - verificationData: verification.fullData + } }); } catch (error: any) { @@ -984,28 +1089,63 @@ export class ComponentTools implements ToolExecutor { private async attachScript(nodeUuid: string, scriptPath: string): Promise { - return new Promise((resolve) => { + return new Promise(async (resolve) => { // 从脚本路径提取组件类名 const scriptName = scriptPath.split('/').pop()?.replace('.ts', '').replace('.js', ''); if (!scriptName) { resolve({ success: false, error: 'Invalid script path' }); return; } - + // 先查找节点上是否已存在该脚本组件 + const allComponentsInfo = await this.getComponents(nodeUuid); + if (allComponentsInfo.success && allComponentsInfo.data?.components) { + const existingScript = allComponentsInfo.data.components.find((comp: any) => comp.type === scriptName); + if (existingScript) { + resolve({ + success: true, + message: `Script '${scriptName}' already exists on node`, + data: { + nodeUuid: nodeUuid, + componentName: scriptName, + existing: true + } + }); + return; + } + } // 首先尝试直接使用脚本名称作为组件类型 Editor.Message.request('scene', 'create-component', { uuid: nodeUuid, component: scriptName // 使用脚本名称而非UUID - }).then((result: any) => { - resolve({ - success: true, - data: { - componentId: result, - scriptPath: scriptPath, - componentName: scriptName, - message: `Script '${scriptName}' attached successfully` + }).then(async (result: any) => { + // 等待一段时间让Editor完成组件添加 + await new Promise(resolve => setTimeout(resolve, 100)); + // 重新查询节点信息验证脚本是否真的添加成功 + const allComponentsInfo2 = await this.getComponents(nodeUuid); + if (allComponentsInfo2.success && allComponentsInfo2.data?.components) { + const addedScript = allComponentsInfo2.data.components.find((comp: any) => comp.type === scriptName); + if (addedScript) { + resolve({ + success: true, + message: `Script '${scriptName}' attached successfully`, + data: { + nodeUuid: nodeUuid, + componentName: scriptName, + existing: false + } + }); + } else { + resolve({ + success: false, + error: `Script '${scriptName}' was not found on node after addition. Available components: ${allComponentsInfo2.data.components.map((c: any) => c.type).join(', ')}` + }); } - }); + } else { + resolve({ + success: false, + error: `Failed to verify script addition: ${allComponentsInfo2.error || 'Unable to get node components'}` + }); + } }).catch((err: Error) => { // 备用方案：使用场景脚本 const options = { @@ -1013,7 +1153,6 @@ export class ComponentTools implements ToolExecutor { method: 'attachScript', args: [nodeUuid, scriptPath] }; - Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { resolve(result); }).catch(() => { @@ -1274,45 +1413,43 @@ export class ComponentTools implements ToolExecutor { return Boolean(inputValue); case 'color': - if (typeof inputValue === 'object' && inputValue !== null) { - // 先检查对象的值是否都是数字或字符串，避免对复杂对象使用'in'操作符 + // 优化的颜色处理，支持多种输入格式 + if (typeof inputValue === 'string') { + // 字符串格式：十六进制、颜色名称、rgb()/rgba() + return this.parseColorString(inputValue); + } else if (typeof inputValue === 'object' && inputValue !== null) { try { - // 如果输入是颜色对象，直接使用 const inputKeys = Object.keys(inputValue); + // 如果输入是颜色对象，验证并转换 if (inputKeys.includes('r') || inputKeys.includes('g') || inputKeys.includes('b')) { return { - r: Number(inputValue.r) || 0, - g: Number(inputValue.g) || 0, - b: Number(inputValue.b) || 0, - a: inputValue.a !== undefined ? Number(inputValue.a) : 255 + r: Math.min(255, Math.max(0, Number(inputValue.r) || 0)), + g: Math.min(255, Math.max(0, Number(inputValue.g) || 0)), + b: Math.min(255, Math.max(0, Number(inputValue.b) || 0)), + a: inputValue.a !== undefined ? Math.min(255, Math.max(0, Number(inputValue.a))) : 255 }; } } catch (error) { - // 如果使用'in'操作符出错，说明不是有效的颜色对象 - console.warn(`[smartConvertValue] Invalid color input: ${JSON.stringify(inputValue)}`); + console.warn(`[smartConvertValue] Invalid color object: ${JSON.stringify(inputValue)}`); } - } else if (typeof inputValue === 'string') { - // 如果是字符串，尝试解析为十六进制颜色 - return this.parseColorString(inputValue); } - // 保持原值结构，只更新提供的值 - try { - const inputKeys = typeof inputValue === 'object' && inputValue ? Object.keys(inputValue) : []; - return { - r: inputKeys.includes('r') ? Number(inputValue.r) : (originalValue.r || 255), - g: inputKeys.includes('g') ? Number(inputValue.g) : (originalValue.g || 255), - b: inputKeys.includes('b') ? Number(inputValue.b) : (originalValue.b || 255), - a: inputKeys.includes('a') ? Number(inputValue.a) : (originalValue.a || 255) - }; - } catch (error) { - // 如果有任何错误，返回原值或默认值 - return { - r: originalValue.r || 255, - g: originalValue.g || 255, - b: originalValue.b || 255, - a: originalValue.a || 255 - }; + // 如果有原值，保持原值结构并更新提供的值 + if (originalValue && typeof originalValue === 'object') { + try { + const inputKeys = typeof inputValue === 'object' && inputValue ? Object.keys(inputValue) : []; + return { + r: inputKeys.includes('r') ? Math.min(255, Math.max(0, Number(inputValue.r))) : (originalValue.r || 255), + g: inputKeys.includes('g') ? Math.min(255, Math.max(0, Number(inputValue.g))) : (originalValue.g || 255), + b: inputKeys.includes('b') ? Math.min(255, Math.max(0, Number(inputValue.b))) : (originalValue.b || 255), + a: inputKeys.includes('a') ? Math.min(255, Math.max(0, Number(inputValue.a))) : (originalValue.a || 255) + }; + } catch (error) { + console.warn(`[smartConvertValue] Error processing color with original value: ${error}`); + } } + // 默认返回白色 + console.warn(`[smartConvertValue] Using default white color for invalid input: ${JSON.stringify(inputValue)}`); + return { r: 255, g: 255, b: 255, a: 255 }; case 'vec2': if (typeof inputValue === 'object' && inputValue !== null) { @@ -1370,16 +1507,27 @@ export class ComponentTools implements ToolExecutor { } } - private parseColorString(colorStr: string): { r: number; g: number; b: number; a: number } { - // 简单的颜色字符串解析（支持#RRGGBB格式） // cSpell:ignore RRGGBB - if (colorStr.startsWith('#') && colorStr.length === 7) { - const r = parseInt(colorStr.substring(1, 3), 16); - const g = parseInt(colorStr.substring(3, 5), 16); - const b = parseInt(colorStr.substring(5, 7), 16); - return { r, g, b, a: 255 }; + private parseColorString(colorStr: string): { r: number; g: number; b: number; a: number } { + const str = colorStr.trim(); + + // 只支持十六进制格式 #RRGGBB 或 #RRGGBBAA + if (str.startsWith('#')) { + if (str.length === 7) { // #RRGGBB + const r = parseInt(str.substring(1, 3), 16); + const g = parseInt(str.substring(3, 5), 16); + const b = parseInt(str.substring(5, 7), 16); + return { r, g, b, a: 255 }; + } else if (str.length === 9) { // #RRGGBBAA + const r = parseInt(str.substring(1, 3), 16); + const g = parseInt(str.substring(3, 5), 16); + const b = parseInt(str.substring(5, 7), 16); + const a = parseInt(str.substring(7, 9), 16); + return { r, g, b, a }; + } } - // 默认返回白色 - return { r: 255, g: 255, b: 255, a: 255 }; + + // 如果不是有效的十六进制格式，返回错误提示 + throw new Error(`Invalid color format: "${colorStr}". Only hexadecimal format is supported (e.g., "#FF0000" or "#FF0000FF")`); } private async verifyPropertyChange(nodeUuid: string, componentType: string, property: string, originalValue: any, expectedValue: any): Promise<{ verified: boolean; actualValue: any; fullData: any }> { @@ -1498,4 +1646,132 @@ export class ComponentTools implements ToolExecutor { fullData: null }; } + + /** + * 检测是否为节点属性，如果是则重定向到对应的节点方法 + */ + private async checkAndRedirectNodeProperties(args: any): Promise { + const { nodeUuid, componentType, property, propertyType, value } = args; + + // 检测是否为节点基础属性（应该使用 set_node_property） + const nodeBasicProperties = [ + 'name', 'active', 'layer', 'mobility', 'parent', 'children', 'hideFlags' + ]; + + // 检测是否为节点变换属性（应该使用 set_node_transform） + const nodeTransformProperties = [ + 'position', 'rotation', 'scale', 'eulerAngles', 'angle' + ]; + + // Detect attempts to set cc.Node properties (common mistake) + if (componentType === 'cc.Node' || componentType === 'Node') { + if (nodeBasicProperties.includes(property)) { + return { + success: false, + error: `Property '${property}' is a node basic property, not a component property`, + instruction: `Please use set_node_property method to set node properties: set_node_property(uuid="${nodeUuid}", property="${property}", value=${JSON.stringify(value)})` + }; + } else if (nodeTransformProperties.includes(property)) { + return { + success: false, + error: `Property '${property}' is a node transform property, not a component property`, + instruction: `Please use set_node_transform method to set transform properties: set_node_transform(uuid="${nodeUuid}", ${property}=${JSON.stringify(value)})` + }; + } + } + + // Detect common incorrect usage + if (nodeBasicProperties.includes(property) || nodeTransformProperties.includes(property)) { + const methodName = nodeTransformProperties.includes(property) ? 'set_node_transform' : 'set_node_property'; + return { + success: false, + error: `Property '${property}' is a node property, not a component property`, + instruction: `Property '${property}' should be set using ${methodName} method, not set_component_property. Please use: ${methodName}(uuid="${nodeUuid}", ${nodeTransformProperties.includes(property) ? property : `property="${property}"`}=${JSON.stringify(value)})` + }; + } + + return null; // 不是节点属性，继续正常处理 + } + + /** + * 生成组件建议信息 + */ + private generateComponentSuggestion(requestedType: string, availableTypes: string[], property: string): string { + // 检查是否存在相似的组件类型 + const similarTypes = availableTypes.filter(type => + type.toLowerCase().includes(requestedType.toLowerCase()) || + requestedType.toLowerCase().includes(type.toLowerCase()) + ); + + let instruction = ''; + + if (similarTypes.length > 0) { + instruction += `\n\n🔍 Found similar components: ${similarTypes.join(', ')}`; + instruction += `\n💡 Suggestion: Perhaps you meant to set the '${similarTypes[0]}' component?`; + } + + // Recommend possible components based on property name + const propertyToComponentMap: Record = { + 'string': ['cc.Label', 'cc.RichText', 'cc.EditBox'], + 'text': ['cc.Label', 'cc.RichText'], + 'fontSize': ['cc.Label', 'cc.RichText'], + 'spriteFrame': ['cc.Sprite'], + 'color': ['cc.Label', 'cc.Sprite', 'cc.Graphics'], + 'normalColor': ['cc.Button'], + 'pressedColor': ['cc.Button'], + 'target': ['cc.Button'], + 'contentSize': ['cc.UITransform'], + 'anchorPoint': ['cc.UITransform'] + }; + + const recommendedComponents = propertyToComponentMap[property] || []; + const availableRecommended = recommendedComponents.filter(comp => availableTypes.includes(comp)); + + if (availableRecommended.length > 0) { + instruction += `\n\n🎯 Based on property '${property}', recommended components: ${availableRecommended.join(', ')}`; + } + + // Provide operation suggestions + instruction += `\n\n📋 Suggested Actions:`; + instruction += `\n1. Use get_components(nodeUuid="${requestedType.includes('uuid') ? 'YOUR_NODE_UUID' : 'nodeUuid'}") to view all components on the node`; + instruction += `\n2. If you need to add a component, use add_component(nodeUuid="...", componentType="${requestedType}")`; + instruction += `\n3. Verify that the component type name is correct (case-sensitive)`; + + return instruction; + } + + /** + * 快速验证资源设置结果 + */ + private async quickVerifyAsset(nodeUuid: string, componentType: string, property: string): Promise { + try { + const rawNodeData = await Editor.Message.request('scene', 'query-node', nodeUuid); + if (!rawNodeData || !rawNodeData.__comps__) { + return null; + } + + // 找到组件 + const component = rawNodeData.__comps__.find((comp: any) => { + const compType = comp.__type__ || comp.cid || comp.type; + return compType === componentType; + }); + + if (!component) { + return null; + } + + // 提取属性值 + const properties = this.extractComponentProperties(component); + const propertyData = properties[property]; + + if (propertyData && typeof propertyData === 'object' && 'value' in propertyData) { + return propertyData.value; + } else { + return propertyData; + } + } catch (error) { + console.error(`[quickVerifyAsset] Error:`, error); + return null; + } + } } \ No newline at end of file diff --git a/source/tools/node-tools.ts b/source/tools/node-tools.ts index 33be7ed..2bafc22 100644 --- a/source/tools/node-tools.ts +++ b/source/tools/node-tools.ts @@ -1,11 +1,13 @@ import { ToolDefinition, ToolResponse, ToolExecutor, NodeInfo } from '../types'; +import { ComponentTools } from './component-tools'; export class NodeTools implements ToolExecutor { + private componentTools = new ComponentTools(); getTools(): ToolDefinition[] { return [ { name: 'create_node', - description: 'Create a new node in the scene. IMPORTANT: You should always provide parentUuid to specify where to create the node. If parentUuid is not provided, the node will be created at the scene root.', + description: 'Create a new node in the scene. Supports creating empty nodes, nodes with components, or instantiating from assets (prefabs, etc.). IMPORTANT: You should always provide parentUuid to specify where to create the node.', inputSchema: { type: 'object', properties: { @@ -27,6 +29,59 @@ export class NodeTools implements ToolExecutor { type: 'number', description: 'Sibling index for ordering (-1 means append at end)', default: -1 + }, + assetUuid: { + type: 'string', + description: 'Asset UUID to instantiate from (e.g., prefab UUID). When provided, creates a node instance from the asset instead of an empty node.' + }, + assetPath: { + type: 'string', + description: 'Asset path to instantiate from (e.g., "db://assets/prefabs/MyPrefab.prefab"). Alternative to assetUuid.' + }, + components: { + type: 'array', + items: { type: 'string' }, + description: 'Array of component type names to add to the new node (e.g., ["cc.Sprite", "cc.Button"])' + }, + unlinkPrefab: { + type: 'boolean', + description: 'If true and creating from prefab, unlink from prefab to create a regular node', + default: false + }, + keepWorldTransform: { + type: 'boolean', + description: 'Whether to keep world transform when creating the node', + default: false + }, + initialTransform: { + type: 'object', + properties: { + position: { + type: 'object', + properties: { + x: { type: 'number' }, + y: { type: 'number' }, + z: { type: 'number' } + } + }, + rotation: { + type: 'object', + properties: { + x: { type: 'number' }, + y: { type: 'number' }, + z: { type: 'number' } + } + }, + scale: { + type: 'object', + properties: { + x: { type: 'number' }, + y: { type: 'number' }, + z: { type: 'number' } + } + } + }, + description: 'Initial transform to apply to the created node' } }, required: ['name'] @@ -89,7 +144,7 @@ export class NodeTools implements ToolExecutor { }, { name: 'set_node_property', - description: 'Set node property value (prefer using set_node_transform for position/rotation/scale)', + description: 'Set node property value (prefer using set_node_transform for active/layer/mobility/position/rotation/scale)', inputSchema: { type: 'object', properties: { @@ -253,150 +308,190 @@ export class NodeTools implements ToolExecutor { private async createNode(args: any): Promise { return new Promise(async (resolve) => { - let targetParentUuid = args.parentUuid; - - // 如果没有提供父节点UUID，获取场景根节点 - if (!targetParentUuid) { - try { - const sceneInfo = await Editor.Message.request('scene', 'query-node-tree'); - if (sceneInfo && typeof sceneInfo === 'object' && !Array.isArray(sceneInfo) && Object.prototype.hasOwnProperty.call(sceneInfo, 'uuid')) { - targetParentUuid = (sceneInfo as any).uuid; - console.log(`No parent specified, using scene root: ${targetParentUuid}`); - } else if (Array.isArray(sceneInfo) && sceneInfo.length > 0 && sceneInfo[0].uuid) { - // 如果返回的是数组，使用第一个元素（通常是场景根节点） - targetParentUuid = sceneInfo[0].uuid; - console.log(`No parent specified, using scene root: ${targetParentUuid}`); - } else { - // 备用方案：尝试获取当前场景 - const currentScene = await Editor.Message.request('scene', 'query-current-scene'); - if (currentScene && currentScene.uuid) { - targetParentUuid = currentScene.uuid; + try { + let targetParentUuid = args.parentUuid; + + // 如果没有提供父节点UUID，获取场景根节点 + if (!targetParentUuid) { + try { + const sceneInfo = await Editor.Message.request('scene', 'query-node-tree'); + if (sceneInfo && typeof sceneInfo === 'object' && !Array.isArray(sceneInfo) && Object.prototype.hasOwnProperty.call(sceneInfo, 'uuid')) { + targetParentUuid = (sceneInfo as any).uuid; + console.log(`No parent specified, using scene root: ${targetParentUuid}`); + } else if (Array.isArray(sceneInfo) && sceneInfo.length > 0 && sceneInfo[0].uuid) { + targetParentUuid = sceneInfo[0].uuid; + console.log(`No parent specified, using scene root: ${targetParentUuid}`); + } else { + const currentScene = await Editor.Message.request('scene', 'query-current-scene'); + if (currentScene && currentScene.uuid) { + targetParentUuid = currentScene.uuid; + } } + } catch (err) { + console.warn('Failed to get scene root, will use default behavior'); } - } catch (err) { - console.warn('Failed to get scene root, will use default behavior'); } - } - // 如果指定了父节点，先验证父节点是否存在 - if (targetParentUuid) { - try { - const parentNode = await Editor.Message.request('scene', 'query-node', targetParentUuid); - if (!parentNode) { + // 如果提供了assetPath，先解析为assetUuid + let finalAssetUuid = args.assetUuid; + if (args.assetPath && !finalAssetUuid) { + try { + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', args.assetPath); + if (assetInfo && assetInfo.uuid) { + finalAssetUuid = assetInfo.uuid; + console.log(`Asset path '${args.assetPath}' resolved to UUID: ${finalAssetUuid}`); + } else { + resolve({ + success: false, + error: `Asset not found at path: ${args.assetPath}` + }); + return; + } + } catch (err) { resolve({ success: false, - error: `Parent node with UUID '${targetParentUuid}' not found` + error: `Failed to resolve asset path '${args.assetPath}': ${err}` }); return; } - } catch (err) { - resolve({ - success: false, - error: `Failed to verify parent node: ${err}` - }); - return; } - } - const nodeData: any = { - name: args.name, - type: args.nodeType || 'cc.Node' - }; - - // 使用正确的create-node API参数结构 - if (targetParentUuid) { - const createNodeOptions = { - parent: targetParentUuid, - name: args.name, - components: args.nodeType && args.nodeType !== 'Node' ? [args.nodeType] : undefined + // 构建create-node选项 + const createNodeOptions: any = { + name: args.name }; - - Editor.Message.request('scene', 'create-node', createNodeOptions).then((nodeUuid: any) => { - // 如果需要设置特定的兄弟索引，使用set-parent API - // 添加延迟以避免内部状态竞争 - if (args.siblingIndex !== undefined && args.siblingIndex >= 0 && nodeUuid) { - setTimeout(() => { - Editor.Message.request('scene', 'set-parent', { - parent: targetParentUuid, - uuids: [nodeUuid], - keepWorldTransform: false - }).then(() => { - resolve({ - success: true, - data: { - uuid: nodeUuid, - name: args.name, - parentUuid: targetParentUuid, - message: args.parentUuid - ? `Node '${args.name}' created under specified parent` - : `Node '${args.name}' created at scene root (no parent specified)` - } - }); - }).catch(() => { - // 即使移动失败，节点已创建，返回成功但带警告 - resolve({ - success: true, - data: { - uuid: nodeUuid, - name: args.name, - message: `Node '${args.name}' created but may not be under intended parent`, - warning: 'Failed to move node to specified parent' - } - }); - }); - }, 100); // 100ms延迟 - } else { - // Get complete node info for verification - this.getNodeInfo(nodeUuid).then((nodeInfo) => { - resolve({ - success: true, - data: { - uuid: nodeUuid, - name: args.name, - message: `Node '${args.name}' created successfully` - }, - verificationData: { - nodeInfo: nodeInfo.data, - creationDetails: { - parentUuid: targetParentUuid, - nodeType: args.nodeType || 'Node', - timestamp: new Date().toISOString() - } - } - }); - }).catch(() => { - resolve({ - success: true, - data: { - uuid: nodeUuid, - name: args.name, - message: `Node '${args.name}' created successfully (verification failed)` - } - }); - }); + + // 设置父节点 + if (targetParentUuid) { + createNodeOptions.parent = targetParentUuid; + } + + // 从资源实例化 + if (finalAssetUuid) { + createNodeOptions.assetUuid = finalAssetUuid; + if (args.unlinkPrefab) { + createNodeOptions.unlinkPrefab = true; } - }).catch((err: Error) => { - resolve({ success: false, error: err.message }); - }); - } else { - // 没有找到场景根节点，使用默认行为（创建在场景根节点） - const createNodeOptions = { - name: args.name, - components: args.nodeType && args.nodeType !== 'Node' ? [args.nodeType] : undefined - }; - - Editor.Message.request('scene', 'create-node', createNodeOptions).then((result: any) => { - resolve({ - success: true, - data: { - uuid: result, - name: args.name, - message: `Node '${args.name}' created at default location (scene root not found)`, - warning: 'Could not determine scene root, node created at default location' + } + + // 添加组件 + if (args.components && args.components.length > 0) { + createNodeOptions.components = args.components; + } else if (args.nodeType && args.nodeType !== 'Node' && !finalAssetUuid) { + // 只有在不从资源实例化时才添加nodeType组件 + createNodeOptions.components = [args.nodeType]; + } + + // 保持世界变换 + if (args.keepWorldTransform) { + createNodeOptions.keepWorldTransform = true; + } + + // 不使用dump参数处理初始变换，创建后使用set_node_transform设置 + + console.log('Creating node with options:', createNodeOptions); + + // 创建节点 + const nodeUuid = await Editor.Message.request('scene', 'create-node', createNodeOptions); + const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid; + + // 处理兄弟索引 + if (args.siblingIndex !== undefined && args.siblingIndex >= 0 && uuid && targetParentUuid) { + try { + await new Promise(resolve => setTimeout(resolve, 100)); // 等待内部状态更新 + await Editor.Message.request('scene', 'set-parent', { + parent: targetParentUuid, + uuids: [uuid], + keepWorldTransform: args.keepWorldTransform || false + }); + } catch (err) { + console.warn('Failed to set sibling index:', err); + } + } + + // 添加组件（如果提供的话） + if (args.components && args.components.length > 0 && uuid) { + try { + await new Promise(resolve => setTimeout(resolve, 100)); // 等待节点创建完成 + for (const componentType of args.components) { + try { + const result = await this.componentTools.execute('add_component', { + nodeUuid: uuid, + componentType: componentType + }); + if (result.success) { + console.log(`Component ${componentType} added successfully`); + } else { + console.warn(`Failed to add component ${componentType}:`, result.error); + } + } catch (err) { + console.warn(`Failed to add component ${componentType}:`, err); + } } - }); - }).catch((err: Error) => { - resolve({ success: false, error: err.message }); + } catch (err) { + console.warn('Failed to add components:', err); + } + } + + // 设置初始变换（如果提供的话） + if (args.initialTransform && uuid) { + try { + await new Promise(resolve => setTimeout(resolve, 150)); // 等待节点和组件创建完成 + await this.setNodeTransform({ + uuid: uuid, + position: args.initialTransform.position, + rotation: args.initialTransform.rotation, + scale: args.initialTransform.scale + }); + console.log('Initial transform applied successfully'); + } catch (err) { + console.warn('Failed to set initial transform:', err); + } + } + + // 获取创建后的节点信息进行验证 + let verificationData: any = null; + try { + const nodeInfo = await this.getNodeInfo(uuid); + if (nodeInfo.success) { + verificationData = { + nodeInfo: nodeInfo.data, + creationDetails: { + parentUuid: targetParentUuid, + nodeType: args.nodeType || 'Node', + fromAsset: !!finalAssetUuid, + assetUuid: finalAssetUuid, + assetPath: args.assetPath, + timestamp: new Date().toISOString() + } + }; + } + } catch (err) { + console.warn('Failed to get verification data:', err); + } + + const successMessage = finalAssetUuid + ? `Node '${args.name}' instantiated from asset successfully` + : `Node '${args.name}' created successfully`; + + resolve({ + success: true, + data: { + uuid: uuid, + name: args.name, + parentUuid: targetParentUuid, + nodeType: args.nodeType || 'Node', + fromAsset: !!finalAssetUuid, + assetUuid: finalAssetUuid, + message: successMessage + }, + verificationData: verificationData + }); + + } catch (err: any) { + resolve({ + success: false, + error: `Failed to create node: ${err.message}. Args: ${JSON.stringify(args)}` }); } }); diff --git a/source/tools/prefab-tools.ts b/source/tools/prefab-tools.ts index b285dc7..792f08f 100644 --- a/source/tools/prefab-tools.ts +++ b/source/tools/prefab-tools.ts @@ -60,7 +60,7 @@ export class PrefabTools implements ToolExecutor { }, { name: 'create_prefab', - description: 'Create a prefab from a node', + description: 'Create a prefab from a node with all children and components', inputSchema: { type: 'object', properties: { @@ -70,44 +70,16 @@ export class PrefabTools implements ToolExecutor { }, savePath: { type: 'string', - description: 'Path to save the prefab' + description: 'Path to save the prefab (e.g., db://assets/prefabs/MyPrefab.prefab)' }, prefabName: { type: 'string', description: 'Prefab name' - }, - includeChildren: { - type: 'boolean', - description: 'Whether to include child nodes', - default: true - }, - includeComponents: { - type: 'boolean', - description: 'Whether to include components', - default: true } }, required: ['nodeUuid', 'savePath', 'prefabName'] } }, - { - name: 'create_prefab_from_node', - description: 'Create a prefab from a node (alias for create_prefab)', - inputSchema: { - type: 'object', - properties: { - nodeUuid: { - type: 'string', - description: 'Source node UUID' - }, - prefabPath: { - type: 'string', - description: 'Path to save the prefab' - } - }, - required: ['nodeUuid', 'prefabPath'] - } - }, { name: 'update_prefab', description: 'Update an existing prefab', @@ -221,8 +193,6 @@ export class PrefabTools implements ToolExecutor { return await this.instantiatePrefab(args); case 'create_prefab': return await this.createPrefab(args); - case 'create_prefab_from_node': - return await this.createPrefabFromNode(args); case 'update_prefab': return await this.updatePrefab(args.prefabPath, args.nodeUuid); case 'revert_prefab': @@ -287,8 +257,10 @@ export class PrefabTools implements ToolExecutor { } private async instantiatePrefab(args: any): Promise { - return new Promise((resolve) => { - Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo: any) => { + return new Promise(async (resolve) => { + try { + // 获取预制体资源信息 + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath); if (!assetInfo) { throw new Error('预制体未找到'); } @@ -319,10 +291,16 @@ export class PrefabTools implements ToolExecutor { }; } - return Editor.Message.request('scene', 'create-node', createNodeOptions); - }).then((nodeUuid: string | string[]) => { - // 获取实际的节点UUID + // 创建节点 + const nodeUuid = await Editor.Message.request('scene', 'create-node', createNodeOptions); const uuid = Array.isArray(nodeUuid) ? nodeUuid[0] : nodeUuid; + + // 注意：create-node API从预制体资源创建时应该自动建立预制体关联 + console.log('预制体节点创建成功:', { + nodeUuid: uuid, + prefabUuid: assetInfo.uuid, + prefabPath: args.prefabPath + }); resolve({ success: true, @@ -331,19 +309,183 @@ export class PrefabTools implements ToolExecutor { prefabPath: args.prefabPath, parentUuid: args.parentUuid, position: args.position, - message: '预制体实例化成功' + message: '预制体实例化成功，已建立预制体关联' } }); - }).catch((err: Error) => { + } catch (err: any) { resolve({ success: false, error: `预制体实例化失败: ${err.message}`, instruction: '请检查预制体路径是否正确，确保预制体文件格式正确' }); - }); + } }); } + /** + * 建立节点与预制体的关联关系 + * 这个方法创建必要的PrefabInfo和PrefabInstance结构 + */ + private async establishPrefabConnection(nodeUuid: string, prefabUuid: string, prefabPath: string): Promise { + try { + // 读取预制体文件获取根节点的fileId + const prefabContent = await this.readPrefabFile(prefabPath); + if (!prefabContent || !prefabContent.data || !prefabContent.data.length) { + throw new Error('无法读取预制体文件内容'); + } + + // 找到预制体根节点的fileId (通常是第二个对象，即索引1) + const rootNode = prefabContent.data.find((item: any) => item.__type === 'cc.Node' && item._parent === null); + if (!rootNode || !rootNode._prefab) { + throw new Error('无法找到预制体根节点或其预制体信息'); + } + + // 获取根节点的PrefabInfo + const rootPrefabInfo = prefabContent.data[rootNode._prefab.__id__]; + if (!rootPrefabInfo || rootPrefabInfo.__type !== 'cc.PrefabInfo') { + throw new Error('无法找到预制体根节点的PrefabInfo'); + } + + const rootFileId = rootPrefabInfo.fileId; + + // 使用scene API建立预制体连接 + const prefabConnectionData = { + node: nodeUuid, + prefab: prefabUuid, + fileId: rootFileId + }; + + // 尝试使用多种API方法建立预制体连接 + const connectionMethods = [ + () => Editor.Message.request('scene', 'connect-prefab-instance', prefabConnectionData), + () => Editor.Message.request('scene', 'set-prefab-connection', prefabConnectionData), + () => Editor.Message.request('scene', 'apply-prefab-link', prefabConnectionData) + ]; + + let connected = false; + for (const method of connectionMethods) { + try { + await method(); + connected = true; + break; + } catch (error) { + console.warn('预制体连接方法失败，尝试下一个方法:', error); + } + } + + if (!connected) { + // 如果所有API方法都失败，尝试手动修改场景数据 + console.warn('所有预制体连接API都失败，尝试手动建立连接'); + await this.manuallyEstablishPrefabConnection(nodeUuid, prefabUuid, rootFileId); + } + + } catch (error) { + console.error('建立预制体连接失败:', error); + throw error; + } + } + + /** + * 手动建立预制体连接（当API方法失败时的备用方案） + */ + private async manuallyEstablishPrefabConnection(nodeUuid: string, prefabUuid: string, rootFileId: string): Promise { + try { + // 尝试使用dump API修改节点的_prefab属性 + const prefabConnectionData = { + [nodeUuid]: { + '_prefab': { + '__uuid__': prefabUuid, + '__expectedType__': 'cc.Prefab', + 'fileId': rootFileId + } + } + }; + + await Editor.Message.request('scene', 'set-property', { + uuid: nodeUuid, + path: '_prefab', + dump: { + value: { + '__uuid__': prefabUuid, + '__expectedType__': 'cc.Prefab' + } + } + }); + + } catch (error) { + console.error('手动建立预制体连接也失败:', error); + // 不抛出错误，因为基本的节点创建已经成功 + } + } + + /** + * 读取预制体文件内容 + */ + private async readPrefabFile(prefabPath: string): Promise { + try { + // 尝试使用asset-db API读取文件内容 + let assetContent: any; + try { + assetContent = await Editor.Message.request('asset-db', 'query-asset-info', prefabPath); + if (assetContent && assetContent.source) { + // 如果有source路径，直接读取文件 + const fs = require('fs'); + const path = require('path'); + const fullPath = path.resolve(assetContent.source); + const fileContent = fs.readFileSync(fullPath, 'utf8'); + return JSON.parse(fileContent); + } + } catch (error) { + console.warn('使用asset-db读取失败，尝试其他方法:', error); + } + + // 备用方法：转换db://路径为实际文件路径 + const fsPath = prefabPath.replace('db://assets/', 'assets/').replace('db://assets', 'assets'); + const fs = require('fs'); + const path = require('path'); + + // 尝试多个可能的项目根路径 + const possiblePaths = [ + path.resolve(process.cwd(), '../../NewProject_3', fsPath), + path.resolve('/Users/lizhiyong/NewProject_3', fsPath), + path.resolve(fsPath), + // 如果是根目录下的文件，也尝试直接路径 + path.resolve('/Users/lizhiyong/NewProject_3/assets', path.basename(fsPath)) + ]; + + console.log('尝试读取预制体文件，路径转换:', { + originalPath: prefabPath, + fsPath: fsPath, + possiblePaths: possiblePaths + }); + + for (const fullPath of possiblePaths) { + try { + console.log(`检查路径: ${fullPath}`); + if (fs.existsSync(fullPath)) { + console.log(`找到文件: ${fullPath}`); + const fileContent = fs.readFileSync(fullPath, 'utf8'); + const parsed = JSON.parse(fileContent); + console.log('文件解析成功，数据结构:', { + hasData: !!parsed.data, + dataLength: parsed.data ? parsed.data.length : 0 + }); + return parsed; + } else { + console.log(`文件不存在: ${fullPath}`); + } + } catch (readError) { + console.warn(`读取文件失败 ${fullPath}:`, readError); + } + } + + throw new Error('无法找到或读取预制体文件'); + } catch (error) { + console.error('读取预制体文件失败:', error); + throw error; + } + } + private async tryCreateNodeWithPrefab(args: any): Promise { return new Promise((resolve) => { Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo: any) => { @@ -524,6 +666,98 @@ export class PrefabTools implements ToolExecutor { }); } + /** + * 使用 asset-db API 创建预制体的新方法 + * 深度整合引擎的资源管理系统，实现完整的预制体创建流程 + */ + private async createPrefabWithAssetDB(nodeUuid: string, savePath: string, prefabName: string, includeChildren: boolean, includeComponents: boolean): Promise { + return new Promise(async (resolve) => { + try { + console.log('=== 使用 Asset-DB API 创建预制体 ==='); + console.log(`节点UUID: ${nodeUuid}`); + console.log(`保存路径: ${savePath}`); + console.log(`预制体名称: ${prefabName}`); + + // 第一步：获取节点数据（包括变换属性） + const nodeData = await this.getNodeData(nodeUuid); + if (!nodeData) { + resolve({ + success: false, + error: '无法获取节点数据' + }); + return; + } + + console.log('获取到节点数据，子节点数量:', nodeData.children ? nodeData.children.length : 0); + + // 第二步：先创建资源文件以获取引擎分配的UUID + console.log('创建预制体资源文件...'); + const tempPrefabContent = JSON.stringify([{"__type__": "cc.Prefab", "_name": prefabName}], null, 2); + const createResult = await this.createAssetWithAssetDB(savePath, tempPrefabContent); + if (!createResult.success) { + resolve(createResult); + return; + } + + // 获取引擎分配的实际UUID + const actualPrefabUuid = createResult.data?.uuid; + if (!actualPrefabUuid) { + resolve({ + success: false, + error: '无法获取引擎分配的预制体UUID' + }); + return; + } + console.log('引擎分配的UUID:', actualPrefabUuid); + + // 第三步：使用实际UUID重新生成预制体内容 + const prefabContent = await this.createStandardPrefabContent(nodeData, prefabName, actualPrefabUuid, includeChildren, includeComponents); + const prefabContentString = JSON.stringify(prefabContent, null, 2); + + // 第四步：更新预制体文件内容 + console.log('更新预制体文件内容...'); + const updateResult = await this.updateAssetWithAssetDB(savePath, prefabContentString); + + // 第五步：创建对应的meta文件（使用实际UUID） + console.log('创建预制体meta文件...'); + const metaContent = this.createStandardMetaContent(prefabName, actualPrefabUuid); + const metaResult = await this.createMetaWithAssetDB(savePath, metaContent); + + // 第六步：重新导入资源以更新引用 + console.log('重新导入预制体资源...'); + const reimportResult = await this.reimportAssetWithAssetDB(savePath); + + // 第七步：尝试将原始节点转换为预制体实例 + console.log('尝试将原始节点转换为预制体实例...'); + const convertResult = await this.convertNodeToPrefabInstance(nodeUuid, actualPrefabUuid, savePath); + + resolve({ + success: true, + data: { + prefabUuid: actualPrefabUuid, + prefabPath: savePath, + nodeUuid: nodeUuid, + prefabName: prefabName, + convertedToPrefabInstance: convertResult.success, + createAssetResult: createResult, + updateResult: updateResult, + metaResult: metaResult, + reimportResult: reimportResult, + convertResult: convertResult, + message: convertResult.success ? '预制体创建并成功转换原始节点' : '预制体创建成功，但节点转换失败' + } + }); + + } catch (error) { + console.error('创建预制体时发生错误:', error); + resolve({ + success: false, + error: `创建预制体失败: ${error}` + }); + } + }); + } + private async createPrefab(args: any): Promise { return new Promise(async (resolve) => { try { @@ -541,7 +775,26 @@ export class PrefabTools implements ToolExecutor { const fullPath = pathParam.endsWith('.prefab') ? pathParam : `${pathParam}/${prefabName}.prefab`; - // 尝试使用Cocos Creator的原生预制体创建API + const includeChildren = args.includeChildren !== false; // 默认为 true + const includeComponents = args.includeComponents !== false; // 默认为 true + + // 优先使用新的 asset-db 方法创建预制体 + console.log('使用新的 asset-db 方法创建预制体...'); + const assetDbResult = await this.createPrefabWithAssetDB( + args.nodeUuid, + fullPath, + prefabName, + includeChildren, + includeComponents + ); + + if (assetDbResult.success) { + resolve(assetDbResult); + return; + } + + // 如果 asset-db 方法失败，尝试使用Cocos Creator的原生预制体创建API + console.log('asset-db 方法失败，尝试原生API...'); const nativeResult = await this.createPrefabNative(args.nodeUuid, fullPath); if (nativeResult.success) { resolve(nativeResult); @@ -549,6 +802,7 @@ export class PrefabTools implements ToolExecutor { } // 如果原生API失败，使用自定义实现 + console.log('原生API失败，使用自定义实现...'); const customResult = await this.createPrefabCustom(args.nodeUuid, fullPath, prefabName); resolve(customResult); @@ -598,7 +852,7 @@ export class PrefabTools implements ToolExecutor { console.log('节点UUID:', nodeData.uuid?.value || '未知'); console.log('预制体保存路径:', prefabPath); console.log(`开始创建预制体，节点数据:`, nodeData); - const prefabJsonData = await this.createStandardPrefabData(nodeData, prefabName, prefabUuid); + const prefabJsonData = await this.createStandardPrefabContent(nodeData, prefabName, prefabUuid, true, true); // 5. 创建标准meta文件数据 const standardMetaData = this.createStandardMetaData(prefabName, prefabUuid); @@ -607,6 +861,9 @@ export class PrefabTools implements ToolExecutor { const saveResult = await this.savePrefabWithMeta(prefabPath, prefabJsonData, standardMetaData); if (saveResult.success) { + // 保存成功后，将原始节点转换为预制体实例 + const convertResult = await this.convertNodeToPrefabInstance(nodeUuid, prefabPath, prefabUuid); + resolve({ success: true, data: { @@ -614,7 +871,10 @@ export class PrefabTools implements ToolExecutor { prefabPath: prefabPath, nodeUuid: nodeUuid, prefabName: prefabName, - message: '自定义预制体创建成功' + convertedToPrefabInstance: convertResult.success, + message: convertResult.success ? + '自定义预制体创建成功，原始节点已转换为预制体实例' : + '预制体创建成功，但节点转换失败' } }); } else { @@ -634,51 +894,128 @@ export class PrefabTools implements ToolExecutor { } private async getNodeData(nodeUuid: string): Promise { - return new Promise((resolve) => { - Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeInfo: any) => { + return new Promise(async (resolve) => { + try { + // 首先获取基本节点信息 + const nodeInfo = await Editor.Message.request('scene', 'query-node', nodeUuid); if (!nodeInfo) { resolve(null); return; } - // 尝试获取节点的完整序列化数据 - Editor.Message.request('scene', 'serialize-node', { - node: nodeUuid, - includeChildren: true - }).then((serializedData: any) => { - resolve(serializedData); - }).catch(() => { - // 如果序列化失败，尝试获取节点的详细信息 - this.getNodeDetailedInfo(nodeUuid).then((detailedInfo: any) => { - resolve(detailedInfo || nodeInfo); - }).catch(() => { - resolve(nodeInfo); - }); - }); - }).catch(() => { + console.log(`获取节点 ${nodeUuid} 的基本信息成功`); + + // 使用query-node-tree获取包含子节点的完整结构 + const nodeTree = await this.getNodeWithChildren(nodeUuid); + if (nodeTree) { + console.log(`获取节点 ${nodeUuid} 的完整树结构成功`); + resolve(nodeTree); + } else { + console.log(`使用基本节点信息`); + resolve(nodeInfo); + } + } catch (error) { + console.warn(`获取节点数据失败 ${nodeUuid}:`, error); resolve(null); - }); + } }); } - private async getNodeDetailedInfo(nodeUuid: string): Promise { - return new Promise((resolve) => { - // 获取节点的详细信息，包括组件和子节点 - Editor.Message.request('scene', 'query-node-detail', nodeUuid).then((detailInfo: any) => { - if (detailInfo) { - resolve(detailInfo); - } else { - // 如果无法获取详细信息，构建基本节点信息 - this.buildBasicNodeInfo(nodeUuid).then((basicInfo: any) => { - resolve(basicInfo); - }).catch(() => { - resolve(null); - }); + // 使用query-node-tree获取包含子节点的完整节点结构 + private async getNodeWithChildren(nodeUuid: string): Promise { + try { + // 获取整个场景树 + const tree = await Editor.Message.request('scene', 'query-node-tree'); + if (!tree) { + return null; + } + + // 在树中查找指定的节点 + const targetNode = this.findNodeInTree(tree, nodeUuid); + if (targetNode) { + console.log(`在场景树中找到节点 ${nodeUuid}，子节点数量: ${targetNode.children ? targetNode.children.length : 0}`); + + // 增强节点树，获取每个节点的正确组件信息 + const enhancedTree = await this.enhanceTreeWithMCPComponents(targetNode); + return enhancedTree; + } + + return null; + } catch (error) { + console.warn(`获取节点树结构失败 ${nodeUuid}:`, error); + return null; + } + } + + // 在节点树中递归查找指定UUID的节点 + private findNodeInTree(node: any, targetUuid: string): any { + if (!node) return null; + + // 检查当前节点 + if (node.uuid === targetUuid || node.value?.uuid === targetUuid) { + return node; + } + + // 递归检查子节点 + if (node.children && Array.isArray(node.children)) { + for (const child of node.children) { + const found = this.findNodeInTree(child, targetUuid); + if (found) { + return found; } - }).catch(() => { - resolve(null); + } + } + + return null; + } + + /** + * 使用MCP接口增强节点树，获取正确的组件信息 + */ + private async enhanceTreeWithMCPComponents(node: any): Promise { + if (!node || !node.uuid) { + return node; + } + + try { + // 使用MCP接口获取节点的组件信息 + const response = await fetch('http://localhost:8585/mcp', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + "jsonrpc": "2.0", + "method": "tools/call", + "params": { + "name": "component_get_components", + "arguments": { + "nodeUuid": node.uuid + } + }, + "id": Date.now() + }) }); - }); + + const mcpResult = await response.json(); + if (mcpResult.result?.content?.[0]?.text) { + const componentData = JSON.parse(mcpResult.result.content[0].text); + if (componentData.success && componentData.data.components) { + // 更新节点的组件信息为MCP返回的正确数据 + node.components = componentData.data.components; + console.log(`节点 ${node.uuid} 获取到 ${componentData.data.components.length} 个组件，包含脚本组件的正确类型`); + } + } + } catch (error) { + console.warn(`获取节点 ${node.uuid} 的MCP组件信息失败:`, error); + } + + // 递归处理子节点 + if (node.children && Array.isArray(node.children)) { + for (let i = 0; i < node.children.length; i++) { + node.children[i] = await this.enhanceTreeWithMCPComponents(node.children[i]); + } + } + + return node; } private async buildBasicNodeInfo(nodeUuid: string): Promise { @@ -704,6 +1041,79 @@ export class PrefabTools implements ToolExecutor { }); } + // 验证节点数据是否有效 + private isValidNodeData(nodeData: any): boolean { + if (!nodeData) return false; + if (typeof nodeData !== 'object') return false; + + // 检查基本属性 - 适配query-node-tree的数据格式 + return nodeData.hasOwnProperty('uuid') || + nodeData.hasOwnProperty('name') || + nodeData.hasOwnProperty('__type__') || + (nodeData.value && ( + nodeData.value.hasOwnProperty('uuid') || + nodeData.value.hasOwnProperty('name') || + nodeData.value.hasOwnProperty('__type__') + )); + } + + // 提取子节点UUID的统一方法 + private extractChildUuid(childRef: any): string | null { + if (!childRef) return null; + + // 方法1: 直接字符串 + if (typeof childRef === 'string') { + return childRef; + } + + // 方法2: value属性包含字符串 + if (childRef.value && typeof childRef.value === 'string') { + return childRef.value; + } + + // 方法3: value.uuid属性 + if (childRef.value && childRef.value.uuid) { + return childRef.value.uuid; + } + + // 方法4: 直接uuid属性 + if (childRef.uuid) { + return childRef.uuid; + } + + // 方法5: __id__引用 - 这种情况需要特殊处理 + if (childRef.__id__ !== undefined) { + console.log(`发现__id__引用: ${childRef.__id__}，可能需要从数据结构中查找`); + return null; // 暂时返回null，后续可以添加引用解析逻辑 + } + + console.warn('无法提取子节点UUID:', JSON.stringify(childRef)); + return null; + } + + // 获取需要处理的子节点数据 + private getChildrenToProcess(nodeData: any): any[] { + const children: any[] = []; + + // 方法1: 直接从children数组获取（从query-node-tree返回的数据） + if (nodeData.children && Array.isArray(nodeData.children)) { + console.log(`从children数组获取子节点，数量: ${nodeData.children.length}`); + for (const child of nodeData.children) { + // query-node-tree返回的子节点通常已经是完整的数据结构 + if (this.isValidNodeData(child)) { + children.push(child); + console.log(`添加子节点: ${child.name || child.value?.name || '未知'}`); + } else { + console.log('子节点数据无效:', JSON.stringify(child, null, 2)); + } + } + } else { + console.log('节点没有子节点或children数组为空'); + } + + return children; + } + private generateUUID(): string { // 生成符合Cocos Creator格式的UUID const chars = '0123456789abcdef'; @@ -762,9 +1172,9 @@ export class PrefabTools implements ToolExecutor { }, "_lpos": { "__type__": "cc.Vec3", - "x": node.position?.x || 0, - "y": node.position?.y || 0, - "z": node.position?.z || 0 + "x": 0, + "y": 0, + "z": 0 }, "_lrot": { "__type__": "cc.Quat", @@ -775,9 +1185,9 @@ export class PrefabTools implements ToolExecutor { }, "_lscale": { "__type__": "cc.Vec3", - "x": node.scale?.x || 1, - "y": node.scale?.y || 1, - "z": node.scale?.z || 1 + "x": 1, + "y": 1, + "z": 1 }, "_mobility": 0, "_layer": 1073741824, @@ -1171,6 +1581,780 @@ export class PrefabTools implements ToolExecutor { return modifiedData; } + /** + * 使用 asset-db API 创建资源文件 + */ + private async createAssetWithAssetDB(assetPath: string, content: string): Promise<{ success: boolean; data?: any; error?: string }> { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'create-asset', assetPath, content, { + overwrite: true, + rename: false + }).then((assetInfo: any) => { + console.log('创建资源文件成功:', assetInfo); + resolve({ success: true, data: assetInfo }); + }).catch((error: any) => { + console.error('创建资源文件失败:', error); + resolve({ success: false, error: error.message || '创建资源文件失败' }); + }); + }); + } + + /** + * 使用 asset-db API 创建 meta 文件 + */ + private async createMetaWithAssetDB(assetPath: string, metaContent: any): Promise<{ success: boolean; data?: any; error?: string }> { + return new Promise((resolve) => { + const metaContentString = JSON.stringify(metaContent, null, 2); + Editor.Message.request('asset-db', 'save-asset-meta', assetPath, metaContentString).then((assetInfo: any) => { + console.log('创建meta文件成功:', assetInfo); + resolve({ success: true, data: assetInfo }); + }).catch((error: any) => { + console.error('创建meta文件失败:', error); + resolve({ success: false, error: error.message || '创建meta文件失败' }); + }); + }); + } + + /** + * 使用 asset-db API 重新导入资源 + */ + private async reimportAssetWithAssetDB(assetPath: string): Promise<{ success: boolean; data?: any; error?: string }> { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'reimport-asset', assetPath).then((result: any) => { + console.log('重新导入资源成功:', result); + resolve({ success: true, data: result }); + }).catch((error: any) => { + console.error('重新导入资源失败:', error); + resolve({ success: false, error: error.message || '重新导入资源失败' }); + }); + }); + } + + /** + * 使用 asset-db API 更新资源文件内容 + */ + private async updateAssetWithAssetDB(assetPath: string, content: string): Promise<{ success: boolean; data?: any; error?: string }> { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'save-asset', assetPath, content).then((result: any) => { + console.log('更新资源文件成功:', result); + resolve({ success: true, data: result }); + }).catch((error: any) => { + console.error('更新资源文件失败:', error); + resolve({ success: false, error: error.message || '更新资源文件失败' }); + }); + }); + } + + /** + * 创建符合 Cocos Creator 标准的预制体内容 + * 完整实现递归节点树处理，匹配引擎标准格式 + */ + private async createStandardPrefabContent(nodeData: any, prefabName: string, prefabUuid: string, includeChildren: boolean, includeComponents: boolean): Promise { + console.log('开始创建引擎标准预制体内容...'); + + const prefabData: any[] = []; + let currentId = 0; + + // 1. 创建预制体资产对象 (index 0) + const prefabAsset = { + "__type__": "cc.Prefab", + "_name": prefabName || "", // 确保预制体名称不为空 + "_objFlags": 0, + "__editorExtras__": {}, + "_native": "", + "data": { + "__id__": 1 + }, + "optimizationPolicy": 0, + "persistent": false + }; + prefabData.push(prefabAsset); + currentId++; + + // 2. 递归创建完整的节点树结构 + const context = { + prefabData, + currentId: currentId + 1, // 根节点占用索引1，子节点从索引2开始 + prefabAssetIndex: 0, + nodeFileIds: new Map(), // 存储节点ID到fileId的映射 + nodeUuidToIndex: new Map(), // 存储节点UUID到索引的映射 + componentUuidToIndex: new Map() // 存储组件UUID到索引的映射 + }; + + // 创建根节点和整个节点树 - 注意：根节点的父节点应该是null，不是预制体对象 + await this.createCompleteNodeTree(nodeData, null, 1, context, includeChildren, includeComponents, prefabName); + + console.log(`预制体内容创建完成，总共 ${prefabData.length} 个对象`); + console.log('节点fileId映射:', Array.from(context.nodeFileIds.entries())); + + return prefabData; + } + + /** + * 递归创建完整的节点树，包括所有子节点和对应的PrefabInfo + */ + private async createCompleteNodeTree( + nodeData: any, + parentNodeIndex: number | null, + nodeIndex: number, + context: { + prefabData: any[], + currentId: number, + prefabAssetIndex: number, + nodeFileIds: Map, + nodeUuidToIndex: Map, + componentUuidToIndex: Map + }, + includeChildren: boolean, + includeComponents: boolean, + nodeName?: string + ): Promise { + const { prefabData } = context; + + // 创建节点对象 + const node = this.createEngineStandardNode(nodeData, parentNodeIndex, nodeName); + + // 确保节点在指定的索引位置 + while (prefabData.length <= nodeIndex) { + prefabData.push(null); + } + console.log(`设置节点到索引 ${nodeIndex}: ${node._name}, _parent:`, node._parent, `_children count: ${node._children.length}`); + prefabData[nodeIndex] = node; + + // 为当前节点生成fileId并记录UUID到索引的映射 + const nodeUuid = this.extractNodeUuid(nodeData); + const fileId = nodeUuid || this.generateFileId(); + context.nodeFileIds.set(nodeIndex.toString(), fileId); + + // 记录节点UUID到索引的映射 + if (nodeUuid) { + context.nodeUuidToIndex.set(nodeUuid, nodeIndex); + console.log(`记录节点UUID映射: ${nodeUuid} -> ${nodeIndex}`); + } + + // 先处理子节点（保持与手动创建的索引顺序一致） + const childrenToProcess = this.getChildrenToProcess(nodeData); + if (includeChildren && childrenToProcess.length > 0) { + console.log(`处理节点 ${node._name} 的 ${childrenToProcess.length} 个子节点`); + + // 为每个子节点分配索引 + const childIndices: number[] = []; + console.log(`准备为 ${childrenToProcess.length} 个子节点分配索引，当前ID: ${context.currentId}`); + for (let i = 0; i < childrenToProcess.length; i++) { + console.log(`处理第 ${i+1} 个子节点，当前currentId: ${context.currentId}`); + const childIndex = context.currentId++; + childIndices.push(childIndex); + node._children.push({ "__id__": childIndex }); + console.log(`✅ 添加子节点引用到 ${node._name}: {__id__: ${childIndex}}`); + } + console.log(`✅ 节点 ${node._name} 最终的子节点数组:`, node._children); + + // 递归创建子节点 + for (let i = 0; i < childrenToProcess.length; i++) { + const childData = childrenToProcess[i]; + const childIndex = childIndices[i]; + await this.createCompleteNodeTree( + childData, + nodeIndex, + childIndex, + context, + includeChildren, + includeComponents, + childData.name || `Child${i+1}` + ); + } + } + + // 然后处理组件 + if (includeComponents && nodeData.components && Array.isArray(nodeData.components)) { + console.log(`处理节点 ${node._name} 的 ${nodeData.components.length} 个组件`); + + const componentIndices: number[] = []; + for (const component of nodeData.components) { + const componentIndex = context.currentId++; + componentIndices.push(componentIndex); + node._components.push({ "__id__": componentIndex }); + + // 记录组件UUID到索引的映射 + const componentUuid = component.uuid || (component.value && component.value.uuid); + if (componentUuid) { + context.componentUuidToIndex.set(componentUuid, componentIndex); + console.log(`记录组件UUID映射: ${componentUuid} -> ${componentIndex}`); + } + + // 创建组件对象，传入context以处理引用 + const componentObj = this.createComponentObject(component, nodeIndex, context); + prefabData[componentIndex] = componentObj; + + // 为组件创建 CompPrefabInfo + const compPrefabInfoIndex = context.currentId++; + prefabData[compPrefabInfoIndex] = { + "__type__": "cc.CompPrefabInfo", + "fileId": this.generateFileId() + }; + + // 如果组件对象有 __prefab 属性，设置引用 + if (componentObj && typeof componentObj === 'object') { + componentObj.__prefab = { "__id__": compPrefabInfoIndex }; + } + } + + console.log(`✅ 节点 ${node._name} 添加了 ${componentIndices.length} 个组件`); + } + + + // 为当前节点创建PrefabInfo + const prefabInfoIndex = context.currentId++; + node._prefab = { "__id__": prefabInfoIndex }; + + const prefabInfo: any = { + "__type__": "cc.PrefabInfo", + "root": { "__id__": 1 }, + "asset": { "__id__": context.prefabAssetIndex }, + "fileId": fileId, + "targetOverrides": null, + "nestedPrefabInstanceRoots": null + }; + + // 根节点的特殊处理 + if (nodeIndex === 1) { + // 根节点没有instance，但可能有targetOverrides + prefabInfo.instance = null; + } else { + // 子节点通常有instance为null + prefabInfo.instance = null; + } + + prefabData[prefabInfoIndex] = prefabInfo; + context.currentId = prefabInfoIndex + 1; + } + + /** + * 将UUID转换为Cocos Creator的压缩格式 + * 基于真实Cocos Creator编辑器的压缩算法实现 + * 前5个hex字符保持不变，剩余27个字符压缩成18个字符 + */ + private uuidToCompressedId(uuid: string): string { + const BASE64_KEYS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; + + // 移除连字符并转为小写 + const cleanUuid = uuid.replace(/-/g, '').toLowerCase(); + + // 确保UUID有效 + if (cleanUuid.length !== 32) { + return uuid; // 如果不是有效的UUID，返回原始值 + } + + // Cocos Creator的压缩算法：前5个字符保持不变，剩余27个字符压缩成18个字符 + let result = cleanUuid.substring(0, 5); + + // 剩余27个字符需要压缩成18个字符 + const remainder = cleanUuid.substring(5); + + // 每3个hex字符压缩成2个字符 + for (let i = 0; i < remainder.length; i += 3) { + const hex1 = remainder[i] || '0'; + const hex2 = remainder[i + 1] || '0'; + const hex3 = remainder[i + 2] || '0'; + + // 将3个hex字符(12位)转换为2个base64字符 + const value = parseInt(hex1 + hex2 + hex3, 16); + + // 12位分成两个6位 + const high6 = (value >> 6) & 63; + const low6 = value & 63; + + result += BASE64_KEYS[high6] + BASE64_KEYS[low6]; + } + + return result; + } + + /** + * 创建组件对象 + */ + private createComponentObject(componentData: any, nodeIndex: number, context?: { + nodeUuidToIndex?: Map, + componentUuidToIndex?: Map + }): any { + let componentType = componentData.type || componentData.__type__ || 'cc.Component'; + const enabled = componentData.enabled !== undefined ? componentData.enabled : true; + + // console.log(`创建组件对象 - 原始类型: ${componentType}`); + // console.log('组件完整数据:', JSON.stringify(componentData, null, 2)); + + // 处理脚本组件 - MCP接口已经返回正确的压缩UUID格式 + if (componentType && !componentType.startsWith('cc.')) { + console.log(`使用脚本组件压缩UUID类型: ${componentType}`); + } + + // 基础组件结构 + const component: any = { + "__type__": componentType, + "_name": "", + "_objFlags": 0, + "__editorExtras__": {}, + "node": { "__id__": nodeIndex }, + "_enabled": enabled + }; + + // 提前设置 __prefab 属性占位符，后续会被正确设置 + component.__prefab = null; + + // 根据组件类型添加特定属性 + if (componentType === 'cc.UITransform') { + const contentSize = componentData.properties?.contentSize?.value || { width: 100, height: 100 }; + const anchorPoint = componentData.properties?.anchorPoint?.value || { x: 0.5, y: 0.5 }; + + component._contentSize = { + "__type__": "cc.Size", + "width": contentSize.width, + "height": contentSize.height + }; + component._anchorPoint = { + "__type__": "cc.Vec2", + "x": anchorPoint.x, + "y": anchorPoint.y + }; + } else if (componentType === 'cc.Sprite') { + // 处理Sprite组件的spriteFrame引用 + const spriteFrameProp = componentData.properties?._spriteFrame || componentData.properties?.spriteFrame; + if (spriteFrameProp) { + component._spriteFrame = this.processComponentProperty(spriteFrameProp, context); + } else { + component._spriteFrame = null; + } + + component._type = componentData.properties?._type?.value ?? 0; + component._fillType = componentData.properties?._fillType?.value ?? 0; + component._sizeMode = componentData.properties?._sizeMode?.value ?? 1; + component._fillCenter = { "__type__": "cc.Vec2", "x": 0, "y": 0 }; + component._fillStart = componentData.properties?._fillStart?.value ?? 0; + component._fillRange = componentData.properties?._fillRange?.value ?? 0; + component._isTrimmedMode = componentData.properties?._isTrimmedMode?.value ?? true; + component._useGrayscale = componentData.properties?._useGrayscale?.value ?? false; + + // 调试：打印Sprite组件的所有属性（已注释） + // console.log('Sprite组件属性:', JSON.stringify(componentData.properties, null, 2)); + component._atlas = null; + component._id = ""; + } else if (componentType === 'cc.Button') { + component._interactable = true; + component._transition = 3; + component._normalColor = { "__type__": "cc.Color", "r": 255, "g": 255, "b": 255, "a": 255 }; + component._hoverColor = { "__type__": "cc.Color", "r": 211, "g": 211, "b": 211, "a": 255 }; + component._pressedColor = { "__type__": "cc.Color", "r": 255, "g": 255, "b": 255, "a": 255 }; + component._disabledColor = { "__type__": "cc.Color", "r": 124, "g": 124, "b": 124, "a": 255 }; + component._normalSprite = null; + component._hoverSprite = null; + component._pressedSprite = null; + component._disabledSprite = null; + component._duration = 0.1; + component._zoomScale = 1.2; + // 处理Button的target引用 + const targetProp = componentData.properties?._target || componentData.properties?.target; + if (targetProp) { + component._target = this.processComponentProperty(targetProp, context); + } else { + component._target = { "__id__": nodeIndex }; // 默认指向自身节点 + } + component._clickEvents = []; + component._id = ""; + } else if (componentType === 'cc.Label') { + component._string = componentData.properties?._string?.value || "Label"; + component._horizontalAlign = 1; + component._verticalAlign = 1; + component._actualFontSize = 20; + component._fontSize = 20; + component._fontFamily = "Arial"; + component._lineHeight = 25; + component._overflow = 0; + component._enableWrapText = true; + component._font = null; + component._isSystemFontUsed = true; + component._spacingX = 0; + component._isItalic = false; + component._isBold = false; + component._isUnderline = false; + component._underlineHeight = 2; + component._cacheMode = 0; + component._id = ""; + } else if (componentData.properties) { + // 处理所有组件的属性（包括内置组件和自定义脚本组件） + for (const [key, value] of Object.entries(componentData.properties)) { + if (key === 'node' || key === 'enabled' || key === '__type__' || + key === 'uuid' || key === 'name' || key === '__scriptAsset' || key === '_objFlags') { + continue; // 跳过这些特殊属性，包括_objFlags + } + + // 对于以下划线开头的属性，需要特殊处理 + if (key.startsWith('_')) { + // 确保属性名保持原样（包括下划线） + const propValue = this.processComponentProperty(value, context); + if (propValue !== undefined) { + component[key] = propValue; + } + } else { + // 非下划线开头的属性正常处理 + const propValue = this.processComponentProperty(value, context); + if (propValue !== undefined) { + component[key] = propValue; + } + } + } + } + + // 确保 _id 在最后位置 + const _id = component._id || ""; + delete component._id; + component._id = _id; + + return component; + } + + /** + * 处理组件属性值，确保格式与手动创建的预制体一致 + */ + private processComponentProperty(propData: any, context?: { + nodeUuidToIndex?: Map, + componentUuidToIndex?: Map + }): any { + if (!propData || typeof propData !== 'object') { + return propData; + } + + const value = propData.value; + const type = propData.type; + + // 处理null值 + if (value === null || value === undefined) { + return null; + } + + // 处理空UUID对象，转换为null + if (value && typeof value === 'object' && value.uuid === '') { + return null; + } + + // 处理节点引用 + if (type === 'cc.Node' && value?.uuid) { + // 在预制体中，节点引用需要转换为 __id__ 形式 + if (context?.nodeUuidToIndex && context.nodeUuidToIndex.has(value.uuid)) { + // 内部引用：转换为__id__格式 + return { + "__id__": context.nodeUuidToIndex.get(value.uuid) + }; + } + // 外部引用：设置为null，因为外部节点不属于预制体结构 + console.warn(`Node reference UUID ${value.uuid} not found in prefab context, setting to null (external reference)`); + return null; + } + + // 处理资源引用（预制体、纹理、精灵帧等） + if (value?.uuid && ( + type === 'cc.Prefab' || + type === 'cc.Texture2D' || + type === 'cc.SpriteFrame' || + type === 'cc.Material' || + type === 'cc.AnimationClip' || + type === 'cc.AudioClip' || + type === 'cc.Font' || + type === 'cc.Asset' + )) { + // 对于预制体引用，保持原始UUID格式 + const uuidToUse = type === 'cc.Prefab' ? value.uuid : this.uuidToCompressedId(value.uuid); + return { + "__uuid__": uuidToUse, + "__expectedType__": type + }; + } + + // 处理组件引用（包括具体的组件类型如cc.Label, cc.Button等） + if (value?.uuid && (type === 'cc.Component' || + type === 'cc.Label' || type === 'cc.Button' || type === 'cc.Sprite' || + type === 'cc.UITransform' || type === 'cc.RigidBody2D' || + type === 'cc.BoxCollider2D' || type === 'cc.Animation' || + type === 'cc.AudioSource' || (type?.startsWith('cc.') && !type.includes('@')))) { + // 在预制体中，组件引用也需要转换为 __id__ 形式 + if (context?.componentUuidToIndex && context.componentUuidToIndex.has(value.uuid)) { + // 内部引用：转换为__id__格式 + console.log(`Component reference ${type} UUID ${value.uuid} found in prefab context, converting to __id__`); + return { + "__id__": context.componentUuidToIndex.get(value.uuid) + }; + } + // 外部引用：设置为null，因为外部组件不属于预制体结构 + console.warn(`Component reference ${type} UUID ${value.uuid} not found in prefab context, setting to null (external reference)`); + return null; + } + + // 处理复杂类型，添加__type__标记 + if (value && typeof value === 'object') { + if (type === 'cc.Color') { + return { + "__type__": "cc.Color", + "r": Math.min(255, Math.max(0, Number(value.r) || 0)), + "g": Math.min(255, Math.max(0, Number(value.g) || 0)), + "b": Math.min(255, Math.max(0, Number(value.b) || 0)), + "a": value.a !== undefined ? Math.min(255, Math.max(0, Number(value.a))) : 255 + }; + } else if (type === 'cc.Vec3') { + return { + "__type__": "cc.Vec3", + "x": Number(value.x) || 0, + "y": Number(value.y) || 0, + "z": Number(value.z) || 0 + }; + } else if (type === 'cc.Vec2') { + return { + "__type__": "cc.Vec2", + "x": Number(value.x) || 0, + "y": Number(value.y) || 0 + }; + } else if (type === 'cc.Size') { + return { + "__type__": "cc.Size", + "width": Number(value.width) || 0, + "height": Number(value.height) || 0 + }; + } else if (type === 'cc.Quat') { + return { + "__type__": "cc.Quat", + "x": Number(value.x) || 0, + "y": Number(value.y) || 0, + "z": Number(value.z) || 0, + "w": value.w !== undefined ? Number(value.w) : 1 + }; + } + } + + // 处理数组类型 + if (Array.isArray(value)) { + // 节点数组 + if (propData.elementTypeData?.type === 'cc.Node') { + return value.map(item => { + if (item?.uuid && context?.nodeUuidToIndex?.has(item.uuid)) { + return { "__id__": context.nodeUuidToIndex.get(item.uuid) }; + } + return null; + }).filter(item => item !== null); + } + + // 资源数组 + if (propData.elementTypeData?.type && propData.elementTypeData.type.startsWith('cc.')) { + return value.map(item => { + if (item?.uuid) { + return { + "__uuid__": this.uuidToCompressedId(item.uuid), + "__expectedType__": propData.elementTypeData.type + }; + } + return null; + }).filter(item => item !== null); + } + + // 基础类型数组 + return value.map(item => item?.value !== undefined ? item.value : item); + } + + // 其他复杂对象类型，保持原样但确保有__type__标记 + if (value && typeof value === 'object' && type && type.startsWith('cc.')) { + return { + "__type__": type, + ...value + }; + } + + return value; + } + + /** + * 创建符合引擎标准的节点对象 + */ + private createEngineStandardNode(nodeData: any, parentNodeIndex: number | null, nodeName?: string): any { + // 调试：打印原始节点数据（已注释） + // console.log('原始节点数据:', JSON.stringify(nodeData, null, 2)); + + // 提取节点的基本属性 + const getValue = (prop: any) => { + if (prop?.value !== undefined) return prop.value; + if (prop !== undefined) return prop; + return null; + }; + + const position = getValue(nodeData.position) || getValue(nodeData.value?.position) || { x: 0, y: 0, z: 0 }; + const rotation = getValue(nodeData.rotation) || getValue(nodeData.value?.rotation) || { x: 0, y: 0, z: 0, w: 1 }; + const scale = getValue(nodeData.scale) || getValue(nodeData.value?.scale) || { x: 1, y: 1, z: 1 }; + const active = getValue(nodeData.active) ?? getValue(nodeData.value?.active) ?? true; + const name = nodeName || getValue(nodeData.name) || getValue(nodeData.value?.name) || 'Node'; + const layer = getValue(nodeData.layer) || getValue(nodeData.value?.layer) || 1073741824; + + // 调试输出 + console.log(`创建节点: ${name}, parentNodeIndex: ${parentNodeIndex}`); + + const parentRef = parentNodeIndex !== null ? { "__id__": parentNodeIndex } : null; + console.log(`节点 ${name} 的父节点引用:`, parentRef); + + return { + "__type__": "cc.Node", + "_name": name, + "_objFlags": 0, + "__editorExtras__": {}, + "_parent": parentRef, + "_children": [], // 子节点引用将在递归过程中动态添加 + "_active": active, + "_components": [], // 组件引用将在处理组件时动态添加 + "_prefab": { "__id__": 0 }, // 临时值，后续会被正确设置 + "_lpos": { + "__type__": "cc.Vec3", + "x": position.x, + "y": position.y, + "z": position.z + }, + "_lrot": { + "__type__": "cc.Quat", + "x": rotation.x, + "y": rotation.y, + "z": rotation.z, + "w": rotation.w + }, + "_lscale": { + "__type__": "cc.Vec3", + "x": scale.x, + "y": scale.y, + "z": scale.z + }, + "_mobility": 0, + "_layer": layer, + "_euler": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "_id": "" + }; + } + + /** + * 从节点数据中提取UUID + */ + private extractNodeUuid(nodeData: any): string | null { + if (!nodeData) return null; + + // 尝试多种方式获取UUID + const sources = [ + nodeData.uuid, + nodeData.value?.uuid, + nodeData.__uuid__, + nodeData.value?.__uuid__, + nodeData.id, + nodeData.value?.id + ]; + + for (const source of sources) { + if (typeof source === 'string' && source.length > 0) { + return source; + } + } + + return null; + } + + /** + * 创建最小化的节点对象，不包含任何组件以避免依赖问题 + */ + private createMinimalNode(nodeData: any, nodeName?: string): any { + // 提取节点的基本属性 + const getValue = (prop: any) => { + if (prop?.value !== undefined) return prop.value; + if (prop !== undefined) return prop; + return null; + }; + + const position = getValue(nodeData.position) || getValue(nodeData.value?.position) || { x: 0, y: 0, z: 0 }; + const rotation = getValue(nodeData.rotation) || getValue(nodeData.value?.rotation) || { x: 0, y: 0, z: 0, w: 1 }; + const scale = getValue(nodeData.scale) || getValue(nodeData.value?.scale) || { x: 1, y: 1, z: 1 }; + const active = getValue(nodeData.active) ?? getValue(nodeData.value?.active) ?? true; + const name = nodeName || getValue(nodeData.name) || getValue(nodeData.value?.name) || 'Node'; + const layer = getValue(nodeData.layer) || getValue(nodeData.value?.layer) || 33554432; + + return { + "__type__": "cc.Node", + "_name": name, + "_objFlags": 0, + "_parent": null, + "_children": [], + "_active": active, + "_components": [], // 空的组件数组，避免组件依赖问题 + "_prefab": { + "__id__": 2 + }, + "_lpos": { + "__type__": "cc.Vec3", + "x": position.x, + "y": position.y, + "z": position.z + }, + "_lrot": { + "__type__": "cc.Quat", + "x": rotation.x, + "y": rotation.y, + "z": rotation.z, + "w": rotation.w + }, + "_lscale": { + "__type__": "cc.Vec3", + "x": scale.x, + "y": scale.y, + "z": scale.z + }, + "_layer": layer, + "_euler": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "_id": "" + }; + } + + /** + * 创建标准的 meta 文件内容 + */ + private createStandardMetaContent(prefabName: string, prefabUuid: string): any { + return { + "ver": "2.0.3", + "importer": "prefab", + "imported": true, + "uuid": prefabUuid, + "files": [ + ".json" + ], + "subMetas": {}, + "userData": { + "syncNodeName": prefabName, + "hasIcon": false + } + }; + } + + /** + * 尝试将原始节点转换为预制体实例 + */ + private async convertNodeToPrefabInstance(nodeUuid: string, prefabUuid: string, prefabPath: string): Promise<{ success: boolean; error?: string }> { + return new Promise((resolve) => { + // 这个功能需要深入的场景编辑器集成，暂时返回失败 + // 在实际的引擎中，这涉及到复杂的预制体实例化和节点替换逻辑 + console.log('节点转换为预制体实例的功能需要更深入的引擎集成'); + resolve({ + success: false, + error: '节点转换为预制体实例需要更深入的引擎集成支持' + }); + }); + } + private async restorePrefabNode(nodeUuid: string, assetUuid: string): Promise { return new Promise((resolve) => { // 使用官方API restore-prefab 还原预制体节点 @@ -1233,33 +2417,42 @@ export class PrefabTools implements ToolExecutor { prefabData.push(rootNode.node); currentId = rootNode.nextId; - // 添加根节点的 PrefabInfo + // 添加根节点的 PrefabInfo - 修复asset引用使用UUID const rootPrefabInfo = { "__type__": "cc.PrefabInfo", "root": { "__id__": 1 }, "asset": { - "__id__": 0 + "__uuid__": prefabUuid }, "fileId": this.generateFileId(), - "targetOverrides": null + "instance": null, + "targetOverrides": [], + "nestedPrefabInstanceRoots": [] }; prefabData.push(rootPrefabInfo); return prefabData; } + private async createNodeObject(nodeData: any, parentId: number | null, prefabData: any[], currentId: number): Promise<{ node: any; nextId: number }> { const nodeId = currentId++; - // 提取节点的基本属性 - const position = nodeData.position?.value || { x: 0, y: 0, z: 0 }; - const rotation = nodeData.rotation?.value || { x: 0, y: 0, z: 0, w: 1 }; - const scale = nodeData.scale?.value || { x: 1, y: 1, z: 1 }; - const active = nodeData.active?.value !== undefined ? nodeData.active.value : true; - const name = nodeData.name?.value || 'Node'; - const layer = nodeData.layer?.value || 33554432; + // 提取节点的基本属性 - 适配query-node-tree的数据格式 + const getValue = (prop: any) => { + if (prop?.value !== undefined) return prop.value; + if (prop !== undefined) return prop; + return null; + }; + + const position = getValue(nodeData.position) || getValue(nodeData.value?.position) || { x: 0, y: 0, z: 0 }; + const rotation = getValue(nodeData.rotation) || getValue(nodeData.value?.rotation) || { x: 0, y: 0, z: 0, w: 1 }; + const scale = getValue(nodeData.scale) || getValue(nodeData.value?.scale) || { x: 1, y: 1, z: 1 }; + const active = getValue(nodeData.active) ?? getValue(nodeData.value?.active) ?? true; + const name = getValue(nodeData.name) || getValue(nodeData.value?.name) || 'Node'; + const layer = getValue(nodeData.layer) || getValue(nodeData.value?.layer) || 33554432; const node: any = { "__type__": "cc.Node", @@ -1270,9 +2463,9 @@ export class PrefabTools implements ToolExecutor { "_children": [], "_active": active, "_components": [], - "_prefab": { + "_prefab": parentId === null ? { "__id__": currentId++ - }, + } : null, "_lpos": { "__type__": "cc.Vec3", "x": position.x, @@ -1303,100 +2496,43 @@ export class PrefabTools implements ToolExecutor { "_id": "" }; - // 添加组件 - if (nodeData.__comps__ && nodeData.__comps__.length > 0) { - for (const comp of nodeData.__comps__) { - const componentId = currentId++; - node._components.push({ "__id__": componentId }); - - // 创建组件对象 - const componentObj = this.createComponentObject(comp, nodeId, currentId++); - prefabData.push(componentObj); - - // 添加组件的 CompPrefabInfo - const compPrefabInfo = { - "__type__": "cc.CompPrefabInfo", - "fileId": this.generateFileId() - }; - prefabData.push(compPrefabInfo); - currentId++; - } + // 暂时跳过UITransform组件以避免_getDependComponent错误 + // 后续通过Engine API动态添加 + console.log(`节点 ${name} 暂时跳过UITransform组件，避免引擎依赖错误`); + + // 处理其他组件（暂时跳过，专注于修复UITransform问题） + const components = this.extractComponentsFromNode(nodeData); + if (components.length > 0) { + console.log(`节点 ${name} 包含 ${components.length} 个其他组件，暂时跳过以专注于UITransform修复`); } - // 处理子节点 - if (nodeData.children && Array.isArray(nodeData.children) && nodeData.children.length > 0) { + // 处理子节点 - 使用query-node-tree获取的完整结构 + const childrenToProcess = this.getChildrenToProcess(nodeData); + if (childrenToProcess.length > 0) { console.log(`=== 处理子节点 ===`); - console.log(`节点 ${name} 包含 ${nodeData.children.length} 个子节点`); - console.log('完整子节点数据:', JSON.stringify(nodeData.children, null, 2)); + console.log(`节点 ${name} 包含 ${childrenToProcess.length} 个子节点`); - for (let i = 0; i < nodeData.children.length; i++) { - const childRef = nodeData.children[i]; - console.log(`第${i}个子节点的完整数据:`, JSON.stringify(childRef, null, 2)); + for (let i = 0; i < childrenToProcess.length; i++) { + const childData = childrenToProcess[i]; + const childName = childData.name || childData.value?.name || '未知'; + console.log(`处理第${i + 1}个子节点: ${childName}`); - // 尝试多种可能的UUID提取方式 - let childUuid = null; - if (typeof childRef === 'string') { - childUuid = childRef; - console.log(`方法1 - 直接字符串: ${childUuid}`); - } else if (childRef && childRef.value) { - if (typeof childRef.value === 'string') { - childUuid = childRef.value; - console.log(`方法2 - value是字符串: ${childUuid}`); - } else if (childRef.value.uuid) { - childUuid = childRef.value.uuid; - console.log(`方法3 - value.uuid: ${childUuid}`); - } else if (childRef.value.__id__) { - console.log(`方法4 - 发现__id__引用: ${childRef.value.__id__}`); - // 这可能是一个内部引用，我们需要不同的处理方式 - continue; - } else { - console.log('方法4 - value不是字符串，内容:', JSON.stringify(childRef.value)); - } - } else if (childRef && childRef.uuid) { - childUuid = childRef.uuid; - console.log(`方法5 - 直接uuid属性: ${childUuid}`); - } else { - console.log('方法6 - 无法识别的子节点格式:', JSON.stringify(childRef)); - } - - if (childUuid && childUuid !== '[object Object]') { - try { - // 获取子节点数据 - const childNodeData = await this.getNodeData(childUuid); - if (childNodeData) { - const childId = currentId; - node._children.push({ "__id__": childId }); - - // 递归创建子节点 - const childResult = await this.createNodeObject(childNodeData, nodeId, prefabData, currentId); - prefabData.push(childResult.node); - currentId = childResult.nextId; - - // 为子节点添加PrefabInfo - const childPrefabInfo = { - "__type__": "cc.PrefabInfo", - "root": { - "__id__": 1 // 指向根节点 - }, - "asset": { - "__id__": 0 // 指向Prefab资源 - }, - "fileId": this.generateFileId(), - "instance": null, - "targetOverrides": null, - "nestedPrefabInstanceRoots": null - }; - prefabData.push(childPrefabInfo); - currentId++; - - console.log(`✅ 已添加子节点: ${childNodeData.name?.value || '未知'}`); - console.log(`子节点在预制体数组中的索引: ${currentId}`); - } else { - console.warn(`无法获取子节点数据: ${childUuid}`); - } - } catch (error) { - console.error(`处理子节点 ${childUuid} 时出错:`, error); - } + try { + const childId = currentId; + node._children.push({ "__id__": childId }); + + // 递归创建子节点 + const childResult = await this.createNodeObject(childData, nodeId, prefabData, currentId); + prefabData.push(childResult.node); + currentId = childResult.nextId; + + // 子节点不需要PrefabInfo，只有根节点需要 + // 子节点的_prefab应该设置为null + childResult.node._prefab = null; + + console.log(`✅ 成功添加子节点: ${childName}`); + } catch (error) { + console.error(`处理子节点 ${childName} 时出错:`, error); } } } @@ -1404,32 +2540,261 @@ export class PrefabTools implements ToolExecutor { return { node, nextId: currentId }; } - private createComponentObject(componentData: any, nodeId: number, prefabInfoId: number): any { - const componentType = componentData.__type__ || 'cc.Component'; + // 从节点数据中提取组件信息 + private extractComponentsFromNode(nodeData: any): any[] { + const components: any[] = []; + // 从不同位置尝试获取组件数据 + const componentSources = [ + nodeData.__comps__, + nodeData.components, + nodeData.value?.__comps__, + nodeData.value?.components + ]; + + for (const source of componentSources) { + if (Array.isArray(source)) { + components.push(...source.filter(comp => comp && (comp.__type__ || comp.type))); + break; // 找到有效的组件数组就退出 + } + } + + return components; + } + + // 创建标准的组件对象 + private createStandardComponentObject(componentData: any, nodeId: number, prefabInfoId: number): any { + const componentType = componentData.__type__ || componentData.type; + + if (!componentType) { + console.warn('组件缺少类型信息:', componentData); + return null; + } + + // 基础组件结构 - 基于官方预制体格式 const component: any = { "__type__": componentType, "_name": "", "_objFlags": 0, - "__editorExtras__": {}, "node": { "__id__": nodeId }, - "_enabled": componentData.enabled !== undefined ? componentData.enabled : true, + "_enabled": this.getComponentPropertyValue(componentData, 'enabled', true), "__prefab": { "__id__": prefabInfoId - }, - "_id": "" + } }; - - // 复制组件的其他属性 - for (const key in componentData) { - if (!key.startsWith('_') && key !== '__type__' && key !== 'enabled' && key !== 'node') { - component[key] = componentData[key]; + + // 根据组件类型添加特定属性 + this.addComponentSpecificProperties(component, componentData, componentType); + + // 添加_id属性 + component._id = ""; + + return component; + } + + // 添加组件特定的属性 + private addComponentSpecificProperties(component: any, componentData: any, componentType: string): void { + switch (componentType) { + case 'cc.UITransform': + this.addUITransformProperties(component, componentData); + break; + case 'cc.Sprite': + this.addSpriteProperties(component, componentData); + break; + case 'cc.Label': + this.addLabelProperties(component, componentData); + break; + case 'cc.Button': + this.addButtonProperties(component, componentData); + break; + default: + // 对于未知类型的组件，复制所有安全的属性 + this.addGenericProperties(component, componentData); + break; + } + } + + // UITransform组件属性 + private addUITransformProperties(component: any, componentData: any): void { + component._contentSize = this.createSizeObject( + this.getComponentPropertyValue(componentData, 'contentSize', { width: 100, height: 100 }) + ); + component._anchorPoint = this.createVec2Object( + this.getComponentPropertyValue(componentData, 'anchorPoint', { x: 0.5, y: 0.5 }) + ); + } + + // Sprite组件属性 + private addSpriteProperties(component: any, componentData: any): void { + component._visFlags = 0; + component._customMaterial = null; + component._srcBlendFactor = 2; + component._dstBlendFactor = 4; + component._color = this.createColorObject( + this.getComponentPropertyValue(componentData, 'color', { r: 255, g: 255, b: 255, a: 255 }) + ); + component._spriteFrame = this.getComponentPropertyValue(componentData, 'spriteFrame', null); + component._type = this.getComponentPropertyValue(componentData, 'type', 0); + component._fillType = 0; + component._sizeMode = this.getComponentPropertyValue(componentData, 'sizeMode', 1); + component._fillCenter = this.createVec2Object({ x: 0, y: 0 }); + component._fillStart = 0; + component._fillRange = 0; + component._isTrimmedMode = true; + component._useGrayscale = false; + component._atlas = null; + } + + // Label组件属性 + private addLabelProperties(component: any, componentData: any): void { + component._visFlags = 0; + component._customMaterial = null; + component._srcBlendFactor = 2; + component._dstBlendFactor = 4; + component._color = this.createColorObject( + this.getComponentPropertyValue(componentData, 'color', { r: 0, g: 0, b: 0, a: 255 }) + ); + component._string = this.getComponentPropertyValue(componentData, 'string', 'Label'); + component._horizontalAlign = 1; + component._verticalAlign = 1; + component._actualFontSize = 20; + component._fontSize = this.getComponentPropertyValue(componentData, 'fontSize', 20); + component._fontFamily = 'Arial'; + component._lineHeight = 40; + component._overflow = 1; + component._enableWrapText = false; + component._font = null; + component._isSystemFontUsed = true; + component._isItalic = false; + component._isBold = false; + component._isUnderline = false; + component._underlineHeight = 2; + component._cacheMode = 0; + } + + // Button组件属性 + private addButtonProperties(component: any, componentData: any): void { + component.clickEvents = []; + component._interactable = true; + component._transition = 2; + component._normalColor = this.createColorObject({ r: 214, g: 214, b: 214, a: 255 }); + component._hoverColor = this.createColorObject({ r: 211, g: 211, b: 211, a: 255 }); + component._pressedColor = this.createColorObject({ r: 255, g: 255, b: 255, a: 255 }); + component._disabledColor = this.createColorObject({ r: 124, g: 124, b: 124, a: 255 }); + component._duration = 0.1; + component._zoomScale = 1.2; + } + + // 添加通用属性 + private addGenericProperties(component: any, componentData: any): void { + // 只复制安全的、已知的属性 + const safeProperties = ['enabled', 'color', 'string', 'fontSize', 'spriteFrame', 'type', 'sizeMode']; + + for (const prop of safeProperties) { + if (componentData.hasOwnProperty(prop)) { + const value = this.getComponentPropertyValue(componentData, prop); + if (value !== undefined) { + component[`_${prop}`] = value; + } } } + } + + // 创建Vec2对象 + private createVec2Object(data: any): any { + return { + "__type__": "cc.Vec2", + "x": data?.x || 0, + "y": data?.y || 0 + }; + } + + // 创建Vec3对象 + private createVec3Object(data: any): any { + return { + "__type__": "cc.Vec3", + "x": data?.x || 0, + "y": data?.y || 0, + "z": data?.z || 0 + }; + } + + // 创建Size对象 + private createSizeObject(data: any): any { + return { + "__type__": "cc.Size", + "width": data?.width || 100, + "height": data?.height || 100 + }; + } + + // 创建Color对象 + private createColorObject(data: any): any { + return { + "__type__": "cc.Color", + "r": data?.r ?? 255, + "g": data?.g ?? 255, + "b": data?.b ?? 255, + "a": data?.a ?? 255 + }; + } - return component; + // 判断是否应该复制组件属性 + private shouldCopyComponentProperty(key: string, value: any): boolean { + // 跳过内部属性和已处理的属性 + if (key.startsWith('__') || key === '_enabled' || key === 'node' || key === 'enabled') { + return false; + } + + // 跳过函数和undefined值 + if (typeof value === 'function' || value === undefined) { + return false; + } + + return true; + } + + + // 获取组件属性值 - 重命名以避免冲突 + private getComponentPropertyValue(componentData: any, propertyName: string, defaultValue?: any): any { + // 尝试直接获取属性 + if (componentData[propertyName] !== undefined) { + return this.extractValue(componentData[propertyName]); + } + + // 尝试从value属性中获取 + if (componentData.value && componentData.value[propertyName] !== undefined) { + return this.extractValue(componentData.value[propertyName]); + } + + // 尝试带下划线前缀的属性名 + const prefixedName = `_${propertyName}`; + if (componentData[prefixedName] !== undefined) { + return this.extractValue(componentData[prefixedName]); + } + + return defaultValue; + } + + // 提取属性值 + private extractValue(data: any): any { + if (data === null || data === undefined) { + return data; + } + + // 如果有value属性，优先使用value + if (typeof data === 'object' && data.hasOwnProperty('value')) { + return data.value; + } + + // 如果是引用对象，保持原样 + if (typeof data === 'object' && (data.__id__ !== undefined || data.__uuid__ !== undefined)) { + return data; + } + + return data; } private createStandardMetaData(prefabName: string, prefabUuid: string): any {