Sample Workflows

Workflow 1: Learn a New UE5 Concept

Scenario: You're new to Blueprint interfaces and want to understand them.

Steps:

1. Open Orion: Window > Azimuth Orion
2. Set mode: Orbital (Ask)
3. Type: "Explain Blueprint interfaces in simple terms. When should I use them?"
4. Click Send
5. AI provides beginner-friendly explanation with use cases
6. Follow-up: "Show me a simple example"
7. AI provides example interface (BPI_Interactable) with sample methods
8. Follow-up: "How do I implement this in a Blueprint?"
9. AI provides step-by-step instructions with node names
10. You create the interface in your project, following the guidance

Result: You learned Blueprint interfaces from scratch without leaving the editor.

---

Workflow 2: Debug a Blueprint with Vision

Scenario: Your character Blueprint has a health system that's not working correctly. Damage events aren't reducing health.

Steps:

1. Switch to vision model: Settings > Model ID > GPT-4o (or Grok Vision, Claude 3.5+)
2. Open the Blueprint: Double-click BP_PlayerCharacter in Content Browser
3. Navigate to the health logic in the graph (zoom/pan to show TakeDamage event)
4. Click the Screenshot button in Orion toolbar (up arrow icon)
5. Toast appears: "Screenshot captured successfully. It will be included with your next Orion query."
6. Open Orion chat (Window > Azimuth Orion, or it may auto-focus)
7. Type your question: "The health doesn't decrease when taking damage. What's wrong with this setup?"
8. Click Send
9. AI examines your screenshot and responds:

"Looking at your screenshot, I can see the TakeDamage custom event with the following flow:

• TakeDamage event (exec out)
• Damage parameter (float input)
• UpdateHealth function node (NOT connected)

The problem: The execution pin from TakeDamage is not connected to UpdateHealth. The event fires when damage is taken, but nothing happens because there's no execution flow. Connect the white exec output pin from TakeDamage to the white exec input pin of UpdateHealth. This will cause the health value to actually decrease when TakeDamage is called."

10. Fix the connection in your Blueprint graph (drag exec pin)
11. Compile (Ctrl+S or Compile button)
12. Test in PIE (Play In Editor)
13. Confirm: Health now decreases when you take damage!

Result: Visual debugging with AI identified the disconnected node in seconds.

Screenshot Placeholder: [Blueprint graph screenshot showing TakeDamage event node with DISCONNECTED exec pin, and UpdateHealth function node nearby. Red arrow annotation shows where the connection should be.]

---

Workflow 3: Understand a Marketplace Material

Scenario: You bought a material pack. One material is named M_Foliage_Master and you want to know what it does before using it.

Steps:

1. Locate the material in Content Browser (Content/MarketplacePack/Materials/)
2. Right-click M_Foliage_Master
3. Hover: Azimuth Orion
4. Click: Describe to Orion
5. Orion chat opens with message: "Describing M_Foliage_Master to Orion..."
6. AI responds:

"M_Foliage_Master is a Surface material with the following properties:

• Blend Mode: Masked (for opacity cutout—allows transparency without translucency cost)
• Shading Model: DefaultLit (standard PBR lighting)
• Two-Sided: Yes (renders both sides of polygons—essential for foliage since leaves are thin planes)
• Dithered Opacity: Enabled (soft edges instead of hard cutoff)
• Expression Count: 47 nodes

Analysis: This material is optimized for real-time foliage rendering (trees, grass, bushes). The Masked blend mode with dithered opacity provides good visual quality without the performance cost of Translucent materials. Two-sided rendering is standard for foliage (you see both sides of leaf planes). With 47 expression nodes, this is moderately complex—within acceptable limits for foliage that appears in large quantities.

Recommendation: Use this material for leaf cards, grass blades, or any thin geometry that needs transparency. Avoid using two-sided materials for large solid surfaces (unnecessary performance cost)."

7. You now understand:
   • It's designed for foliage (leaves, grass)
   • It's optimized (Masked blend mode)
   • It's two-sided (for thin geometry)
   • It's performant enough for large quantities

Result: You learned what the material does without opening the Material Editor, reading docs, or guessing.

---

Workflow 4: Generate C++ Boilerplate

Scenario: You need a C++ health component for your game.

Steps:

1. Open Orion: Window > Azimuth Orion
2. Set mode: C++ Mode
3. Type your request: "Generate a C++ ActorComponent class for a health system with TakeDamage, Heal, and OnHealthChanged delegate"
4. Click Send
5. AI provides complete code:

// HealthComponent.h
#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "HealthComponent.generated.h"

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnHealthChanged, float, NewHealth, float, MaxHealth);

UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class YOURGAME_API UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UHealthComponent();

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth;

    UPROPERTY(BlueprintAssignable, Category="Health")
    FOnHealthChanged OnHealthChanged;

    UFUNCTION(BlueprintCallable, Category="Health")
    void TakeDamage(float DamageAmount);

    UFUNCTION(BlueprintCallable, Category="Health")
    void Heal(float HealAmount);

    UFUNCTION(BlueprintCallable, BlueprintPure, Category="Health")
    float GetHealthPercentage() const;

protected:
    virtual void BeginPlay() override;
};

// HealthComponent.cpp
#include "HealthComponent.h"

UHealthComponent::UHealthComponent()
{
    PrimaryComponentTick.bCanEverTick = false;
    CurrentHealth = MaxHealth;
}

void UHealthComponent::BeginPlay()
{
    Super::BeginPlay();
    CurrentHealth = MaxHealth;
}

void UHealthComponent::TakeDamage(float DamageAmount)
{
    if (DamageAmount <= 0.0f) return;
    
    CurrentHealth = FMath::Max(0.0f, CurrentHealth - DamageAmount);
    OnHealthChanged.Broadcast(CurrentHealth, MaxHealth);
    
    if (CurrentHealth <= 0.0f)
    {
        UE_LOG(LogTemp, Warning, TEXT("%s died"), *GetOwner()->GetName());
    }
}

void UHealthComponent::Heal(float HealAmount)
{
    if (HealAmount <= 0.0f) return;
    
    CurrentHealth = FMath::Min(MaxHealth, CurrentHealth + HealAmount);
    OnHealthChanged.Broadcast(CurrentHealth, MaxHealth);
}

float UHealthComponent::GetHealthPercentage() const
{
    return CurrentHealth / MaxHealth;
}

6. Click the copy button on each code block
7. Create files in your project:
   • Source/YourGame/HealthComponent.h
   • Source/YourGame/HealthComponent.cpp
8. Paste the code
9. Replace YOURGAME_API with your project's API macro
10. Compile your project (Build button or Ctrl+Alt+F11)
11. Add component to Blueprints: Open BP_PlayerCharacter, Components panel > Add Component > Health Component

Result: Fully functional health component generated in 30 seconds.

---

Workflow 5: Optimize a Complex Blueprint

Scenario: Your enemy AI Blueprint (BP_EnemyAI) has 200+ nodes and runs slowly. You need optimization suggestions.

Steps:

1. Open the Blueprint: Double-click BP_EnemyAI in Content Browser
2. Click Orion toolbar: Send > Full Graph to Orion
3. Wait (large Blueprints take a moment to process)
4. AI acknowledges: "I've received BP_EnemyAI with 9 graphs and 237 nodes. What would you like to know?"
5. Type: "Find performance issues and suggest optimizations"
6. Click Send
7. AI analyzes and responds:

"I've analyzed BP_EnemyAI. Here are performance concerns and recommendations:

1. Tick Event is Active with Expensive Operations

• Current: The Tick event executes 12 nodes every frame, including GetAllActorsOfClass (very expensive) and multiple distance calculations.
• Recommendation: Disable Tick and use a Timer instead. Enemy AI doesn't need frame-perfect updates. Set a timer for 0.1-0.5 seconds (adjustable based on how responsive enemies need to be).

2. GetAllActorsOfClass Called Frequently

• Current: In the LookForTarget function, GetAllActorsOfClass(PlayerCharacter) is called every tick or every timer execution.
• Recommendation: Cache the player reference in BeginPlay. Get the player once, store in a variable, reuse it. Only call GetAllActorsOfClass if the cached reference becomes invalid.

3. Heavy BeginPlay Initialization

• Current: BeginPlay has 50+ nodes including LoadAsset calls and complex initialization.
• Recommendation: If you have many enemy instances, heavy BeginPlay causes level load hitching. Split initialization: BeginPlay (only essentials), then call an Initialize function 0.1s later via a Timer.

4. Unused Variables

• Found: 'DebugMode' (Boolean), 'TestCounter' (Integer) are defined but never referenced.
• Recommendation: Remove unused variables to reduce clutter and Blueprint compilation overhead.

5. Nested For Loops in Tick

• Current: ForEachLoop nested inside another ForEachLoop in the Tick event.
• Recommendation: Nested loops in Tick are extremely expensive (O(n²) complexity). Move this logic to a function called on-demand (e.g., when enemy state changes), not every frame."

8. Implement suggested fixes:
   • Disable Tick, add Timer (SetTimerByFunctionName, 0.2s loop)
   • Cache player reference in BeginPlay
   • Move asset loading to a delayed Initialize function
   • Remove unused variables
   • Move nested loop logic to OnStateChanged custom event
9. Compile and test
10. Measure performance improvement (Stat Game, Stat SceneRendering)

Result: Enemy AI performance improved by 60-80% after applying AI recommendations.

---