[UE5] Checkpoints and Respawning: Return to the Last Marker When You Fall

You cross the platforms and the goal is close. Then the last jump fails and you start over from the beginning. Even one resume point along the way makes trying again much easier.

A checkpoint is a mechanism that remembers where to return on failure. Respawning is the logic that puts the player back into a playable state. Beyond restoring position, it also settles falling speed and the controls you temporarily stopped.

This article builds the flow of recording a marker on a platform when touched, darkening the screen on a fall, and returning to that marker. Not having touched a marker yet returns you to where you first appeared.

What You'll Learn

• Preparing a return point where you can stand safely
• Remembering the last checkpoint you passed
• Making detection, stopping, fading, and returning one flow
• Confirming where you return and that controls resume

We use UE5's Third Person template. It is for people who can create Blueprint variables and Custom Events. We proceed as an example of returning the same character, single-player, within the same level.

Returning is more than "restoring the position"

Moving a fallen character to a platform while its falling speed remains slams it into the ground right after the return. Leaving input stopped means you get back but cannot move.

We proceed in this order.

1. Stop : raise a flag that a return is in progress and stop input and movement
2. Darken and wait : black out the screen to hide the moment the location switches
3. Return : move the character to the remembered position and rotation
4. Resume : brighten the screen and restore movement and input

We gather that flow into a Custom Event called HandlePlayerDeath . A Custom Event is a named entry point for logic. Because we use a short Delay, we build it in the event graph rather than as a normal function. Other causes of death can connect to the same event later.

The checkpoint record lives on the character we return. Since we move rather than destroy the character, the return-point variable survives. We do not reopen the level, so other Actors' states stay as they are.

Preparation: three platforms and the first return point

1. Build somewhere you can walk and fall from

Open a Third Person Blueprint project. Where the template offers a "Variant", use "None", and confirm movement and jumping in Play first.

Duplicate the level for experimenting and build three platforms from Cubes. If there is an existing floor or obstacle under the gaps, arrange things so you do not land before entering the fall-detection volume we place later.

With standard 100 cm Cubes, this arrangement works. All three have Scale (6, 6, 0.5) , Rotation (0, 0, 0) , and Collision "BlockAll".

Platform	Location	Role
A	(0, 0, 300)	The first platform
B	(850, 0, 300)	The first checkpoint
C	(1700, 0, 300)	The second checkpoint

At these dimensions, the platform tops sit at Z=325. Move the existing Player Start above A, at (-150, 0, 425) for instance, with Yaw=0. Use "Default Player Start" for Play's starting position.

Appearing at A and walking on the platforms means you are ready. It does not return you after a fall yet.

2. Create two variables on the character

Open Content/ThirdPerson/Blueprints/BP_ThirdPersonCharacter and add these.

Variable name	Type	Default and purpose
LastCheckpointTransform	Transform	Set to the actual spawn point in BeginPlay
bIsDead	Boolean	false. Set true only during return handling

A Transform bundles position, rotation, and scale. Here it remembers "where and facing which way to return" together.

Wire Set LastCheckpointTransform into BeginPlay's white exec line and pass Get Actor Transform 's (Target Self) output into its value. If BeginPlay already has logic, do not delete it; append to the end.

This returns you to where you actually appeared even without passing a checkpoint. It avoids flinging you to the world origin from an empty Transform default.

Enable "Generate Overlap Events" on the character's "Capsule Component". Disable the same setting on the visual "Mesh"; this example detects volume entry with the capsule. The capsule is the rounded collision volume wrapping the character.

Update the return point when a checkpoint is passed

1. Decide the return spot above the platform

Create BP_Checkpoint with Actor as the parent and add these three components, all children of DefaultSceneRoot.

Component	Name	Settings
Box Collision	Trigger	Relative Location=(0,0,100), Box Extent=(100,100,100)
Arrow	RespawnPoint	Relative Location=(0,0,100), Relative Rotation=(0,0,0)
Static Mesh	Marker	Assign Cube. Relative Location=(0,-120,60), Scale=(0.15,0.15,1.2), Collision NoCollision

The Marker is a thin pillar showing where to pass. Once comfortable, swap it for a flag or brazier look.

Set the Trigger's Collision Presets to "Custom", Collision Enabled to "Query Only", and Object Type to "WorldDynamic". Set only the Pawn response to "Overlap" with the rest "Ignore", and enable "Generate Overlap Events".

Overlap is the setting that detects whoever passes through. Our Trigger is not a wall; it only reports that the character entered.

RespawnPoint marks where the capsule's center goes after returning. Right against the ground embeds the body, so place it a little above half the capsule's height. At the standard size, 100 cm above is a guide; adjust the height if you change the size. Choose somewhere spacious and away from walls and platform edges.

Place BP_Checkpoint above B and C. With the platforms above, their Locations are (850,0,325) and (1700,0,325) . Keep the Actor Scale at (1,1,1) and adjust the Trigger's size with Box Extent.

2. Create a "remember here" entry on the character

Create a Custom Event SetCheckpoint in BP_ThirdPersonCharacter and add one input named NewCheckpoint of type Transform.

Wire the white line SetCheckpoint → Branch with bIsDead's Get in Condition. Leave True unconnected to end, and continue from False into Set LastCheckpointTransform . Connect the event's NewCheckpoint into the value and display Checkpoint recorded with a Print Text after it.

We check bIsDead so the recording logic does not run when you return into the Trigger mid-respawn. It is normally false, so touching the next marker overwrites the return point.

Set every Print Text in this article to "Print to Screen" and "Print to Log" enabled, Duration=5, and Key=None. That shows it on screen for five seconds and leaves a record in the Output Log.

3. Pass the marker's location to whoever passed

Select the Trigger in BP_Checkpoint and add "On Component Begin Overlap". That event fires when someone enters the volume.

Wire the white output into Cast To BP_ThirdPersonCharacter 's exec input and Other Actor into Object. Other Actor is whoever just entered. Only on a successful Cast do we treat them as our character.

Place RespawnPoint in the graph as a Get and create Get World Transform from its blue output. Use the one whose Target connects to RespawnPoint.

A World Transform is a position and rotation relative to the whole level. Left as a Relative Transform, both B and C would be the same "100 cm above the parent" and could not express in-level return points.

Connect the Cast's success white output into the SetCheckpoint call. Pass "As BP Third Person Character" into Target and Get World Transform's output into NewCheckpoint.

Leave Cast Failed unconnected so nothing happens for other Actors. Compile and Play, and the record message appearing when you approach B's or C's pillar means pass detection works.

On falling, stop, fade, and return

1. Prevent double execution during a return

Create a Custom Event HandlePlayerDeath with no arguments in BP_ThirdPersonCharacter's event graph.

The white line goes event → Branch with bIsDead's Get as the Condition. Leave True unconnected to end, and continue from False into Set bIsDead=true . Put Starting respawn in the Print Text after it.

bIsDead is a flag saying "a return is in progress". Setting it true first keeps the same event, called from another volume, from stacking waits and fades. We set it back to false at the end of the return.

2. Stop input and the body already in motion

After the Print Text, wire the white exec line in this order.

Order	Node	Target and inputs
1	Stop Jumping	Target Self
2	Disable Input	Target Self. Get Player Controller (Player Index=0) into Player Controller
3	Stop Movement Immediately	Character Movement's Get into Target
4	Disable Movement	The same Character Movement Get into Target

Character Movement is the component handling the character's walking, jumping, and falling. Place it in the graph as a Get from "Components" and drag from it to create nodes targeting that component.

A Player Controller manages the player's input and view. Single-player here means Get Player Controller's Player Index is 0. Disable Input specifies "stop input from this player to Self".

Disable Input alone does not clear falling speed. Stop Movement Immediately zeroes the velocity and Disable Movement sets the movement mode to None so it does not keep falling while you wait. Stop Jumping clears a jump state left held down.

3. Black out the screen to make time for the switch

Place Start Camera Fade after Disable Movement. Pass Get Player Camera Manager (Player Index=0) into Target.

Player Camera Manager manages what that player sees. Start Camera Fade overlays a specified color on the screen and changes its intensity over time.

Input	Value when darkening
From Alpha	0
To Alpha	1
Duration	0.2
Color	Black (R=0, G=0, B=0)
Should Fade Audio	false
Hold when Finished	true

Alpha 0 is transparent and 1 fully covers. It goes 0 to 1 over 0.2 seconds and Hold when Finished keeps it black.

Wire Start Camera Fade's white output into Delay (Duration=0.5). Start Camera Fade's output does not wait for the fade to complete. The Delay lets us wait a little after it goes black at 0.2 seconds before returning.

4. Return to the remembered position and rotation

Wire the Delay's "Completed" into Set Actor Transform . Target is Self and LastCheckpointTransform's Get goes into New Transform. Set "Sweep" false and "Teleport" true.

Sweep is false so nothing stops it against a wall along the way and it moves straight to the specified point. In exchange, confirm at placement time that the return point itself is clear. Teleport is not a setting that zeroes velocity, so step 2's velocity reset is still needed.

Then connect Set Control Rotation . Target is Get Player Controller (Player Index=0). Create Break Transform from LastCheckpointTransform and pass its Rotation into New Rotation.

The Third Person camera uses the Controller's rotation separately from the character's body. Returning only the body can leave the camera facing the pre-fall direction, so we align that too.

5. Brighten and hand control back

Place another Start Camera Fade after Set Control Rotation with the same Get Player Camera Manager as Target. This time From Alpha=1, To Alpha=0, Duration=0.2, Color black, Should Fade Audio false, and Hold when Finished false.

Wire its white output into a Delay (Duration=0.2) and follow "Completed" with this order.

1. Set Movement Mode targeting Character Movement, with New Movement Mode "Walking"
2. Enable Input targeting Self, with Get Player Controller (Player Index=0) as Player Controller
3. Set bIsDead=false
4. A Print Text saying Respawned

Walking is the normal movement mode for walking on the ground. Restoring only input while the movement mode stays None leaves you unable to walk, so restore both.

With that, HandlePlayerDeath has a connected white exec line from start to finish, including the Delays in between.

6. Call HandlePlayerDeath from under the platforms

Create BP_KillVolume with Actor as the parent, add a Box Collision, and name it KillBox . Its Collision settings match the checkpoint's Trigger: Query Only, Pawn only Overlap, Generate Overlap Events enabled.

From KillBox's "On Component Begin Overlap", wire the white line and Other Actor → Object into Cast To BP_ThirdPersonCharacter. Call HandlePlayerDeath from the Cast's success with "As BP Third Person Character" in Target. Leave Cast Failed unconnected.

Place this BP_KillVolume beneath the platforms. With the arrangement above, one example is Actor Location (850,0,100) , Scale (1,1,1) , and KillBox Box Extent (2000,800,50) . The box's top at Z=150 detects a fallen character without catching them on the platforms.

Also confirm it detects above World Settings' Kill Z . Kill Z is the height at which Actors that fall too far below the world are handled. If the character is destroyed first, this "return the same character" logic cannot continue.

The BP_KillVolume we build here is a custom detection volume made from an Actor and a Box Collision. Distinguish it from the procedure of placing a standard "Kill Z Volume".

Confirm: does it return to the last marker passed?

Compile and save everything, then Play. Click the screen to take control and confirm in this order.

Action	Expected result
Fall off the side of A before reaching B	After the fade, you return to A's initial spawn point
Approach B's pillar, see the record message, then fall	You return to B's RespawnPoint
Record at C too, then fall	This time you return to C
After returning, walk, look around, and jump	All controls work again
Fall again	One return sequence runs again
Stop Play and Play again	The record starts over from the initial spawn point

In the Output Log too, check that one Starting respawn → Respawned pair appears per fall. Try pressing movement keys during the return to confirm you do not run off on your own and can control again once the screen returns.

Symptom	Where to look first
No record message appears	Generate Overlap Events on the Trigger and Capsule, the Pawn Overlap, the Cast's Object
Falling does not start a return	Whether you land on a floor before entering the KillBox. The Target and white line from Cast success
It returns to the origin	Whether BeginPlay put a value into LastCheckpointTransform
B and C both return to the same place	Whether you use RespawnPoint's Get World Transform
You cannot move after returning	Whether both Set Movement Mode=Walking and Enable Input ran
The screen stays black	Whether the second Start Camera Fade goes 1 → 0. The white line after the Delay
You fall again right after returning	RespawnPoint's height, platform size, and its position relative to the KillBox
The second fall does not return you	Whether the final Set bIsDead=false ran

Begin Overlap is not an event that fires continuously while inside a volume. When returns repeat, revisit not only the double-execution guard but also whether you are returning to a dangerous spot and re-entering.

Bonus: HP, saving, and the rebuild approach

Restoring HP while keeping coins

When combining health and collectibles, decide how they are handled on return in advance. You could use rules like these.

Item	Example rule	Where to add it
HP	Restore to full	Assign MaxHealth into CurrentHealth after returning the position and before brightening
Collected coins	Keep what was gathered	Do not change the coin count in the return logic
States such as attacking or invulnerable	Return to normal	Restore the corresponding variables and timers before brightening
Enemies and doors	Decide by your game's rules	Notify the necessary Actors to reset

Simply returning the same character does not restore variables and timers automatically. To avoid bugs such as "the position returned but I cannot attack", confirm each state you restore.

To combine with the health and damage article, connect the entry for HP reaching 0 into HandlePlayerDeath. Check bIsDead on the damage-receiving side too so extra damage does not get through during a return.

For a design that keeps coins, also keep collected coin Actors in their destroyed state, thinking of the held count and the collectibles remaining in the stage as a set . Keeping only the count while coins respawn every time lets you farm the same spot forever.

How it differs from rebuilding the character

Besides moving the same character as here, there is also destroying the old Pawn and creating a new one. A Pawn is what a Controller operates. A Character is a kind of Pawn with walking and similar mechanisms built in.

Approach	What changes	What to confirm
Reposition	You keep using the same character	You specify what to restore yourself: HP, velocity, attack state, and so on
Rebuild	The controlled Pawn becomes a new one	Where surviving records live, spawn success, transferring control, and UI references

GameMode's RestartPlayerAtTransform and the like are entry points for spawning a Pawn at a specified location. Calling it does not reset the whole game's state, though. You need a procedure covering the old Pawn's and Controller's states too.

When rebuilding, keep the checkpoint outside the Pawn being destroyed. In single-player within one level, GameMode is a candidate. GameMode is rebuilt when the level reopens, so it is not a place that survives for the whole game run. The Game Framework article sorts out the roles.

To keep it after closing the game

This example's LastCheckpointTransform is a value the current character remembers. It does not survive stopping Play or reloading the level.

To carry it temporarily across levels, use GameInstance; to keep it after closing the game, use a Save Game. Returning to another level means recording not just the position but which checkpoint in which level.

For a game whose level layouts change later, saving an ID such as Checkpoint_B and finding the corresponding marker in the current level is another approach. Start by confirming the return point switches A → B → C, then extend to the save scope your game needs.

Summary

• Returning is a set: not just restoring position but stopping, fading, and handing control back
• Remember the marker you passed and return there when you fall
• Always place the return point above the fall detection
• Confirm all the way through being able to control again right after returning

The question to ask afterwards is "can you start moving the instant you return?" If you stay frozen, the logic handing control back is missing.

To carry records into the next level, GameInstance; to keep them until the next launch, Save Game.

Reference: Official camera fade documentation, Stop Movement Immediately, Set Actor Transform.