UE5 Make Actor Face Player

What You Will Build

• A Blueprint Actor that always rotates toward the player
• A clean look-at setup using Find Look at Rotation
• A visible cube mesh so you can clearly test the rotation
• A reusable Blueprint pattern for target-facing behavior
• A foundation you can later adapt for enemies, turrets, cameras, and NPCs

Why This Logic Matters

“Look at the player” sounds simple, but it is a core gameplay pattern. Many systems need to calculate a direction from one object to another.

You use this kind of logic when building:

• AI enemies that turn toward the player
• turrets that aim at a target
• security cameras that track movement
• NPCs that face the player during dialogue
• billboard-style actors that rotate toward the camera
• projectiles or effects that need directional alignment

The key idea is simple: take the position of the actor, take the position of the target, calculate the rotation between them, and apply that rotation.

That is exactly what Find Look at Rotation does.

What Find Look at Rotation Does

Find Look at Rotation takes two world-space locations:

• Start: where the looking object is
• Target: where the object should look

The node returns a Rotator. That rotator points from the Start location toward the Target location.

In plain English, it answers this question:

What rotation does this actor need so it faces that target?

Once you have that rotation, you can feed it into Set Actor Rotation to rotate the actor.

Step 1: Create a Blueprint Actor

Open the Content Drawer, right-click in an empty space, and choose:

Blueprint Class > Actor

Name the Blueprint:

BP_EnemyActor

The name is only for this example. You can rename it based on your use case, such as:

• BP_Turret
• BP_LookAtActor
• BP_CameraTracker
• BP_NPC_LookAtPlayer

Open the Blueprint after creating it.

Step 2: Add a Cube Component

Inside the Blueprint, go to the Components panel.

Click Add and choose:

Cube

This gives the actor a visible mesh so you can clearly see it rotating in the level.

You can replace the cube later with any mesh. For testing, a cube is fine because it makes rotation easy to read.

Step 3: Open the Event Graph

Go to the Event Graph.

You should see the default Blueprint events, including:

• Event BeginPlay
• Event Tick

For this quick setup, we use Event Tick because we want the actor to update its rotation continuously every frame as the player moves.

Step 4: Add Find Look at Rotation

Right-click in the graph and search for:

Find Look at Rotation

Add the node to the graph.

This is the core node of the setup. It needs a Start location and a Target location.

Step 5: Connect Start to This Actor’s Location

The Start input should be the location of the actor that is doing the looking.

Right-click and add:

Get Actor Location

If you call Get Actor Location inside this Blueprint without specifying another actor, it returns the location of this actor itself.

Connect the Return Value of Get Actor Location into the Start input of Find Look at Rotation.

This tells Unreal:

Start calculating the look direction from this actor's position.

Step 6: Get the Player Pawn

Now you need the Target location. In this example, the target is the player.

Right-click and add:

Get Player Pawn

This node returns the player-controlled Pawn at the specified player index. For a normal single-player Third Person Template project, Player Index 0 is correct.

From the Return Value of Get Player Pawn, drag out and search for:

Get Actor Location

This gives you the world location of the player.

Step 7: Connect Target to the Player Location

Connect the player’s Get Actor Location return value into the Target input of Find Look at Rotation.

Now the node has both positions:

• Start: BP_EnemyActor location
• Target: Player Pawn location

This means the returned rotation will point from the actor toward the player.

Step 8: Apply the Rotation with Set Actor Rotation

Right-click in the graph and add:

Set Actor Rotation

Connect the Return Value from Find Look at Rotation into the New Rotation input of Set Actor Rotation.

Then connect the execution pin from Event Tick into Set Actor Rotation.

Now every frame, Unreal will:

1. get this actor’s location
2. get the player’s location
3. calculate the rotation from actor to player
4. apply that rotation to the actor

How the Full Blueprint Flow Works

The full logic looks like this:

Event Tick
    Set Actor Rotation
        New Rotation = Find Look at Rotation
            Start = Get Actor Location
            Target = Get Player Pawn > Get Actor Location

This is small, but it teaches an important pattern: using locations to generate direction and rotation.

Once you understand this flow, you can apply the same logic to many gameplay systems.

Step 9: Place the Actor in the Level

Compile and save the Blueprint.

Go back to the level, open the Content Drawer, and drag:

BP_EnemyActor

into the map.

Place it somewhere visible so you can easily watch the rotation during gameplay.

Step 10: Test the Look-At Behavior

Press Play and move your character around.

The cube should continuously rotate to face the player.

If the actor rotates correctly, the look-at setup is working.

Why Event Tick Works Here

Event Tick runs every frame. Since the player can move every frame, updating rotation every frame gives immediate tracking.

For a quick beginner setup, this is fine.

But do not blindly use Tick everywhere. Tick is easy, but it can become expensive if hundreds or thousands of actors run unnecessary logic every frame.

For one actor or a few enemies, this setup is fine. For many actors, you should consider optimization.

How to Optimize This Later

If you use this logic on many actors, you can optimize it by:

• only updating rotation when the player is nearby
• using a timer instead of Tick
• updating every 0.05 or 0.1 seconds instead of every frame
• disabling the logic when the actor is off-screen or inactive
• using AI perception to decide when the enemy should track the player

The beginner version teaches the concept. The optimized version depends on your game.

Common Issue: The Actor Tilts Up or Down

One common problem with Find Look at Rotation is that the actor may pitch upward or downward if the player is higher or lower than the actor.

For example, if the player jumps or stands on a platform, the actor may rotate on pitch as well as yaw.

If you only want the actor to rotate horizontally, use only the yaw value from the returned rotation and keep pitch and roll at zero.

The idea is:

Break Rotator
Use Yaw
Make Rotator
Pitch = 0
Yaw = LookAtYaw
Roll = 0
Set Actor Rotation

This is usually better for enemies, NPCs, and turrets that should rotate left and right without leaning forward or backward.

Common Issue: The Mesh Faces the Wrong Direction

Sometimes the Blueprint works, but the mesh visually points sideways or backward.

That usually means the mesh’s forward direction does not match Unreal’s expected forward direction.

In Unreal Engine, actors generally use the X axis as forward. If your mesh was modeled facing a different direction, the actor rotation may be mathematically correct but visually wrong.

You can fix this by:

• rotating the mesh component inside the Blueprint
• fixing the mesh orientation in a modeling tool
• adding a rotation offset in Blueprint

Common Issue: Get Player Pawn Returns Nothing

In most single-player templates, Get Player Pawn works immediately.

But it can fail or return nothing if:

• there is no player pawn spawned yet
• you are using a custom player setup
• the player index is wrong
• the logic runs before the pawn exists
• you are testing in a multiplayer setup without thinking about player ownership

For more advanced projects, store a target reference instead of calling Get Player Pawn every frame.

Better Version: Store the Player Reference Once

The simple tutorial version calls Get Player Pawn every Tick. For learning, that is fine.

A cleaner version is to get the player once on BeginPlay and store it in a variable.

The improved flow would be:

Event BeginPlay
    Get Player Pawn
    Set TargetActor

Event Tick
    Is Valid TargetActor
    Get Actor Location
    TargetActor > Get Actor Location
    Find Look at Rotation
    Set Actor Rotation

This avoids repeatedly searching for the player every frame and makes the system easier to adapt for other targets.

Reusable Version: Look at Any Target

If you want this to be modular, do not hardcode the player forever.

Create an Actor variable named:

LookAtTarget

Then use that actor’s location as the Target input.

Now the same Blueprint can look at:

• the player
• an enemy
• a camera
• a waypoint
• a boss target
• an interaction object

That is a better architecture if you plan to reuse the system.

Using Look-At Logic for Turrets

Turrets are one of the most obvious use cases for this logic.

A basic turret can:

• detect the player
• calculate look-at rotation
• rotate toward the player
• fire when aligned

For a turret, you usually want yaw-only rotation for the base and pitch rotation for the barrel. That means you may split the look-at rotation into separate components instead of applying the full rotator to the whole actor.

Using Look-At Logic for Enemies

For enemies, look-at rotation is useful when the enemy needs to face the player before attacking, speaking, chasing, or aiming.

However, for full AI movement, you should not always rotate the actor manually every Tick. Character Movement and AI Controller rotation settings may already control orientation.

Use this logic carefully with AI. It is great for simple examples, but in real AI characters you need to consider movement rotation, controller rotation, animation direction, and aiming offsets.

Using Look-At Logic for Cameras

You can also use Find Look at Rotation for cameras.

A camera can use its own location as Start and the target actor’s location as Target. Then it can rotate to keep the target in view.

This is useful for:

• security cameras
• cinematic cameras
• target tracking cameras
• simple cutscene setups

Nodes Used

• Event Tick
• Find Look at Rotation
• Get Actor Location
• Get Player Pawn
• Set Actor Rotation

Common Mistakes to Avoid

• Connecting Start and Target backwards
• Forgetting to apply the returned rotation with Set Actor Rotation
• Using Tick on too many actors without optimization
• Letting the actor pitch up and down when you only want yaw rotation
• Using a mesh with the wrong forward direction and thinking the node is broken
• Calling Get Player Pawn repeatedly in larger systems instead of storing a target reference

Final Result

You now have a Blueprint Actor that continuously faces the player using Find Look at Rotation.

The setup is small, but the concept is powerful. You are calculating a direction from one world location to another, converting that into a rotation, and applying it to an actor.

That same idea appears constantly in Unreal Engine gameplay programming.

Conclusion

In this tutorial, you created a reusable look-at Blueprint setup in Unreal Engine 5. You created a Blueprint Actor, added a cube for testing, used Find Look at Rotation with the actor location and player location, and applied the result with Set Actor Rotation on Tick.

This gives you a simple foundation for enemies, turrets, cameras, NPCs, and any object that needs to face a target.

Watch the full tutorial on YouTube: Make Actors Face the Player with Find Look at Rotation

Subscribe for more Unreal Engine tutorials: Subscribe to Rambod on YouTube

Frequently Asked Questions

What does Find Look at Rotation do in Unreal Engine?

Find Look at Rotation calculates the rotator needed to point from a Start location toward a Target location.

How do I make an actor face the player in UE5?

Use Get Actor Location for the actor, Get Player Pawn followed by Get Actor Location for the player, feed both into Find Look at Rotation, and apply the result with Set Actor Rotation.

Should I use Event Tick for look-at rotation?

For a small beginner setup, yes. For many actors, optimize with timers, distance checks, visibility checks, or stored target references.

Why is my actor tilting up and down?

The full look-at rotation includes pitch. If you only want horizontal turning, break the rotator and use only yaw while setting pitch and roll to zero.

Why does my mesh face the wrong direction?

The mesh may not be aligned with Unreal’s forward axis. Rotate the mesh component inside the Blueprint or fix the mesh orientation.

Can I use this for turrets and enemies?

Yes. This same logic can be adapted for turrets, enemies, cameras, NPCs, and any actor that needs to track a target.