Smart Events User Guide

Smart Events is a drop-in replacement for UnityEvent that can do things over time. Declare an event in a script the same way you would a UnityEvent, then call Invoke(). In the Inspector, each event holds a list of actions that run from top to bottom: wait, check a condition, loop, animate, play a sound, spawn, update the UI, load a scene, call any method, and more.

Small gameplay sequences that normally each need their own script (“open the door, wait, play a sound, fade the light”, “when the player enters, show a message for two seconds”) are built right in the Inspector.

What you get:

• 19 action types, from Wait and If to Audio, Scene changes and more, plus 20 UI operations and 12 tween types.
• Events with values: SmartEvent<int>, SmartEvent<GameObject, float>… The values flow into conditions, texts and method parameters.
• 11 ready-made components you can add to any object without code: Lifecycle, Update, Trigger (3D/2D), Collision (3D/2D), Pointer (click/hover), Timer, Key, Visibility and Event Channel Listener.
• Reusable assets: Smart Sequences (action lists saved as assets) and Event Channels (global events).
• Global values: read or set any static value (screen size, time scale, FPS lock, your own static fields).
• Live debugging: in Play Mode, running actions light up in the Inspector, and events get an Invoke button.

1. Import Smart Events from the Package Manager (My Assets). Everything is inside Assets/Doxfen Studios/SmartEvents.
2. Open the demo: Window > Doxfen > Smart Events > Open Demo Scene, then press Play.
3. If Unity asks to import TMP Essentials, click Import TMP Essentials.

The demo is a guided tour of 29 steps in 11 short chapters. Each step says what will happen and what to watch, a blue marker highlights the object it is about, and the result appears when it is done. Use Previous / Replay / Next (or the arrow keys), or let Auto Play run. In the purple “Try It Yourself” area you can click the cube, press Space, and watch balls roll into the goal.

To see how any step is built, select the Smart Events Showcase object and open Steps in the Inspector (the tour shows the element number, and Show in Inspector selects it for you).

To uninstall, delete the SmartEvents folder. Smart Events never changes project settings or other packages.

Step 1: declare an event in any script.

using Doxfen.UtilityTools.SmartEvents;
using UnityEngine;

public class Door : MonoBehaviour
{
    public SmartEvent OnOpened;          // no value
    public SmartEvent<int> OnKeysChanged; // passes an int

    public void Open() => OnOpened.Invoke();
}

Step 2: add actions in the Inspector. Click +, choose an Action Type (the list is searchable) and fill in its fields.

Step 3: invoke it. Call OnOpened.Invoke() from code, or press the Invoke button that appears on every event in Play Mode.

Actions run top to bottom. Instant actions (set a value, call a method, play a sound) happen immediately. Wait, Wait Until, Loop and tweens that wait for completion pause only this event. The rest of the game keeps running.

Every invoke is independent. Invoke the same event twice and two copies run side by side, each with its own values and its own spawned objects.

It is safe. If one action fails (for example a method throws an exception), Smart Events logs the error with the action’s name and the rest of the event still runs. Missing targets are skipped with a clear warning.

It survives scene loads. A sequence like “fade out, load scene, fade in” keeps running. A single hidden runner object named [SmartEvents] drives every sequence, tween and sound.

Working with actions in the Inspector

Most fields have a small dropdown on their left that chooses where the value comes from:

Complex values (lists, structs, components) show an extra row to read their Count, one Element or a Field inside them, for example transform > position > x.

Global values

Global values are grouped in the dropdown:

• Smart Events: FPS, frame time, resolution, aspect ratio, clock, date, battery %, online, is paused, active scene, memory.
• Unity: Time, Application (FPS lock, platform…), Screen, Quality (vSync), System Info (device, CPU, GPU, RAM, battery), Audio, Cursor, Physics, Rendering, Camera.main, Random.
• Your Scripts: every public static field and property in your project’s scripts, listed automatically.

Writable values (marked as such) can be changed with Set Property Value, for example to lock the frame rate with Application.targetFrameRate.

Logic

Flow

GameObject

Audio and game

UI

Animation

Tween options:

• Target From: an object assigned in the Inspector, or a Value, so you can animate spawned objects and event values.
• Wait Until Finished: the next action waits for the tween to end.
• Ignore Time Scale: keeps animating while the game is paused.
• On Complete: actions that run when the tween finishes.

Each object has one tween per property (position, rotation, scale, color…). A new tween replaces the old one, and shakes and punches first return the object to its resting pose, so repeated effects never drift.

Debug

Add them with Add Component > Doxfen > Smart Events. Each one already contains the right events, so you only add actions.

Smart Sequence

A Smart Sequence is an action list saved as an asset, for example “Hit Feedback”, “Coin Pickup” or “Open Panel”. Build it once, then use it everywhere with the Run Sequence action.

• Create one: Assets > Create > Doxfen > Smart Events > Smart Sequence (or the New button on a Run Sequence action).
• The sequence receives one value, its Target GameObject. Inside, use Event Variable 0: Target as the target of tweens, sounds and method calls.
• Assets can’t reference scene objects. Use the Target, prefabs, Global values or spawned objects instead.
• From code: mySequence.Play(targetGameObject);

Event Channel

An Event Channel is a global event saved as an asset, for example “Player Died” or “Goal Scored”. Any object can raise it, and every Event Channel Listener that uses it reacts. The two sides never reference each other.

• Create one: Assets > Create > Doxfen > Smart Events > Event Channel.
• Raise it with Invoke Method (Target: the channel asset, Function: Raise), or from code: channel.Raise(someObject);
• In Play Mode, the channel’s Inspector shows its listener count and a Raise Now button.

In Play Mode the Inspector shows what is happening:

• Each event shows how many times it was invoked and how long ago, plus an Invoke button to run it right away (event values use their defaults).
• An action flashes when it runs. Actions that are still running (Waits, Loops, tweens being waited for) show a green bar and the word “running”. A counter shows how often each action ran.

This makes it easy to see where a sequence is waiting and to test events without writing code.

public SmartEvent onDone;            // also SmartEvent<T0>, <T0, T1>, <T0, T1, T2>, <T0, T1, T2, T3>

onDone.Invoke();                     // run Inspector actions, then code listeners
onDone.AddListener(OnDone);          // code listeners, like UnityEvent
onDone.RemoveListener(OnDone);
onDone.RemoveAllListeners();
onDone.On(A).On(B);                  // chain listeners
onDone.StopRunningActions();         // stop sequences that are still running
onDone.InvokeWithDefaults();         // invoke with default values
bool any = onDone.HasAnyListeners;   // also HasInspectorActions, HasCodeListeners
onDone.Actions.Add(new SmartEventAction()); // build actions from code

Lists, arrays and subclasses (class DamageEvent : SmartEvent<int> {}) all work in the Inspector.

An exception thrown by a code listener is logged and doesn’t break the caller.

All code lives in the Doxfen.UtilityTools.SmartEvents namespaces and in its own assemblies, so it never clashes with your project.

Smart Events was tested in player builds on Mono and on IL2CPP (WebGL), both with Managed Stripping Level: High.

Invoke Method, Property, Global values and Set Property Value use reflection. Unity’s code stripping can remove members that are only used this way. If a call works in the Editor but not in a build:

• add [UnityEngine.Scripting.Preserve] to the method, field or property, or
• list the assembly or type in a link.xml file, or
• lower Managed Stripping Level.

When a member is missing at runtime, Smart Events logs a warning that names it.

Performance

• An event with no Inspector actions costs almost nothing (100,000 invokes took under 1 ms in our tests).
• One shared runner drives every sequence. Starting 2,000 sequences at once took about 4 ms.
• Live-debug tracking exists only in the Editor and is compiled out of builds.

• Only public methods, fields and properties can be called or read (static ones through Global).
• Events carry up to 4 values (SmartEvent<T0, T1, T2, T3>).
• Loop Index is the index of the innermost loop.
• While loops run at most one iteration per frame. Use Repeat for instant loops.
• Smart Sequence assets can’t reference scene objects (a Unity rule for assets). Use the Target value.
• The built-in tweens are lightweight. They don’t replace a full tweening library (no paths or custom curves).
• Renaming a method that an Invoke Method action calls breaks that call, the same as with UnityEvent. A warning names the missing method.
• Smart Events can be edited on one selected object at a time (multi-object editing shows a notice).

Email info@doxfen.com. Please include your Unity version and a screenshot of the event.

Smart Events is licensed under the Unity Asset Store EULA. It contains no third-party code.