【Unreal Engine】Moving Away from Event Tick: Designing with Timers and Events

Performance Issues with Event Tick

Blueprint's "Event Tick" node is convenient because it executes every frame, but this "every frame execution" is exactly what erodes performance.

This article explains "Tick-less Design" for building high-performance game logic while minimizing Event Tick usage.

Event Tick Costs and Problems

How Event Tick Works and Its Cost

Event Tick is an event that executes every frame as long as an Actor or Component is active. For example, if a game runs at 60FPS (Frames Per Second), Event Tick executes 60 times per second.

Logic connected to this node is processed in that frame. What happens if 100 enemy characters each perform complex AI processing or distance checks in Event Tick?

Even if processing within Tick is very light, as the number of Actors increases, the number of operations explodes, placing heavy load on the CPU. Since Blueprint is slower than C++, this load becomes significant.

Common Mistake: "Polling" in Tick

A typical example where beginners tend to use Event Tick is Polling.

Example: Constantly checking distance to player

// Event Tick -> Get Distance To Player -> Branch (Distance < 500) -> Do Something

This processing executes every frame whether the player is nearby or not. During the 99% of time when the player is far away, wasteful distance calculations keep running.

---

Alternatives for Tick-less Design

The key to high-performance design is switching to an Event-Driven mindset where "execute only necessary processing when necessary."

Instead of "constantly checking" like Event Tick, execute processing only "when something happens."

Alternative 1: Use "Timer" for Periodic Processing

For processing that doesn't need to be every frame but should execute periodically (e.g., AI target re-search, periodic healing), use Timer nodes.

Timer can call events or functions at specified intervals (e.g., every 0.5 seconds).

Blueprint Example: Heal HP Every 0.5 Seconds

// Event BeginPlay
//   -> Set Timer by Event
//      - Event: Custom Event (Heal Over Time)
//      - Time: 0.5
//      - Looping: True
//
// Custom Event (Heal Over Time)
//   -> Add Health (e.g., +1)

With this method, while Event Tick executes 60 times per second in a 60FPS environment, Timer executes only 2 times. A significant load reduction.

Alternative 2: Use "Event Dispatcher" for Inter-Actor Communication

Instead of Actor A constantly monitoring Actor B's state (polling), have Actor B notify via event when its state changes. This is Event Dispatcher.

Example: Notify when door opens

1. Door Actor: Call Event Dispatcher (e.g., OnDoorOpened) at the end of door opening processing.
2. Player Actor: Bind processing (e.g., log display) to the OnDoorOpened event.

// [Door Actor]
// Event Open Door -> ... (Open Door Logic) ... -> Call OnDoorOpened

// [Player Actor]
// Event BeginPlay -> Get Door Reference -> Bind Event to OnDoorOpened -> Custom Event (Door Opened Handler)

This ensures related processing executes only at the moment the "event" of door opening occurs.

Alternative 3: Use "Collision Events" for Physical Detection

The aforementioned problem of "constantly checking distance to player" can be solved with physics engine events built into Unreal Engine, not Event Tick.

Example: Detect entry into trigger volume

1. Trigger Volume: Use On Component Begin Overlap event.
2. Logic: Execute processing (e.g., UI display, damage application) from this event.

// [Trigger Volume Component]
// On Component Begin Overlap (Other Actor is Player)
//   -> Do Something (e.g., Apply Damage)

This event executes only once at the moment Actors actually overlap, or once at the moment overlap ends. Far more efficient than calculating distance every frame in Event Tick.

---

Optimizations When Tick is Necessary

Some processing, like movement or camera control, really does need every-frame updates. In those cases, apply these optimizations.

Best Practice: Adjust Tick Execution Interval

By setting "Tick Interval" in Actor properties, you can reduce Tick execution frequency.

• Default: 0.0 (executes every frame)
• Example Setting: 0.1 (executes 10 times per second)

For processing like AI detection where some delay is acceptable, this setting can significantly improve performance.

Best Practice: Enable/Disable Tick Only When Needed

When Tick processing isn't needed—such as when Actor is off-screen or AI is in idle state—disable Tick.

// Disable Tick
// Set Actor Tick Enabled (New Tick Enabled: False)

// Enable Tick
// Set Actor Tick Enabled (New Tick Enabled: True)

For example, when enemy AI loses sight of the player, disable Tick and switch to executing only detection processing every few seconds via Timer, bringing idle load close to zero.

Advanced: Tick Group and Latent Action

For more advanced control, these features are also available.

Tick Group

A mechanism for controlling Tick execution order. You can set Tick Group in Actor properties:

• PrePhysics: Execute before physics simulation (movement input processing, etc.)
• DuringPhysics: Execute during physics simulation
• PostPhysics: Execute after physics simulation (processing based on physics results)

Effective when you want to guarantee order of dependent processing.

Latent Action (Delay, Timeline, etc.)

Delay nodes and Timeline are powerful alternatives for implementing time-based processing without using Tick:

• Delay: Resume processing after specified seconds
• Timeline: Interpolate values over time (door opening/closing, fade in/out, etc.)

These can be used in Event Graph to implement time-based processing while maintaining Tick-less design.

---

Summary of Tick Alternatives

Event Tick is powerful, but considering overall game performance, its use should be limited to cases where you can answer "Yes" to the question "Is it really necessary every frame?"

Tick Alternative	Use Case	Execution Frequency
Timer	Periodic processing (healing, AI periodic checks)	Specified interval (e.g., every 0.5 seconds)
Event Dispatcher	Asynchronous inter-Actor communication (state change notification)	Only when event occurs
Collision Events	Physical contact, range detection	Only at moment of contact/separation
Tick Interval	When every-frame processing is needed but frequency can be reduced	Specified interval (e.g., every 0.1 seconds)

By being conscious of Tick-less design, your Unreal Engine project will run faster and more stable. Performance-conscious design is the first step toward professional development.