🎨 Introduction to Blueprints

What Are Blueprints?

Imagine you want a door that opens when the player presses a button. In traditional programming, you'd write code in a text editor—lines of functions, variables, if-statements, and loops. In Unreal Engine, you can do the same thing visually by connecting boxes (nodes) that represent actions, checks, and data.

Why Blueprints Are Revolutionary

Before visual scripting, game development was divided into two camps:

• Programmers: Could write code and build complex systems, but needed to compile and restart to see changes
• Designers/Artists: Had creative vision but couldn't implement ideas without a programmer's help

Blueprints changed everything. Now:

• ✅ Anyone can script: No programming background required—if you understand "when this happens, do that," you can Blueprint
• ✅ Instant feedback: Make changes and see results immediately without recompiling
• ✅ Visual debugging: Watch values update in real-time, see execution flow highlighted
• ✅ Rapid prototyping: Build and test gameplay mechanics in minutes, not hours
• ✅ Powerful yet accessible: Can create everything from simple door logic to entire AI systems
• ✅ Full engine integration: Every Unreal feature is accessible through Blueprint nodes

What Can Blueprints Do?

Blueprints can handle virtually any gameplay task:

Visual Scripting Explained

Let's understand how visual scripting works by comparing it to traditional text-based programming.

Text Code vs. Visual Nodes

Here's the same simple logic expressed both ways:

void AMyDoor::OnInteract()
{
    if (!bIsOpen)
    {
        bIsOpen = true;
        PlaySound(OpenSound);
        RotateDoor(90.0f);
    }
}

Both accomplish the exact same thing. The visual version:

• ✅ Is easier to read for non-programmers
• ✅ Shows the flow visually—you can see the path execution takes
• ✅ Can be modified without recompiling C++
• ✅ Provides visual debugging (nodes light up during execution)

How Visual Scripting Works

flowchart LR
    A[Event Triggered] --> B{Condition Check}
    B -->|True| C[Execute Actions]
    B -->|False| D[Do Nothing]
    C --> E[Action 1: Play Sound]
    E --> F[Action 2: Rotate Door]
    F --> G[Action 3: Set Variable]
    G --> H[Complete]
    D --> H
    
    style A fill:#4CAF50,stroke:#2e7d32,color:#fff
    style B fill:#ff9800,stroke:#e65100,color:#fff
    style C fill:#2196F3,stroke:#1565c0,color:#fff
    style D fill:#9e9e9e,stroke:#616161,color:#fff
    style E fill:#667eea,stroke:#4527a0,color:#fff
    style F fill:#667eea,stroke:#4527a0,color:#fff
    style G fill:#667eea,stroke:#4527a0,color:#fff
    style H fill:#4CAF50,stroke:#2e7d32,color:#fff

Figure: Blueprint execution flow from event trigger through conditional logic to actions.

Key Visual Scripting Concepts

1. Nodes

Nodes are the building blocks—boxes that represent actions, functions, variables, or events. Each node has:

• Execution pins (white): Control flow—which node runs next
• Data pins (colored): Input/output values (numbers, text, objects)
• Name/title: What the node does

Example nodes:

• "Print String" - Displays text on screen
• "Add" - Adds two numbers
• "Play Sound" - Plays an audio file
• "Spawn Actor" - Creates a new object in the world

2. Pins and Wires

Pins are connection points on nodes. You drag wires between pins to connect nodes:

• Execution wires (white): Define the order nodes execute
• Data wires (colored): Pass values between nodes

The flow is left-to-right: Execution starts at an event node (left) and flows right through connected nodes.

3. Events

Events are starting points—they fire when something happens, triggering a chain of nodes:

• "BeginPlay" - Fires when the Actor starts (game begins)
• "Event Tick" - Fires every frame (~60 times per second)
• "OnBeginOverlap" - Fires when something touches a collision volume
• "OnClicked" - Fires when player clicks on the Actor

Blueprint Types

Unreal offers several types of Blueprints, each suited for different purposes. Understanding which to use is essential.

graph TD
    A[Blueprint Types] --> B[Level Blueprint]
    A --> C[Blueprint Class]
    A --> D[Blueprint Component]
    A --> E[Blueprint Interface]
    A --> F[Blueprint Macro Library]
    
    C --> C1[Actor Blueprint]
    C --> C2[Pawn/Character Blueprint]
    C --> C3[Game Mode Blueprint]
    C --> C4[Widget Blueprint UI]
    
    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:#00bcd4,stroke:#006064,color:#fff
    style C1 fill:#e3f2fd,stroke:#2196F3
    style C2 fill:#e3f2fd,stroke:#2196F3
    style C3 fill:#e3f2fd,stroke:#2196F3
    style C4 fill:#e3f2fd,stroke:#2196F3

Figure: The hierarchy of Blueprint types in Unreal Engine.

1. Level Blueprint

Every level has one Level Blueprint—it's level-specific logic that only exists in that particular map.

Use cases:

• Level-specific events (opening a door when player enters an area)
• Cinematics and scripted sequences
• Controlling specific Actors in the level
• Win/lose conditions for that level

Access: Blueprints menu → Open Level Blueprint

2. Blueprint Class

Blueprint Classes are reusable templates—you create them once, then place multiple instances in any level. They're the most common Blueprint type.

Use cases:

• Interactive objects: Doors, chests, buttons, levers, pickups
• Props with behavior: Spinning coins, flickering lights, moving platforms
• Characters and enemies: Player controller, AI enemies, NPCs
• Projectiles: Bullets, arrows, magic spells
• Game systems: Spawn points, checkpoints, trigger volumes

Common Blueprint Class types:

Creating a Blueprint Class: Content Browser → Right-click → Blueprint Class → Choose parent class

3. Blueprint Component

Blueprint Components are reusable pieces of functionality you can add to any Actor Blueprint.

Think of Components as LEGO bricks: You snap them onto Actors to add abilities.

Example Components:

• Point Light Component: Makes the Actor emit light
• Static Mesh Component: Gives the Actor visible geometry
• Collision Component: Adds collision detection
• Movement Component: Handles physics and movement
• Audio Component: Plays sounds
• Custom Blueprint Components: You can create your own!

4. Blueprint Interface

Blueprint Interfaces define functions that multiple Blueprint Classes can implement differently.

Use case: You want to send a message "React to Damage" to many different Actors (players, enemies, destructible crates), but each responds differently.

• Player: Reduce health, play hurt animation
• Enemy: Reduce health, play hit effect, aggro player
• Crate: Break apart, spawn loot

With an Interface, you can call "TakeDamage" on any Actor, and each implements it their own way. This is advanced—we'll cover it in Module 4.

5. Blueprint Macro Library and Function Library

Macro Libraries and Function Libraries are collections of reusable Blueprint snippets you can call from anywhere.

• Macros: Collapse commonly used node groups into a single reusable node
• Functions: Reusable logic with inputs/outputs, like a mini-program
• Function Libraries: Collections of utility functions available project-wide

Example: A "CalculateDistance" function library node you can use anywhere to find distance between two points.

Which Blueprint Type Should I Use?

Quick decision guide:

flowchart TD
    A{What are you making?} --> B{Does it exist only in one level?}
    B -->|Yes| C[Level Blueprint]
    B -->|No| D{Is it a reusable object?}
    D -->|Yes| E[Blueprint Class]
    D -->|No| F{Is it reusable functionality?}
    F -->|Yes| G[Component or Function Library]
    
    E --> H{What kind of object?}
    H -->|Interactive prop| I[Actor Blueprint]
    H -->|Player/enemy character| J[Character or Pawn BP]
    H -->|UI element| K[Widget Blueprint]
    H -->|Game rules| L[Game Mode Blueprint]
    
    style A fill:#667eea,stroke:#4527a0,color:#fff
    style C fill:#4CAF50,stroke:#2e7d32,color:#fff
    style E fill:#2196F3,stroke:#1565c0,color:#fff
    style G fill:#ff9800,stroke:#e65100,color:#fff
    style I fill:#e3f2fd,stroke:#2196F3
    style J fill:#e3f2fd,stroke:#2196F3
    style K fill:#e3f2fd,stroke:#2196F3
    style L fill:#e3f2fd,stroke:#2196F3

Figure: Decision tree for choosing the right Blueprint type.

The Blueprint Editor

When you open a Blueprint Class, the Blueprint Editor launches—this is your visual programming workspace.

Opening the Blueprint Editor

1. In Content Browser, find a Blueprint asset (blue icon)
2. Double-click to open
3. The Blueprint Editor window appears

Blueprint Editor Interface

Figure: The Blueprint Editor interface showing components, event graph canvas, and details panel.

Key Areas of the Blueprint Editor

1. Toolbar (Top)

Main actions:

• Compile: Converts your visual script into executable code (green = success, red = errors)
• Save: Saves your Blueprint changes
• Class Settings: Configure Blueprint properties (parent class, replication, etc.)
• Play: Quick test—launches the game to test your Blueprint

2. Tabs (Below Toolbar)

Different modes/views:

• Event Graph: Main visual scripting canvas (where you spend most time)
• Construction Script: Runs when the Actor is placed/moved in editor (setup logic)
• Viewport: 3D preview of your Actor with Components
• Functions: Custom functions you create

3. Components Panel (Left)

Shows all Components attached to this Blueprint:

• Hierarchy of Components (parent-child relationships)
• Add new Components with "+ Add" button
• Select Components to configure in Details panel

4. My Blueprint Panel (Left, Below Components)

Overview of your Blueprint's structure:

• Variables: Data storage (health, speed, isOpen, etc.)
• Functions: Reusable logic chunks
• Macros: Collapsed node groups
• Event Graphs: All your event graphs listed

5. Event Graph Canvas (Center)

The main workspace—where you place and connect nodes:

• Navigation: Right-click drag to pan, scroll wheel to zoom
• Add nodes: Right-click in empty space, search for nodes
• Connect nodes: Drag from output pin to input pin
• Select nodes: Click to select, drag to move, Ctrl+Click for multi-select

6. Details Panel (Right)

Shows properties of the selected node or Component:

• Input values for function nodes
• Settings and options
• Component properties (transforms, materials, collision)

Event-Driven Programming

Blueprints use event-driven programming—logic doesn't run continuously, it runs in response to specific events. Understanding this is crucial.

How Events Work

sequenceDiagram
    participant Engine as Unreal Engine
    participant Blueprint as Your Blueprint
    participant Player as Game/Player
    
    Note over Engine,Player: Game Running (60 FPS)
    
    Player->>Engine: Press 'E' key
    Engine->>Blueprint: Fire "InputAction E" Event
    Blueprint->>Blueprint: Execute connected nodes
    Blueprint->>Engine: Play door animation
    Blueprint->>Engine: Play sound
    Note over Blueprint: Execution complete
    
    Note over Engine,Player: Waiting for next event...
    
    Player->>Engine: Collide with trigger
    Engine->>Blueprint: Fire "OnBeginOverlap" Event
    Blueprint->>Blueprint: Check if player
    Blueprint->>Engine: Display message
    Note over Blueprint: Execution complete

Figure: Event-driven execution sequence showing how events trigger Blueprint logic.

Common Blueprint Events

Execution Flow

When an event fires, execution flows left-to-right through connected nodes:

flowchart LR
    A[Event Fires] -->|White wire| B[Node 1]
    B -->|Executes| C[Node 2]
    C -->|Executes| D[Node 3]
    D -->|Complete| E((End))
    
    style A fill:#e74c3c,stroke:#c0392b,color:#fff
    style B fill:#667eea,stroke:#4527a0,color:#fff
    style C fill:#667eea,stroke:#4527a0,color:#fff
    style D fill:#667eea,stroke:#4527a0,color:#fff
    style E fill:#4CAF50,stroke:#2e7d32,color:#fff

Figure: Blueprint execution flows left-to-right through connected nodes until complete.

Key points:

• Execution follows white wires (execution pins)
• Nodes execute in order, one after another
• If there's no white wire connection, execution stops
• Multiple outputs (Branch node: True/False) create different execution paths

Event Tick vs. Event-Based Logic

A common beginner mistake: overusing Event Tick.

Event Tick (60 times/sec)
  Check if player pressed 'E'
  Check if door is closed
  If both true, open door

Event InputAction 'E'
  Check if door is closed
  If true, open door

When to use Event Tick:

• ✅ Continuous smooth movement (rotating platforms, scrolling textures)
• ✅ Following/tracking (camera following player, enemy AI tracking)
• ✅ Countdown timers
• ✅ Interpolation (smooth transitions)

When NOT to use Event Tick:

• ❌ Waiting for player input (use Input events instead)
• ❌ Collision detection (use Overlap/Hit events instead)
• ❌ One-time setup (use BeginPlay instead)
• ❌ Checking for rare conditions (use event dispatchers or timers instead)

Creating Your First Blueprint

Let's walk through creating a simple interactive Blueprint Actor—a spinning collectible coin that disappears when touched.

Step-by-Step: Spinning Coin Blueprint

flowchart TD
    A[Create Blueprint Class] --> B[Add Static Mesh Component]
    B --> C[Configure Mesh & Collision]
    C --> D[Create Variables]
    D --> E[Add Event BeginPlay]
    E --> F[Add Event Tick for Rotation]
    F --> G[Add OnBeginOverlap Event]
    G --> H[Add Collection Logic]
    H --> I[Test & Debug]
    
    style A fill:#4CAF50,stroke:#2e7d32,color:#fff
    style B fill:#2196F3,stroke:#1565c0,color:#fff
    style C fill:#2196F3,stroke:#1565c0,color:#fff
    style D fill:#ff9800,stroke:#e65100,color:#fff
    style E fill:#667eea,stroke:#4527a0,color:#fff
    style F fill:#667eea,stroke:#4527a0,color:#fff
    style G fill:#667eea,stroke:#4527a0,color:#fff
    style H fill:#667eea,stroke:#4527a0,color:#fff
    style I fill:#4CAF50,stroke:#2e7d32,color:#fff

Figure: Workflow for creating your first Blueprint Actor.

Part 1: Create the Blueprint Class

1. In Content Browser, navigate to Content/MyProject/Blueprints/
2. Right-click in empty space → Blueprint Class
3. Select Actor as parent class
4. Name it BP_Collectible_Coin
5. Double-click to open in Blueprint Editor

Part 2: Add Visual Mesh

1. In Components panel, click + Add
2. Search for "Static Mesh", add it
3. Rename component to CoinMesh
4. With CoinMesh selected, in Details panel:
   • Set Static Mesh to a cylinder or coin mesh (or use Starter Content)
   • Adjust scale if needed (e.g., 0.5, 0.5, 0.1 for flat coin)

Part 3: Add Collision

1. Click + Add → Sphere Collision
2. Rename to CollectionTrigger
3. In Details panel:
   • Set Sphere Radius to cover the coin (e.g., 50)
   • Under Collision, check Generate Overlap Events

Part 4: Create Variables

1. Switch to Event Graph tab
2. In My Blueprint panel, click + Variable
3. Name it RotationSpeed
4. In Details panel, set type to Float
5. Check "Instance Editable" (allows setting per-instance)
6. Set Default Value to 100.0
7. Click Compile to save

Part 5: Add Rotation Logic (Event Tick)

1. Right-click in Event Graph → Add Event → Event Tick
2. This event fires every frame with a "Delta Seconds" output (time since last frame)
3. Drag from Event Tick's execution pin → search "Add Relative Rotation"
4. Connect it
5. On the AddRelativeRotation node:
   • Click the "Delta Rotation" pin
   • In Details, set Yaw (Z-axis) to connect to RotationSpeed variable
   • Multiply RotationSpeed by Delta Seconds (for smooth frame-independent rotation)

Node setup:

• Event Tick → AddRelativeRotation
• Get RotationSpeed → Multiply (by Delta Seconds) → Make Rotator (Yaw input) → AddRelativeRotation

Part 6: Add Collection Logic

1. In Components panel, select CollectionTrigger
2. In Details panel, scroll down to Events
3. Click the green + next to "On Component Begin Overlap"
4. This creates an event in the Event Graph
5. From the event's execution pin:
   • Add Print String node → set text to "Coin Collected!"
   • Then add Play Sound at Location (optional, choose a pickup sound)
   • Then add Destroy Actor node (removes the coin from the world)

Part 7: Compile and Test

1. Click Compile button (should turn green)
2. Click Save
3. Close Blueprint Editor
4. Drag BP_Collectible_Coin from Content Browser into your level
5. Press Alt+P to Play
6. Walk into the coin—it should spin, display "Coin Collected!", and disappear!

Common First Blueprint Issues

Blueprints vs C++

A common question: Should I use Blueprints or C++? The answer: Often both! They're designed to work together.

Comparison Table

When to Use Each

The Hybrid Approach (Recommended)

Professional teams typically use both together:

flowchart TD
    A[C++ Base Classes] --> B[Blueprint Child Classes]
    A --> C[Blueprint-Callable Functions]
    B --> D[Designers/Artists Extend]
    C --> D
    D --> E[Final Game Content]
    
    A1[Example: C++ Character Base] --> B1[BP_Player inherits]
    A1 --> C1[Jump Function in C++]
    B1 --> D1[Designers add double-jump]
    C1 --> D1
    
    style A fill:#9c27b0,stroke:#6a1b9a,color:#fff
    style B fill:#2196F3,stroke:#1565c0,color:#fff
    style C fill:#9c27b0,stroke:#6a1b9a,color:#fff
    style D fill:#4CAF50,stroke:#2e7d32,color:#fff
    style E fill:#ff9800,stroke:#e65100,color:#fff

Figure: Hybrid workflow where C++ provides foundation and Blueprints extend functionality.

Workflow example:

1. Programmer creates AWeapon C++ class with functions like Fire(), Reload()
2. These functions are marked BlueprintCallable
3. Designer creates BP_RocketLauncher Blueprint inheriting from AWeapon
4. Designer adds rocket-specific visuals, sounds, fire rate in Blueprint
5. Designer calls C++ Fire() function but customizes behavior in Blueprint

This combines the best of both: C++ performance and structure, Blueprint flexibility and iteration speed.

Blueprint Best Practices

As your Blueprints grow, following best practices keeps them maintainable and performant.

Organization and Readability

1. Use Comments

Add comment boxes to explain sections of logic:

• Select nodes → C key to create comment box
• Type descriptive text: "Check if player has key"
• Color-code comments for different sections

2. Group Related Logic into Functions

Instead of one giant Event Graph, break logic into functions:

• My Blueprint panel → Functions → + Function
• Name descriptively: OpenDoor, CalculateDamage, SpawnPickup
• Call functions from events—keeps graphs clean

3. Naming Conventions

Use consistent, descriptive names:

4. Keep Graphs Clean

• ✅ Align nodes horizontally/vertically (select multiple → Q to align)
• ✅ Avoid wire spaghetti—use Reroute nodes for long wires
• ✅ Delete unused nodes
• ✅ Straighten wires (double-click wire to add bend point, drag to shape)

Performance Best Practices

1. Minimize Event Tick Usage

Event Tick runs every frame—use sparingly:

• ❌ Bad: Check for conditions every tick
• ✅ Good: Use Timers for periodic checks (Set Timer by Function Name)
• ✅ Good: Use event-based triggers instead

2. Cache References

Don't repeatedly search for Actors—store references:

Event Tick
  Get All Actors of Class (Player)
  Do something with player

Event BeginPlay
  Get Player Controller
  Store in PlayerRef variable

Event Tick
  Use PlayerRef variable

3. Use Pure Functions

Pure functions (no execution pins, colored nodes) don't execute—they just return values. They're free!

• Get Variable → Pure function (just returns value)
• Math operations → Pure (Add, Multiply, etc.)

4. Profile and Optimize

Use Blueprint profiling tools:

• Console command: stat game (shows performance stats)
• Blueprint Profiler: Tools → Blueprint Profiler (shows which Blueprints are slow)
• Focus optimization where profiler shows bottlenecks

Debugging Best Practices

1. Use Print String Liberally

Print String is your best friend for debugging:

• Add Print String nodes to see execution flow
• Print variable values: "Health: " + ToString(Health)
• Use different colors for different messages

2. Use Breakpoints

Right-click a node → Add Breakpoint:

• Game pauses when execution hits breakpoint
• Inspect all variable values at that moment
• Step through nodes one at a time (F10)

3. Watch Variables

Right-click a variable → Watch This Value:

• Variable's value displays during Play
• Updates in real-time
• Great for seeing state changes

Summary

Blueprints are Unreal Engine's visual scripting superpower, enabling anyone to create complex gameplay without writing traditional code. You've learned the foundations—now it's time to build!

Key Takeaways

• 🎨 Blueprint Visual Scripting uses nodes and wires instead of text code—accessible to everyone
• 📦 Blueprint Types: Level Blueprints (level-specific), Blueprint Classes (reusable), Components (modular)
• 🖥️ Blueprint Editor has Components panel, Event Graph canvas, and Details panel for visual programming
• ⚡ Event-Driven: Logic executes in response to events (BeginPlay, Tick, Overlap, Input), not continuously
• 🔗 Execution Flow: White wires connect nodes left-to-right, defining execution order
• 🔧 Components are LEGO bricks—snap them onto Actors to add functionality
• ⚖️ Blueprints vs C++: Use Blueprints for rapid iteration and gameplay, C++ for core systems and performance
• 📏 Best Practices: Use comments, create functions, cache references, minimize Tick usage
• 🐛 Debugging: Print String, breakpoints, and watch values are your debugging toolkit
• 🎯 Hybrid Approach: C++ provides foundation, Blueprints extend and customize

What's Next?

Now that you understand Blueprint basics, the next lesson will dive deeper into Lesson 3.2: Blueprint Communication and Variables. You'll learn how to make Blueprints talk to each other, manage data with variables, and create complex interactions between multiple Actors.