- Build a trigger-driven interaction from scratch: overlap event → timeline → animated result.
- Use variables and branches to give an interaction state (locked/unlocked, count, on/off).
- Put a simple UMG widget on screen and update it from gameplay.
- Walk an unfamiliar Blueprint graph node-by-node and say what each node does — including one an AI built.
2:00 · Brief The event-driven world
A level is a noun; a Blueprint makes it a verb. Everything interactive in Unreal — doors, elevators, pickups, entire game modes — reduces to the same sentence: when this event fires, run these nodes, changing this state. Learn to see that sentence and no graph will scare you.
Two kinds of wire
White wires are time: the order in which things execute, one pulse per event. Colored wires are data: values flowing into node inputs. Most beginner confusion is mixing these up. When you read any graph — yours, a classmate's, an agent's — trace the white wire first, then ask what data each node consumed.
The vocabulary for today
- Trigger volumes — collision shapes that fire overlap events when the player enters or leaves. The doorbell of every interaction.
- Timelines — nodes that play a value curve over seconds. The difference between a door that teleports open and one that swings.
- Branches and state — a Boolean plus a Branch node turns behavior into rules: only open if unlocked, only count each pickup once.
- Widgets (UMG) — screen-space UI, built like a layout and driven from gameplay. In VR (Week 11) UI moves into the world, but the wiring is the same.
Reading before writing
From this week forward, half the Blueprints you touch will have been written by someone else — a marketplace asset, a template, or an agent acting through MCP. Studios already work this way. The skill that gets you hired isn't producing nodes; it's auditing them: what does this graph do, what state does it touch, and where would it break?
The Unreal MCP plugin you're using this week is first-party Epic — an MCP server inside the editor that Claude Code and other agents drive over local HTTP, with tools for actors, lighting, materials, Blueprints, and automation tests. It's Experimental: local-only, no auth, incomplete docs. Discussion: what new failure modes appear when an AI can touch your Blueprint graph directly?
2:45 · Guided lab A door, a pickup, a counter
Three classic interactions, built by hand, in order of difficulty. Everything the agent does at 4:00 you will have just done yourself — that's deliberate.
- Make the door actor
Content browser → new Blueprint Class → Actor, name it
BP_Door. Add a Static Mesh component (any door-ish mesh from your project or Fab) and a Box Collision component scaled to cover the approach area. - Wire the trigger
Select the Box Collision, add its On Component Begin Overlap event. Print String first — always prove the event fires before building on it. Walk into it in PIE.
- Animate with a timeline
Add a Timeline node with a float track running 0→1 over about a second. Feed it into a Lerp driving the door mesh's relative rotation (closed → open) via Set Relative Rotation. Wire End Overlap to Reverse so the door closes behind you.
- Give it state
Add a Boolean
bLocked, default true, editable per-instance (Instance Editable). Branch on it before the timeline plays. Drop two doors in the level, lock one, and confirm they behave differently. - Build the pickup
New Actor Blueprint
BP_Pickup: mesh, sphere collision, overlap event. On overlap: destroy the actor. Make it slowly rotate on Event Tick so it reads as "take me" — affordance is design, not decoration. - Count what you collect
The count has to live somewhere that outlives the pickup — put an Integer on the player (or Game Mode). From the pickup's overlap, get that owner, increment the count, then destroy. This is your first cross-Blueprint communication; casting gets formalized next week.
- Show it on screen
Create a Widget Blueprint with a Text Block bound to the count. On BeginPlay (player), Create Widget → Add to Viewport. Collect three pickups and watch the number move.
- Commit
Push everything. The agent works on this exact scene next — the diff after its session is tonight's homework material.
4:00 · AI lab The agent wires a graph
Same problem, agent-assisted: describe an interaction in plain English, let Claude Code build it through Unreal MCP, then audit every node it placed. You just built these by hand, so you know exactly what right looks like.
With the editor running and ModelContextProtocol.StartServer active, watch the outliner and content browser while the agent works. Note whether it builds roughly your architecture — trigger, branch, timeline — or something stranger.
Now verify: open the graph yourself and check the explanation against the actual nodes. Agents narrate confidently even when the graph diverged from the plan — the graph is ground truth, not the prose.
Compare its self-review to your own read of the graph. Anything it missed — or invented — goes in your log. Then decide, node by node, what to keep.
- The agent-built interaction actually works in PIE — you tested it, not just read about it.
- You annotated the agent's graph node-by-node (comment boxes in the graph are ideal) in your own words.
- You found at least one thing to fix or reject in the agent's work — there is always one.
- The git diff of the agent session is committed separately from your hand-built work.
- AILOG.md has today's session: prompts, what it built, what you changed and why.
5:15 · Crit / share Graphs up
Screens up, event graphs visible. Each person shows one interaction — hand-built or agent-built — and the room reads it cold: trace the white wire out loud before the author explains anything. Where the room's reading and the author's intent diverge, that's this week's lesson made visible.
Homework — due before Week 9
| Task | Deliverable |
|---|---|
| Finish annotating the agent-built Blueprint: comment boxes over every functional cluster, in your words. | Annotated graph committed, plus screenshots in your AILOG.md entry. |
| Build one new interaction of your own design (elevator, light switch, secret wall — your call) using a trigger, a timeline, and state. | Working Blueprint in your sandbox repo, demoed at next week's open. |
| Project 2 final push: Architectural Visualization is due at next week's crit. | Hero stills, flythrough, and pipeline notes ready to show; AI development log current. |
Resources
- Blueprints Visual Scripting — the official reference; bookmark the Timeline and UMG pages.
- Unreal MCP in the Unreal Editor — the toolsets the agent used today, documented.
- VP Land: UE 5.8's embedded MCP server — a good outside read on what agent-driven editing means.
- Epic Developer Community — Learning — the Blueprint courses go deeper than we can in one session.