NodeCanvas

https://nodecanvas.paradoxnotion.com/documentation
Admin
NodeCanvas is a visual scripting framework for Unity that provides tools for creating advanced AI,...
Tokens:26,736
Snippets:369
Trust Score:7.2
Update:4 months ago
Show doc for...
Tokens:
Raw
### Create a Simple Behaviour Tree in Code

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-a-behaviour-in-code

This example demonstrates creating a basic Behaviour Tree with a Sequencer root and two Wait actions. It shows how to instantiate the BehaviourTree, add nodes, assign tasks, and start the graph execution.

```csharp
using UnityEngine;
using NodeCanvas.Framework;
using NodeCanvas.BehaviourTrees;
using NodeCanvas.Tasks.Actions;

public class Example : MonoBehaviour {
    void Awake() {
        //Create the Behaviour Tree
        var bt = ScriptableObject.CreateInstance<BehaviourTree>();

        //Sequencer root
        var sequencer = bt.AddNode<Sequencer>();

        //First ActionNode
        var action1 = sequencer.AddChild<ActionNode>();
        action1.task = Task.Create<Wait>(bt);

        //Second ActionNode
        var action2 = sequencer.AddChild<ActionNode>();
        action2.task = Task.Create<Wait>(bt);

        //Start the behaviour tree with a target agent (this in this case),
        //and an optional parent blackboard (null in this case, so only the local graph blackboard is used.
        //Update mode determines when the graph updates (can be Manual).
        bt.StartGraph(this, null, Graph.UpdateMode.NormalUpdate);
    }
}
```

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

### Assign Blackboard to Runtime BehaviourTreeOwner

Source: https://nodecanvas.paradoxnotion.com/documentation?section=runtime-instantiation-tips

This example shows how to assign a Blackboard to a BehaviourTreeOwner that is added at runtime. This is useful when you need a specific blackboard for your agents.

```csharp
using UnityEngine;
using NodeCanvas.Framework;
using NodeCanvas.BehaviourTrees;

public class Example : MonoBehaviour {
    public int count;
    public BehaviourTree bt;
    public Blackboard blackboard;

    void Start(){
        for (int i = 0; i < count; i++){
            var agent = new GameObject("Agent").AddComponent<BehaviourTreeOwner>();
            agent.blackboard = blackboard;
            agent.StartBehaviour(bt);
        }
    }
}
```

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

### Start Dialogue from MonoBehaviour

Source: https://nodecanvas.paradoxnotion.com/documentation?section=dialogue-trees

Initiates a dialogue tree when the space key is pressed. Requires a reference to a DialogueTreeController.

```csharp
using UnityEngine;
using NodeCanvas.DialogueTrees;

public class Example : MonoBehaviour {
    public DialogueTreeController dialogue;

    void Update() {
        if (Input.GetKeyDown(KeyCode.Space)) {
            dialogue.StartDialogue();
        }
    }
}
```

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

### Implemented Action Example

Source: https://nodecanvas.paradoxnotion.com/documentation?section=the-script-control-tasks

Forwards task execution to a script function. The function must return a Status and can take zero or one parameter.

```csharp
using NodeCanvas.Framework;
public class Example : MonoBehaviour {
    public Status SomeAction(string text) {
        Debug.Log(text);
        return Status.Success;
    }
}
```

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

### StartDialogue Methods

Source: https://nodecanvas.paradoxnotion.com/documentation?section=dialogue-trees

The DialogueTreeController provides several methods to start a dialogue tree, allowing for customization with default actors and completion callbacks.

```APIDOC
## StartDialogue Methods

### Description
These methods initiate a dialogue tree. You can start a dialogue with no default actor, with a specified default actor, with a callback for when the dialogue finishes, or with both a default actor and a callback.

### Methods

1.  **StartDialogue()**
    *   **Description**: Starts the DialogueTree without a default actor.
    *   **Signature**: `public void StartDialogue();`

2.  **StartDialogue(IDialogueActor defaultActor)**
    *   **Description**: Starts the DialogueTree with a provided default actor.
    *   **Parameters**:
        *   `defaultActor` (IDialogueActor) - The default actor to use for the dialogue.
    *   **Signature**: `public void StartDialogue(IDialogueActor defaultActor);`

3.  **StartDialogue(Action<bool> callback)**
    *   **Description**: Starts the DialogueTree with a callback that is invoked when the dialogue finishes.
    *   **Parameters**:
        *   `callback` (Action<bool>) - A callback function that receives a boolean indicating if the dialogue finished successfully.
    *   **Signature**: `public void StartDialogue(Action<bool> callback);`

4.  **StartDialogue(IDialogueActor defaultActor, Action<bool> callback)**
    *   **Description**: Starts the DialogueTree with a provided default actor and a callback for when the dialogue finishes.
    *   **Parameters**:
        *   `defaultActor` (IDialogueActor) - The default actor to use for the dialogue.
        *   `callback` (Action<bool>) - A callback function that receives a boolean indicating if the dialogue finished successfully.
    *   **Signature**: `public void StartDialogue(IDialogueActor defaultActor, Action<bool> callback);`
```

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

### Simple Condition Task Example

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-tasks

A basic Condition Task that always returns true. This serves as a minimal example for creating a Condition Task.

```csharp
using UnityEngine;
using NodeCanvas.Framework;

public class EmptyCondition : ConditionTask
{
    protected override bool OnCheck()
    {
        return true;
    }
}
```

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

### DialogueTreeController StartDialogue Overloads

Source: https://nodecanvas.paradoxnotion.com/documentation?section=dialogue-trees

Demonstrates various ways to start a dialogue tree using the DialogueTreeController. These methods allow for specifying a default actor and a callback function.

```csharp
///Start the DialogueTree without a default actor
public void StartDialogue();

///Start the DialogueTree with provided default actor
public void StartDialogue(IDialogueActor defaultActor)

///Start the DialogueTree with a callback for when it's finished
public void StartDialogue(Action<bool> callback)

///Start the DialogueTree with provided default actor and provided callback for when dialogue is finished
public void StartDialogue(IDialogueActor defaultActor, Action<bool> callback)
```

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

### Instantiate Behaviour Tree Asset Directly

Source: https://nodecanvas.paradoxnotion.com/documentation?section=runtime-instantiation-tips

Use this when you have a BehaviourTree asset and want to start it without a BehaviourTreeOwner. The StartGraph method takes the agent, an optional parent blackboard, and the update mode.

```csharp
public class Example : MonoBehaviour{
    public BehaviourTree bt; //the BT asset reference
    void Start() {
        bt = Instantiate<BehaviourTree>(bt);
        bt.StartGraph(this, null, Graph.UpdateMode.NormalUpdate);
    }
}
```

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

### Manually Ticking a BehaviourTree at Runtime

Source: https://nodecanvas.paradoxnotion.com/documentation?section=runtime-instantiation-tips

This example demonstrates how to manually instantiate and tick BehaviourTrees at runtime. It sets up multiple agents, assigns them a shared blackboard and BehaviourTree, and then ticks them in the Update loop. Ensure you have a BehaviourTree asset and a Blackboard asset assigned.

```csharp
using UnityEngine;
using System.Collections.Generic;
using NodeCanvas.Framework;
using NodeCanvas.BehaviourTrees;

public class Example : MonoBehaviour {
    public int count;
    public BehaviourTree bt;
    public Blackboard blackboard;
    private List<BehaviourTreeOwner> agents = new List<BehaviourTreeOwner>();

    void Start(){
        for (int i = 0; i < count; i++){
            var agent = new GameObject("Agent").AddComponent<BehaviourTreeOwner>();
            agent.blackboard = blackboard;
            agent.StartBehaviour(bt, Graph.UpdateMode.Manual, null);
            agents.Add(agent);
        }
    }

    void Update(){
        foreach (BehaviourTreeOwner agent in agents){
            agent.Tick();
        }
    }
}
```

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

### Simple Action Task Example

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-tasks

A basic Action Task that logs the agent's name and then ends the action successfully. This demonstrates the fundamental structure of an Action Task.

```csharp
using UnityEngine;
using NodeCanvas.Framework;

public class SimpleAction : ActionTask
{
    protected override void OnExecute()
    {
        Debug.Log("My agent is " + agent.name);
        EndAction(true);
    }
}
```

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

### Task with Custom Object Field and Parameter

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-object-drawers

Example of a task that uses the custom struct both as a direct field and as a BBParameter.

```csharp
public class MyTask : ActionTask{
    public MyExampleStruct example;
    public BBParameter<MyExampleStruct> parameterExample;
}
```

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

### C# Script for Data Binding Example

Source: https://nodecanvas.paradoxnotion.com/documentation?section=data-binding-variables

This C# script demonstrates a simple MonoBehaviour with a private field and a public property that can be data-bound to a Blackboard variable.

```csharp
using UnityEngine;

public class DataBindExample : MonoBehaviour {
    [SerializeField]
    private float _health;

    public float health {
        get {
            return _health;
        }
        set {
            _health = value;
        }
    }
}
```

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

### Add BehaviourTreeOwner Component at Runtime

Source: https://nodecanvas.paradoxnotion.com/documentation?section=runtime-instantiation-tips

Use this when you only have a BehaviourTree asset and no BehaviourTreeOwner. Add the component to a new GameObject and then start the behaviour.

```csharp
using UnityEngine;
using NodeCanvas.BehaviourTrees;

public class Example : MonoBehaviour {
    public int count;
    public BehaviourTree bt;

    void Start(){
        for (int i = 0; i < count; i++){
            var agent = new GameObject("Agent").AddComponent<BehaviourTreeOwner>();
            agent.StartBehaviour(bt);
        }
    }
}
```

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

### Move To Target Action with BBParameters

Source: https://nodecanvas.paradoxnotion.com/documentation?section=using-bbparameters-in-tasks

An example of a 'Move To Target' action task showcasing the use of multiple BBParameters for 'Target', 'Speed', and 'Keep Distance'. 'Target' is linked to a blackboard variable, while 'Speed' and 'Keep Distance' are set to direct values.

```csharp
// Example demonstrating BBParameters for Target, Speed, and Keep Distance
// Target is linked to a Blackboard variable, Speed and Keep Distance are direct values.
public class MoveToTargetAction : ActionTask {
    public BBParameter<Transform> Target;
    public BBParameter<float> Speed;
    public BBParameter<float> KeepDistance;

    protected override void OnUpdate() {
        // Task logic to move towards the target
    }
}
```

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

### Delay Action Task Example

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-tasks

An Action Task that waits for a specified duration before completing. This utilizes the elapsedTime property to control the delay.

```csharp
using UnityEngine;
using NodeCanvas.Framework;

public class WaitAction : ActionTask
{
    public float timeToWait;

    protected override void OnUpdate()
    {
        if (elapsedTime > timeToWait)
            EndAction(true);
    }
}
```

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

### Blackboard API Methods

Source: https://nodecanvas.paradoxnotion.com/documentation?section=blackboard-api

Provides methods for managing Blackboard variables, including adding, getting, setting values, and saving/loading states. Use these to interact with Blackboard data from scripts.

```csharp
//Adds a new variable to the Blackboard of type and name specified.
public Variable AddVariable(string name, Type type)
//Gets the Variable instance of name and type specified.
public Variable GetVariable(string name, Type type)
//The generic version of the above.
public Variable<T> GetVariable<T>(string name)
//Get a variable value that is of specified name and of type T or assignable to type T.
//This is easier because it returns the value directly instead of the variable instance.
public T GetVariableValue<T>(string name)
//Set the value of a variable with specified name to the new value passed.
public void SetVariableValue(string name, object value)
```

```csharp
//////Following is the API for saving/loading the blackboard variables.///
//Save the variables state in PlayerPrefs with the key specified.
//Returns the serialized blackboard json string.
public string Save(string prefsKey)
//Loads the variables back from PlayerPrefs from the key specified. Returns true if success.
public bool Load(string prefsKey)
//Returns the serialized blackboard to json. Unity object references will be stored in the provided list.
public string Serialize(List<UnityEngine.Object> references, bool pretyJson = false)
//Deserialize a previously serialized json blackboard. Unity object references will be loaded from the provided list. Returns true if success.
public bool Deserialize(string json, List<UnityEngine.Object> references)
```

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

### WaitAction with BBParameter

Source: https://nodecanvas.paradoxnotion.com/documentation?section=using-bbparameters-in-tasks

This example demonstrates a WaitAction using BBParameter<float> for the 'timeToWait' field. Access the BBParameter's value using the '.value' property.

```csharp
using UnityEngine;
using NodeCanvas.Framework;

public class WaitAction : ActionTask {
    public BBParameter<float> timeToWait;

    protected override void OnUpdate() {
        if (elapsedTime > timeToWait.value)
            EndAction(true);
    }
}
```

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

### GraphOwner API Methods and Properties

Source: https://nodecanvas.paradoxnotion.com/documentation?section=graphowner-api

Key methods and properties of the GraphOwner class for managing graphs, including starting, stopping, pausing, sending events, and accessing parameters.

```csharp
//The Graph currently assigned
Graph graph {get;set;}
//The Blackboard currently assigned
Blackboard blackboard {get;set;}
//Is the Graph running?
bool isRunning {get;}
//Is the Graph paused?
bool isPaused {get;}
//Starts the behaviour
void StartBehaviour()
//Starts the behaviour and get a callback when and if it's finished
void StartBehaviour(System.Action callback)
//Start a new behaviour graph
void StartBehaviour(Graph newGraph)
//Both of the above
void StartBehaviour(Graph newGraph, System.Action callback)
//Stops the behaviour
void StopBehaviour()
//Pause the behaviour
void PauseBehaviour()
//Sends an event
void SendEvent(string eventName)
//Sends a value event
void SendEvent<T>(string eventName, T value)
//Send a global event. Same as Graph.SendGlobalEvent
static void SendGlobalEvent(string eventName)
//Send a global value event. Same as Graph.SendGlobalEvent
static void SendGlobalEvent<T>(string eventName, T value)
//Calls a public method of name "methodName" on all tasks of the assigned graph
void SendTaskMessage(string methodName, object value = null)
//Returns an exposed parameter value
T GetExposedParameterValue<T>(string name)
//Sets an exposed parameter value (if it doesn't exist a new one is created)
void SetExposedParameterValue<T>(string name, T value)
```

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

### Instantiate BehaviourTreeOwner Prefab at Runtime

Source: https://nodecanvas.paradoxnotion.com/documentation?section=runtime-instantiation-tips

Use this when you have a prefab with a BehaviourTreeOwner and a BehaviourTree asset. Instantiate the prefab and then call StartBehaviour on it with the BehaviourTree asset.

```csharp
using UnityEngine;
using NodeCanvas.BehaviourTrees;

public class Example : MonoBehaviour {
    public int count;
    public BehaviourTreeOwner agent;
    public BehaviourTree bt;

    void Start(){
        for (int i = 0; i < count; i++){
            var newAgent = Instantiate(agent);
            newAgent.StartBehaviour(bt);
        }
    }
}
```

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

### Switch Behaviours at Runtime

Source: https://nodecanvas.paradoxnotion.com/documentation?section=runtime-instantiation-tips

Demonstrates how to switch between different BehaviourTrees at runtime using SwitchBehaviour. This allows for dynamic changes in agent behavior.

```csharp
using UnityEngine;
using NodeCanvas.BehaviourTrees;

public class Example : MonoBehaviour {
    public BehaviourTree idleBehaviour;
    public BehaviourTree fleeBehaviour;
    public BehaviourTree attackBehaviour;
    private BehaviourTreeOwner agent;

    void Start(){
        agent = new GameObject("Agent").AddComponent<BehaviourTreeOwner>();
        agent.StartBehaviour(idleBehaviour);
    }

    void Update(){
        if (Input.GetKeyDown(KeyCode.Alpha1)) agent.SwitchBehaviour(idleBehaviour);
        if (Input.GetKeyDown(KeyCode.Alpha2)) agent.SwitchBehaviour(fleeBehaviour);
        if (Input.GetKeyDown(KeyCode.Alpha3)) agent.SwithBehaviour(attackBehaviour);
    }
}
```

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

### Task with Custom Range Attribute

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-object-drawers

Example of a task using the custom MyRange attribute on float and BBParameter<float> fields.

```csharp
public class MyTask : ActionTask{
    [MyRange(0,1)]
    public float myFloat;
    [MyRange(0,1)]
    public BBParameter<float> myParameterFloat;
}
```

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

### Core API for Action Tasks

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-tasks

This outlines the essential methods and properties available when creating custom Action Tasks. These include agent, blackboard, elapsedTime, OnInit, OnExecute, OnUpdate, OnStop, OnPause, SendEvent, StartCoroutine, and EndAction.

```csharp
//This is the agent for whom the action will take place.
public Component agent {get;}
//This is the blackboard that you can use to read/write variables manualy if needed.
public IBlackboard blackboard {get;}
//This is the time in seconds the action is running.
public float elapsedTime {get;}
//Called only the first time the action is executed and before anything else.
//Return null if everything is OK. Return an info string if there is a problem.
virtual protected string OnInit()
//Called once when the action is executed.
virtual protected void OnExecute()
//Called every frame while the action is running.
virtual protected void OnUpdate()
//Called when the action stops for any reason.
//Either because you called EndAction or cause the action was interrupted.
virtual protected void OnStop()
//Called when the action is paused comonly when it was still running while the behaviour graph gets paused.
virtual protected void OnPause()
//Send an event to the behaviour graph. Use this along with the CheckEvent condition.
protected void SendEvent(string)
//Similar to above, but sends a value along with the event.
protected void SendEvent<T>(string, T)
//You can use coroutines from within action task as normal.
protected Coroutine StartCoroutine(IEnumerator)
//You must call this to end the action. You can call this from wherever you want,
//although typicaly is done in either OnExecute or OnUpdate
public void EndAction(bool)
```

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

### Load Blackboard State from PlayerPrefs

Source: https://nodecanvas.paradoxnotion.com/documentation?section=save-load

Loads a previously saved Blackboard state from PlayerPrefs using a specified key. Returns true if the load was successful, false otherwise.

```csharp
bool success = blackboard.Load("mySaveKey");
```

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

### Implement a Custom Object Drawer

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-object-drawers

Create a custom drawer by deriving from ObjectDrawer<T> and implementing the OnGUI method to define the inspector GUI for the specified struct or class.

```csharp
public class MyExampleClassDrawer : ObjectDrawer<MyExampleStruct>{
    public override MyExampleStruct OnGUI(GUIContent content, MyExampleStruct instance){
        GUILayout.BeginVertical("box");
        instance.number = EditorGUILayout.Slider("Number", instance.number, 0, 10);
        instance.trigger = EditorGUILayout.ToggleLeft("Trigger", instance.trigger);
        GUILayout.EndVertical();
        return instance;
    }
}
```

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

### FSMOwner API

Source: https://nodecanvas.paradoxnotion.com/documentation?section=graphowner-api

The FSMOwner extends GraphOwner for managing Finite State Machines (FSMs), providing methods to trigger states by name and retrieve state names.

```APIDOC
### FSMOwner : GraphOwner<FSM>

### Description
The FSMOwner has the following on top of the inherited GraphOwner ones:

### Properties
- **currentStateName** (string) - The current State's name.
- **previousStateName** (string) - The previous State's name.

### Methods
- **TriggerState(string)** (FSMState) - Triggers a state of the current FSM by name. Returns the FSMState node triggered.
- **GetStateNames()** (string[]) - Return the names of all states of the current FSM assigned to the FSMOwner.
```

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

### Blackboard Save & Load Methods

Source: https://nodecanvas.paradoxnotion.com/documentation?section=save-load

These methods allow direct saving and loading of Blackboard variable states to and from PlayerPrefs. Note that UnityEngine Object references cannot be saved this way.

```APIDOC
## Save Blackboard State

### Description
Saves the current state of the Blackboard's variables to PlayerPrefs using a specified key. The method returns the JSON string representation of the saved state.

### Method
`string Save(string saveKey)`

### Parameters
#### Path Parameters
- **saveKey** (string) - Required - The key under which to save the Blackboard state in PlayerPrefs.

### Response
#### Success Response (string)
- Returns the JSON string of the serialized Blackboard state.

## Load Blackboard State

### Description
Loads a previously saved Blackboard state from PlayerPrefs using the provided key. Returns a boolean indicating whether the load operation was successful.

### Method
`bool Load(string saveKey)`

### Parameters
#### Path Parameters
- **saveKey** (string) - Required - The key of the saved Blackboard state to load from PlayerPrefs.

### Response
#### Success Response (bool)
- Returns `true` if the Blackboard state was successfully loaded, `false` otherwise.
```

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

### GraphOwner API

Source: https://nodecanvas.paradoxnotion.com/documentation?section=graphowner-api

The GraphOwner class provides core functionality for managing and controlling graphs in NodeCanvas. It includes methods for starting, stopping, pausing, and sending events to the assigned graph, as well as managing exposed parameters.

```APIDOC
## GraphOwner API

### Description
The GraphOwner class has the following important methods and properties:

### Properties
- **graph** (Graph) - The graph currently assigned.
- **blackboard** (Blackboard) - The blackboard currently assigned.
- **isRunning** (bool) - Is the graph running?
- **isPaused** (bool) - Is the graph paused?

### Methods
- **StartBehaviour()** - Starts the behaviour.
- **StartBehaviour(System.Action callback)** - Starts the behaviour and gets a callback when and if it's finished.
- **StartBehaviour(Graph newGraph)** - Starts a new behaviour graph.
- **StartBehaviour(Graph newGraph, System.Action callback)** - Starts a new behaviour graph with a callback.
- **StopBehaviour()** - Stops the behaviour.
- **PauseBehaviour()** - Pauses the behaviour.
- **SendEvent(string eventName)** - Sends an event.
- **SendEvent<T>(string eventName, T value)** - Sends a value event.
- **SendGlobalEvent(string eventName)** - Sends a global event. Same as Graph.SendGlobalEvent.
- **SendGlobalEvent<T>(string eventName, T value)** - Sends a global value event. Same as Graph.SendGlobalEvent.
- **SendTaskMessage(string methodName, object value = null)** - Calls a public method of name "methodName" on all tasks of the assigned graph.
- **GetExposedParameterValue<T>(string name)** - Returns an exposed parameter value.
- **SetExposedParameterValue<T>(string name, T value)** - Sets an exposed parameter value (if it doesn't exist a new one is created).
```

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

### Example JSON Representation of a Behaviour Tree

Source: https://nodecanvas.paradoxnotion.com/documentation?section=json-importexport

This JSON represents a simple behaviour tree with two sequencers, a condition node, and two action nodes. It includes node positions, types, and connections. Default values are not serialized in practice.

```json
{
  "nodes": [
    { "dynamic": false, "random": false, "_collapsed": false, "_position": { "x": 5708.0, "y": 5031.0 }, "_name": null, "_tag": null, "_comment": null, "_isBreakpoint": false, "$type": "NodeCanvas.BehaviourTrees.Sequencer", "$id": "1"
    },
    { "dynamic": false, "random": false, "_collapsed": false, "_position": { "x": 5608.0, "y": 5147.0 }, "_name": null, "_tag": null, "_comment": null, "_isBreakpoint": false, "$type": "NodeCanvas.BehaviourTrees.Sequencer", "$id": "2"
    },
    { "_condition": null, "_collapsed": false, "_position": { "x": 5512.998046875, "y": 5259.998046875 }, "_name": null, "_tag": null, "_comment": null, "_isBreakpoint": false, "$type": "NodeCanvas.BehaviourTrees.ConditionNode", "$id": "3"
    },
    { "_action": null, "_collapsed": false, "_position": { "x": 5705.0, "y": 5262.0 }, "_name": null, "_tag": null, "_comment": null, "_isBreakpoint": false, "$type": "NodeCanvas.BehaviourTrees.ActionNode", "$id": "4"
    },
    { "_action": null, "_collapsed": false, "_position": { "x": 5822.0, "y": 5150.0 }, "_name": null, "_tag": null, "_comment": null, "_isBreakpoint": false, "$type": "NodeCanvas.BehaviourTrees.ActionNode", "$id": "5"
    }
  ],
  "connections": [
    { "_sourceNode": { "$ref": "1" }, "_targetNode": { "$ref": "2" }, "_isDisabled": false, "$type": "NodeCanvas.BehaviourTrees.BTConnection"
    },
    { "_sourceNode": { "$ref": "1" }, "_targetNode": { "$ref": "5" }, "_isDisabled": false, "$type": "NodeCanvas.BehaviourTrees.BTConnection"
    },
    { "_sourceNode": { "$ref": "2" }, "_targetNode": { "$ref": "3" }, "_isDisabled": false, "$type": "NodeCanvas.BehaviourTrees.BTConnection"
    },
    { "_sourceNode": { "$ref": "2" }, "_targetNode": { "$ref": "4" }, "_isDisabled": false, "$type": "NodeCanvas.BehaviourTrees.BTConnection"
    }
  ],
  "canvasGroups": null,
  "localBlackboard": {
    "_name": "Local Blackboard",
    "_variables": [],
    "$type": "NodeCanvas.Framework.Internal.BlackboardSource"
  }
}
```

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

### Core API for Condition Tasks

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-tasks

This outlines the essential methods and properties for creating custom Condition Tasks. It includes agent, blackboard, OnInit, OnCheck, OnEnable, OnDisable, and YieldReturn.

```csharp
//This is the agent for whom the action will take place.
public Component agent {get;}
//This is the blackboard that you can use to read/write variables manualy if needed.
public IBlackboard blackboard {get;}
//Same as action task.
virtual protected string OnInit()
//Called when the condition is enabled, which depends on the system the condition is used within.
//OnEnable can be useful for subscribing to events for example.
virtual protected void OnEnable()
//This is called when the condition is checked. Override and return true or false.
virtual protected bool OnCheck()
//Called when the condition is disabled, which depends on the system the condition is used within.
//OnDisable can be useful for un-subscribing from events for example.
virtual protected void OnDisable()
//This is a helper method to make the condition return true or false from outside the OnCheck method.
protected void YieldReturn(bool)
```

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

### Blackboard API Methods

Source: https://nodecanvas.paradoxnotion.com/documentation?section=blackboard-api

This section outlines the core methods available for interacting with the Blackboard component, including adding, retrieving, and setting variable values, as well as saving and loading blackboard states.

```APIDOC
## Blackboard API

The Blackboard can easily be accessed manually to read/write from/to its variables. All you need is a reference to it of course. Within tasks and nodes, you get a reference through the .blackboard inherited property, but you can always of course use GetComponent<Blackboard>() since blackboard is a component.

### Methods

#### AddVariable
Adds a new variable to the Blackboard of type and name specified.

- **name** (string) - The name of the variable.
- **type** (Type) - The type of the variable.
- **Returns**: Variable - The newly added Variable instance.

#### GetVariable
Gets the Variable instance of name and type specified.

- **name** (string) - The name of the variable.
- **type** (Type) - The type of the variable.
- **Returns**: Variable - The Variable instance.

#### GetVariable<T>
Gets the Variable instance of name and type specified (generic version).

- **name** (string) - The name of the variable.
- **Returns**: Variable<T> - The generic Variable instance.

#### GetVariableValue<T>
Gets the value of a variable that is of specified name and of type T or assignable to type T.

- **name** (string) - The name of the variable.
- **Returns**: T - The value of the variable.

#### SetVariableValue
Sets the value of a variable with the specified name to the new value passed.

- **name** (string) - The name of the variable.
- **value** (object) - The new value to set.

### Saving and Loading

#### Save
Saves the variables state in PlayerPrefs with the key specified.

- **prefsKey** (string) - The PlayerPrefs key to save the variables under.
- **Returns**: string - The serialized blackboard JSON string.

#### Load
Loads the variables back from PlayerPrefs from the key specified.

- **prefsKey** (string) - The PlayerPrefs key to load the variables from.
- **Returns**: bool - True if the load was successful, false otherwise.

#### Serialize
Serializes the blackboard variables to JSON. Unity object references will be stored in the provided list.

- **references** (List<UnityEngine.Object>) - A list to store Unity object references.
- **prettyJson** (bool) - Optional. If true, formats the JSON for readability.
- **Returns**: string - The serialized blackboard JSON string.

#### Deserialize
Deserializes a previously serialized JSON blackboard. Unity object references will be loaded from the provided list.

- **json** (string) - The JSON string representing the blackboard state.
- **references** (List<UnityEngine.Object>) - A list containing Unity object references to be loaded.
- **Returns**: bool - True if deserialization was successful, false otherwise.
```

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

### Custom ActionTask Using OnGUI

Source: https://nodecanvas.paradoxnotion.com/documentation?section=using-fixedupdate-and-ongui

Integrate OnGUI logic into a custom ActionTask by subscribing to MonoManager.current.onGUI. This allows for immediate UI updates or interactions within the task. Remember to unsubscribe in OnStop.

```csharp
using NodeCanvas.Framework;
using ParadoxNotion.Services;

namespace NodeCanvas.Tasks.Actions
{
    public class OnGUIActionTask : ActionTask
    {
        protected override void OnExecute()
        {
            MonoManager.current.onGUI += OnGUI;
        }

        void OnGUI()
        {
            ///Your OnGUI code, like for example...
            if (UnityEngine.GUILayout.Button("OK"))
            {
                EndAction();
            }
        }

        protected override void OnStop()
        {
            MonoManager.current.onGUI -= OnGUI;
        }
    }
}
```

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

### Using Description Attribute for Tasks

Source: https://nodecanvas.paradoxnotion.com/documentation?section=using-task-attributes

Use the [Description] attribute to provide a help description for a Task that will be displayed within the task's inspector.

```csharp
 [Description("This task performs a specific action.")]
 public class MyActionTask : ActionTask
```

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

### Template for Custom Behavior Tree Node

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-bt-nodes

A template demonstrating common methods that can be overridden for custom BT nodes (Composites, Decorators, Leafs). Includes methods for graph start/stop/pause, execution, reset, and optional GUI customization.

```csharp
using UnityEngine;
using NodeCanvas.Framework;
using ParadoxNotion.Design;

namespace NodeCanvas.BehaviourTrees
{
    [Category("My Nodes")]
    [Icon("SomeIcon")]
    [Description("Some description")]
    public class NodeName : BTNode
    {
        //When the BT starts
        public override void OnGraphStarted()
        {
        }

        //When the BT stops
        public override void OnGraphStoped()
        {
        }

        //When the BT pauses
        public override void OnGraphPaused()
        {
        }

        //When the node is Ticked
        protected override Status OnExecute(Component agent, IBlackboard blackboard)
        {
            return Status.Success;
        }

        //When the node resets (start of graph, interrupted, new tree traversal).
        protected override void OnReset()
        {
        }

        #if UNITY_EDITOR
        //This GUI is shown IN the node IF you want
        protected override void OnNodeGUI()
        {
        }

        //This GUI is shown when the node is selected IF you want
        protected override void OnNodeInspectorGUI()
        {
            DrawDefaultInspector(); //this is done when you dont override this method anyway.
        }
        #endif
    }
}
```

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

### Blackboard Serialization & Deserialization

Source: https://nodecanvas.paradoxnotion.com/documentation?section=save-load

These methods provide functionality to serialize and deserialize Blackboard variables to and from JSON format, allowing for custom save systems. Unity object references are handled separately.

```APIDOC
## Serialize Blackboard Variables

### Description
Serializes the Blackboard's variables into a JSON string. Any UnityEngine Object references encountered are added to the provided list.

### Method
`string Serialize(List<UnityEngine.Object> references, bool prettyJson = false)`

### Parameters
#### Path Parameters
- **references** (List<UnityEngine.Object>) - Required - A list to store any UnityEngine Object references found during serialization.
- **prettyJson** (bool) - Optional - If true, the output JSON will be formatted for readability.

### Response
#### Success Response (string)
- Returns the JSON string representation of the serialized Blackboard variables.

## Deserialize Blackboard Variables

### Description
Deserializes Blackboard variables from a given JSON string. UnityEngine Object references are loaded from the provided list.

### Method
`bool Deserialize(string json, List<UnityEngine.Object> references)`

### Parameters
#### Path Parameters
- **json** (string) - Required - The JSON string containing the serialized Blackboard variables.
- **references** (List<UnityEngine.Object>) - Required - A list from which to load UnityEngine Object references.

### Response
#### Success Response (bool)
- Returns `true` if the deserialization was successful, `false` otherwise.
```

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

### Implementing FSM State Callbacks

Source: https://nodecanvas.paradoxnotion.com/documentation?section=fsm-callbacks

Implement the IStateCallbackReceiver interface in your MonoBehaviour to receive notifications for state entry, update, and exit events.

```csharp
using UnityEngine;

public class StateCallbacksExample : MonoBehaviour, IStateCallbackReceiver {
    public void OnStateEnter(IState state) {
    }

    public void OnStateUpdate(IState state) {
    }

    public void OnStateExit(IState state) {
    }
}
```

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

### FSMOwner Specific API

Source: https://nodecanvas.paradoxnotion.com/documentation?section=graphowner-api

Additional methods and properties for FSMOwner, including triggering states and retrieving state names.

```csharp
//The current State's name
string currentStateName {get;}
//The previous State's name
string previousStateName {get;}
//Triggers a state of the current FSM by name. Returns the FSMState node triggered.
FSMState TriggerState(string)
//Return the names of all states of the current FSM assigned to the FSMOwner
string[] GetStateNames()
```

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

### Implement a Custom Attribute Drawer

Source: https://nodecanvas.paradoxnotion.com/documentation?section=creating-custom-object-drawers

Implement a drawer for a custom attribute by deriving from AttributeDrawer<T>. The OnGUI method handles drawing the inspector GUI based on the field type.

```csharp
public class MyRangeDrawer : AttributeDrawer<MyRangeAttribute>{
    public override object OnGUI(GUIContent content, object instance) {
        if ( fieldInfo.FieldType == typeof(float) ) {
            return EditorGUILayout.Slider(content, (float)instance, (float)attribute.min, (float)attribute.max);
        }
        if ( fieldInfo.FieldType == typeof(int) ) {
            return EditorGUILayout.IntSlider(content, (int)instance, (int)attribute.min, (int)attribute.max);
        }
        return MoveNextDrawer();
    }
}
```

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

### Save Blackboard State to PlayerPrefs

Source: https://nodecanvas.paradoxnotion.com/documentation?section=save-load

Saves the current state of a NodeCanvas Blackboard to PlayerPrefs using a specified key. Returns the JSON string representation of the saved state.

```csharp
string json = blackboard.Save("mySaveKey");
```

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

### Using ShowButton Attribute

Source: https://nodecanvas.paradoxnotion.com/documentation?section=using-task-attributes

Use the [ShowButton] attribute over a field to display a button in the inspector. Clicking the button calls a specified method.

```csharp
 [ShowButton("Perform Action", "MyMethodCall")]
 public BBParameter<float> parameterToActOn;
```
Tokens:
Raw