@akiojin/unity-mcp-server 2.14.14

package/src/tools/analysis/getAnimatorState.js

@@ -0,0 +1,326 @@
+// Tool definition for get_animator_state
+export const getAnimatorStateToolDefinition = {
+    name: 'get_animator_state',
+    description: 'Get Animator state: layers, transitions, and parameter values for a GameObject.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            gameObjectName: {
+                type: 'string',
+                description: 'Name of the GameObject with the Animator component'
+            },
+            includeParameters: {
+                type: 'boolean',
+                description: 'Include all animator parameters and their current values. Default: true',
+                default: true
+            },
+            includeStates: {
+                type: 'boolean',
+                description: 'Include current state information for each layer. Default: true',
+                default: true
+            },
+            includeTransitions: {
+                type: 'boolean',
+                description: 'Include active transition information. Default: true',
+                default: true
+            },
+            includeClips: {
+                type: 'boolean',
+                description: 'Include animation clip information. Default: false',
+                default: false
+            },
+            layerIndex: {
+                type: 'number',
+                description: 'Specific layer index to query (-1 for all layers). Default: -1',
+                default: -1
+            }
+        },
+        required: ['gameObjectName']
+    }
+};
+
+// Tool definition for get_animator_runtime_info
+export const getAnimatorRuntimeInfoToolDefinition = {
+    name: 'get_animator_runtime_info',
+    description: 'Get Animator runtime info (IK, root motion, performance) — Play mode only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            gameObjectName: {
+                type: 'string',
+                description: 'Name of the GameObject with the Animator component'
+            },
+            includeIK: {
+                type: 'boolean',
+                description: 'Include IK (Inverse Kinematics) information. Default: true',
+                default: true
+            },
+            includeRootMotion: {
+                type: 'boolean',
+                description: 'Include root motion information. Default: true',
+                default: true
+            },
+            includeBehaviours: {
+                type: 'boolean',
+                description: 'Include state machine behaviours. Default: false',
+                default: false
+            }
+        },
+        required: ['gameObjectName']
+    }
+};
+
+// Handler for get_animator_state
+export async function getAnimatorStateHandler(unityConnection, args) {
+    try {
+        // Check connection
+        if (!unityConnection.isConnected()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get animator state: Unity connection not available'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Validate required parameters
+        if (!args.gameObjectName) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get animator state: gameObjectName is required'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Send command to Unity
+        const result = await unityConnection.sendCommand('get_animator_state', args);
+
+        // Check for errors
+        if (!result || typeof result === 'string') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get animator state: Invalid response format`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get animator state: ${result.error}`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Format the response
+        let text = result.summary || `Animator state retrieved for '${args.gameObjectName}'`;
+        
+        if (result.controllerName) {
+            text += `\nController: ${result.controllerName}`;
+        }
+
+        if (result.layers && Array.isArray(result.layers)) {
+            text += `\n\n## Layer States:`;
+            result.layers.forEach(layer => {
+                text += `\n\n### Layer ${layer.layerIndex}: ${layer.layerName || 'Base Layer'}`;
+                text += `\n- Weight: ${layer.layerWeight}`;
+                
+                if (layer.currentState) {
+                    text += `\n- Current State: ${layer.currentState.name || `Hash: ${layer.currentState.fullPathHash}`}`;
+                    text += `\n  - Normalized Time: ${layer.currentState.normalizedTime?.toFixed(3)}`;
+                    text += `\n  - Speed: ${layer.currentState.speed}`;
+                    if (layer.currentState.motion) {
+                        text += `\n  - Motion: ${layer.currentState.motion}`;
+                    }
+                }
+
+                if (layer.activeTransition) {
+                    text += `\n- Active Transition:`;
+                    text += `\n  - Duration: ${layer.activeTransition.duration}`;
+                    text += `\n  - Progress: ${(layer.activeTransition.normalizedTime * 100).toFixed(1)}%`;
+                    if (layer.activeTransition.nextState) {
+                        text += `\n  - To: ${layer.activeTransition.nextState.name || 'Unknown'}`;
+                    }
+                }
+            });
+        }
+
+        if (result.parameters && Object.keys(result.parameters).length > 0) {
+            text += `\n\n## Parameters:`;
+            for (const [name, param] of Object.entries(result.parameters)) {
+                text += `\n- ${name} (${param.type}): ${param.value}`;
+                if (param.defaultValue !== undefined && param.type !== 'Trigger') {
+                    text += ` [default: ${param.defaultValue}]`;
+                }
+            }
+        }
+
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: text
+                }
+            ],
+            isError: false
+        };
+    } catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to get animator state: ${error.message}`
+                }
+            ],
+            isError: true
+        };
+    }
+}
+
+// Handler for get_animator_runtime_info
+export async function getAnimatorRuntimeInfoHandler(unityConnection, args) {
+    try {
+        // Check connection
+        if (!unityConnection.isConnected()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get animator runtime info: Unity connection not available'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Validate required parameters
+        if (!args.gameObjectName) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get animator runtime info: gameObjectName is required'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Send command to Unity
+        const result = await unityConnection.sendCommand('get_animator_runtime_info', args);
+
+        // Check for errors
+        if (!result || typeof result === 'string') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get animator runtime info: Invalid response format`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get animator runtime info: ${result.error}`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Format the response
+        let text = result.summary || `Animator runtime info retrieved for '${args.gameObjectName}'`;
+        
+        text += `\n\n## General Info:`;
+        text += `\n- Controller: ${result.runtimeAnimatorController || 'None'}`;
+        text += `\n- Update Mode: ${result.updateMode}`;
+        text += `\n- Culling Mode: ${result.cullingMode}`;
+        text += `\n- Speed: ${result.speed}`;
+        text += `\n- Playback Time: ${result.playbackTime?.toFixed(3)}`;
+
+        if (result.avatar) {
+            text += `\n\n## Avatar:`;
+            text += `\n- Name: ${result.avatar.name}`;
+            text += `\n- Valid: ${result.avatar.isValid}`;
+            text += `\n- Human: ${result.avatar.isHuman}`;
+        }
+
+        if (result.rootMotion) {
+            text += `\n\n## Root Motion:`;
+            text += `\n- Apply Root Motion: ${result.rootMotion.applyRootMotion}`;
+            text += `\n- Has Root Motion: ${result.rootMotion.hasRootMotion}`;
+            text += `\n- Velocity: (${result.rootMotion.velocity.x?.toFixed(2)}, ${result.rootMotion.velocity.y?.toFixed(2)}, ${result.rootMotion.velocity.z?.toFixed(2)})`;
+            text += `\n- Angular Velocity: (${result.rootMotion.angularVelocity.x?.toFixed(2)}, ${result.rootMotion.angularVelocity.y?.toFixed(2)}, ${result.rootMotion.angularVelocity.z?.toFixed(2)})`;
+        }
+
+        if (result.ikInfo) {
+            text += `\n\n## IK Info:`;
+            text += `\n- Human Scale: ${result.ikInfo.humanScale}`;
+            text += `\n- Feet Pivot Active: ${result.ikInfo.feetPivotActive}`;
+            text += `\n- Pivot Weight: ${result.ikInfo.pivotWeight}`;
+            
+            if (result.ikInfo.goals) {
+                text += `\n\n### IK Goals:`;
+                for (const [goal, data] of Object.entries(result.ikInfo.goals)) {
+                    text += `\n- ${goal}:`;
+                    text += `\n  - Position Weight: ${data.positionWeight}`;
+                    text += `\n  - Rotation Weight: ${data.rotationWeight}`;
+                }
+            }
+        }
+
+        if (result.behaviours && result.behaviours.length > 0) {
+            text += `\n\n## State Machine Behaviours:`;
+            result.behaviours.forEach(behaviour => {
+                text += `\n- Layer ${behaviour.layer}: ${behaviour.type} (${behaviour.enabled ? 'Enabled' : 'Disabled'})`;
+            });
+        }
+
+        text += `\n\n## Performance:`;
+        text += `\n- Has Bound Playables: ${result.hasBoundPlayables}`;
+        text += `\n- Has Transform Hierarchy: ${result.hasTransformHierarchy}`;
+        text += `\n- Is Optimizable: ${result.isOptimizable}`;
+        text += `\n- Gravity Weight: ${result.gravityWeight}`;
+
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: text
+                }
+            ],
+            isError: false
+        };
+    } catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to get animator runtime info: ${error.message}`
+                }
+            ],
+            isError: true
+        };
+    }
+}

package/src/tools/analysis/getComponentValues.js

@@ -0,0 +1,182 @@
+/**
+ * Tool definition for get_component_values
+ */
+export const getComponentValuesToolDefinition = {
+    name: 'get_component_values',
+    description: 'Get properties/values from a component on a GameObject (scene or prefab mode).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            gameObjectName: {
+                type: 'string',
+                description: 'Name of the GameObject'
+            },
+            componentType: {
+                type: 'string',
+                description: 'Type of component (e.g., "Light", "Camera", "Rigidbody")'
+            },
+            componentIndex: {
+                type: 'number',
+                description: 'Index if multiple components of same type. Default: 0'
+            },
+            includePrivateFields: {
+                type: 'boolean',
+                description: 'Include non-public fields. Default: false'
+            },
+            includeInherited: {
+                type: 'boolean',
+                description: 'Include inherited properties. Default: true'
+            }
+        },
+        required: ['gameObjectName', 'componentType']
+    }
+};
+
+/**
+ * Handler for get_component_values tool
+ */
+export async function getComponentValuesHandler(unityConnection, args) {
+    try {
+        // Check connection
+        if (!unityConnection.isConnected()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get component values: Unity connection not available'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Validate required parameters
+        if (!args.componentType) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get component values: componentType is required'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Validate componentIndex if provided
+        if (args.componentIndex !== undefined && args.componentIndex < 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get component values: componentIndex must be non-negative'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Send command to Unity
+        const result = await unityConnection.sendCommand('get_component_values', args);
+
+        // The unityConnection.sendCommand already extracts the result field
+        // from the response, so we access properties directly on result
+        if (!result || typeof result === 'string') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get component values: Invalid response format`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Check if result has error property (error response from Unity)
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get component values: ${result.error}`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Success response - result is already the unwrapped data
+        console.log('[DEBUG] GetComponentValues - Full result:', JSON.stringify(result, null, 2));
+        
+        let responseText = result.summary || `Component values retrieved`;
+        
+        // Add detailed property information if available
+        if (result.properties && Object.keys(result.properties).length > 0) {
+            console.log('[DEBUG] Properties found:', Object.keys(result.properties).length);
+            responseText += '\n\nProperties:';
+            for (const [key, value] of Object.entries(result.properties)) {
+                if (value && typeof value === 'object') {
+                    if (value.error) {
+                        responseText += `\n- ${key}: ERROR - ${value.error}`;
+                    } else {
+                        const valueStr = value.value ? JSON.stringify(value.value, null, 2) : 'null';
+                        const typeStr = value.type || 'unknown';
+                        responseText += `\n- ${key} (${typeStr}): ${valueStr}`;
+                        
+                        // Add range info if available
+                        if (value.range) {
+                            responseText += ` [range: ${value.range.min}-${value.range.max}]`;
+                        }
+                        
+                        // Add tooltip if available
+                        if (value.tooltip) {
+                            responseText += ` // ${value.tooltip}`;
+                        }
+                        
+                        // Add serialization info
+                        if (value.serialized) {
+                            responseText += ` (SerializeField)`;
+                        }
+                        if (value.hiddenInInspector) {
+                            responseText += ` (HideInInspector)`;
+                        }
+                    }
+                }
+            }
+        } else {
+            console.log('[DEBUG] No properties found in result');
+            console.log('[DEBUG] Result keys:', Object.keys(result));
+        }
+        
+        // Add debug information if available
+        if (result.debug) {
+            responseText += '\n\nDebug Info:';
+            responseText += `\n- Properties type: ${result.debug.propertiesType}`;
+            responseText += `\n- Properties count: ${result.debug.propertiesCount}`;
+            if (result.debug.firstPropertyKey) {
+                responseText += `\n- First property key: ${result.debug.firstPropertyKey}`;
+            }
+        }
+        
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseText
+                }
+            ],
+            isError: false
+        };
+    } catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to get component values: ${error.message}`
+                }
+            ],
+            isError: true
+        };
+    }
+}

package/src/tools/analysis/getGameObjectDetails.js

@@ -0,0 +1,159 @@
+/**
+ * Tool definition for get_gameobject_details
+ */
+export const getGameObjectDetailsToolDefinition = {
+    name: 'get_gameobject_details',
+    description: 'Get details for a GameObject by name or path (children/components/materials).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            gameObjectName: {
+                type: 'string',
+                description: 'Name of the GameObject to inspect'
+            },
+            path: {
+                type: 'string',
+                description: 'Full hierarchy path to the GameObject (use either name or path)'
+            },
+            includeChildren: {
+                type: 'boolean',
+                description: 'Include full hierarchy details. Default: false'
+            },
+            includeComponents: {
+                type: 'boolean',
+                description: 'Include all component details. Default: true'
+            },
+            includeMaterials: {
+                type: 'boolean',
+                description: 'Include material information. Default: false'
+            },
+            maxDepth: {
+                type: 'number',
+                description: 'Maximum depth for child traversal. Default: 3, Range: 0-10'
+            }
+        },
+        required: ['gameObjectName']
+    }
+};
+
+/**
+ * Handler for get_gameobject_details tool
+ */
+export async function getGameObjectDetailsHandler(unityConnection, args) {
+    try {
+        // Check connection
+        if (!unityConnection.isConnected()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get GameObject details: Unity connection not available'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Validate that either gameObjectName or path is provided
+        if (!args.gameObjectName && !args.path) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get GameObject details: Either gameObjectName or path must be provided'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Validate that only one identifier is provided
+        if (args.gameObjectName && args.path) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to get GameObject details: Provide either gameObjectName or path, not both'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Validate maxDepth if provided
+        if (args.maxDepth !== undefined) {
+            if (args.maxDepth < 0 || args.maxDepth > 10) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Failed to get GameObject details: maxDepth must be between 0 and 10'
+                        }
+                    ],
+                    isError: true
+                };
+            }
+        }
+
+        // Build params only with provided values and defaults where needed
+        const params = {};
+        
+        if (args.gameObjectName) params.gameObjectName = args.gameObjectName;
+        if (args.path) params.path = args.path;
+        if (args.includeChildren !== undefined) params.includeChildren = args.includeChildren;
+        if (args.includeComponents !== undefined) params.includeComponents = args.includeComponents;
+        if (args.includeMaterials !== undefined) params.includeMaterials = args.includeMaterials;
+        if (args.maxDepth !== undefined) params.maxDepth = args.maxDepth;
+
+        // Send command to Unity
+        const result = await unityConnection.sendCommand('get_gameobject_details', args);
+
+        // The unityConnection.sendCommand already extracts the result field
+        // from the response, so we access properties directly on result
+        if (!result || typeof result === 'string') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get GameObject details: Invalid response format`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Check if result has error property (error response from Unity)
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get GameObject details: ${result.error}`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Success response - result is already the unwrapped data
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.summary || `GameObject details retrieved`
+                }
+            ],
+            isError: false
+        };
+    } catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to get GameObject details: ${error.message}`
+                }
+            ],
+            isError: true
+        };
+    }
+}