Actions
Actions define what the Behavior System should do once the configured logic allows execution to continue.
They are the execution part of the pipeline and are evaluated after events, rules, and operators have already contributed to the decision flow.
For a broader introduction to the system, see Overview.
For shared function setup and binding behavior, see Function Nodes and Bindings.
Adding Actions
Actions can be added directly inside a Behavior Asset by using Add Action.
Once added, an action can be reordered using the arrow buttons to move it up or down in the execution list. This makes it possible to control the order in which actions appear in the overall behavior flow.
Because the system is evaluated from top to bottom, action order is an important part of how the final behavior is structured.
Action Functions
Each action is based on a selected function. Once a function is chosen, that function becomes the executable logic of the action.
The available function list includes both built-in functionality and custom functions that are exposed to the Behavior System.
Custom functions can be provided through Blueprint function libraries or through C++.
Triggering Actions
Actions determine their execution based on the part of the behavior flow above them.
In many cases this means they evaluate the results of the operators placed above them. However, actions are not always dependent on operators. When the trigger mode is set to Always Execute, an action can run regardless of whether the operators above it evaluate to true or false. It can also run even when no operator exists above it at all.
This means the trigger mode is what ultimately defines how strongly an action depends on the operator state above it.
Trigger Mode
Each action defines a Trigger Mode that controls how it reacts to the operators above it in the behavior flow.
Trigger Mode | Behavior |
|---|---|
And | The action executes only if all relevant operators above it evaluate to true. |
Or | The action executes if at least one relevant operator above it evaluates to true. |
Always Execute | The action executes regardless of operator results. It can also execute when no operator exists above it. |
The selected trigger mode determines how the action interprets the state of the flow above it.
Flow Direction
Behavior Assets are evaluated from top to bottom, similar to a flow graph.
This means that actions only evaluate the part of the graph above them. Depending on the selected trigger mode, they may use operator results from that section to decide whether they should execute.
If the trigger mode is set to Always Execute, the action can continue independently of those operator results and does not require an operator to exist above it.
Continue or Stop After This
Each action also defines what should happen after it has executed.
The available options are:
Continue
Stop After This
Continue
The behavior continues evaluating the remaining flow after the current action has been executed.
Stop After This
The behavior stops after this action and does not continue with the remaining flow.
This makes it possible to use an action as a terminating step when no further execution should happen afterward.
Chaining Actions
Multiple actions can be placed one after another.
This makes it possible to build larger execution chains inside a single Behavior Asset. Depending on the trigger mode and the structure above each action, these actions may either respond to operator results or continue independently.
In particular, actions using Always Execute can still run even if no operator exists directly above them. This allows action sequences to continue without requiring every step to be gated by additional operator nodes.
Data Flow After an Action
A special rule applies once an action is followed by another operator.
When an operator appears after an action, everything below that point begins a new evaluation segment. The later part of the flow no longer has direct access to references from the earlier segment.
The only data that can still be forwarded from the earlier part of the graph are the outputs of the action.
Inputs and Outputs
Actions can expose inputs and outputs depending on the selected function.
These pins can be connected to:
event context values
outputs from previous rules
outputs from previous actions
This allows actions to participate in a larger data flow instead of acting as isolated execution nodes.
For details about supported pin types, context values, exposed inputs, and custom functions, see Function Nodes and Bindings.