Blueprint Basics · Beginner · 15 min
Make an Actor Spin or Move With Blueprints
Make a coin spin and a platform glide using Event Tick with Delta Seconds, then a Timeline for buttery-smooth motion — your first taste of bringing a scene to life.
Before this: What Is a Blueprint? Create Your First One (No Code Required), Event Graph Basics: BeginPlay, Nodes, and Wires Explained
- Spin an Actor every frame with Event Tick and AddActorLocalRotation
- Use Delta Seconds so motion is the same speed on every machine
- Move an Actor smoothly with a Timeline instead of Tick
- Recognise the equivalent C++ approach and when each one fits
From a frozen scene to a living one
Up to now your Blueprints have reacted once — something happens on BeginPlay, or when a value changes. But games feel alive because things keep moving: a coin spins, a door slides open, a platform drifts back and forth. In this lesson you'll make an Actor do exactly that, and it's genuinely a few nodes of work.
We'll cover the two everyday tools for ongoing motion. First, Event Tick — a special event that fires every single frame, perfect for a constant spin. Then a Timeline — a built-in node that animates a value smoothly over a set time, perfect for a platform that eases in and out. By the end you'll know which to reach for, and you'll see the same idea written in C++ so the words stop being mysterious.
Four terms, then we build
Tap a card to flip it
Spin an Actor with Event Tick
We'll make a simple Actor (think of a coin or a gem) rotate forever. Open or create a Blueprint Actor with a visible mesh component, then open its Event Graph. Tick off each step as you go.
- 1Find (or add) the Event Tick node
In the Event Graph you'll usually already see a greyed-out 'Event Tick' node sitting near 'Event BeginPlay'. If it isn't there, right-click on empty graph space, type 'Event Tick', and add it.
Event Tick has a white execution pin on the right and a blue 'Delta Seconds' output pin. That blue pin is the secret to smooth, frame-rate-independent motion.
TipGreyed-out events are just unused — drag a wire out of one and it 'wakes up'. You don't add a second copy.
- 2Add a rotation node
Drag a wire from Event Tick's white execution pin into empty space and let go. In the search box type 'AddActorLocalRotation' and pick it. This rotates the whole Actor relative to where it currently faces.
The node has a 'Delta Rotation' input split into Roll, Pitch and Yaw. For a coin-style spin around the upright axis, you'll set Yaw.
TipRight-click the 'Delta Rotation' pin and choose 'Split Struct Pin' to get separate Roll / Pitch / Yaw boxes instead of one combined input.
- 3Multiply your spin speed by Delta Seconds
Drag a wire from the blue 'Delta Seconds' output and search for 'float * float' to add a Multiply node. Type a speed into the other input — try 90, meaning 90 degrees per second.
Plug the Multiply result into the Yaw box of your rotation node. Multiplying by Delta Seconds is what turns 'per frame' into 'per second', so the spin looks identical on a slow laptop and a fast desktop.
TipThink of it as: speed-per-second x how-much-time-passed-this-frame = the right amount to move this frame. Always do this for Tick-driven motion.
- 4Compile and play
Click 'Compile' (top-left of the Blueprint editor), then 'Save'. Make sure your Actor is placed in the level, then press Play.
Your Actor should spin smoothly and forever. Change the 90 to 360 and it whirls four times as fast; use a negative number to reverse the direction.
TipIf it spins but jitters or speeds up when you look away, you almost certainly forgot the Delta Seconds multiply — go back and add it.
Why use AddActorLocalRotation each frame instead of just setting the rotation to a bigger number?
'Add' means relative — it nudges the Actor a little further from wherever it currently is, so a small amount each frame stacks up into continuous spinning without you tracking the total angle yourself.
If you used 'SetActorRotation' with a fixed value instead, the Actor would just snap to that one angle and sit there. To spin by setting, you'd have to store and increase an angle variable every frame — more nodes for the same result. For a constant spin, 'Add' is the simple, natural choice.
When Tick isn't the right tool: smooth, controlled motion
Event Tick is perfect for 'do a little, forever' — a constant spin, a hover bob. But a lot of motion has a clear start and end: a platform that slides three metres to the right and stops, a door that opens once. You could do that on Tick with extra variables and checks, but it gets fiddly fast, and easing (slow-fast-slow) is awkward.
That's exactly what a Timeline is for. A Timeline is a node you drop into the graph that, once played, marches a value along a curve you draw — from 0 to 1 over, say, 2 seconds. You read that value out and use it to drive position. Because you can shape the curve, the motion can ease gently in and out instead of starting and stopping abruptly.
Move an Actor with a Timeline
We'll slide the Actor smoothly from its start position to a target, kicked off on BeginPlay. This introduces a couple of new node ideas, so take it a step at a time.
- 1Add a Timeline node
Right-click in the Event Graph, search 'Add Timeline', and add one. Give it a clear name like 'MovePlatform'. It appears as a node with a 'Play' input and an 'Update' output that fires every frame while it's running.
Double-click the Timeline node to open its own editor. Add a 'Float Track', then add two keys: one at time 0 with value 0, and one at time 2 with value 1. Right-click the keys and choose 'Auto' interpolation for smooth easing.
TipA value that runs 0 to 1 is called an 'alpha'. It's a handy, reusable way to mean 'how far through the motion are we' regardless of actual distances.
- 2Kick it off on BeginPlay
Back in the Event Graph, drag from Event BeginPlay's execution pin into the Timeline's 'Play' input (or 'Play from Start'). Now the moment the game starts, the Timeline begins running for its two seconds.
TipYou can trigger 'Play' from anything — an overlap, a button press — not just BeginPlay. That's covered in the overlap-and-pickup lesson.
- 3Lerp between a start and an end position
Drag from the Timeline's 'Update' pin to a 'SetActorLocation' node. For the new location, add a 'Lerp (Vector)' node: set 'A' to the start location, 'B' to the target location, and plug the Timeline's float output into 'Alpha'.
'Lerp' (linear interpolate) blends between A and B by the alpha: 0 gives you A, 1 gives you B, 0.5 the midpoint. As the Timeline drives alpha from 0 to 1, the Actor glides from start to target.
TipCapture the start position once on BeginPlay into a Vector variable, and set B to that start plus an offset (e.g. +300 on X). Then the platform always moves relative to where you place it in the level.
- 4Compile, play, and shape the feel
Compile, Save, and Play. The Actor should glide to its target over two seconds and stop.
Reopen the Timeline and drag the curve handles to change the easing, or change the second key's time to make the move faster or slower. Tick 'Loop' on the Timeline if you want it to repeat.
TipFor a platform that goes there-and-back-forever, enable 'Loop' and make your curve go 0 to 1 and back to 0, or play it normally then play it 'Reversed' when it finishes.
The same spin in Blueprint and in C++
Event Tick -> AddActorLocalRotation, with the Yaw fed by (SpinSpeed x Delta Seconds).
No typing, instantly visual, and easy to tweak live. This is where every beginner should start, and it's perfectly production-viable for simple motion. The Delta Seconds pin is handed to you on the Tick node.
In a C++ Actor you override the Tick function. Unreal passes the frame time in as DeltaTime — the exact same number as the Delta Seconds pin in Blueprint — and you multiply your speed by it for the very same reason.
C++ is faster to run and better for hundreds of moving Actors, but slower to iterate on. Many real projects do exactly this: prototype the motion in Blueprint, then port the hot ones to C++ if profiling says they need it. See the code block below for the snippet.
The equivalent C++ Tick
void ASpinningActor::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
// 90 degrees per second around the up (Yaw) axis.
const float SpinSpeed = 90.f;
AddActorLocalRotation(FRotator(0.f, SpinSpeed * DeltaTime, 0.f));
}
// Reminder: enable ticking in the constructor, or Tick never runs:
// PrimaryActorTick.bCanEverTick = true;QuizCheck yourself
1Why do you multiply your spin or movement speed by Delta Seconds inside Event Tick?
Delta Seconds is how long the last frame took. Multiplying by it converts 'per frame' into 'per second', so a 30 fps and a 144 fps machine move the Actor by the same amount over the same time.
2You want a platform to slide three metres and stop, with gentle easing. Best tool?
A Timeline has a clear start and end and a shapeable curve, so it's ideal for finite, eased motion. Tick is better for constant, never-ending movement like a spin.
3In the C++ Tick function, the value named DeltaTime corresponds to which Blueprint pin?
They are the same number — the time since the previous frame. That's why both approaches multiply speed by it for frame-rate-independent motion.
Make a collectible that both spins AND gently bobs up and down — the classic floating-coin look. Use Event Tick for the spin you already built, and add a little vertical bob on top.
Hint 1
The spin is exactly what you built: Event Tick -> AddActorLocalRotation with Yaw = speed x Delta Seconds.
Hint 2
For the bob, you need a value that smoothly goes up and down over time. A Sine wave does this — search for the 'Sin (Radians)' or 'Get Game Time in Seconds' nodes and feed time into a sine.
Hint 3
Multiply the sine output (which ranges -1 to 1) by a small height like 20, and feed it into the Z of a SetActorRelativeLocation on your mesh component each frame.
Keep the Tick -> AddActorLocalRotation spin from earlier. Off the same Tick, get 'Get Game Time in Seconds', multiply it by a bob speed (e.g. 3), feed that into 'Sin (Radians)'. Multiply the result by a height (e.g. 20).
Make a Vector with X = 0, Y = 0, Z = that bob value, and feed it into 'SetActorRelativeLocation' on the mesh (relative, so it bobs around its placed position). Compile and play — the coin spins and floats.
Because everything is driven from Tick and built from time, it's automatically frame-rate-independent. A Timeline with a looping curve is an equally valid way to do the bob if you prefer drawing the motion by hand.
You can now
Tick these off — you've earned them:
- Wire Event Tick to AddActorLocalRotation to spin an Actor
- Multiply movement by Delta Seconds for frame-rate-independent speed
- Build and play a Timeline that slides an Actor smoothly with a Lerp
- Explain when Tick fits versus when a Timeline fits
- Read the equivalent C++ Tick snippet and recognise DeltaTime
Mark this lesson complete
We'll remember it on your Academy page and unlock the next lesson below.
Questions beginners ask
My Actor won't spin at all — what's the first thing to check?
Confirm the Actor is actually placed in the level (an unplaced Blueprint never runs), that you Compiled and Saved after wiring the nodes, and that you dragged a wire OUT of Event Tick rather than leaving it greyed-out and unused. Then check the rotation amount isn't zero.
Should I use Event Tick or a Timeline?
Use Event Tick for continuous, never-ending motion like a spin or a hover. Use a Timeline for motion with a clear start and end, or when you want smooth easing — like a door opening or a platform sliding to a point and stopping. Timelines also stop themselves when finished, which is kinder on performance.
Is doing this in C++ better than Blueprint?
Not for learning, and not for a handful of moving objects — Blueprint is fast to build and perfectly capable here. C++ runs faster and scales to large numbers of Actors, so a common pattern is to prototype motion in Blueprint and port only the performance-critical pieces to C++ later. Both multiply by Delta Seconds for the same reason.
Does Tick slow my game down?
A few ticking Actors are nothing to worry about, but Tick runs every frame on every enabled Actor, so it adds up across hundreds of them. Disable ticking on Actors that aren't moving (untick 'Start with Tick Enabled' or call 'Set Actor Tick Enabled'), and prefer Timelines for one-shot motion since they stop on their own.