Implementing Interrupts and Reactive Behaviors

In this lesson, you will learn how to design reactive behavior tree structures that allow your AI agents to immediately abandon current tasks when high-priority environmental triggers occur.

The Problem with Linear Execution

In a standard behavior tree, a Sequence node typically finishes its entire chain of tasks before re-evaluating the tree’s root. If an agent is performing a long animation—like "Patrolling"—it might ignore a "Player Spotted" trigger until the current patrol waypoint is reached. This makes your AI feel unresponsive or "robotic."

Implementing Reactive Interrupts

To solve this, we use the Selector node’s ability to act as a gatekeeper. By placing high-priority Condition nodes at the very left of your root Selector, you ensure the tree re-evaluates the environment before every tick.

If a "Danger" condition returns Success, the root Selector ignores the remaining nodes (your lower-priority tasks) and immediately switches control to a "Flee" subtree. Because behavior trees evaluate from left to right, the Selector effectively "interrupts" the current process as soon as the high-priority condition is met.

Structuring the Tree

Consider this high-level structure:

1. Root Selector
   • Priority Sequence (e.g., "Check Danger" -> "Flee")
   • Main Task Sequence (e.g., "Patrol")

If "Check Danger" succeeds, the tree enters the "Flee" sequence. Even if the "Patrol" sequence was mid-execution, the tree structure forces it to abort because the Selector has already satisfied its requirements with the higher-priority node.

// Logic concept for a Reactive Selector
public override NodeState Evaluate() {
    // Priority check (Interrupt)
    if (dangerSensor.IsThreatPresent()) {
        return fleeSubtree.Evaluate();
    }
    
    // Normal behavior
    return patrolSequence.Evaluate();
}

By decoupling your environmental sensing from your task-based sequences and using Selector nodes to enforce priority, you create AI that reacts to the world dynamically rather than following a rigid script. This pattern ensures that vital survival instincts take precedence over routine actions without needing complex hard-coded state management.

Key Takeaway: Use root-level Selector nodes to prioritize reactive subtrees, ensuring that environmental interrupts override ongoing tasks the moment they are triggered.