Behavior Designer

https://opsive.com/support/documentation/behavior-designer
Admin
Behavior Designer is a visual behavior tree implementation tool for Unity that enables programmers,...
Tokens:36,134
Snippets:430
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Legacy Behavior Designer Task Example

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

A sample task implementation using the version 1 Behavior Designer API.

```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 = "";
        }
    }
}
```

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

### Implement TargetPosition for Line Formation

Source: https://opsive.com/support/documentation/behavior-designer-formations-pack/new-formation-task

Example implementation of TargetPosition to arrange agents in a line with two-unit spacing.

```csharp
protected override Vector3 TargetPosition(int index, float zLookAhead)
{
   return transforms[0].TransformPoint(index * 2, 0, zLookAhead);
}
```

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

### Updated Behavior Designer Pro Task Example

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

The migrated version of the task, updated to use the Opsive Graph Designer and Behavior Designer Pro namespaces and generic shared variables.

```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 = "";
        }
    }
}
```

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

### Implement a custom class Shared Variable

Source: https://opsive.com/support/documentation/behavior-designer/variables/creating-shared-variables

Example showing how to define a custom serializable class and its corresponding Shared Variable wrapper.

```csharp
    [System.Serializable]
    public class CustomClass
    {
        public int myInt;
        public Object myObject;
    }

    [System.Serializable]
    public class SharedCustomClass : SharedVariable<CustomClass>
    {
        public static implicit operator SharedCustomClass(CustomClass value) { return new SharedCustomClass { Value = value }; }
    }
```

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

### Iterator Task Output Example

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

Example output generated by the Log Value task when used with an Iterator.

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

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

### Conditional Baked Behavior Tree Start

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

Prevent behavior tree systems from starting on clients by checking server authority before calling StartBakedBehaviorTree.

```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);
        }
    }
}
```

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

### Define a Basic Action Task

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

Initial implementation of an Action task that calculates a random destination using SharedVariables upon task start.

```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);
    }
}
```

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

### Log Task Changes Output

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

Example of the console output generated when Log Task Changes is enabled.

```csharp
GameObject - Behavior: Push task Sequence (index 0) at stack index 0
GameObject - Behavior: Push task Wait (index 1) at stack index 0
GameObject - Behavior: Pop task Wait (index 1) at stack index 0 with status Success
GameObject - Behavior: Push task Wait (index 2) at stack index 0
GameObject - Behavior: Pop task Wait (index 2) at stack index 0 with status Success
GameObject - Behavior: Pop task Sequence (index 0) at stack index 0 with status Success
Disabling GameObject - Behavior
```

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

### Control Behavior Tree Execution

Source: https://opsive.com/support/documentation/behavior-designer/behavior-tree-component

Methods to start or stop the behavior tree, with an optional pause parameter for the disable function.

```csharp
public void EnableBehavior();
// pause:  temporarily stop the behavior tree at its current execution point. It can be resumed with EnableBehavior.
public void DisableBehavior(bool pause = false);
```

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

### Instantiate and Enable Baked Behavior Trees

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

System implementation to instantiate entities from baked data and initialize the 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);
    }
}
```

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

### Pooling External Behavior Trees

Source: https://opsive.com/support/documentation/behavior-designer/external-behavior-trees

Demonstrates how to instantiate and initialize a pool of external behavior trees for reuse, and how to assign them to a behavior tree component at runtime.

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

public class ExternalPoolExample : MonoBehaviour {
    public BehaviorTree behaviorTree;
    public ExternalBehavior externalBehaviorTree;

    private ExternalBehavior[] externalPool;
    private int index;

    public void Awake()
    {
        // Instantiate five External Behavior Tree which will be reused. The Init method will deserialize the External Behavior Tree.
        externalPool = new ExternalBehavior[5];
        for (int i = 0; i < externalPool.Length; ++i) {
            externalPool[i] = Object.Instantiate(externalBehaviorTree);
            externalPool[i].Init();
        }
    }

    public void OnGUI()
    {
        // Assign the next External Behavior Tree within the simplified pool.
        if (GUILayout.Button("Assign")) {
            behaviorTree.DisableBehavior();
            behaviorTree.ExternalBehavior = externalPool[index];
            behaviorTree.EnableBehavior();
            index = (index + 1) % externalPool.Length;
        }
    }
}
```

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

### Save and Load a Single Behavior Tree

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

Demonstrates saving and loading a single behavior tree instance to a specified file path.

```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);
    }
}
```

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

### Implement OnAwake Caching

Source: https://opsive.com/support/documentation/behavior-designer/writing-a-new-conditional-task

Cache target transforms during the task initialization phase.

```csharp
   public override void OnAwake()
   {
      var targets = GameObject.FindGameObjectsWithTag(targetTag);
      possibleTargets = new Transform[targets.Length];
      for (int i = 0; i < targets.Length; ++i) {
         possibleTargets[i] = targets[i].transform;
      }
   }
```

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

### Accessing Variables within a Task

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

Use the Value property of a SharedVariable to get or set values inside a custom task.

```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");
        }
```

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

### Define Help URL

Source: https://opsive.com/support/documentation/behavior-designer/task-attributes

Associates a help webpage with a task, accessible via the doc icon in the task inspector.

```csharp
[HelpURL("http://www.example.com")]
public class MyTask : Action
{
```

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

### Save and Load Agent State in C#

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

Demonstrates how to bundle behavior tree data with transform properties into a custom structure for JSON serialization.

```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);
    }
```

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

### Enable BehaviorTree on Server

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

Use this script to conditionally enable the behavior tree component based on whether the current instance is the server.

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

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

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

### Implement an Attribute-based Object Drawer

Source: https://opsive.com/support/documentation/behavior-designer/object-drawers

Create the drawer logic for the custom attribute. This script must be placed within an Editor folder.

```csharp
using UnityEngine;
using UnityEditor;
using BehaviorDesigner.Editor;

[CustomObjectDrawer(typeof(RangeAttribute))]
public class RangeDrawer : ObjectDrawer
{
   public override void OnGUI(GUIContent label)
   {
      var rangeAttribute = (RangeAttribute)attribute;
      value = EditorGUILayout.Slider(label, (float)value, rangeAttribute.min, rangeAttribute.max);
   }
}
```

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

### Create and Assign Behavior Tree via Script

Source: https://opsive.com/support/documentation/behavior-designer/behavior-tree-component/create-a-behavior-tree-from-script

Instantiates a BehaviorTree component at runtime and assigns an external behavior tree reference. StartWhenEnabled is set to false to prevent immediate execution.

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

public class CreateTree : MonoBehaviour
{
    public ExternalBehaviorTree behaviorTree;

    private void Start()
    {
        var bt = gameObject.AddComponent<BehaviorTree>();
        bt.StartWhenEnabled = false;
        bt.ExternalBehavior = behaviorTree;
    }
}
```

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

### Implement a Custom Formation

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

Create a new formation type by inheriting from FormationsBase and implementing the CalculateFormationPosition method.

```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;
    }
}
```

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

### Implement task state persistence

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

Use these methods to define how task data is saved and loaded within the Behavior Designer system.

```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)
```

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

### Implement Movement Logic in OnUpdate

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

Extends the Action task to include movement logic and task status reporting during the update loop.

```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;
    }
}
```

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

### Implement OnUpdate Method

Source: https://opsive.com/support/documentation/behavior-designer/writing-a-new-action-task

Logic for checking target proximity and updating object position during the task execution.

```csharp
   public override TaskStatus OnUpdate()
   {
      if (Vector3.SqrMagnitude(transform.position - target.Value.position) < 0.1f) {
         return TaskStatus.Success;
      }
      transform.position = Vector3.MoveTowards(transform.position, target.Value.position, speed * Time.deltaTime);
      return TaskStatus.Running;
   }
```

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

### Complete MoveTowards Task

Source: https://opsive.com/support/documentation/behavior-designer/writing-a-new-action-task

The full implementation of the MoveTowards action task including variables and logic.

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

public class MoveTowards : Action
{
   // The speed of the object
   public float speed = 0;
   // The transform that the object is moving towards
   public SharedTransform target;

   public override TaskStatus OnUpdate()
   {
      // Return a task status of success once we've reached the target
      if (Vector3.SqrMagnitude(transform.position - target.Value.position) < 0.1f) {
         return TaskStatus.Success;
      }
      // We haven't reached the target yet so keep moving towards it
      transform.position = Vector3.MoveTowards(transform.position, target.Value.position, speed * Time.deltaTime);
      return TaskStatus.Running;
   }
}
```

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

### Save and Load Multiple Behavior Trees with Save Manager

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

Uses the Save Manager to handle saving and loading an array of behavior trees to a single file.

```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);
    }
}
```

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

### Implement a Dynamic Subtree Reference Task

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

Inherit from SubtreeReference to dynamically select subtrees at runtime. Override EvaluateSubtrees to define selection logic and the Subtrees property to return the 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)] };
    }
}
```

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

### Implement IDamageable Interface

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

Defines the required properties and methods for any object capable of receiving damage.

```csharp
public interface IDamageable
{
	bool IsAlive { get; }  // Whether the object is currently alive
	void Damage(float amount);  // Take damage by the specified amount
}
```

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

### Subscribe to Behavior Events

Source: https://opsive.com/support/documentation/behavior-designer/behavior-tree-component

Events available for monitoring the lifecycle of the behavior tree.

```csharp
OnBehaviorStart
OnBehaviorRestart
OnBehaviorEnd
```

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

### Define a C# script for property binding

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

Create a script with a public property that includes both a getter and a setter to enable binding within Behavior Designer.

```csharp
public class Health : MonoBehaviour
{
    [Tooltip("The starting health value")]
    [SerializeField] protected float m_StartHealth = 100;

    private float m_HealthAmount;

    public float HealthAmount { get => m_HealthAmount; set => m_HealthAmount = value; }
}
```

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

### Create a Custom Object Drawer for a Class

Source: https://opsive.com/support/documentation/behavior-designer/object-drawers

Define a custom inspector layout for a specific class type by overriding the OnGUI method. This script must be placed within an Editor folder.

```csharp
using UnityEngine;
using UnityEditor;
using BehaviorDesigner.Editor;

[CustomObjectDrawer(typeof(CustomClass))]
public class CustomClassDrawer : ObjectDrawer
{
   public override void OnGUI(GUIContent label)
   {
      var customClass = value as CustomClass;
      EditorGUILayout.BeginVertical();
      if (FieldInspector.DrawFoldout(customClass.GetHashCode(), label)) {
         EditorGUI.indentLevel++;
         customClass.myInt = EditorGUILayout.IntSlider("Integer", customClass.myInt, 0, 10);
         customClass.myObject = EditorGUILayout.ObjectField("Object", customClass.myObject, typeof(UnityEngine.Object), true);
         EditorGUI.indentLevel--;
      }
      EditorGUILayout.EndVertical();
   }
}
```

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

### Log Message Format

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

The structural template for interpreting task change log messages.

```csharp
{game object name } - {behavior name}: {task change} {task type} (index {task index}) at stack index {stack index} {optional status}
```

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

### Implement OnUpdate Logic

Source: https://opsive.com/support/documentation/behavior-designer/writing-a-new-conditional-task

Check targets against the field of view and return task status.

```csharp
   public override TaskStatus OnUpdate()
   {
      for (int i = 0; i < possibleTargets.Length; ++i) {
         if (WithinSight(possibleTargets[i], fieldOfViewAngle)) {
            target.Value = possibleTargets[i];
            return TaskStatus.Success;
         }
      }
      return TaskStatus.Failure;
   }
```

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

### Define Action Task Class

Source: https://opsive.com/support/documentation/behavior-designer/writing-a-new-action-task

Initial class definition inheriting from the Action base class.

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

public class MoveTowards : Action
{
}
```

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

### Define a Task with an Array of Task References

Source: https://opsive.com/support/documentation/behavior-designer/referencing-tasks

Use an array to reference multiple tasks of the same type.

```csharp
public class TaskA : Action
{
   public TaskB[] referencedTasks;
}
```

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

### Implement IAttackAgent Interface

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

Defines the required properties and methods for any agent capable of performing attacks.

```csharp
public interface IAttackAgent
{
	// Properties
	float MinAttackDistance { get; }    // Minimum distance required to attack
	float MaxAttackDistance { get; }    // Maximum distance the agent can attack from
	float AttackAngleThreshold { get; } // Maximum angle from target to agent for attack

	// Methods
	void RotateTowards(Vector3 direction);  // Rotate agent towards specified direction
	void Attack(Transform targetTransform, IDamageable targetDamageable); // Perform attack
}
```

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

### Implement Custom Save and Load for Action Tasks

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

Use these overrides to manually manage task state persistence when MemberVisibility.None is returned. Ensure the Unity.Entities namespace is included for access to World and Entity types.

```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;
    }
```

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

### Task Lifecycle and Properties

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

The Task class provides several methods for lifecycle management and properties for task configuration.

```APIDOC
## Task API

### Description
The Task class provides a set of methods and properties that allow developers to define custom behavior tree tasks. These methods mirror the lifecycle of Unity's MonoBehaviour.

### Methods
- **OnAwake()**: Called once when the behavior tree is enabled.
- **OnStart()**: Called immediately before execution to setup variables.
- **OnUpdate()**: Runs the actual task logic; returns a TaskStatus.
- **OnFixedUpdate()**: Executes during the FixedUpdate loop.
- **OnEnd()**: Called after execution on success or failure.
- **OnPause(bool paused)**: Called when the behavior is paused or resumed.
- **GetPriority()**: Returns the priority of the task for the Priority Selector.
- **GetUtility()**: Returns the utility of the task for the Utility Selector.
- **OnBehaviorComplete()**: Called after the behavior tree finishes executing.
- **OnReset()**: Called by the inspector to reset public properties.
- **OnDrawGizmos()**: Allows OnDrawGizmos to be called from the tasks.

### Properties
- **Owner**: Reference to the behavior that owns this task.
- **name**: The name of the task.
- **comment**: A comment associated with the task.
- **instant**: If true, the task moves to the next task within the same update tick upon completion; if false, it waits one update tick.
```

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

### Bake Spawn Data for Entity Spawner

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

Defines a component and a Baker to convert a GameObject prefab reference into an ECS entity reference.

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

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,
            });
        }
    }
}
```

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

### IDamagable Interface Methods

Source: https://opsive.com/support/documentation/behavior-designer-tactical-pack/interfaces

Required methods for implementing the IDamagable interface to handle damage and health state.

```csharp
// Take damage by the specified amount.
void Damage(float amout);

// Is the object currently alive?
bool IsAlive();
```

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

### Implement a Custom Action Task in C#

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

Defines a custom Action task that moves an agent to a random point, demonstrating variable usage, lifecycle overrides, and state serialization.

```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")]
[Description("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;
    }
}
```

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

### Retrieving All Variables

Source: https://opsive.com/support/documentation/behavior-designer/variables/accessing-variables-from-non-task-objects

Retrieve a collection of all variables defined in the BehaviorTree.

```csharp
var variables = BehaviorTree.GetAllVariables();
```

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

### Declare Task Variables

Source: https://opsive.com/support/documentation/behavior-designer/writing-a-new-conditional-task

Define public variables for configuration and private variables for internal caching.

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

public class WithinSight : Conditional
{
   public float fieldOfViewAngle;
   public string targetTag;
   public SharedTransform target;

   private Transform[] possibleTargets;
}
```

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

### Manually Tick Behavior Trees

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

Use these methods to trigger behavior tree execution when the update interval is set to Manual.

```csharp
BehaviorManager.instance.Tick();
```

```csharp
BehaviorManager.instance.Tick(BehaviorTree)
```

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

### Implement Manual Entity Task Structure

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

Defines the required ITreeLogicNode, IAuthoringTask, and IReevaluateResponder interfaces for a custom entity task.

```csharp
public struct WithinDistance : ITreeLogicNode, IAuthoringTask, IConditional, IReevaluateResponder
{
    // Required ITreeLogicNode parameters.
    [Tooltip("The index of the node.")]
    [SerializeField] ushort m_Index;
    [Tooltip("The parent index of the node. ushort.MaxValue indicates no parent.")]
    [SerializeField] ushort m_ParentIndex;
    [Tooltip("The sibling index of the node. ushort.MaxValue indicates no sibling.")]
    [SerializeField] ushort m_SiblingIndex;

    // Required ITreeLogicNode properties.
    public ushort Index { get => m_Index; set => m_Index = value; }
    public ushort ParentIndex { get => m_ParentIndex; set => m_ParentIndex = value; }
    public ushort SiblingIndex { get => m_SiblingIndex; set => m_SiblingIndex = value; }
    public ushort RuntimeIndex { get; set; }

    // Required IAuthoringTask properties.
    public ComponentType Flag { get => typeof(WithinDistanceFlag); }
    public System.Type SystemType { get => typeof(WithinDistanceTaskSystem); }

    // Required IReevaluateResponder properties.
    public ComponentType ReevaluateFlag { get => typeof(WithinDistanceReevaluateFlag); }
    public System.Type ReevaluateSystemType { get => typeof(WithinDistanceReevaluateTaskSystem); }

    /// <summary>
    /// Adds the IBufferElementData to the entity.
    /// </summary>
    /// <param name="world">The world that the entity exists.</param>
    /// <param name="entity">The entity that the IBufferElementData should be assigned to.</param>
    /// <param name="gameObject">The GameObject that the entity is attached to.</param>
    /// <returns>The index of the element within the buffer.</returns>
    public intAddBufferElement(World world, Entity entity)
    {
        DynamicBuffer<WithinDistanceComponent> buffer;
        if (world.EntityManager.HasBuffer<WithinDistanceComponent>(entity)) {
            buffer = world.EntityManager.GetBuffer<WithinDistanceComponent>(entity);
        } else {
            buffer = world.EntityManager.AddBuffer<WithinDistanceComponent>(entity);
        }

        buffer.Add(new WithinDistanceComponent()
        {
            Index = RuntimeIndex,
        });
        return buffer.Length - 1;
    }

    /// <summary>
    /// Clears the IBufferElementData from the entity.
    /// </summary>
    /// <param name="world">The world that the entity exists.</param>
    /// <param name="entity">The entity that the IBufferElementData should be cleared from.</param>
    public void ClearBufferElement(World world, Entity entity)
    {
        DynamicBuffer<WithinDistanceComponent> buffer;
        if (world.EntityManager.HasBuffer<WithinDistanceComponent>(entity)) {
            buffer = world.EntityManager.GetBuffer<WithinDistanceComponent>(entity);
            buffer.Clear();
        }
    }
}
```

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

### Accessing Global Variables

Source: https://opsive.com/support/documentation/behavior-designer/variables/accessing-variables-from-non-task-objects

Interact with global variables using the GlobalVariables.Instance singleton.

```csharp
GlobalVariables.Instance.GetVariable("MyVariable");
GlobalVariables.Instance.SetVariable("MyVariable", value);
```

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

### IAttackAgent Interface Methods

Source: https://opsive.com/support/documentation/behavior-designer-tactical-pack/interfaces

Required methods for implementing the IAttackAgent interface to define agent attack capabilities.

```csharp
// Returns the furthest distance that the agent is able to attack from.
float AttackDistance();

// Can the agent attack?
bool CanAttack();

// Returns the maximum angle that the agent can attack from.
float AttackAngle();

// Does the actual attack.
void Attack(Vector3 targetPosition);
```

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

### Implement GameObject-based task lifecycle callbacks

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

Override these virtual methods to define task behavior during the lifecycle of the behavior tree.

```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()
```

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

### Behavior Tree Component API Methods

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

Methods for controlling the execution state, task retrieval, and persistence of the behavior tree.

```csharp
/// <summary>
/// Starts the behavior tree.
/// </summary>
/// <returns>True if the behavior tree was started.</returns>
bool StartBehavior()

 /// <summary>
/// Stars the branch with the specified event task type.
/// </summary>
/// <param name="eventTaskType">The branch that should be started.</param>
/// <returns>True if the branch was started.</returns>
bool StartBranch(Type eventTaskType)

 /// <summary>
/// Starts the branch with the specified event task.
/// </summary>
/// <param name="eventTask">The branch that should be started.</param>
/// <returns>True if the branch was started.</returns>
bool StartBranch(IEventNode eventTask)

 /// <summary>
/// Returns the task at the specified index.
/// </summary>
/// <param name="index">The index of the task.</param>
/// <returns>The task at the specified index.</returns>
ILogicNode GetTask(int index)

 /// <summary>
/// Finds the task with the specified type.
/// </summary>
/// <returns>The first task found with the specified type (can be null).</returns>
T FindTask<T>() where T : Task

/// <summary>
/// Finds the tasks with the specified type. This method does not have any allocations.
/// </summary>
/// <param name="foundTasks">A pre-initialized array that will contain the found tasks.</param>
/// <returns>The number of tasks found with the specified type.</returns>
int FindTasks<T>(T[] foundTasks) where T : Task

 /// <summary>
/// Finds the tasks with the specified type.
/// </summary>
/// <returns>An array containing the found tasks.</returns>
T[] FindTasks<T>() where T : Task
 /// <summary>
/// Ticks the behavior tree. The UpdateMode must be set to Manual.
/// </summary>
void Tick()

 /// <summary>
/// Reevaluates the SubtreeReferences by calling the EvaluateSubtrees method.
/// </summary>
void ReevaluateSubtreeReferences()

 /// <summary>
/// Stops or pauses the behavior tree.
/// </summary>
/// <param name="pause">Should the behavior tree be paused?</param>
/// <returns>True if the behavior tree was stopped or paused.</returns>
bool StopBehavior(bool pause = false)

 /// <summary>
/// Restarts the behavior tree.
/// </summary>
/// <returns>True if the behavior tree was restarted.</returns>
bool RestartBehavior()

 /// <summary>
/// Returns the SharedVariable with the specified name and scope.
/// </summary>
/// <param name="name">The name of the SharedVariable that should be retrieved.</param>
/// <param name="scope">The scope of the SharedVariable that should be retrieved.</param>
/// <returns>The SharedVariable with the specified name (can be null).</returns>
SharedVariable GetVariable(string name, SharedVariable.SharingScope scope)

 /// <summary>
/// Saves the behavior tree at the specified file path.
/// </summary>
/// <param name="filePath">The file path to save the behavior tree at. The file will be replaced if it already exists.</param>
/// <param name="variableSaveScope">Specifies which variables should be saved. Graph variables will automatically be saved.</param>
/// <returns>True if the behavior tree was successfully saved.</returns>
bool Save(string filePath, SaveManager.VariableSaveScope variableSaveScope)

 /// <summary>
/// Loads the behavior tree from the specified file path.
/// </summary>
/// <param name="filePath">The file path to load the behavior tree at.</param>
/// <returns>True if the behavior tree was successfully loaded.</returns>
bool Load(string filePath)
```

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

### Add Node Metadata Attributes

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

Applies NodeIcon and Description attributes to the class for better visualization within the Behavior Designer editor.

```csharp
using Opsive.GraphDesigner.Runtime;

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