Unreal Analyzer MCP

🚀 UnrealCodeAnalyzer

UnrealCodeAnalyzer is a powerful code analysis tool designed specifically for Unreal Engine and custom codebases. It offers comprehensive code review, API documentation generation, and game type-specific analysis capabilities.

🚀 Quick Start

UnrealCodeAnalyzer provides a set of powerful features for code analysis and API documentation generation in the Unreal Engine environment. Here's how you can get started:

Installation and Configuration

1. Install Dependencies

npm install

2. Set the Codebase Path

   • Specify the path to the Unreal Engine or custom codebase during initialization.

3. Run the Analysis Tool

node src/UnrealCodeAnalyzer.ts --path /your/unreal/engine/path

✨ Features

Core Functional Modules

1. Code Analysis Tools

   • Class Hierarchy Analysis: Provide complete class information through inheritance relationships and interface implementations.
   • Member Analysis: Deeply analyze the methods, properties, and events of each class.
   • Reference Search: Quickly locate the usage of classes, methods, or variables.

2. API Documentation Generator

   • Automatically generate API documentation, including syntax examples and usage instructions.
   • Support filtering by category and module.

3. Game Type Knowledge Base

   • Provide analysis of specific functional components for different game types (e.g., shooters, RPGs).

4. MCP Server Integration

   • Provide the ability to interact with Epic's Material Change Protocol (MCP) server, supporting tool registration and request processing.

5. Learning Resource Center

   • Integrate official Unreal Engine documentation, tutorial videos, and community resources.

File Structure

unreal-code-analyzer/
├── src/
│   ├── UnrealCodeAnalyzer.ts       # Core analysis class
│   ├── Analyzers/                 # Various code analyzers
│   │   └── CodeSearchAnalyzer.ts  # Code search analyzer
│   ├── Servers/                   # MCP server implementation
│   │   └── McpServer.ts          # MCP server logic
│   ├── Documenters/              # Documentation generation tools
│   │   └──apidoc-generator.ts    # Automatic documentation generation tool
│   └── TestSuites/               # Test suites
│       └── UnrealCodeAnalyzer.test.ts  # Core function tests
├── public/
│   ├── index.html                 # Main interface
│   └── assets/                   # Static resource folder
└── package.json                  # Project dependency configuration

💻 Usage Examples

Analyze Unreal Engine Classes

const analyzer = new UnrealCodeAnalyzer('/path/to/UnrealEngine');
const FVectorClass = await analyzer.getClass('FVector');
console.log(FVectorClass.hierarchy); // Output inheritance relationship

Generate API Documentation

const docGenerator = new ApidocGenerator();
docGenerator.generateDocumentation('MyClass', '/output/path');

📚 Documentation

Usage Instructions

1. Analyze Class Hierarchy

Get the complete inheritance relationship and interface implementation:

const analyzer = new UnrealCodeAnalyzer();
const classHierarchy = analyzer.analyzeClass('MyClass');

2. Member Analysis

Analyze all members of a specified class:

const members = await analyzer.analyzeMembers('MyClass', true);
// Contains detailed information about methods, properties, and events

3. Reference Search

Find all references to a symbol in the codebase:

const references = analyzer.findReferences('MyFunction');

4. Code Search

Search for code snippets based on file patterns:

const results = await analyzer.searchCode(
    'some search pattern',
    { extensions: ['.cpp', '.h'], directories: ['src'] }
);

5. Subsystem Analysis

Analyze relevant information about a specific Unreal Engine subsystem:

const subsystemInfo = await analyzer.analyzeSubsystem('Physics');
// Returns information such as core classes and key features

Error Handling

• Common Errors
  • Path Not Set: You must specify the codebase path during initialization.
  • Invalid Search Pattern: Ensure that the search pattern is correct.

Performance Considerations

• Optimization Suggestions
  • Use the default filters to reduce the analysis scope.
  • For large projects, it is recommended to perform analysis module by module.

Testing

1. Run Tests

npm test

2. Write Custom Tests

describe('UnrealCodeAnalyzer', () => {
    it('should analyze class hierarchy', async () => {
        // Test logic
    });
});

Contribution Guidelines

1. Submit Issues

   • Report issues or suggestions by submitting an issue on GitHub.

2. Participate in Development

   • Fork the repository and develop on your own branch. Then, submit a Pull Request.

🔧 Technical Details

Project Features

• Modular Design: Each functional module is independent and extensible.
• High-Performance Analysis: The optimized code processing flow ensures quick response.
• Multi-Platform Support: Supports Windows, Linux, and macOS systems.

📄 License

[Project license information]

For more information, please refer to the project's GitHub repository or contact the development team.