Unreal-mcp/skills/blueprint-workflow/prompt.md

Blueprint Workflow Skill

You are executing a Blueprint workflow command for Unreal Engine. This skill helps with analyzing, converting, and transforming Blueprints.

Command: {{command}}

Arguments: {{args}}

---

Instructions by Command

If command is analyze

1. Use read_blueprint tool to parse the Blueprint

2. Use profile_blueprint tool if editor is connected

3. Analyze for common issues:

   • Heavy Event Tick usage (operations per frame)
   • Blueprint casts (expensive operations)
   • Tick-dependent logic that could be event-driven
   • Large Blueprint graphs that should be split
   • Missing async loading for assets
   • Component lookups that should be cached

4. Report findings in this format:

## Performance Analysis: <Blueprint Name>

### Issues Found
🔴 HIGH: <issue description>
   → Suggestion: <fix>

🟡 MEDIUM: <issue description>
   → Suggestion: <fix>

🟢 LOW: <issue description>
   → Suggestion: <fix>

### Metrics
- Estimated Tick Cost: <X> operations/frame
- Complexity Score: <LOW/MEDIUM/HIGH>
- Optimization Potential: <percentage>%

### Recommendations
1. <recommendation>
2. <recommendation>

---

If command is bp-to-cpp

1. Use read_blueprint tool to parse the Blueprint structure

2. Extract:

   • Variables (types, defaults, replication)
   • Functions (parameters, return types)
   • Events (delegates, dispatchers)
   • Components

3. Generate C++ code following Epic standards:

   • Proper UCLASS, UPROPERTY, UFUNCTION macros
   • Blueprint-friendly specifiers (BlueprintCallable, BlueprintReadWrite)
   • Network replication if needed (Replicated, ReplicatedUsing)
   • Categories for organization

4. Output format:

// <ClassName>.h
#pragma once

#include "CoreMinimal.h"
#include "<ParentClass>.h"
#include "<ClassName>.generated.h"

UCLASS(Blueprintable)
class MYPROJECT_API <AClassName> : public <AParentClass>
{
    GENERATED_BODY()

public:
    <AClassName>();

    // Properties
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "...")
    <Type> <PropertyName>;

    // Functions
    UFUNCTION(BlueprintCallable, Category = "...")
    <ReturnType> <FunctionName>(<Params>);

protected:
    virtual void BeginPlay() override;
};

// <ClassName>.cpp
#include "<ClassName>.h"

<AClassName>::<AClassName>()
{
    // Set defaults
}

void <AClassName>::BeginPlay()
{
    Super::BeginPlay();
}

<ReturnType> <AClassName>::<FunctionName>(<Params>)
{
    // Implementation
}

5. Note any Blueprint-specific logic that cannot be directly converted

---

If command is cpp-to-bp

1. Use scan_cpp_classes to find the C++ class

2. Extract exposed properties and functions (UPROPERTY, UFUNCTION with Blueprint specifiers)

3. Use create_blueprint_from_cpp tool to create the Blueprint

4. If editor not connected, generate a Python script:

import unreal

# Create Blueprint from <CppClass>
factory = unreal.BlueprintFactory()
factory.set_editor_property('parent_class', unreal.find_class('<CppClass>'))

asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
blueprint = asset_tools.create_asset(
    '<BlueprintName>',
    '<OutputPath>',
    unreal.Blueprint,
    factory
)

if blueprint:
    unreal.EditorAssetLibrary.save_asset('<OutputPath>/<BlueprintName>')
    unreal.log('Created: <OutputPath>/<BlueprintName>')

5. Report what was created:

## Blueprint Created: <BlueprintName>

### Parent Class
<CppClass>

### Exposed Properties (tweakable in Blueprint)
- <PropertyName>: <Type> = <Default>
- ...

### Callable Functions
- <FunctionName>(<Params>) → <ReturnType>
- ...

### Events
- <EventName>
- ...

### Location
<OutputPath>/<BlueprintName>

---

If command is transform

1. Use read_blueprint to get current Blueprint structure

2. Understand the modification request: "{{args}}"

3. Design the changes needed:

   • New variables
   • New functions
   • Modified logic
   • New components

4. Generate the transformation:

   • If simple: Generate Python script to modify Blueprint
   • If complex: Generate new C++ base class + new Blueprint

5. Report the transformation:

## Blueprint Transformation: <BlueprintName>

### Requested Change
"<modification_description>"

### Changes Made
1. Added variable: <name> (<type>)
2. Added function: <name>()
3. Modified: <what was changed>

### New Features
- <feature description>

### Generated Files
- <file1>
- <file2>

### Next Steps
1. <what user needs to do>

---

If command is optimize

1. First run analyze workflow internally

2. Identify optimization opportunities:

   • Event Tick → Events + Timers
   • Blueprint casts → Interfaces
   • Heavy logic → C++ conversion candidates
   • Repeated operations → Caching

3. For each HIGH impact issue:

   • Generate optimized C++ code
   • Or generate Python script to refactor Blueprint

4. Report:

## Optimization Report: <BlueprintName>

### Before
- Tick Cost: <X> ops/frame
- Complexity: <SCORE>

### After (Estimated)
- Tick Cost: <Y> ops/frame
- Complexity: <SCORE>
- **Performance Gain: +<Z>%**

### Optimizations Applied
1. <optimization description>
   - Before: <what it was>
   - After: <what it became>
   - Gain: +<X>%

### Generated Files
- <file1> - <description>
- <file2> - <description>

### Manual Steps Required
1. <step>
2. <step>

---

Important Notes

• Always use MCP tools when available (read_blueprint, create_blueprint_from_cpp, etc.)
• If editor not connected, generate scripts for manual execution
• Follow Epic Coding Standards for all C++ code
• Preserve Blueprint functionality when converting
• Add comments explaining complex conversions
• Warn about any functionality that cannot be preserved