UE5 Timeline Nodes 101: Connecting Time and Values with an Automatic Door

The player turns back while an automatic door is opening. In that moment, starting back down from its current height feels more natural than snapping fully open before closing.

Timeline is what you use for mechanisms like this that "move over time and can also run backwards from partway". This article builds a door that slides upward, going from a one-second opening motion to one that opens as you approach and closes as you leave.

What You'll Learn

• Building values along a time axis with keys and curves
• What Timeline, Lerp, and Set each handle
• How Play and Reverse open and close from the current position
• An exercise comparing different curves and playback rates

A Timeline emits values and cues along time

A Timeline lets you place markers saying "at this time, use this value". Those markers are keys . Placing two keys, 0 at 0 seconds and 1 at 1 second, lets you also retrieve the values in between.

The line of change connecting keys is a curve . The horizontal axis is time and the vertical axis is value. Connecting 0 to 1 with a straight line gives 0.5 at 0.5 seconds.

The 0 to 1 here is not the door's height itself. We use it as how far along it is: "0 means closed" and "1 means fully open". We convert it into an actual position through Lerp later.

Separately from value outputs, a Timeline has white exec pins. These two matter most.

Output	What it is for
Update	Apply the value to a position and the like when it updates
Finished	Continue to the next logic once it has played to the end

A Timeline emitting values does not move the door by itself. You connect all the way through calling position-setting logic from Update and passing it the computed position .

Leave time management to the Timeline

You could build the same door with Event Tick , which runs every frame. Then you manage "how many seconds passed", "where to stop", and "how to go backwards" yourself.

A Timeline holds a playback position and direction and advances while reading the curve. Leaving looping off ends playback when it reaches an end. The door side can focus on the cues to start and reverse and on applying the value.

Not writing time arithmetic into Event Tick is the convenience here. A Timeline also uses time-based updates, so internal update work does not vanish. Tick suits some situations, such as continuously following a moving target. Choosing between them is also covered in the Event Tick and Timer article.

Play and Reverse advance from the current position

A Timeline holds "which second it is currently playing". That time is the playback position . It differs from the door's world position.

Input	How it treats the playback position
Play	Advances forward from the current time
Play from Start	Returns to 0 seconds, then advances
Reverse	Runs backwards from the current time
Reverse from End	Jumps to the end, then runs backwards
Stop	Halts while keeping the current time

Calling Reverse on a one-second Timeline that has reached 0.5 seconds runs from 0.5 back to 0. It does not need to jump to the one-second mark first. Applied to the door's position, that closes it from whatever height it opened to.

Conversely, calling Play while it is closing advances it back toward open from there. Because we want a round trip that inherits the current position, we combine Play and Reverse.

Finished also fires on reaching the end when going forward and the start when going backward. To run logic "only when the door finishes opening", also check whether Direction, the playback direction output, is Forward. Stop is an instruction to halt partway, so stopping alone does not call Finished.

Choose a track by the kind of value you change

A track is the row where you edit one value's change in a Timeline. The name of the track you add becomes the output pin name on the Timeline in the event graph.

Track	What it emits	Example uses
Float Track	One number	Openness, volume, opacity
Vector Track	Three numbers: X, Y, and Z	Position and Scale
Color Track	A color	Light color or display color
Event Track	An execution cue at a specified time	Triggering audio or display partway

We use one Float Track here, named Alpha , going from 0 to 1. Alpha here is a number representing how far open it is.

Unlike value-emitting tracks, an Event Track exists to call logic when playback passes that time. Placing a key at 0.8 seconds emits a cue just before it finishes opening. That time is also passed in reverse, so sounds you want only when opening need the playback direction considered in the wiring.

Hands-On: start with a door that opens in one second

We use a Third Person Blueprint project. Choose None where a "Variant" is offered at creation. This is for people who know how to create components and variables and connect Blueprint pins.

1. Build the door and the range that detects approach

Create a Blueprint Class BP_AutoDoor with Actor as the parent. Add a Static Mesh named DoorMesh and a Box Collision named TriggerBox , making both children of DefaultSceneRoot .

Assign the standard Cube from Engine/BasicShapes to DoorMesh. If you cannot find it, show engine content in the asset picker.

Item	DoorMesh	TriggerBox
Relative Location	X=0 / Y=0 / Z=150	X=0 / Y=0 / Z=150
Rotation	all 0	all 0
Scale	X=0.2 / Y=2 / Z=3	all 1
Box Extent	—	X=200 / Y=200 / Z=200

Relative Location is the position measured from the parent. Placing a 300 cm tall door's center at Z=150 aligns the door's bottom with the Root's height.

Box Extent is the distance from the box's center to each face. 200 means 400 cm end to end. The TriggerBox covers a range including in front of and behind the door. Making it DoorMesh's child would move the range up and down too, so we split them under the same Root.

Set DoorMesh's Mobility to Movable, Simulate Physics off, and Collision Presets to BlockAll. That makes a panel you can move from Blueprint that blocks the player.

The TriggerBox is not "a wall that stops you on impact" but "a range that detects entering and leaving". Configure it like this.

• Collision Presets: Custom
• Collision Enabled: Query Only
• Object Type: WorldDynamic
• Collision Responses: set everything to Ignore first, then Pawn to Overlap
• Generate Overlap Events: on

Query Only is the setting used for checking overlaps and the like. Setting only Pawn to Overlap keeps it from detecting the floor or the door itself. We do not wire the overlap events yet.

2. Decide the closed and open positions

Create two Vector variables, compile, and enter their defaults.

Variable	Default	Meaning
ClosedLocation	X=0 / Y=0 / Z=150	The closed door's center
OpenLocation	X=0 / Y=0 / Z=370	The open door's center

Moving from 150 to 370 is 220 cm of travel. The open door's bottom sits at 220 cm, tall enough to walk under.

3. Create a Timeline going from 0 to 1 in one second

Right-click empty space in the event graph and choose Add Timeline . Name it DoorTimeline and double-click to open the editor.

Add a Float Track and name it Alpha . Right-click the graph to add two keys and match the selected keys' Time and Value to these.

Key	Time	Value
Start	0	0
End	1	1

Select both keys, right-click, and set interpolation to Linear . That connects the keys with a straight line, changing the value at a constant pace.

Set Length to 1 with Use Last Keyframe, AutoPlay, and Loop all off. We use the entered Length as the end here. Use Last Keyframe can make the last key the end, but let's start by stating the length explicitly.

4. Compute the position with Lerp and apply it from Update

Back in the event graph, place Lerp (Vector) . Get ClosedLocation and search for Lerp from its yellow pin to pick the Vector version.

Lerp input	Connected from
A	Get ClosedLocation
B	Get OpenLocation
Alpha	DoorTimeline's Alpha

Lerp uses Alpha to choose where between A and B to land. 0 is A, 1 is B, and 0.5 is the midpoint.

Timeline time	Alpha	Computed door center Z
0 s	0	150
0.5 s	0.5	260
1 s	1	370

Next drag DoorMesh from the component list into the graph and create Set Relative Location from its blue output.

• Target: DoorMesh
• New Location: Lerp's Return Value
• White exec input: DoorTimeline's Update
• Sweep: off

Do not run a white exec line through Lerp. Keep the colored lines that compute values separate from the white line that calls the position setter.

ClosedLocation and OpenLocation are parent-relative positions, so we match the destination to Set Relative Location. Placing the Actor elsewhere in the level lets you use those same two values.

5. Open once at Play start

For a check, connect Event BeginPlay 's white output into DoorTimeline's Play. Compile and save.

The diagram shows the side that applies the position. Alpha connects to the Lerp described above, and its Return Value is the yellow "Lerp result" line passed into New Location.

Place one BP_AutoDoor in the level with the Actor's Scale at 1, 1, 1 , rotation 0, and the Root's height aligned to the floor. Position it so the door is visible from the player's start.

On Play, success is the door rising 220 cm over one second and stopping there . We are not using the approach check yet, so it opens even while you watch from a distance.

That confirms the parts where the Timeline advances time, Lerp computes the intermediate position, and Update applies it via Set.

Open on approach and close on leaving

Stop Play and disconnect the check line from BeginPlay to Play. Now we change the playback direction when entering and leaving the TriggerBox.

1. Receive the player entering and leaving

Select TriggerBox in the component list and add On Component Begin Overlap and On Component End Overlap from Events in the Details panel.

Overlap is the state of ranges overlapping rather than colliding and pushing apart. Begin is the cue that overlap started and End that it ended.

The event's Other Actor holds whoever entered or left. We want to react only to the player, so build this check in both events.

1. Search == from Other Actor's blue pin to create an Object equality comparison
2. Pass Get Player Pawn 's (Player Index=0) Return Value into the other side
3. Connect the comparison result into a Branch's Condition
4. Connect the event's white exec output into that Branch

What == checks is whether the other party is "the same as the Pawn the first player controls". It is not comparing shapes or names.

Overlap events must be enabled on both the detecting and the other side. Open the template's BP_ThirdPersonCharacter and turn Generate Overlap Events on for the Capsule Component and off for the visual Mesh. Our check uses the single collision capsule surrounding the body. After changing it, compile and save the character too, then return to BP_AutoDoor.

2. Wire to the same Timeline's Play and Reverse

Connect the two Branches' True outputs like this, leaving False empty.

Branch on the event side	True goes to
Begin Overlap	DoorTimeline's Play
End Overlap	DoorTimeline's Reverse

The diagram shows the Begin side. On the End side, build the same comparison of that event's own Other Actor plus a Branch and connect True into Reverse.

Do not add more Timelines. Connect both lines into the input side of the DoorTimeline you already made. The Update-to-position part stays as it is.

Compile, Play, and click the game screen. Approach from outside the range first. Stopping in front of the door opening it fully, and leaving the range closing it, means the enter and leave checks work too.

3. Turn back before it opens fully

Next, back away as soon as the door starts moving — step slightly into the range and immediately out. Confirm it starts closing from partway up rather than going all the way.

If it only opened partway, closing does not take a full second either. Reversing at playback position 0.4 seconds, for instance, returns to 0 in about 0.4 seconds at normal playback rate.

Approaching again while it closes reopens from that height. That is Play and Reverse inheriting the current playback position.

Compare with Reverse from End

Stop Play and temporarily rewire the End Overlap Branch's True from Reverse to Reverse from End .

Leave the range right after it starts opening, the same way. This time it plays backwards from the end, so it jumps to the fully open height before closing . That shows Reverse suits a door you want returning from its current height.

After checking, stop Play, restore the connection to Reverse, and confirm partway closing again. Switching the opening side's Play to Play from Start likewise shows a difference: re-entering mid-close returns to 0 seconds before reopening.

Try changing the curve and playback rate

Even within the same one second, which values it passes through changes the impression. Start by adding one key and comparing.

Change the first and second halves' speeds with a middle key

Stop Play and add a key of Time=0.5 , Value=0.25 to DoorTimeline's Alpha. Set all three keys to Linear and leave Length at 1.

It used to be half open at 0.5 seconds; now it is only a quarter open at the same time. It covers the remaining three quarters in the remaining half of the time, so it is slow in the first half and fast in the second .

This joins two straight lines, so the speed switches at the middle. To smooth acceleration and deceleration, use curved interpolation such as Auto, or adjust tangents with User. A tangent decides which way and how much the line leans near a key.

Interpolation	How it connects keys
Linear	Connects with a straight line
Constant	Holds the value until the next key, then switches
Auto	Adjusts the curve automatically to fit surrounding keys
User / Break	Adjust tangents yourself. Break adjusts each side separately

Choosing Auto does not produce the same easing for every key arrangement. Look at the curve's shape and confirm the motion with Play. After this comparison, delete the middle key and return to the original two Linear keys.

Speed the whole motion up with Set Play Rate

"My Blueprint" also has a variable of the same name for specifying DoorTimeline. Get it and create Set Play Rate from its blue pin. Target is DoorTimeline.

Connect a white line from the BeginPlay you disconnected earlier into this Set Play Rate and set New Rate to 2 . On Play, the one-second Timeline plays at double speed, so it opens fully in about 0.5 seconds.

New Rate	Time to play a one-second Timeline to the end
0.5	About 2 seconds
1	About 1 second
2	About 0.5 seconds

The curve is "how it progresses along the way" and Play Rate is "how fast it moves along that time axis". The opening height lives in OpenLocation. Separating what changes what makes adjusting easier.

Return New Rate to 1 after comparing. The Set Play Rate from BeginPlay can stay.

Checks for when it does not work

Symptom	Where to check
Nothing moves even in the BeginPlay check	Whether a white line reaches Play, whether Alpha has two keys with different values, whether Update connects to Set
It snaps open after a delay	Whether Set is called from Finished rather than Update, whether interpolation is Constant
Approaching does nothing	The TriggerBox events, whether Pawn is Overlap, Generate Overlap Events on both sides and the Other Actor comparison
It repeatedly opens and closes	Whether the TriggerBox became DoorMesh's child, whether the player's visual Mesh also emits overlap events
The door jumps somewhere else	Whether you use Set Relative Location and whether Closed/Open values are parent-relative
It keeps replaying after opening	Whether Loop is off
It stays open and never closes	Whether the End Overlap side's True reaches Reverse, whether you are still inside the range
It does not reach the final height	Whether Length is shorter than the last key, whether Alpha's final Value is 1
You walk through the closed door	Whether DoorMesh's Collision Presets is BlockAll and Simulate Physics is off

When you cannot tell how far it got, call Print String from Update and pass Alpha into In String to display the changing value. Number-to-text conversion is inserted automatically. Restore the original connection to Set after checking. The Print String article is also a useful reference on displaying values.

Where you can add a Timeline

The Timeline itself in this article goes into an Actor Blueprint's event graph. The same Add Timeline is not available in function or macro graphs. Widget Blueprints and Actor Component Blueprints cannot build the same shape directly either.

Instructing a Timeline you already made is a separate matter, though. Inside a function you can get the DoorTimeline variable and call Timeline Component operation nodes such as Play and Stop. Think of the part that updates values over time and the part that instructs playback separately.

For UI position or opacity, UMG's Widget Animation works, and for scenes bundling cameras and characters, Sequencer does. Rather than hunting for the same node where it cannot go, choose the feature that fits what you want to move.

Bonus: good to know up front

• The same 0 to 1 works for other values : making Lerp's A/B rotations drives facing, and colors drive color changes. You also change Lerp's type and the node that finally applies it. To make a material glow, continue to the Dynamic Material Instance article.
• Following a moving target has other combinations : Interp To nodes can be easier for continuously moving a current value toward a target that changes each frame. The rotation and interpolation article compares them with a turret tracking a target.
• Curves can be shared : creating an asset such as a Curve Float and specifying it in a track's External Curve lets several Blueprints use the same curve shape. This is not a fifth track type but a way to read the curve from an external asset.
• Announce that it opened : checking Direction from Finished and notifying via Event Dispatcher only when Forward separates it from a notification for finishing closing.
• More people detected changes the closing condition : we detected one player with one capsule. A door many people pass through should manage whether anyone remains in the range rather than closing the moment one leaves.

Summary

The Timeline holds time and progress, Lerp computes the intermediate position, and Update applies it to the door via Set. Building this division lets you adjust opening height, easing, and playback rate separately.

Beyond the door opening fully, try what happens when you turn back partway. That lets you confirm through actual opening and closing what "advances from the current playback position" means for Play and Reverse.

Reference: Epic's Timeline nodes, Keys and curves, Editing Timelines, Begin Overlap.