Behavior Designer Pro

https://opsive.com/support/documentation/behavior-designer-pro
Admin
Behavior Designer Pro is a successful behavior tree tool for Unity that upgrades popular features to...
Tokens:29,192
Snippets:324
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Start Behavior Tree

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Starts the behavior tree. Use this method to initiate the execution of the behavior tree.

```csharp
bool StartBehavior()

```

--------------------------------

### Start Branch by Event Task

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Starts a specific branch of the behavior tree using an IEventNode instance. This provides a direct way to start a branch with a given task.

```csharp
bool StartBranch(IEventNode eventTask)

```

--------------------------------

### Behavior Designer v1 Task Example

Source: https://opsive.com/support/documentation/behavior-designer-pro/getting-started/task-migration

This is an example of a task created for version 1 of Behavior Designer. It demonstrates the original namespace and attribute usage.

```csharp
using UnityEngine;
using BehaviorDesigner.Runtime;
using BehaviorDesigner.Runtime.Tasks;
using Tooltip = BehaviorDesigner.Runtime.Tasks.TooltipAttribute;

namespace MyNamespace
{
    [TaskCategory("Common")]
    [TaskIcon("Assets/MyIcon.png")]
    [TaskDescription("Logs to the console.")]
    public class MyTask : Action
    {
        [Tooltip("Text to output to the log")]
        public SharedString text;

        public override TaskStatus OnUpdate()
        {
            Debug.Log(text.Value);
            return TaskStatus.Success;
        }

        public override void OnReset()
        {
            // Reset the properties back to their original values
            text = "";
        }
    }
}
```

--------------------------------

### StartBehavior

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Starts the behavior tree. This method initiates the execution of the behavior tree.

```APIDOC
## StartBehavior

### Description
Starts the behavior tree.

### Method
bool StartBehavior()

### Returns
True if the behavior tree was started.
```

--------------------------------

### Start Baked Behavior Tree on Server

Source: https://opsive.com/support/documentation/behavior-designer-pro/networking

This system ensures that baked Behavior Trees are started only on the server. The `IsServer` check should be adapted to your networking solution. This prevents Behavior Tree systems from initializing on clients.

```csharp
public partial struct EntitySpawnerSystem : ISystem
{
    /// <summary>
    /// Sets the system requirements.
    /// </summary>
    /// <param name="state">The current SystemState.</param>
    private void OnCreate(ref SystemState state)
    {
        state.RequireForUpdate<SpawnData>();
    }

    /// <summary>
    /// Spawns the entities.
    /// </summary>
    /// <param name="state">The current SystemState.</param>
    private void OnUpdate(ref SystemState state)
    {
        state.Enabled = false;

        var spawner = SystemAPI.ManagedAPI.GetSingleton<SpawnData>();
        var entities = state.EntityManager.Instantiate(spawner.Prefab, 100, Allocator.Temp);

        // Any custom setup for each entity. This can include adding new components, enabling components, setting entity data, etc.

        // The behavior trees have been baked.
        if (spawner.IsServer) { // Your networking implementation for determining if the agent is on the server.
            BehaviorTree.StartBakedBehaviorTree(world, entity);
        }   
    }
}
```

--------------------------------

### Start Branch by Event Task Type

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Starts a specific branch of the behavior tree identified by its event task type. This is useful for triggering specific behaviors.

```csharp
bool StartBranch(Type eventTaskType)

```

--------------------------------

### StartBranch (IEventNode)

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Starts the branch with the specified event task. This method is used to initiate a specific branch identified by an IEventNode.

```APIDOC
## StartBranch (IEventNode)

### Description
Starts the branch with the specified event task.

### Method
bool StartBranch(IEventNode eventTask)

### Parameters
#### Path Parameters
- **eventTask** (IEventNode) - Required - The branch that should be started.

### Returns
True if the branch was started.
```

--------------------------------

### Iterator Task Example Output

Source: https://opsive.com/support/documentation/behavior-designer-pro/concepts/tasks/decorator/iterator

This example shows the output of the Log Value task when used with the Iterator task. The Iterator task traverses a list and sets a variable to each element.

```text
FirstElement (UnityEngine.GameObject)
SecondElement (UnityEngine.GameObject)
ThirdElement (UnityEngine.GameObject)
```

--------------------------------

### Manual Tick Example

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Demonstrates the need to manually tick the behavior tree when its UpdateMode is set to Manual. This is common in turn-based games.

```csharp
// If your behavior tree is set to a _Manual Update Mode_ then you will need to tick the tree by calling _BehaviorTree.Tick_.
// This is useful for turn-based games.
// See the TurnBased sample scene for an example of manually ticking the behavior tree.

```

--------------------------------

### Custom Event Node for Delayed Branch Start - C#

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/event-node

Implement a custom Event Node that starts a behavior branch after a specified delay. Ensure the Behavior Designer runtime is initialized before use.

```csharp
using Opsive.BehaviorDesigner.Runtime.Tasks.Events;
using Opsive.GraphDesigner.Runtime;
using Opsive.GraphDesigner.Runtime.Variables;
using UnityEngine;

/// <summary>
/// Starts the branch after the specified amount of time.
/// </summary>
[AllowMultipleTypes]
public class StartBranchDelay : EventNode
{
    [Tooltip("Specifies when the brnach should start.")]
    [SerializeField] protected SharedVariable<float> m_StartDelay;

    /// <summary>
    /// Initializes the node to the specified graph.
    /// </summary>
    /// <param name="graph">The graph that is initializing the task.</param>
    public override void Initialize(IGraph graph)
    {
        base.Initialize(graph);

        m_BehaviorTree.Invoke("StartBranch", m_StartDelay.Value);
    }

    /// <summary>
    /// Starts the branch.
    /// </summary>
    private void StartBranch()
    {
        m_BehaviorTree.StartBranch(this);
    }
}
```

--------------------------------

### StartBranch (Type)

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Stars the branch with the specified event task type. This allows starting a specific part of the behavior tree based on its type.

```APIDOC
## StartBranch (Type)

### Description
Stars the branch with the specified event task type.

### Method
bool StartBranch(Type eventTaskType)

### Parameters
#### Path Parameters
- **eventTaskType** (Type) - Required - The branch that should be started.

### Returns
True if the branch was started.
```

--------------------------------

### Behavior Designer Pro Task Example

Source: https://opsive.com/support/documentation/behavior-designer-pro/getting-started/task-migration

This task has been updated for Behavior Designer Pro, reflecting changes in namespaces, attributes, and shared variable types. It shows the new structure required for compatibility.

```csharp
using UnityEngine;
using Opsive.BehaviorDesigner.Runtime.Tasks;
using Opsive.BehaviorDesigner.Runtime.Tasks.Actions;
using Opsive.GraphDesigner.Runtime;
using Opsive.GraphDesigner.Runtime.Variables;

namespace MyNamespace
{
    [Opsive.Shared.Utility.Category("Common")]
    [NodeIcon("Assets/MyIcon.png")]
    [NodeDescription("Logs to the console.")]
    public class MyTask : Action
    {
        [Tooltip("Text to output to the log")]
        public SharedVariable<string> text;

        public override TaskStatus OnUpdate()
        {
            Debug.Log(text.Value);
            return TaskStatus.Success;
        }

        public override void Reset()
        {
            // Reset the properties back to their original values
            text = "";
        }
    }
}
```

--------------------------------

### Custom Utility Evaluator Example

Source: https://opsive.com/support/documentation/behavior-designer-pro/concepts/tasks/composite/utility-selector

Create a custom utility evaluator by inheriting from the UtilityEvaluator abstract class and implementing the GetUtilityValue method. This example returns a constant utility value of 5.

```csharp
using Opsive.BehaviorDesigner.Runtime.Tasks.Decorators;

public class MyUtilityEvaluator : UtilityEvaluator
{
   /// <summary>
   /// Returns the utility of the decorator. The higher the utility the more likely the task will run next.
   /// </summary>
   /// <returns>The utility of the decorator.</returns>
   public override float GetUtilityValue() { return 5; }
}
```

--------------------------------

### Custom Formation Implementation

Source: https://opsive.com/support/documentation/behavior-designer-pro-formations-pack

Example of creating a custom formation by inheriting from FormationsBase and implementing the CalculateFormationPosition method. This custom formation does not assign optimal indices and always returns Vector3.zero for the agent's position.

```csharp
using Opsive.BehaviorDesigner.AddOns.FormationsPack.Runtime.Tasks;
using UnityEngine;

public class MyFormation : FormationsBase
{
    /// <summary>
    /// Should the optimal indicies be assigned? This should be set to false for random formations.
    /// </summary>
    public override bool AssignOptimialIndicies => true;

    /// <summary>
    /// Calculate the position for this agent in the skirmisher formation.
    /// </summary>
    /// <param name="index">The index of this agent in the formation.</param>
    /// <param name="totalAgents">The total number of agents in the formation.</param>
    /// <param name="center">The center position of the formation.</param>
    /// <param name="forward">The forward direction of the formation.</param>
    /// <param name="samplePosition">Should the position be sampled?</param>
    /// <returns>The position for this agent.</returns>
    public override Vector3 CalculateFormationPosition(int index, int totalAgents, Vector3 center, Vector3 forward, bool samplePosition)
    {
        return Vector3.zero;
    }
}
```

--------------------------------

### Restart Behavior Tree

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Restarts the behavior tree. This method reinitializes and starts the behavior tree from its beginning.

```csharp
bool RestartBehavior()

```

--------------------------------

### WithinDistance Task System Implementation

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/entity-task

Implements the DOTS task system for WithinDistance logic. It includes OnCreate for query setup and OnUpdate to schedule the job.

```csharp
/// <summary>
/// Runs the WithinDistance logic.
/// </summary>
[DisableAutoCreation]
public partial struct WithinDistanceTaskSystem : ISystem
{
    private EntityQuery m_Query;

    /// <summary>
    /// Creates the required objects for use within the job system.
    /// </summary>
    /// <param name="state">The current SystemState.</param>
    [BurstCompile]
    private void OnCreate(ref SystemState state)
    {
        m_Query = new EntityQueryBuilder(Allocator.Temp)
        .WithAllRW<TaskComponent>()
        .WithAll<BranchComponent>()
        .WithAll<WithinDistanceComponent, WithinDistanceFlag, EvaluateFlag>()
        .Build(ref state);
    }

    /// <summary>
    /// Updates the job.
    /// </summary>
    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    private void OnUpdate(ref SystemState state)
    {
        state.Dependency = new WithinDistanceJob().ScheduleParallel(m_Query, state.Dependency);
    }

    /// <summary>
    /// Job which executes the task logic.
    /// </summary>
    [BurstCompile]
    private partial struct WithinDistanceJob : IJobEntity
    {
        /// <summary>
        /// Executes the idle logic.
        /// </summary>
        /// <param name="branchComponents">An array of BranchComponents.</param>
        /// <param name="taskComponents">An array of TaskComponents.</param>
        /// <param name="withinDistanceComponents">An array of WithinDistanceComponents.</param>
        [BurstCompile]
        public void Execute(ref DynamicBuffer<BranchComponent> branchComponents, ref DynamicBuffer<TaskComponent> taskComponents, ref DynamicBuffer<WithinDistanceComponent> withinDistanceComponents)
        {
            for (int i = 0; i < withinDistanceComponents.Length; ++i) {
                var withinDistanceComponent = withinDistanceComponents[i];
                var taskComponent = taskComponents[withinDistanceComponent.Index];
                var branchComponent = branchComponents[taskComponent.BranchIndex];

                if (!branchComponent.CanExecute || (taskComponent.Status != TaskStatus.Queued && taskComponent.Status != TaskStatus.Running)) {
                    continue;
                }

                taskComponent.Status = math.distance(withinDistanceComponent.Origin, withinDistanceComponent.Target) < withinDistanceComponent.Distance ? TaskStatus.Success : TaskStatus.Failure;
                taskComponents[withinDistanceComponent.Index] = taskComponent;
            }
        }
    }
}
```

--------------------------------

### RestartBehavior

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Restarts the behavior tree. This method reinitializes and starts the behavior tree execution.

```APIDOC
## RestartBehavior

### Description
Restarts the behavior tree.

### Method
bool RestartBehavior()

### Returns
True if the behavior tree was restarted.
```

--------------------------------

### Get Task by Index

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Retrieves a specific task from the behavior tree using its index. This is useful for accessing tasks directly when their position is known.

```csharp
ILogicNode GetTask(int index)

```

--------------------------------

### Implement OnStart for Random Destination

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

This snippet shows how to implement the OnStart method to choose a random destination within a specified radius using Shared Variables. It requires referencing Opsive.GraphDesigner.Runtime.Variables and Opsive.BehaviorDesigner.Runtime.Tasks.Actions.

```csharp
using Opsive.GraphDesigner.Runtime.Variables;
using Opsive.BehaviorDesigner.Runtime.Tasks.Actions;
using UnityEngine;
public class MoveTowardsRandomPoint : Action
{
    [Tooltip("The center point of the random position.")]
    public SharedVariable<Vector3> m_Center;
    [Tooltip("The radius that contains the random position.")]
    public SharedVariable<float> m_Radius = 10;

    private Vector3 m_Destination;

    /// <summary>
    /// Callback when the task is started.
    /// </summary>
    public override void OnStart()
    {
        m_Destination = m_Center.Value + Random.insideUnitSphere * Random.Range(0, m_Radius.Value);
    }
}
```

--------------------------------

### EntitySpawnerSystem for Spawning Entities

Source: https://opsive.com/support/documentation/behavior-designer-pro/entity-baking

A system that requires SpawnData and spawns 100 entities using the baked prefab. It then enables the baked behavior tree system.

```csharp
public partial struct EntitySpawnerSystem : ISystem
{
    /// <summary>
    /// Sets the system requirements.
    /// </summary>
    /// <param name="state">The current SystemState.</param>
    private void OnCreate(ref SystemState state)
    {
        state.RequireForUpdate<SpawnData>();
    }

    /// <summary>
    /// Spawns the entities.
    /// </summary>
    /// <param name="state">The current SystemState.</param>
    private void OnUpdate(ref SystemState state)
    {
        state.Enabled = false;

        var spawner = SystemAPI.ManagedAPI.GetSingleton<SpawnData>();
        var entities = state.EntityManager.Instantiate(spawner.Prefab, 100, Allocator.Temp);

        // Any custom setup for each entity. This can include adding new components, enabling components, setting entity data, etc.

        // The behavior trees have been baked. Enable the system which starts the behavior trees.
        BehaviorTree.EnableBakedBehaviorTreeSystem(World.DefaultGameObjectInjectionWorld);
    }
}
```

--------------------------------

### Physics and Gizmos Callbacks

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

Implement these methods to receive physics callbacks or draw gizmos. These are overridden for efficiency reasons.

```csharp
ReceiveCollisionEnterCallback
ReceiveCollisionExitCallback
ReceiveCollisionEnter2DCallback
ReceiveCollisionExit2DCallback
ReceiveTriggerEnterCallback
ReceiveTriggerExitCallback
ReceiveTriggerEnter2DCallback
ReceiveTriggerExit2DCallback
ReceiveControllerColliderHitCallback
ReceiveDrawGizmosCallback
ReceiveDrawGizmosSelectedCallback
```

--------------------------------

### Get Shared Variable

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Retrieves a SharedVariable by its name and scope. This is useful for accessing shared data across different parts of the behavior tree.

```csharp
SharedVariable GetVariable(string name, SharedVariable.SharingScope scope)

```

--------------------------------

### Implement OnUpdate for Agent Movement

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

This snippet extends the previous one by adding the OnUpdate method to move the agent towards the chosen destination. It returns TaskStatus.Success when the destination is reached and TaskStatus.Running otherwise. It requires additional namespaces like Opsive.BehaviorDesigner.Runtime.Tasks.

```csharp
using Opsive.GraphDesigner.Runtime.Variables;
using Opsive.BehaviorDesigner.Runtime.Tasks;
using Opsive.BehaviorDesigner.Runtime.Tasks.Actions;
using UnityEngine;

public class MoveTowardsRandomPoint : Action
{
    [Tooltip("The center point of the random position.")]
    public SharedVariable<Vector3> m_Center;
    [Tooltip("The radius that contains the random position.")]
    public SharedVariable<float> m_Radius = 10;
    [Tooltip("The speed that the agent should move towards the destination.")]
    public SharedVariable<float> m_MoveSpeed = 5;

    private Vector3 m_Destination;

    /// <summary>
    /// Callback when the task is started.
    /// </summary>
    public override void OnStart()
    {
        m_Destination = m_Center.Value + Random.insideUnitSphere * Random.Range(0, m_Radius.Value);
    }

    /// <summary>
    /// Executes the task logic. Returns a TaskStatus indicating how the behavior tree flow should proceed.
    /// </summary>
    /// <returns>The status of the task.</returns>
    public override TaskStatus OnUpdate()
    {
        // The agent has arrived when they get close to the destination. 
        if (Vector3.Distance(transform.position, m_Destination) < 0.5f) { 
            return TaskStatus.Success;
        }

        // The agent hasn't arrived yet. Keep moving towards the destination and return a running status.
        transform.position = Vector3.MoveTowards(transform.position, m_Destination, m_MoveSpeed.Value * Time.deltaTime);
        return TaskStatus.Running;
    }
}
```

--------------------------------

### Accessing Variables from External Scripts

Source: https://opsive.com/support/documentation/behavior-designer-pro/variables/accessing-variables

Retrieve a `SharedVariable` by its name from a `BehaviorTree` component in your own scripts. You can then get and set its value using the `SharedVariable.Value` property.

```csharp
using Opsive.BehaviorDesigner.Runtime;
using Opsive.GraphDesigner.Runtime.Variables;
using UnityEngine;

public class AccessVariable : MonoBehaviour
{
    public BehaviorTree m_BehaviorTree;

    public void Start()
    {
        SharedVariable<GameObject> target = m_BehaviorTree.GetVariable<GameObject>("Target");
        target.Value = gameObject;
    }
}
```

--------------------------------

### Save and Load Single Behavior Tree

Source: https://opsive.com/support/documentation/behavior-designer-pro/save-load

Saves and loads a single behavior tree to a specified file location. The second parameter of the `Save` method specifies which additional variables should be saved.

```csharp
using Opsive.BehaviorDesigner.Runtime;
using Opsive.BehaviorDesigner.Runtime.Utility;
using UnityEngine;

public class Saver : MonoBehaviour
{
    [Tooltip("The behavior tree that should be saved.")]
    public BehaviorTree m_BehaviorTree;
    [Tooltip("The location that the behavior tree should be saved.")]
    public string m_SaveLocation = "Assets/BehaviorTree.save";

    /// <summary>
    /// Saves the behavior tree.
    /// </summary>
    public void Save()
    {
        m_BehaviorTree.Save(m_SaveLocation, SaveManager.VariableSaveScope.GameObjectVariables | SaveManager.VariableSaveScope.SceneVariables); // Saves the behavior tree and the GameObject/scene variables.
    }

    /// <summary>
    /// Restores the behavior tree.
    /// </summary>
    public void Load()
    {
        m_BehaviorTree.Load(m_SaveLocation);
    }
}
```

--------------------------------

### Load

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Loads the behavior tree from the specified file path. This method restores a previously saved behavior tree.

```APIDOC
## Load

### Description
Loads the behavior tree from the specified file path.

### Method
bool Load(string filePath)

### Parameters
#### Path Parameters
- **filePath** (string) - Required - The file path to load the behavior tree at.

### Returns
True if the behavior tree was successfully loaded.
```

--------------------------------

### Save and Load Multiple Behavior Trees

Source: https://opsive.com/support/documentation/behavior-designer-pro/save-load

Saves and loads multiple behavior trees to the same file using the Save Manager. This script provides the same functionality as the single behavior tree script but operates on an array of behavior trees.

```csharp
using Opsive.BehaviorDesigner.Runtime;
using Opsive.BehaviorDesigner.Runtime.Utility;
using UnityEngine;

public class Saver : MonoBehaviour
{
    [Tooltip("The behavior trees that should be saved.")]
    public BehaviorTree[] m_BehaviorTrees;
    [Tooltip("The location that the behavior trees should be saved.")]
    public string m_SaveLocation = "Assets/BehaviorTrees.save";

    /// <summary>
    /// Saves the behavior tree.
    /// </summary>
    public void Save()
    {
        SaveManager.Save(m_BehaviorTrees, m_SaveLocation, SaveManager.VariableSaveScope.GameObjectVariables | SaveManager.VariableSaveScope.SceneVariables); // Saves the behavior tree and the GameObject/scene variables.
    }

    /// <summary>
    /// Restores the behavior tree.
    /// </summary>
    public void Load()
    {
        SaveManager.Load(m_BehaviorTrees, m_SaveLocation);
    }
}
```

--------------------------------

### Load Behavior Tree

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Loads a behavior tree from a specified file path. This replaces the current behavior tree with the one from the file.

```csharp
bool Load(string filePath)

```

--------------------------------

### Accessing Variable Value Within a Task

Source: https://opsive.com/support/documentation/behavior-designer-pro/variables/accessing-variables

Use the `Value` property to get and set variable values directly within a Behavior Designer task. Ensure tasks are assigned to the same `SharedVariable` name in the inspector for shared references.

```csharp
using Opsive.BehaviorDesigner.Runtime.Tasks;
using Opsive.BehaviorDesigner.Runtime.Tasks.Conditionals;
using Opsive.GraphDesigner.Runtime.Variables;
using UnityEngine;

public class WithinDistance : Conditional
{
    [Tooltip("The object that the agent is searching for.")]
    [SerializeField] protected SharedVariable<GameObject> m_Target;

    public override TaskStatus OnUpdate()
    {
        GameObject targetGameObject = m_Target.Value;
        if (targetGameObject == null) {
            m_Target.Value = GameObject.Find("Player");
        }
    }
```

--------------------------------

### Enable Behavior Tree on Server Only

Source: https://opsive.com/support/documentation/behavior-designer-pro/networking

This script enables the Behavior Tree component only on the server. Ensure the `IsServer()` method correctly identifies the server environment in your specific networking implementation.

```csharp
public class BehaviorTreeEnabler : MonoBehaviour
{
    [Tooltip("A reference to the behavior tree.")]
    public BehaviorTree m_BehaviorTree;

    private void Awake()
    {
        m_BehaviorTree.enabled = IsServer();
    }
}
```

--------------------------------

### Find Tasks by Type (Pre-allocated Array)

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Finds all tasks of a specified type and stores them in a pre-allocated array. This method is optimized to avoid allocations.

```csharp
int FindTasks<T>(T[] foundTasks) where T : Task

```

--------------------------------

### Pooling Subtrees for Performance

Source: https://opsive.com/support/documentation/behavior-designer-pro/subtrees

This C# script demonstrates how to pool subtrees for improved performance, especially when frequently switching between them. It instantiates a specified number of subtrees, deserializes them, marks them as pooled, and provides a method to assign a pooled subtree to a BehaviorTree component.

```csharp
using Opsive.BehaviorDesigner.Runtime;
using UnityEngine;

public class SubtreePooler : MonoBehaviour
{
    [Tooltip("A reference to the behavior tree that the subtree should be assigned to.")]
    public BehaviorTree m_BehaviorTree;
    [Tooltip("The subtree that should be pooled.")]
    public Subtree m_Subtree;
    [Tooltip("Specifies how large the pool should be.")]
    public int m_PoolSize = 5;

    private Subtree[] m_SubtreePool;
    private int m_Index;

    /// <summary>
    /// Pools the subtrees.
    /// </summary>
    private void Awake()
    {
        m_SubtreePool = new Subtree[m_PoolSize];
        for (int i = 0; i < m_PoolSize; ++i) {
            m_SubtreePool[i] = Object.Instantiate(m_Subtree);
            m_SubtreePool[i].Deserialize();
            m_SubtreePool[i].Pooled = true;
        }
    }

    /// <summary>
    /// Assigns a new pooled subtree to the behavior tree.
    /// </summary>
    public void Assign()
    {
        m_BehaviorTree.Subgraph = m_SubtreePool[m_Index];
        m_Index = (m_Index + 1) % m_PoolSize;
    }
}
```

--------------------------------

### Dynamic Subtree Selection with RandomSubtreeReference

Source: https://opsive.com/support/documentation/behavior-designer-pro/subtrees

This C# script extends the SubtreeReference task to dynamically select and load a random subtree from a list when the behavior tree is initialized. It overrides the Subtrees property to return a randomly chosen subtree.

```csharp
using Opsive.BehaviorDesigner.Runtime.Tasks.Actions;
using Opsive.BehaviorDesigner.Runtime;
using Opsive.GraphDesigner.Runtime;
using UnityEngine;

public class RandomSubtreeReference : SubtreeReference
{
    private Subtree[] m_Selection;

    public override Subtree[] Subtrees => m_Selection != null ? m_Selection : m_Subtrees;

    /// <summary>
    /// Performs any runtime operations to evaluate the array of subtrees that should be returned.
    /// </summary>
    public override void EvaluateSubtrees()
    {
        if (m_Subtrees == null || m_Subtrees.Length == 0) {
            return;
        }

        m_Selection = new Subtree[] { m_Subtrees[Random.Range(0, m_Subtrees.Length)] };
    }
}
```

--------------------------------

### Add Node Description and Icon Attributes

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

This snippet demonstrates how to add a descriptive tooltip and a custom icon to a Behavior Designer task node using attributes. It requires referencing the Opsive.GraphDesigner.Runtime namespace.

```csharp
using Opsive.GraphDesigner.Runtime;

[NodeIcon("Assets/MyIcon.png")]
[NodeDescription("Moves the agent towards a random position within the specified radius.")]
public class MoveTowardsRandomPoint : Action
```

--------------------------------

### Implement Save and Load for Action Task

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

Override GetSaveReflectionType to return MemberVisibility.None and implement Save and Load methods to manually persist task state. This is necessary when the behavior tree needs to be saved and loaded.

```csharp
/// <summary>
    /// Specifies the type of reflection that should be used to save the task.
    /// </summary>
    /// <param name="index">The index of the sub-task. This is used for the task set allowing each contained task to have their own save type.</param>
    public override MemberVisibility GetSaveReflectionType(int index)
    {
        // Do not use reflection to save. This task will implement the Save and Load methods.
        return MemberVisibility.None;
    }

    /// <summary>
    /// Returns the current task state.
    /// </summary>
    /// <param name="world">The DOTS world.</param>
    /// <param name="entity">The DOTS entity.</param>
    /// <returns>The current task state.</returns>
    public override object Save(World world, Entity entity)
    {
        // Only save the destination.
        return m_Destination;
    }

    /// <summary>
    /// Loads the previous task state.
    /// </summary>
    /// <param name="saveData">The previous task state.</param>
    /// <param name="world">The DOTS world.</param>
    /// <param name="entity">The DOTS entity.</param>
    public override void Load(object saveData, World world, Entity entity)
    {
        // The saveData will only contain the objects specified by the Save method.
        m_Destination = (Vector3)saveData;
    }
```

--------------------------------

### Define Spawn Data Component

Source: https://opsive.com/support/documentation/behavior-designer-pro/entity-baking

Defines the IComponentData for spawn data, including the entity prefab to be spawned. This component is used by the EntitySpawner.

```csharp
public struct SpawnData : IComponentData
{
    [Tooltip("The entity prefab that should be spawned.")]
    public Entity Prefab;
}
```

--------------------------------

### MoveTowardsRandomPoint Action Task

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

This C# code defines a custom Behavior Designer action task that moves an agent towards a random point within a specified radius. It includes implementations for OnStart, OnUpdate, GetSaveReflectionType, Save, and Load to manage task state and behavior.

```csharp
using Opsive.Shared.Utility;
using Opsive.GraphDesigner.Runtime;
using Opsive.GraphDesigner.Runtime.Variables;
using Opsive.BehaviorDesigner.Runtime.Tasks;
using Opsive.BehaviorDesigner.Runtime.Tasks.Actions;
using UnityEngine;
using Unity.Entities;

[NodeIcon("Assets/MyIcon.png")]
[NodeDescription("Moves the agent towards a random position within the specified radius.")]
public class MoveTowardsRandomPoint : Action
{
    [Tooltip("The center point of the random position.")]
    public SharedVariable<Vector3> m_Center;
    [Tooltip("The radius that contains the random position.")]
    public SharedVariable<float> m_Radius = 10;
    [Tooltip("The speed that the agent should move towards the destination.")]
    public SharedVariable<float> m_MoveSpeed = 5;

    private Vector3 m_Destination;

    /// <summary>
    /// Callback when the task is started.
    /// </summary>
    public override void OnStart()
    {
        m_Destination = m_Center.Value + Random.insideUnitSphere * Random.Range(0, m_Radius.Value);
    }

    /// <summary>
    /// Executes the task logic. Returns a TaskStatus indicating how the behavior tree flow should proceed.
    /// </summary>
    /// <returns>The status of the task.</returns>
    public override TaskStatus OnUpdate()
    {
        // The agent has arrived when they get close to the destination. 
        if (Vector3.Distance(transform.position, m_Destination) < 0.5f) { 
            return TaskStatus.Success;
        }

        // The agent hasn't arrived yet. Keep moving towards the destination and return a running status.
        transform.position = Vector3.MoveTowards(transform.position, m_Destination, m_MoveSpeed.Value * Time.deltaTime);
        return TaskStatus.Running;
    }

    /// <summary>
    /// Specifies the type of reflection that should be used to save the task.
    /// </summary>
    /// <param name="index">The index of the sub-task. This is used for the task set allowing each contained task to have their own save type.</param>
    public override MemberVisibility GetSaveReflectionType(int index)
    {
        // Do not use reflection to save. This task will implement the Save and Load methods.
        return MemberVisibility.None;
    }

    /// <summary>
    /// Returns the current task state.
    /// </summary>
    /// <param name="world">The DOTS world.</param>
    /// <param name="entity">The DOTS entity.</param>
    /// <returns>The current task state.</returns>
    public override object Save(World world, Entity entity)
    {
        // Only save the destination.
        return m_Destination;
    }

    /// <summary>
    /// Loads the previous task state.
    /// </summary>
    /// <param name="saveData">The previous task state.</param>
    /// <param name="world">The DOTS world.</param>
    /// <param name="entity">The DOTS entity.</param>
    public override void Load(object saveData, World world, Entity entity)
    {
        // The saveData will only contain the objects specified by the Save method.
        m_Destination = (Vector3)saveData;
    }
}
```

--------------------------------

### Core Task Callbacks

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

These are the fundamental callbacks for GameObject-based tasks, similar to Unity's MonoBehaviour lifecycle.

```APIDOC
## Core Task Callbacks

### Description
Callbacks for the main lifecycle events of a GameObject task.

### Methods
- `OnAwake()`: Callback when the behavior tree is initialized.
- `OnEnable()`: Callback when the behavior tree is enabled.
- `OnStart()`: Callback when the task is started.
- `OnUpdate()`: Executes the task logic and returns a `TaskStatus`.
- `OnEnd()`: Callback when the task stops.
- `OnDisable()`: Callback when the behavior tree is disabled.
- `OnDestroy()`: Callback when the behavior tree is destroyed.
```

--------------------------------

### Find Tasks by Type (Array Allocation)

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Finds all tasks of a specified type and returns them as a new array. This method allocates a new array for the results.

```csharp
T[] FindTasks<T>() where T : Task

```

--------------------------------

### GameObject Task Lifecycle Callbacks

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

Implement these callbacks to define the behavior of your task during its lifecycle. They are called at specific points during the behavior tree's execution.

```csharp
/// <summary>
/// Callback when the behavior tree is initialized.
/// </summary>
public virtual void OnAwake()

/// <summary>
/// Callback when the behavior tree is enabled.
/// </summary>
public virtual void OnEnable()

/// <summary>
/// Callback when the task is started.
/// </summary>
public virtual void OnStart()

/// <summary>
/// Executes the task logic. Returns a TaskStatus indicating how the behavior tree flow should proceed.
/// </summary>
/// <returns>The status of the task.</returns>
public virtual TaskStatus OnUpdate()

/// <summary>
/// Callback when the task stops.
/// </summary>
public virtual void OnEnd()

/// <summary>
/// Callback when the behavior tree is disabled.
/// </summary>
public virtual void OnDisable()

/// <summary>
/// Callback when the behavior tree is destroyed.
/// </summary>
public virtual void OnDestroy()
```

--------------------------------

### Physics Callbacks

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

Override these methods to receive physics-related callbacks within your task.

```APIDOC
## Physics Callbacks

### Description
Methods to override for receiving physics callbacks.

### Methods
- `ReceiveCollisionEnterCallback`
- `ReceiveCollisionExitCallback`
- `ReceiveCollisionEnter2DCallback`
- `ReceiveCollisionExit2DCallback`
- `ReceiveTriggerEnterCallback`
- `ReceiveTriggerExitCallback`
- `ReceiveTriggerEnter2DCallback`
- `ReceiveTriggerExit2DCallback`
- `ReceiveControllerColliderHitCallback`
- `ReceiveDrawGizmosCallback`
- `ReceiveDrawGizmosSelectedCallback`
```

--------------------------------

### Save

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Saves the behavior tree at the specified file path. This method allows persisting the current state of the behavior tree.

```APIDOC
## Save

### Description
Saves the behavior tree at the specified file path.

### Method
bool Save(string filePath, SaveManager.VariableSaveScope variableSaveScope)

### Parameters
#### Path Parameters
- **filePath** (string) - Required - The file path to save the behavior tree at. The file will be replaced if it already exists.
- **variableSaveScope** (SaveManager.VariableSaveScope) - Required - Specifies which variables should be saved. Graph variables will automatically be saved.

### Returns
True if the behavior tree was successfully saved.
```

--------------------------------

### Find Task by Type

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Finds the first task of a specified type within the behavior tree. Returns null if no task of the given type is found.

```csharp
T FindTask<T>() where T : Task

```

--------------------------------

### Save and Load Agent State

Source: https://opsive.com/support/documentation/behavior-designer-pro/save-load

Saves the agent's behavior tree data, position, and rotation to a JSON file. Loads the agent's state from a JSON file, restoring behavior tree and transform.

```csharp
/// <summary>
    /// Stores all of the agent save data in one structure.
    /// </summary>
    private struct AgentSaveData
    {
        public SaveData BehaviorTreeSaveData; // The behavior tree save data.
        public Vector3 Position; // The Transform position.
        public Quaternion Rotation; // The Transform rotation.
    }

    /// <summary>
    /// Save the agent state.
    /// </summary>
    public void Save()
    {
        var saveData = m_BehaviorTree.Save();
        if (!saveData.HasValue) {
            return;
        }

        // Create the data structure which contains all of the values that should be saved.
        var agentSaveData = new AgentSaveData() { BehaviorTreeSaveData = saveData.Value, Position = m_Transform.position, Rotation = m_Transform.rotation };
        
        if (File.Exists(m_SaveLocation)) {
            File.Delete(m_SaveLocation);
        }
        try {
            if (!Directory.Exists(Path.GetDirectoryName(m_SaveLocation))) {
                Directory.CreateDirectory(Path.GetDirectoryName(m_SaveLocation));
            }
            var fileStream = File.Create(m_SaveLocation);
            using (var streamWriter = new StreamWriter(fileStream)) {
                streamWriter.Write(JsonUtility.ToJson(agentSaveData));
            }
            fileStream.Close();
        } catch (System.Exception e) {
            Debug.LogException(e);
            return;
        }
    }

    /// <summary>
    /// Load the agent state.
    /// </summary>
    public void Load()
    {
        if (!File.Exists(m_SaveLocation)) {
            return;
        }

        AgentSaveData agentSaveData;
        var fileStream = File.Open(m_SaveLocation, FileMode.Open);
        using (var streamReader = new StreamReader(fileStream)) {
            var fileData = streamReader.ReadToEnd();
            agentSaveData = JsonUtility.FromJson<AgentSaveData>(fileData);
        }
        fileStream.Close();

        // Restore the values.
        m_BehaviorTree.Load(agentSaveData.BehaviorTreeSaveData);

        m_Transform.SetPositionAndRotation(agentSaveData.Position, agentSaveData.Rotation);
    }
```

--------------------------------

### Implement WithinDistanceTaskSystem

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/entity-task

The DOTS system responsible for executing the WithinDistance task logic.

```csharp
/// <summary>
/// Runs the WithinDistance logic.
/// </summary>
[DisableAutoCreation]
public partial struct WithinDistanceTaskSystem : ISystem
{
    private EntityQuery m_Query;

    /// <summary>
    /// Creates the required objects for use within the job system.
    /// </summary>
    /// <param name="state">The current SystemState.</param>
    [BurstCompile]
    private void OnCreate(ref SystemState state)
    {
        m_Query = new EntityQueryBuilder(Allocator.Temp)
        .WithAllRW<TaskComponent>()
        .WithAll<BranchComponent>()
        .WithAll<WithinDistanceComponent, WithinDistanceFlag, EvaluateFlag>()
        .Build(ref state);
    }

    /// <summary>
    /// Updates the job.
    /// </summary>
    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    private void OnUpdate(ref SystemState state)
    {
        state.Dependency = new WithinDistanceJob().ScheduleParallel(m_Query, state.Dependency);
    }
}
```

--------------------------------

### Save/Load API

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

Methods related to the save/load system for tasks, allowing persistence of task state.

```APIDOC
## Save/Load API

### Description
API for managing the save and load state of tasks.

### Methods
- `GetSaveReflectionType(int index)`: Specifies the type of reflection used for saving.
- `Save(World world, Entity entity)`: Returns the current task state.
- `Load(object saveData, World world, Entity entity)`: Loads the previous task state.
```

--------------------------------

### Save Behavior Tree

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Saves the current state of the behavior tree to a specified file path. It can also control which variables are saved.

```csharp
bool Save(string filePath, SaveManager.VariableSaveScope variableSaveScope)

```

--------------------------------

### Save/Load System Integration

Source: https://opsive.com/support/documentation/behavior-designer-pro/new-tasks/gameobject-task

These methods are part of Behavior Designer's save/load system, allowing tasks to specify which objects should persist. Use GetSaveReflectionType to define reflection types and Save/Load to manage task state.

```csharp
/// <summary>
/// Specifies the type of reflection that should be used to save the task.
/// </summary>
/// <param name="index">The index of the sub-task. This is used for the task set allowing each contained task to have their own save type.</param>
public virtual MemberVisibility GetSaveReflectionType(int index)

/// <summary>
/// Returns the current task state.
/// </summary>
/// <param name="world">The DOTS world.</param>
/// <param name="entity">The DOTS entity.</param>
/// <returns>The current task state.</returns>
public virtual object Save(World world, Entity entity)

/// <summary>
/// Loads the previous task state.
/// </summary>
/// <param name="saveData">The previous task state.</param>
/// <param name="world">The DOTS world.</param>
/// <param name="entity">The DOTS entity.</param>
public virtual void Load(object saveData, World world, Entity entity)
```

--------------------------------

### EntitySpawner Baker

Source: https://opsive.com/support/documentation/behavior-designer-pro/entity-baking

The Baker for the EntitySpawner MonoBehaviour. It bakes the spawn data, creating an entity prefab from the assigned GameObject.

```csharp
public class EntitySpawner : MonoBehaviour
{
    [Tooltip("A reference to the behavior tree prefab.")]
    [SerializeField] protected GameObject m_SpawnPrefab;

    /// <summary>
    /// Bakes the spawn data.
    /// </summary>
    private class Baker : Baker<EntitySpawner>
    {
        /// <summary>
        /// Bakes the data.
        /// </summary>
        /// <param name="authoring">The parent authoring component.</param>
        public override void Bake(EntitySpawner authoring)
        {
            if (authoring.m_SpawnPrefab == null) {
                return;
            }
            var entity = GetEntity(TransformUsageFlags.Dynamic);
            var entityPrefab = GetEntity(authoring.m_SpawnPrefab, TransformUsageFlags.Dynamic);
            AddComponentObject(entity, new SpawnData
            {
                Prefab = entityPrefab,
            });
        }
    }
}
```

--------------------------------

### Create Space Attribute Control

Source: https://opsive.com/support/documentation/behavior-designer-pro/extending-the-editor/control-types

Implement a custom UI control for the [Space] attribute. This control sets the height of a VisualElement based on the attribute's height property.

```csharp
using Opsive.Shared.Editor.UIElements.Controls.Attributes;
using System.Reflection;
using UnityEngine.UIElements;

[ControlType(typeof(UnityEngine.SpaceAttribute))]
public class SpaceAttributeControl : AttributeControlBase
{
    /// <summary>
    /// Does the attribute override the type control?
    /// </summary>
    public override bool OverrideTypeControl { get { return false; } }

    /// <summary>
    /// Does the control use a label?
    /// </summary>
    public override bool UseLabel { get { return false; } }

    /// <summary>
    /// Returns the attribute control that should be used for the specified AttributeControlType.
    /// </summary>
    /// <param name="input">The input to the control.</param>
    /// <returns>The created control.</returns>
    protected override VisualElement GetControl(AttributeControlInput input)
    {
        var spaceAttribute = input.Field.GetCustomAttribute<UnityEngine.SpaceAttribute>();
        if (spaceAttribute == null) {
            return null;
        }

        var visualElement = new VisualElement();
        visualElement.style.height = spaceAttribute.height;
        return visualElement;
    }
}
```

--------------------------------

### Unity 6.3.0-6.3.4 TypeLoadException

Source: https://opsive.com/support/documentation/behavior-designer-pro/getting-started/import-errors

A TypeLoadException occurring in Unity versions 6.3.0 to 6.3.4 when opening the Behavior Designer Pro editor. This is due to changes in assembly references for UnityEngine.IMGUIModule.

```csharp
TypeLoadException: Could not resolve type with token 010000d3 from typeref (expected class 'UnityEngine.EventModifiers' in assembly 'UnityEngine.IMGUIModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null')
Opsive.GraphDesigner.Editor.Views.GraphView.OnGeometryChanged (UnityEngine.UIElements.GeometryChangedEvent c) (at <bd9cf0b0ba5a4f9a855802b1ee8dd9d0>:0)
UnityEngine.UIElements.EventCallbackFunctor`1[TEventType].Invoke (UnityEngine.UIElements.EventBase evt) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.EventCallbackRegistry+DynamicCallbackList.Invoke (UnityEngine.UIElements.EventBase evt, UnityEngine.UIElements.BaseVisualElementPanel panel, UnityEngine.UIElements.VisualElement target) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.EventDispatchUtilities.HandleEvent_BubbleUpCallbacks (UnityEngine.UIElements.EventBase evt, UnityEngine.UIElements.BaseVisualElementPanel panel, UnityEngine.UIElements.VisualElement element) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.EventDispatchUtilities.HandleEventAtTargetAndDefaultPhase (UnityEngine.UIElements.EventBase evt, UnityEngine.UIElements.BaseVisualElementPanel panel, UnityEngine.UIElements.VisualElement target) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.EventDispatchUtilities.SendEventDirectlyToTarget (UnityEngine.UIElements.EventBase evt, UnityEngine.UIElements.BaseVisualElementPanel panel, UnityEngine.UIElements.VisualElement target) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.VisualTreeLayoutUpdater.DispatchChangeEvents (System.Collections.Generic.List`1[T] changeEvents, System.Int32 currentLayoutPass) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.VisualTreeLayoutUpdater.Update () (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.VisualTreeUpdater.UpdateVisualTreePhase (UnityEngine.UIElements.VisualTreeUpdatePhase phase) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.Panel.UpdateForRepaint () (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEditor.UIElements.EditorPanel.UpdateForRepaint () (at <9a6866749bf64829b050cb97017b2ca9>:0)
UnityEngine.UIElements.Panel.Repaint (UnityEngine.Event e) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.UIElementsUtility.DoDispatch (UnityEngine.UIElements.BaseVisualElementPanel panel) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.UIElementsUtility.UnityEngine.UIElements.IUIElementsUtility.ProcessEvent (System.Int32 instanceID, System.IntPtr nativeEventPtr, System.Boolean& eventHandled) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.UIEventRegistration.ProcessEvent (System.Int32 instanceID, System.IntPtr nativeEventPtr) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.UIElements.UIEventRegistration+<>c.<.cctor>b__1_2 (System.Int32 i, System.IntPtr ptr) (at <0bcb90c459a2413a94634a44aeb1d754>:0)
UnityEngine.GUIUtility.ProcessEvent (System.Int32 instanceID, System.IntPtr nativeEventPtr, System.Boolean& result) (at <b589a158f82a4d0383d140f349b608e5>:0)
```

--------------------------------

### FindTasks<T> (Array)

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Finds the tasks with the specified type using a pre-initialized array. This method is optimized to avoid allocations.

```APIDOC
## FindTasks<T> (Array)

### Description
Finds the tasks with the specified type. This method does not have any allocations.

### Method
int FindTasks<T>(T[] foundTasks) where T : Task

### Parameters
#### Path Parameters
- **foundTasks** (T[]) - Required - A pre-initialized array that will contain the found tasks.

### Returns
The number of tasks found with the specified type.
```

--------------------------------

### FindTasks<T> (Return Array)

Source: https://opsive.com/support/documentation/behavior-designer-pro/api

Finds the tasks with the specified type and returns them as an array. This method searches for all tasks of a given type.

```APIDOC
## FindTasks<T> (Return Array)

### Description
Finds the tasks with the specified type.

### Method
T[] FindTasks<T>() where T : Task

### Returns
An array containing the found tasks.
```

--------------------------------

### Send Event via Code

Source: https://opsive.com/support/documentation/behavior-designer-pro/events

Use EventHandler.ExecuteEvent to send an event to a specific component. The template type must be a valid object type if the event carries parameters.

```csharp
using Opsive.Shared.Events;

var behaviorTree = GetComponent<BehaviorTree>();
EventHandler.ExecuteEvent<object>(behaviorTree , "MyEvent", 5);
```
Tokens:
Raw