> For the complete documentation index, see [llms.txt](https://giantgrey.gitbook.io/flowreactor/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://giantgrey.gitbook.io/flowreactor/in-depth/node-modules/frnodecontrollable.md).

# FRNodeControllable

The FRNodeControllable module allows you to control an external MonoBehaviour script in the scene – which implements the INodeControllable interface – from a node.\
See the demo scene: **NodeModules**

### Example

The simplest way of using this, is by adding the **External Script Controller** node to your graph.\
FlowReactor then shows you all nodes which have the FRNodeControllable module added in the FlowRector Component.

<figure><img src="/files/wXZMZmCJiJo9q87rVy0U" alt=""><figcaption></figcaption></figure>

Next create a new Monobehaviour script and add the **INodeControllable** interface to it like this:

```csharp
// Namespace
using FlowReactor.Nodes.Modules
 
public class ControllableExample : MonoBehaviour, INodeControllable
{
   // Gets called on node initialization
   public void OnNodeInitialize(Node _node)
   {
      Debug.Log("On Initialization");
   }
   
   // Gets called on node execution
   public void OnNodeExecute()
   {
      Debug.Log("On Execute");
   }
 
   // Gets called on node stop execution
   public void OnNodeStopExecute()
   {
     Debug.Log("On Stop Execute");
   }
   
   // Method for manual controllable method calls
   // This requires that the node which has the FRControllableModule to
   // call the method: CallOnNode(_flowRector, this, null);
   public void OnNode(Node _node,  object[] _parameters){}
}
//
```

### INodeControllable interface

<pre class="language-csharp"><code class="lang-csharp"><strong>using System;
</strong>using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
using FlowReactor;
 
namespace FlowReactor.Nodes.Modules
{
  public interface INodeControllable
  {
    // Automatically called on node initialization
    void OnNodeInitialize(Node _node);
    // Automatically called on node execution
    void OnNodeExecute();
    // Automatically called on node stop execution
    void OnNodeStopExecute();
    // Method for manual controllable method calls
    void OnNode(Node _node, params object[] _parameters);
  }
}
//
</code></pre>

### Add FRNodeControllable to custom node

If you want to implement the FRNodeControllable or any other node module to a custom node, you simply have to create a new instance of the module like this:

```csharp
// Namespace
using FlowReactor.Nodes.Modules;
 
// Create new instance of type FRNodeControllable
FRNodeControllable moduleNodeControllable = new FRNodeControllable();
 
```

Then you can execute the methods in your custom node:

```csharp
//
FRNodeControllable moduleNodeControllable = new FRNodeControllable();
 
// Call OnInitialize method manually
moduleNodeControllable.CallInitializeNode(_flowRector, this);
 
// Call OnNodeExecute method manually
moduleNodeControllable.CallStartExecuteNode(_flowRector, this);
 
// Call OnNodeStopExecute method manually
moduleNodeControllable.CallStopExecuteNode(_flowRector, this);
 
// Call OnNode method manually
moduleNodeControllable.CallOnNode(_flowRector, this, null);
//
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://giantgrey.gitbook.io/flowreactor/in-depth/node-modules/frnodecontrollable.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.