- Choose the right channel for two Blueprints to communicate: cast, interface, or event dispatcher — and say why.
- Create a C++ Actor class, expose a property and function to Blueprints, and subclass it.
- Say when a feature belongs in Blueprints, when it wants C++, and what the hybrid workflow looks like in real studios.
- Evaluate two AI agents on the same task with evidence — approach, correctness, explanation — instead of vibes.
2:00 · Brief How Blueprints talk — and when to leave them
Last week's pickup already smuggled the problem in: one Blueprint needed to change a value living in another. Communication between objects is the actual architecture of interactivity, and Unreal gives you three main channels. Pick wrong and your project turns into wire spaghetti nobody — including your agent — can maintain.
The three channels
- Casting — "I know exactly what you are." Direct and fast, but it hard-couples the two Blueprints: rename or restructure the target and every cast breaks. Fine for player and Game Mode; a trap everywhere else.
- Blueprint Interfaces — "I don't care what you are, only that you can do this." A shared contract (
Interact,TakeDamage) that any actor can implement. This is how one player interaction line drives doors, pickups, and switches alike. - Event Dispatchers — "Something happened; whoever cares, react." The door announces it opened; the lights, the score, the sound all subscribe. One broadcaster, many listeners, no coupling.
When a project wants C++
Blueprints compile to something slower than native code and get unwieldy past a certain complexity. The professional pattern isn't Blueprints or C++ — it's C++ for systems and heavy lifting, Blueprints for behavior and tuning, with C++ base classes exposing knobs (UPROPERTY, UFUNCTION) that designers subclass and tweak. You'll touch that seam today, gently. Nobody becomes a C++ programmer in an afternoon; you will, however, stop being afraid of the folder.
Two agents, one job
Today's AI lab is graded. You'll give Claude Code and Codex the identical interaction task and audit them like a hiring manager: approach, correctness, and how well each explains itself. This is the review skill the industry is scrambling to formalize — and it's why we run two agents all semester instead of one.
If one creative technologist directing agents can do what took a small team, studios gain speed and a brand-new QA problem: catching AI-generated errors before they cascade. Your head-to-head today is practice for a real hiring question — reported offer rates for graduates with verifiable AI-pipeline experience run well above coursework-only peers. Discussion: what does the review process for agent work look like?
2:45 · Guided lab Interfaces, dispatchers, and a first C++ class
We refactor last week's interactions into grown-up architecture, then cross the C++ border once, together, so the first time isn't alone at midnight.
- Make an Interact interface
Content browser → Blueprint Interface, name it
BPI_Interactable, give it one function:Interact. No logic lives here — it's a contract. - Implement it twice
In
BP_DoorandBP_Pickup: Class Settings → addBPI_Interactable, then implement the Interact event — the door toggles, the pickup collects. Two different behaviors, one shared verb. - One line of player code to rule them
On a key press in the player Blueprint, trace or overlap for the nearest actor and call
Interacton it (the interface message node). No casts. Add a third interactable actor and note that the player Blueprint doesn't change — that's the point. - Broadcast with a dispatcher
In
BP_Door, add an Event DispatcherOnOpenedand call it when the door opens. In the Level Blueprint, bind to it and react — flicker a light, print a message. Notice the door knows nothing about the light. - Cross into C++
Tools → New C++ Class → Actor, name it
InteractableBase. The editor generates the class and opens your IDE; let it compile (Live Coding handles rebuilds while the editor runs — if it fights you, closing the editor and building from the IDE is the reliable path). - Expose knobs to Blueprints
In the header add a
UPROPERTY(EditAnywhere, BlueprintReadWrite)floatInteractionRangeand aUFUNCTION(BlueprintCallable)functionDescribeSelfthat logs the actor's name and range. Compile. - Subclass it in Blueprints
Create a Blueprint Class with
InteractableBaseas parent. SetInteractionRangein the Details panel; callDescribeSelffrom BeginPlay. You've just used the hybrid workflow every UE studio runs on. - Commit before the head-to-head
Clean working tree, everything pushed. The next block generates two competing diffs and you'll want them cleanly separated.
4:00 · AI lab Head-to-head: Claude Code vs Codex
Graded exercise. Same spec, two agents, one verdict. Run Claude Code first, commit its work to a branch, reset, then run Codex from the same clean state. Judge the work, not the brand.
Log everything: the plan each agent states, the nodes/files it touches, how long it takes, where it asks for permission versus barrels ahead. Test each build in PIE before judging — a confident explanation of a broken graph scores zero on correctness.
You're scoring self-knowledge: does the agent understand its own work, admit real weaknesses, and reason about scale — or does it flatter its output? Cross-check at least one claim against the actual graph.
Show each agent the other's diff. Watch for substance versus politeness — and whether either one changes its story under pressure. This is where the two usually stop looking interchangeable.
- Both implementations were tested in PIE from the same starting commit — you saw each work or fail yourself.
- Each agent's work lives on its own branch with its own AILOG entries.
- You scored both on the same three axes: approach, correctness, explanation.
- Your verdict cites specific evidence (a node, a decision, a failure) — not tone or speed alone.
- The write-up (see homework) says which you'd hire, for what kind of task, and why.
5:15 · Crit / share Architectural Visualization crit
Project 2 is due: hero stills and flythroughs on the projector, day and night scenarios, pipeline notes in hand. The crit question for archviz is always the client's question — would you sign off on this building from these images? Be ready to say what Datasmith gave you for free, what you repaired, and what the agent did versus what you did. Head-to-head verdicts get thirty seconds each at the end: name your hire.
Homework — due before Week 10
| Task | Deliverable |
|---|---|
| Write up the head-to-head: approach, correctness, explanation quality for each agent, with evidence from your logs and diffs. | One-page verdict ("which I'd hire and why") committed as HEADTOHEAD.md; graded. |
| Get VR-ready: install the Android platform support UE prompts for (if targeting Quest from your machine), enable Developer Mode on your headset, and confirm the lab headsets fit your project plans. | Headset pairs with your machine or a lab machine; note any blockers in AILOG.md. |
| Read the Project 3 brief on the Projects tab and pick your track: interactive VR piece or VP collaboration. | Three-sentence declaration of track and concept, ready to state at Week 10's open. |
Resources
- Blueprints Visual Scripting — the interface and event dispatcher pages are this week's core reading.
- Programming with C++ in Unreal Engine — go exactly as deep as curiosity carries you; the UPROPERTY/UFUNCTION pages matter most.
- Claude Code + UE 5.8 integration guide — background for the head-to-head.
- Claude Code documentation — the workflows section will sharpen your prompting for the graded exercise.