Blueprints I: input, and a character you can drive Project 3 launch

Mon 2:00 · Brief The engine calls you

You don't run your game — the engine does, and it calls your logic on a schedule. Learn that schedule and Blueprint scripting stops feeling like magic.

Blueprints and the game loop

A Blueprint is a visual script you attach to an Actor — nodes and wires instead of typed code. You never call its events yourself; the engine fires them for you at defined moments. Event BeginPlay runs once as the Actor comes to life. Then, every single frame, Unreal fires Event Tick — sixty-plus times a second — which is where you read input and make things happen. This is the game loop: read input, update state, render, repeat, forever, until someone quits.

The key mental shift from a render pipeline is that nothing is pre-baked. There is no Sequencer scrubbing to a known end. Each frame you get a tiny slice of time and you decide what the world looks like at the end of it. Your job in the graph is to answer, every frame: given what the player just did, what changes?

Tick vs. events, and why Delta Seconds matters

Event Tick is the per-frame pulse — great for reading input and driving animation. But frames don't arrive on a fixed clock; a heavy scene runs slower than a light one. So anything that should happen at a steady real-world rate gets multiplied by Delta Seconds, the Delta Seconds pin on Event Tick that reports the time elapsed since the last frame. Move by speed × Delta Seconds and your character crosses the room in the same wall-clock time on a fast or slow machine. Forget it and your game literally runs faster on better hardware.

Not everything is per-frame. Events are the engine calling you when something specific occurs — an On Component Begin Overlap when a collider overlaps, a hit event on a physics contact, a UMG button's click. Tick is "check every frame"; events are "tell me when." Good interactive logic uses both: Tick for continuous things like movement, events for discrete moments like picking something up. We lean hard on events next week.

Reading input the modern way

Unreal reads input through Enhanced Input, the current standard. Instead of hard-coding key checks, you author an Input Action (an abstract intent like "Move," typed as an Axis2D) and bind physical keys and stick axes to it in an Input Mapping Context — one abstraction across keyboard, gamepad, and touch that survives rebinding. In your Character Blueprint you add the mapping context on Event BeginPlay, then handle the Move action to get a Vector2 each frame and turn it into motion. Here is the smallest honest version of today's logic, described as the node graph you'll wire:

Read it node by node. Set Speed on the Anim BP is the connection that matters: push the stick further, the Character moves faster, Speed climbs, and the walk blends to a run — no new animation work, just a wire from gameplay to the Animation Blueprint you built. If you want a taste of C++, the advanced path is the same idea in a ACharacter subclass: bind the action in SetupPlayerInputComponent, call AddMovementInput, and set the anim variable — the Blueprint is doing exactly this under the hood.

Mon 2:45 · Guided lab A character you can drive

We build the graph above together, from empty Blueprint to a character that walks and runs on your input. Do the steps in order — the Anim BP wire only works once movement exists.

1. Enable Enhanced Input

   Enhanced Input is on by default in UE 5.8. Confirm it under Edit → Project Settings → Input, where the default input classes are the Enhanced Input ones. This is the modern input path; everything we wire today assumes it.

2. Start from a Character Blueprint

   Create a Blueprint Class based on Character (BP_PlayerCharacter) and drop your Project 2 skeletal mesh into its Mesh component. A Character already ships with a capsule collider and a Character Movement Component — code-driven movement with collision, gravity, and grounding, exactly right for a player, without you wiring physics by hand.

3. Author the Input Action and Mapping Context

   Create an Input Action IA_Move (Value Type: Axis2D) and an Input Mapping Context IMC_Player. In the context, bind WASD and the left stick to IA_Move with the right modifiers (Swizzle / Negate) so up is +Y and right is +X. This is the intent-to-keys layer.

4. Add the mapping context on BeginPlay

   In BP_PlayerCharacter, on Event BeginPlay, get the player's Enhanced Input Local Player Subsystem and call Add Mapping Context with IMC_Player. Without this step the action never fires — a classic first-day gotcha.

5. Read input and move

   Add the IA_Move event node, split its Action Value into X and Y, and call Add Movement Input with the control-rotation forward vector (× Y) and right vector (× X). Save, hit Play In Editor — you should slide around the floor with clean collision.

6. Wire movement into the Animation Blueprint

   On Event Tick, get the Character's Velocity, take its length, and Set the Speed float on the Anim BP (or set it inside Event Blueprint Update Animation by reading the owning pawn's velocity). The variable name must match the float your Project 2 Blend Space reads. Now standing still holds idle and moving blends up through walk to run.

7. Face the direction of travel

   On the Character Movement Component, enable Orient Rotation to Movement and disable Use Controller Rotation Yaw. The movement component now smoothly turns the Character toward its velocity for free. A character that walks sideways reads as broken; turning to face motion is the cheapest believability you'll ever buy.

8. Test, then back up

   Play and confirm: idle when still, walk at low input, run at full, and a clean turn. Then zip a dated copy of the project. This Character is the spine of Project 3 — get it backed up.

Wed 2:00 · Agent lab An agent wires your player — then you own it

You just built a Character by hand, so you know exactly what one should look like. Now make an agent build one and hold it to your standard.

Wed 3:10 · Crit / share Drive it on the projector

Each person plugs in and drives their character on the big screen — idle, walk, run, a turn — then opens the Character Blueprint and walks the room through two or three nodes, including the behavior they changed themselves. We're listening for genuine understanding, not clean graphs: if you can explain why Delta Seconds exists and what Set Speed is talking to, you own the Blueprint. We close by opening the Project 3 (Interactive Vertical Slice) brief on /fmx320/#projects and scoping it together — a small, real, playable moment, not a whole game.

Homework — due before Week 11

Resources

• Blueprints — Actor Blueprints, the event order, and how the engine calls your graph.
• Enhanced Input — Input Actions and Mapping Contexts, the modern input path we use today.
• Animation Blueprints — setting Anim BP variables from gameplay, the wire we build.
• Unreal MCP — the first-party plugin that lets an agent act in the editor.