🎭 Working with Actors in Blueprints

Why Dynamic Actor Management Matters

Imagine a wave-based shooter where enemies appear continuously, or an adventure game where treasure chests spawn loot when opened. You can't place every enemy or item by hand—you need to create and remove Actors dynamically during gameplay.

Static vs. Dynamic Actors

The Actor Lifecycle

flowchart TD
    A[Blueprint Calls Spawn Actor] --> B[Actor Created in Memory]
    B --> C[Construction Script Runs]
    C --> D[BeginPlay Event Fires]
    D --> E[Actor Exists in World]
    E --> F[Tick Events Fire Each Frame]
    F --> E
    E --> G[Destroy Actor Called]
    G --> H[EndPlay Event Fires]
    H --> I[Actor Removed from Memory]
    
    style A fill:#4CAF50,stroke:#2e7d32,color:#fff
    style B fill:#2196F3,stroke:#1565c0,color:#fff
    style C fill:#ff9800,stroke:#e65100,color:#fff
    style D fill:#9c27b0,stroke:#6a1b9a,color:#fff
    style E fill:#4CAF50,stroke:#2e7d32,color:#fff
    style F fill:#2196F3,stroke:#1565c0,color:#fff
    style G fill:#e74c3c,stroke:#c0392b,color:#fff
    style H fill:#ff9800,stroke:#e65100,color:#fff
    style I fill:#9e9e9e,stroke:#616161,color:#fff

Figure: Complete lifecycle of a dynamically spawned Actor from creation to destruction.

Common Use Cases

Spawning Actors

The Spawn Actor from Class node creates a new Actor instance at runtime and places it in the world.

The Spawn Actor Node

Figure: Spawn Actor from Class node with all essential parameters.

Using Spawn Actor

1. Right-click in Event Graph → search "Spawn Actor from Class"
2. Select the node
3. Set the Class input: Choose which Blueprint to spawn
4. Provide Spawn Transform: Where and how to orient it
5. Set Collision Handling Override: What to do if location is blocked
6. The node returns a reference to the spawned Actor

Essential Parameters

1. Class (Required)

The Blueprint class to instantiate. This must be an Actor-based Blueprint.

• Click the dropdown to select from available Actor Blueprints
• Can be set to a variable for dynamic spawning
• Example: BP_Enemy, BP_Projectile, BP_Pickup

2. Spawn Transform (Required)

Defines where and how the Actor appears in the world.

• Location: X, Y, Z coordinates in world space
• Rotation: Pitch, Yaw, Roll orientation
• Scale: Size multiplier (usually 1, 1, 1)

Common sources for Spawn Transform:

• Get Actor Transform - Spawn at another Actor's location
• Make Transform - Build custom transform from separate values
• Get Socket Transform - Spawn at skeletal mesh socket
• Manual values - Fixed world location

3. Collision Handling Override

Determines behavior when spawn location is blocked by collision:

Basic Spawn Example

Event BeginPlay
  → Get Actor Location (this spawner's position)
  → Spawn Actor from Class:
      Class = BP_Enemy
      Spawn Transform = Actor Location (from above)
      Collision = Adjust If Necessary
  → Print String: "Enemy spawned!"

Spawn at Multiple Locations

Use a For Loop to spawn multiple Actors:

Event: Spawn Wave
  → For Loop (0 to 9)  // Spawn 10 enemies
      Loop Body:
        → Get Random Point in Radius (Center, Radius=1000)
        → Spawn Actor:
            Class = BP_Enemy
            Transform = Random Point + Ground Height
        → Print: "Spawned enemy " + Loop Index

Storing the Spawned Actor Reference

The Spawn Actor node returns a reference to the newly created Actor. Always store this reference if you need to control the Actor later!

flowchart LR
    A[Spawn Actor] --> B[Returns Reference]
    B --> C[Store in Variable]
    C --> D[Use Later to Control Actor]
    
    B --> E[Don't Store]
    E --> F[Can't Access Later!]
    
    style A fill:#4CAF50,stroke:#2e7d32,color:#fff
    style B fill:#2196F3,stroke:#1565c0,color:#fff
    style C fill:#4CAF50,stroke:#2e7d32,color:#fff
    style D fill:#4CAF50,stroke:#2e7d32,color:#fff
    style E fill:#e74c3c,stroke:#c0392b,color:#fff
    style F fill:#e74c3c,stroke:#c0392b,color:#fff

Figure: Always store the returned Actor reference if you need to interact with it later.

Example: Store spawned enemy to control it:

Spawn Actor (BP_Enemy)
  → Set Variable: SpawnedEnemy = Return Value
  
Later, in another event:
  → Get SpawnedEnemy variable
  → Call function on it: TakeDamage(50)

Common Spawning Patterns

Pattern 1: Spawn at Spawn Points

1. Place empty Actors in level as spawn points
2. Tag them "EnemySpawn"
3. Get All Actors of Class (TargetPoint)
4. Filter by tag
5. For each spawn point:
   → Spawn enemy at that location

Pattern 2: Spawn on Timer

Event BeginPlay
  → Set Timer by Event:
      Event = SpawnEnemy
      Time = 5.0 seconds
      Looping = True

Custom Event: SpawnEnemy
  → Spawn Actor at random location

Pattern 3: Spawn with Custom Properties

Spawn Actor (BP_Enemy)
  → Store reference
  → Cast to BP_Enemy
  → Set enemy properties:
      Health = 100
      Speed = 400
      Difficulty = Hard

Destroying Actors

What goes up must come down—spawned Actors should be destroyed when no longer needed to free memory and maintain performance.

The Destroy Actor Node

Figure: Destroy Actor node removes an Actor from the world permanently.

Destroying Actors: The Basics

To destroy an Actor:

1. Right-click in Event Graph → search "Destroy Actor"
2. Connect execution flow to it
3. Provide Target: The Actor to destroy
   • Self - Destroy this Blueprint
   • Variable reference - Destroy another Actor
   • Function return value - Destroy result of query

Common Destroy Patterns

Pattern 1: Self-Destruct

An Actor destroys itself (e.g., projectile hits wall):

Event: OnHit (projectile hits something)
  → Spawn particle effect at impact
  → Play sound at impact location
  → Destroy Actor (Target = Self)

Pattern 2: Destroy After Delay

Automatically clean up after a set time:

Event BeginPlay
  → Delay (5.0 seconds)
  → Destroy Actor (Self)
  
// Useful for: temporary VFX, timed pickups, decals

Pattern 3: Destroy on Condition

Remove Actor when it's no longer needed:

Enemy Health reaches 0
  → Play death animation
  → Delay (2.0 seconds)  // Let animation play
  → Spawn loot
  → Destroy Actor (Self)

Pattern 4: Destroy Multiple Actors

Get All Actors of Class (BP_Enemy)
  → ForEach Loop:
      → Destroy Actor (Array Element)
      
// Clears all enemies from level

Destroy vs. Hide

Get stored enemy reference
→ Branch (Is Valid?)
   True: Call function on enemy
   False: Do nothing (already destroyed)

Getting References to Actors

To interact with an Actor, you need a reference to it—a way to point to that specific Actor. There are multiple ways to get references.

Five Ways to Get Actor References

flowchart TD
    A[Need Actor Reference?] --> B[Method 1: Self]
    A --> C[Method 2: Spawn Return]
    A --> D[Method 3: Overlap Event]
    A --> E[Method 4: Manual Selection]
    A --> F[Method 5: Search Functions]
    
    B --> B1[Use Self node
References this Blueprint]
    C --> C1[Store Spawn Actor return
References spawned Actor]
    D --> D1[Overlap/Hit provides Other Actor
References colliding Actor]
    E --> E1[Instance Editable variable
Assign in editor]
    F --> F1[Get Actor of Class
Get All Actors of Class
Get Overlapping Actors]
    
    style A fill:#667eea,stroke:#4527a0,color:#fff
    style B fill:#4CAF50,stroke:#2e7d32,color:#fff
    style C fill:#2196F3,stroke:#1565c0,color:#fff
    style D fill:#ff9800,stroke:#e65100,color:#fff
    style E fill:#9c27b0,stroke:#6a1b9a,color:#fff
    style F fill:#e74c3c,stroke:#c0392b,color:#fff
    style B1 fill:#e8f5e9,stroke:#4CAF50
    style C1 fill:#e3f2fd,stroke:#2196F3
    style D1 fill:#fff3e0,stroke:#ff9800
    style E1 fill:#f3e5f5,stroke:#9c27b0
    style F1 fill:#ffebee,stroke:#e74c3c

Figure: Five common methods for obtaining Actor references in Blueprints.

Method 1: Self Reference

The Self node references the Blueprint you're currently in.

• Right-click → "Get a reference to self"
• Use when a Blueprint needs to reference itself
• Example: Pass yourself to another Actor

Enemy Blueprint:
  OnBeginPlay
    → Get Self
    → Call function on GameMode: RegisterEnemy(Self)
    
// GameMode now has reference to this enemy

Method 2: Store Spawn Return Value

When you spawn an Actor, store the returned reference:

Create variable: SpawnedProjectile (Type: BP_Projectile)

Fire Weapon:
  → Spawn Actor (BP_Projectile)
  → Set SpawnedProjectile = Return Value
  
Later:
  → Get SpawnedProjectile
  → Call SetVelocity on it

Method 3: Collision Events Provide References

Overlap and Hit events automatically provide references to the other Actor:

Event: OnComponentBeginOverlap
  → Other Actor (output pin) = the Actor that overlapped
  → Use this reference directly
  
Example:
  OnOverlap
    → Get Other Actor
    → Cast to BP_Player
    → If successful: Apply damage to player

Method 4: Manual Assignment (Instance Editable)

Create a variable and assign it manually in the editor:

1. Create variable: DoorToOpen (Type: Actor or BP_Door)
2. Check Instance Editable
3. Place Blueprint in level
4. Select it, find variable in Details panel
5. Use eyedropper to select target Actor in level

Pressure Plate Blueprint:
  Variable: DoorToOpen (Instance Editable)
  
  OnOverlap:
    → Get DoorToOpen
    → Call Open() on it

Method 5: Search Functions

Find Actors dynamically using search functions:

Get Actor of Class

Finds the first Actor of a specific class:

Get Actor of Class (BP_Player)
  → Returns first player Actor found
  → Returns None if not found

Get All Actors of Class

Returns array of all Actors of a class (covered in detail next section)

Get Overlapping Actors

Gets all Actors currently overlapping a component:

Get Overlapping Actors (from collision component)
  → Class Filter = BP_Enemy
  → Returns array of overlapping enemies

Casting Explained

Casting is how you tell Unreal "I know this generic Actor is actually a specific type, let me access its unique features."

Why Casting is Necessary

Many nodes return generic Actor references:

• OnOverlap gives "Other Actor" (generic)
• Get Actor of Class returns "Actor" (generic)
• Spawn Actor returns "Actor" (generic)

But you need access to specific Blueprint's variables/functions!

Figure: Casting converts generic Actor reference to specific type with access to custom functionality.

How to Cast

1. Have an Actor reference (from overlap, spawn, variable, etc.)
2. Right-click → search "Cast to [BlueprintName]"
3. Connect the Actor reference to the Object input pin
4. Use the two output execution pins:
   • Cast Succeeded: It IS that type (use the typed reference)
   • Cast Failed: It's NOT that type (handle appropriately)

Casting Example: Damage Only Players

Event: OnComponentBeginOverlap (explosion radius)
  → Get Other Actor (generic Actor reference)
  → Cast to BP_Player
     Cast Succeeded:
       → Get "As BP Player" output (typed reference)
       → Call TakeDamage(50) on player
     Cast Failed:
       → Do nothing (wasn't a player)

When to Cast

Get All Actors of Class

Sometimes you need to find and interact with every Actor of a specific type in the level—all enemies, all pickups, all lights.

Using Get All Actors of Class

Figure: Get All Actors of Class returns an array with references to every matching Actor.

Basic Usage

Get All Actors of Class
  Actor Class = BP_Enemy
  
Returns: Array of all BP_Enemy instances in level

Common Patterns with Get All Actors

Pattern 1: Damage All Enemies

Explosion Event:
  → Get All Actors of Class (BP_Enemy)
  → ForEach Loop:
      Array Element (each enemy):
        → Get Distance between Explosion and Enemy
        → Branch (Distance < ExplosionRadius)
           True: Call TakeDamage on enemy

Pattern 2: Count Specific Actors

Get All Actors of Class (BP_Collectible)
  → Get array Length
  → Display: "Collectibles remaining: " + Length

Pattern 3: Find Closest Actor

Get All Actors of Class (BP_Enemy)
  → ForEach Loop:
      → Get Distance between Player and Enemy
      → Branch (Distance < ClosestDistance):
         True: 
           → Set ClosestDistance = Distance
           → Set ClosestEnemy = Enemy
  After loop:
    → ClosestEnemy contains nearest enemy reference

Pattern 4: Modify All Actors

Night Mode Activated:
  → Get All Actors of Class (PointLight)
  → ForEach Loop:
      → Set Light Intensity = 2.0
      → Set Light Color = Blue

Performance Considerations

Alternatives to Get All Actors

Actor Communication Patterns

Actors rarely work in isolation—they need to talk to each other. Here are the most common patterns.

Pattern 1: Direct Reference Communication

When: You know exactly which Actors need to communicate
How: Store reference, call functions directly

flowchart LR
    A[Button] -->|Has Reference| B[Door]
    A -->|Calls Function| C[Open Door]
    
    style A fill:#2196F3,stroke:#1565c0,color:#fff
    style B fill:#4CAF50,stroke:#2e7d32,color:#fff
    style C fill:#ff9800,stroke:#e65100,color:#fff

Figure: Direct reference—Button stores Door reference, calls function.

BP_Button:
  Variable: DoorToOpen (Instance Editable, Type: BP_Door)
  
  OnInteract:
    → Get DoorToOpen
    → Call Open() function on door

Pattern 2: Overlap-Based Communication

When: Communication triggered by collision
How: Use overlap events, cast to specific type

BP_DamageZone:
  OnComponentBeginOverlap:
    → Get Other Actor
    → Cast to BP_Player
       Success: Call TakeDamage on player
       Failed: Ignore (not a player)

Pattern 3: Search and Communicate

When: Need to find and affect multiple Actors
How: Get All Actors, loop, communicate

BP_PowerupManager:
  OnPowerupActivated:
    → Get All Actors of Class (BP_Enemy)
    → ForEach Loop:
        → Call SlowDown() on each enemy

Pattern 4: Manager/Registry Pattern

When: Many Actors need coordination
How: Actors register with central manager

BP_Enemy:
  BeginPlay:
    → Get Actor of Class (BP_EnemyManager)
    → Call RegisterEnemy(Self)
    
BP_EnemyManager:
  Variable: EnemyArray (Array of BP_Enemy)
  
  Function: RegisterEnemy(Enemy)
    → Add Enemy to EnemyArray
  
  Function: GetAllEnemies()
    → Return EnemyArray

Pattern 5: Interface Communication

When: Multiple different Actor types need same message
How: Create Blueprint Interface, implement in all types

BPI_Damageable Interface:
  Function: TakeDamage(Amount)
  
Implement in: BP_Player, BP_Enemy, BP_Crate
  
BP_Weapon:
  OnHit:
    → Get Hit Actor
    → Send interface message: TakeDamage(50)
    → If Actor implements interface, it receives message
    → If not, nothing happens (safe)

Choosing Communication Pattern

flowchart TD
    A{Know exact Actors?} -->|Yes| B[Direct Reference]
    A -->|No| C{Triggered by collision?}
    C -->|Yes| D[Overlap + Cast]
    C -->|No| E{Many same-type Actors?}
    E -->|Yes| F[Get All Actors + Loop]
    E -->|No| G{Different types, same message?}
    G -->|Yes| H[Interface]
    G -->|No| I[Manager/Registry Pattern]
    
    style B fill:#4CAF50,stroke:#2e7d32,color:#fff
    style D fill:#2196F3,stroke:#1565c0,color:#fff
    style F fill:#ff9800,stroke:#e65100,color:#fff
    style H fill:#9c27b0,stroke:#6a1b9a,color:#fff
    style I fill:#e74c3c,stroke:#c0392b,color:#fff

Figure: Decision tree for selecting appropriate Actor communication pattern.

Summary

Dynamic Actor management is fundamental to creating interactive, responsive games. You now know how to spawn, destroy, find, and communicate with Actors at runtime.

Key Takeaways

• 🎭 Dynamic Actors are created/destroyed at runtime vs. static placement in editor
• 🌟 Spawn Actor from Class creates new Actors with transform and collision handling
• 💥 Destroy Actor removes Actors and frees memory—always validate references afterward
• 🔗 References are pointers to Actors obtained via Self, Spawn Return, Overlaps, Manual Assignment, or Search
• 🎯 Casting converts generic Actor references to specific types to access custom functionality
• 🔍 Get All Actors of Class finds every Actor of a type—powerful but expensive, avoid in Tick
• 💬 Communication Patterns: Direct Reference, Overlap-Based, Search-Based, Manager/Registry, Interface
• ✅ Best Practices: Store references, validate with Is Valid, avoid searches in Tick, handle Cast Failed, clean up properly

What's Next?

You've completed Module 5: Introduction to Blueprints! You've learned visual scripting fundamentals, variables, flow control, functions, and Actor management. The next module, Module 6: Player Interaction and Input, builds on this foundation by teaching you how to capture player input, control characters, detect collisions, and create interactive objects that respond to player actions.