Databrain

https://giantgrey.gitbook.io/databrain
Admin
Databrain is a data management solution providing tools and a framework for organizing, serializing,...
Tokens:34,734
Snippets:396
Trust Score:10
Update:9 months ago
Show doc for...
Tokens:
Raw
### Start Dialogue via Script - C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/dialogue/dialogue-runtime-setup

Demonstrates how to initiate a dialogue using the DialogueController component in C#. This script includes a reference to the DialogueController and starts a dialogue when an IMGUI button is pressed. Ensure the DialogueController is assigned in the inspector.

```csharp
using UnityEngine;
using Databrain.Dialogue;

public class StartDialogue : MonoBehaviour
{
    // Reference to the dialogue controller
    public DialogueController dialogueController;
    
    public void OnGUI()
    {
        if (GUILayout.Button("Start Dialogue"))
        {
            dialogueController.StartDialogue();
        }
    }
}
```

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

### Basic Dialogue Start Call - C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/dialogue/dialogue-runtime-setup

A minimal C# code snippet showing the direct call to start a dialogue from an existing DialogueController instance. This is the core API method for triggering dialogue.

```csharp
dialogueController.StartDialogue();
```

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

### Start Research by GUID (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/api/progresscontroller

This method initiates a research using the runtime GUID of a specific progress node. It requires a pre-defined ProgressNode object to retrieve its GUID.

```csharp
public ProgressNode MyProgressNode;

progressController.StartResearchInProgressGraphByGuid(MyProgressNode.GetRuntimeDataObject().guid);
```

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

### OnDialogueStart

Source: https://giantgrey.gitbook.io/databrain/add-ons/dialogue/api/idialogueuicontrol

This method is called the first time a dialogue starts.

```APIDOC
## OnDialogueStart()

### Description
Called the first time a dialogue starts.

### Method
Not applicable (Method signature provided)

### Endpoint
Not applicable

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

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

### Start Research by Title (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/api/progresscontroller

This method starts a new research based on its title within the progress graph. It includes error handling for cases where the research cannot be started, possibly due to insufficient resources, and allows subscribing to progress updates.

```csharp
public void StartResearchSpecificNode()
{
    // Research a specific node in the progress graph
    var _node = progressController.StartResearchInProgressGraphByTitle("Bio Engineering");

    if (_node != null)
    {
        _node.OnResearchProgress -= Progress;
        _node.OnResearchProgress += Progress;
     }
    else
    {
        // Research failed. Maybe because we don't have enough resources
        Debug.Log("Research failed, not enough resources");
    }
}
```

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

### Event Listener Example in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/events

Shows how to register a listener for a custom event. It ensures the DataLibrary is ready before registering and defines the callback method to handle the event data.

```csharp
public class EventListener : MonoBehaviour
{
    public DataLibrary data;
    
    [DataObjectDropdown("data")]
    public MyEvent myEvent;
    
    public void Start()
    {
        // As with all DataObjects we have to make sure the DataLibrary is ready
        // before using it.
        data.RegisterInitializationCallback(Ready);
    }
    
    void Ready()
    {
        // DataLibrary is ready. We can now register to the event
        myEvent.RegisterListener(EventCalled);
    }
    
    void EventCalled(MyEventData _data)
    {
        // Event has been called
        Debug.Log("EVENT CALLED " + _data.param1 + " _ " + _data.param2);
    }
}
```

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

### Event Caller Example in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/events

Demonstrates how to raise a custom event with parameters. It includes creating the event parameters and invoking the Raise method.

```csharp
public class EventCaller : MonoBehaviour
{
    public DataLibrary data;
    
    [DataObjectDropdown("data")]
    public MyEvent myEvent;
    
    // Using IMGUI for testing purposes only
    public void OnGUI()
    {
        if (GUILayout.Button("Call Event"))
        {
            // Create parameters
            var _params = new MyEventData();
            _params.param1 = 99.9f;
            _params.param2 = "My Event";
            // Raise event
            myEvent.Raise(_params);
        }
    }
}
```

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

### Subscribe to Research Started Event (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/api/progresscontroller

This code demonstrates subscribing to the OnStartResearch event, which fires when a research begins. The handler logs the title of the started research if the event data is not null.

```csharp
progressController.OnStartResearch += OnStartResearch;

void OnStartResearch(ProgressNode _event)
{
    if (_event != null)
    {
        Debug.Log("Research started " + _event.title);
    }
}
```

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

### Get All and Current Language in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/localization/examples

Retrieves a list of all available languages supported by the LocalizationManager and also fetches the currently active language. The list of languages is typically stored in a 'languages' property, and the current language in 'currentLanguage'.

```csharp
public class LocalizationExample : MonoBehaviour
{
    public LocalizationManager manager;
    
    public void SetLanguage()
    {
        // get all languages
        List<LocalizationManager.Languages> _allLanguages = manager.languages;
        
        // Get current language
        var _currentLanguage = manager.currentLanguage;
    }
}
```

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

### Accessing InventoryUIController Singleton in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/inventory/runtime-ui/setup

Demonstrates how to access and use the InventoryUIController singleton to build the inventory UI at runtime. This is the primary method for populating items dynamically. It requires the InventoryUIController script to be present and properly configured in the scene.

```csharp
using UnityEngine;

public class ExampleUsage : MonoBehaviour
{
    public void BuildInventoryRuntime(ItemData[] data, Transform uiRoot)
    {
        if (InventoryUIController.Instance != null)
        {
            InventoryUIController.Instance.BuildInventory(data, uiRoot);
        }
        else
        {
            Debug.LogError("InventoryUIController instance not found.");
        }
    }
}
```

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

### Access Data from DataLibrary Object by GUID, Title, and Type (C#)

Source: https://giantgrey.gitbook.io/databrain/guides/get-initial-data

This snippet demonstrates how to retrieve data objects from the DataLibrary in C#. It shows how to access data by its unique identifier (GUID), by its title (ensuring uniqueness), and how to fetch all objects of a specified type. The code requires a DataLibrary instance and registers a callback for when the data is ready.

```csharp
public class Enemy : MonoBehaviour
{
    public DataLibrary data;
    
    public void Start()
    {
        // Before accessing the data we have to make sure the data library is ready
        data.RegisterInitializationCallback(Ready);
    }
    
    // Data is ready
    void Ready()
    {
        // Multiple ways for accessing data object at runtime
        
        // 1.
        // Get the enemy data object by Guid.
        // You can optionally pass the data type.
        var _enemyData1 = data.GetInitialDataObjectByGuid("", typeof(EnemyData))  as EnemyData;
        // Get health value;
        var _health = _enemyData1.health;
        
        // 2.
        // Get the enemy data object by its title.
        // In this case you have to make sure that the title is unique.
        // You can optionally pass the data type.
        var _enemyData2 = data.GetInitialDataObjectByTitle("Enemy", typeof(EnemyData))  as EnemyData;
          // Get health value;
        var _health = _enemyData1.health;
        
        // 3.
        // Get all data objects of the type
        var _allEnemies = GetAllInitialDataObjectsByType(typeof(EnemyData));
        // Iterate through all enemies
        for (int i = 0; i < _allEnemies.Count; i ++)
        {
            var _enemy = _allEnenmies[i] as EnemyData;
        }
    }
}
```

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

### Load Localized Text with Parameters in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/localization/examples

Fetches a localized string that supports tag replacements. Parameters are provided in a dictionary where keys are the tags (e.g., '{NAME}') and values are the replacement strings. The tag must be defined in the localized text.

```csharp
// First, define parameters.
// The tag {NAME} must be assigned in the localized text. This part, will then be replaced.
var _params = new Dictionary<string, object>();
_params.Add("{NAME}", inputField.text);

var _localizedTextWithTag = localizationManager.GetLocalizedText("TextParameter", _params);
```

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

### Manual Graph Execution with LogicController in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/logic/execute-graph

Demonstrates manually triggering a logic graph's execution using the LogicController component in Unity. This approach is necessary for graphs that contain component references. It shows how to start execution and how to handle the completion event with a callback.

```csharp
public class ExecuteGraphExample : MonoBehaviour
{
    // Reference to our LogicController component
    public LogicController logicController;
    
    // Call this method manually
    void ExecuteManually()
    {
        logicController.ExecuteGraph();
    }
    
    void ExecuteManuallyWithOnComplete()
    {
        logicController.ExecuteGraph().OnComplete(result =>
        {
            // Get the result value from the return node on completion.
            Debug.Log("Graph complete. Result is: " + result.boolValue);       
        });
    }
}
```

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

### Integrating Runtime GUI into Scene with UIDocument (C#)

Source: https://giantgrey.gitbook.io/databrain/guides/custom-gui

Provides a MonoBehaviour script demonstrating how to display a custom runtime GUI for a DataObject within a Unity scene. It requires references to a DataLibrary, a specific DataObject instance (linked via DataObjectDropdown), and a UIDocument component. The Start method retrieves the RuntimeGUI from the DataObject and adds it to the UIDocument's root visual element.

```csharp
using UnityEngine;
using UnityEngine.UIElements;

public class RuntimeUITest : MonoBehaviour
{
    public DataLibrary data;

    [DataObjectDropdown("data")]
    public TestData testData;

    // Reference of the ui document in the scene
    public UIDocument document;


    public void Start()
    {
        // Create a new root visual element container
        var _root = new VisualElement();
        // Get the runtime GUI from the DataObject and add it to the container
        _root.Add(testData.RuntimeGUI());
        // Add the container to the document
        document.rootVisualElement.Add(_root);
    }
}
```

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

### Get Localized String with C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/localization/examples

Retrieves a localized string from the localization object named 'TextManual' using the LocalizationManager. This requires an instance of LocalizationManager to be available.

```csharp
public class LocalizationExample : MonoBehaviour
{
    public LocalizationManager manager;
    
    public void LoadText()
    {
        var _localizedText = manager.GetLocalizedText("TextManual");
    }
}
```

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

### Start Research in Techtree (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/techtree-legacy/api

Initiates research for a specific technology node within a techtree. Returns the techtree node if successful, or null if there are insufficient resources. It allows subscribing to research progress events.

```csharp
public Techtree.TechtreeNode ResearchTechInTechtree(Techtree _techtree, string _techNodeID)
public Techtree.TechtreeNode ResearchTechInTechtree(Type _techtreeType, string _techtreeTitle, string _techNodeID)
private Techtree.TechtreeNode ResearchTechInTechtree(Type _techtreeType, string _techtreeTitle, string _techNodeID, Techtree _techtree)
```

```csharp
public TechtreeManager techtreeManager;

public void StartResearch()
{
    // Research the first node in the techtree. -1 is the node ID. This can be changed on the node
    var _node = techtreeManager.ResearchTechInTechtree(typeof(Techtree), "PlayerTechtree", "-1");
    
    if (_node != null)
    {
        // Subscribe to the on progress event
        _node.OnResearchProgress -= Progress;
        _node.OnResearchProgress += Progress;
    }
    else
    {
        // Research failed. Maybe because we don't have enough resources
        Debug.Log("Research failed, not enough resources");
    }
}

void Progress(float _progress)
{
    Debug.Log("progress: " + _value);
}
```

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

### Reset XP to Zero (API)

Source: https://giantgrey.gitbook.io/databrain/add-ons/stats/progressions

The ResetXP API function allows for resetting the current experience points of a progression back to zero. This is useful for scenarios requiring a fresh start or a complete reset of a player's or item's progress.

```plaintext
ResetXP
```

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

### Subscribe to Research Complete Event (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/api/progresscontroller

This example shows how to subscribe to the OnResearchComplete event, which is called when a research task is finished. The associated method logs the title of the completed research.

```csharp
progressController.OnResearchComplete += OnResearchComplete;

void OnResearchComplete(ProgressNode _event)
{
    if (_event != null)
    {
       Debug.Log("Research complete " + _event.title);
    }
}
```

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

### Implement Singleton DataManager for DataLibrary in C#

Source: https://giantgrey.gitbook.io/databrain/faq/databrain-faq

Provides an example of a singleton MonoBehaviour class (DataManager) used to hold a DataLibrary. It includes an Awake method for singleton pattern implementation and an OnValidate method to ensure the DataLibrary is found in the editor.

```csharp
// SINGLETON Example
// Please make sure to add the OnValidate method like in this example
// to your singleton class.
public class DataManager : MonoBehaviour
{
    public static DataManager Instance { get; private set; } 

    public DataLibrary data;
    
    
    private void OnValidate()
    {
        Instance = this;
    }

    public void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(this);
            return;
        }

        Instance = this;
    }
}
```

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

### Custom Progress Node Example in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/progress-graph

Demonstrates how to create a custom progress node by deriving from the ProgressNode class in C#. This allows for adding additional fields and overriding methods like ResearchStarted and ResearchCompleted to implement custom logic. It requires the Unity engine for Debug.Log.

```csharp
public class CustomProgressNode : ProgressNode
{
    public float additionalFields;
    
    // Called when this node research has been started
    public override void ResearchStarted()
    {
        Debug.Log("my custom research has started");
    }
    
    // Called when research has been completed
    public override void ResearchCompleted()
    {
        Debug.Log("my custom research is completed");
    }
}
```

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

### Access Data After Initialization Callback (C#)

Source: https://giantgrey.gitbook.io/databrain/guides/get-initial-data

This code example shows how to safely access data from a DataObject after ensuring the DataLibrary has been initialized. It utilizes the RegisterInitializationCallback method to register a callback function that executes once the data is ready, preventing runtime errors.

```csharp
public class Enemy : MonoBehaviour
{
    public DataLibrary data;
    
    // Our data object
    [DataObjectDropdown("data")]   
    public EnemyData enemyData;
    
    public void Start()
    {
        // Before accessing the data we have to make sure the data library is ready.
        // Therefore we're registering a method to the initialization callback.
        data.RegisterInitializationCallback(Ready);     
    }
    
    // Data is ready
    void Ready()
    {
        // Get the initial health value
        var enemyHealth = enemyData.health;
    }
}
```

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

### Clone and Get Dynamic Runtime DataObjects (C#)

Source: https://giantgrey.gitbook.io/databrain/guides/get-set-runtime-data

Shows how to clone a DataObject to the runtime library and obtain a reference to it. This is useful for dynamically creating and modifying data at runtime. It emphasizes the importance of passing the owner game object for managing multiple clones.

```csharp
public class AddToRuntimeLibrary : MonoBehaviour
{
    // The data library reference
    public DataLibrary data;
    
    // The data object we want to clone and add to the runtime library
    [DataObjectDropdown("data")]
    public EnemyData enemyData;   
    // Reference of the enemy class
    public Enemy enemy;
    
    public void Start()
    {
        // Clone the data object enemyData and add it to the runtime library.
        // Pass this game object as the owner. This is important if you have
        // multiple clones of enemyData. This allows you and Databrain to later
        // find the enemyData runtime clone associated to this game object.
        // It also helps the DataObjectDropdown attribute to find the correct 
        // values from the runtime clone
        enemy.runtimeData = data.CloneDataObjectToRuntime(enemyData, this.gameObject) as EnemyData;
        
        /* Get the runtime clone by providing this game object.
        * 
        * enemy.runtimeData = enemyData.GetRuntimeDataObject(this.gameObject);
        * 
        */
    }
}


public class Enemy : MonoBehaviour
{
    public EnemyData runtimeData;
    
    public void Hit()
    {
        runtimeData.health -= 10;
        
        if (runtimeData.health <= 0)
        {
             // Dead   
        }
    }
}
```

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

### Set Current Language with C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/localization/examples

Sets the active language for localization. This method takes a string representing the desired language (e.g., 'English') and updates the LocalizationManager's current language setting.

```csharp
public class LocalizationExample : MonoBehaviour
{
    public LocalizationManager manager;
    
    public void SetLanguage()
    {
        manager.SetLanguage("English");
    }
}
```

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

### Custom Runtime GUI for DataObjects with UI Toolkit (C#)

Source: https://giantgrey.gitbook.io/databrain/guides/custom-gui

Shows how to override the RuntimeGUI method in a DataObject to define a custom user interface that can be displayed at runtime. This example creates fields for a Vector3 position and an integer health value, and registers callbacks to update the DataObject's properties when the UI values change. The generated UI elements are added to a VisualElement root.

```csharp
public class TestData : DataObject
{
    public Vector3 position;
    public int health;
     
    public override VisualElement RuntimeGUI()
    {
        var _root = new VisualElement();
        
        // Vector3 field for our position field
        var _posProp = new Vector3Field();
        _posProp.bindingPath = "position";
        _posProp.RegisterValueChangedCallback<Vector3>(x =>
        {
            position = x.newValue;
        });

        // Int field for our health field
        var _healthProp = new IntegerField();
        _healthProp.RegisterValueChangedCallback<int>(x =>
        {
            health = x.newValue;
        });

        _root.Add(_posProp);
        _root.Add(_healthProp);

        return _root;
    }
}
```

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

### Implement Custom Dialogue UI with C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/dialogue/custom-theme

This C# script demonstrates how to create a custom dialogue UI by implementing the IDialogueUIControl interface. It handles setting the dialogue controller, starting and exiting dialogues, displaying text and choices, and updating timers. It requires Unity UI components like TextMeshProUGUI and Button, and the Databrain.Dialogue namespace.

```csharp
using UnityEngine;
using UnityEngine.UI;
using TMPro;

using Databrain.Dialogue;


public class MyDialogueUI: MonoBehaviour, IDialogueUIControl
{
     // Define your dialogue references such as
     // choices button, dialogue text (TextMeshUI) etc.
     
     public TextMeshProUGUI dialogueText;
     public GameObject choiceButtonPrefab;
     public GameObject optionButtonsContainer;
     
     
     private DialogueController dialogueController;
     private System.Collections.Generic.List<GameObject> existingChoiceButtons = new System.Collections.Generic.List<GameObject>();

     /// <summary>
     /// Called by the dialogue controller in the scene, which passes a reference to the dialogue controller to your dialogue ui script.
     /// </summary>
     public void SetDialogueController(DialogueController dialogueController)
     {
          this.dialogueController = dialogueController;
     }

     /// <summary>
     /// Called the first time a dialogue starts
     /// </summary>
     public void OnDialogueStart()
     {
          // show the dialogue UI.
          
          
          // Clear old choice buttons
          for (int j = 0; j < existingChoiceButtons.Count; j++)
          {
               if (existingChoiceButtons[j] != null)
               {
                    Destroy(existingChoiceButtons[j].gameObject);
               }
          }
          existingChoiceButtons.Clear();
     }

     /// <summary>
     /// Called every time a new dialogue text is requested
     /// </summary>
     /// <param name="dialogueEventData"></param>
     public void ShowNextDialogueText(DialogueEventData dialogueEventData)
     {
          // Update dialogue text. Get the localized text by passing in the selected language from the dialogue controller
          dialogueText.text = dialogueEventData.dialogueText.GetLocalizedText(dialogueController.GetSelectedLanguage());
     }
     
     /// <summary>
     /// Called when choices are requested
     /// </summary>
     /// <param name="dialogueEventData"></param>
     public void ShowChoices(DialogueEventData  dialogueEventData)
     {
          // Build choices buttons
          
          // Clear old buttons first
          for (int j = 0; j < existingChoiceButtons.Count; j++)
          {
               if (existingChoiceButtons[j] != null)
               {
                    Destroy(existingChoiceButtons[j].gameObject);
               }
          }
          existingChoiceButtons.Clear();
          
          for (int i = 0; i < dialogueEventData.choices.Count;  i++)
          {
               // Skip choices which are not connected in the dialouge graph
               if (dialogueEventData.choices[i] == null)
               {
                    continue;
               }
                    
               // Instantiate the choice button prefab
               var _choiceInstance = Instantiate(choiceButtonPrefab);
               // Get the TextMeshProUGUI component from the button and assign the localized text
               _choiceInstance .GetComponentInChildren<TextMeshProUGUI>().text = dialogueEventData.choices[i].GetLocalizedText(dialogueController.GetSelectedLanguage());
               
               // Get the Button component and assign an action to the OnClick event.
               var _button = _choiceInstance .GetComponent<Button>();
               int choiceIndex = i; // Capture the loop variable
               _button.onClick.AddListener(() => 
               {
                    // Select choice with index + 1 because 0 = default choice when timers up
                    dialogueController.SelectChoice(choiceIndex + 1);
               });
               
               // Add the choice button instance to the options UI container
               _choiceInstance.transform.SetParent(optionButtonsContainer.transform, false);
               
               // Add the button instance to the list so we can destroy them later
               existingChoiceButtons.Add(_choiceInstance.gameObject);
          }
     }
     
     /// <summary>
     /// Constantly called by DialogueController to update the timer UI
     /// </summary>
     /// <param name="_remainingTime"></param>
     /// <param name="_totalTime"></param>
     public void UpdateTimer(float _remainingTime, float _totalTime){}
 
     /// <summary>
     /// Called when dialogue is finished, by the OnExitDialogue node.
     /// </summary>
     public void OnDialogueExit()
     {
          // Hide dialouge UI
     }


}
```

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

### Subscribe to Research Failed Event (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/api/progresscontroller

This snippet shows how to subscribe to the OnStartResearchFailed event, which is triggered when starting a research fails. It includes a callback function to handle the failure, logging the status code.

```csharp
progressController.OnStartResearchFailed += OnResearchFailed;

void OnResearchFailed(ProgressEventData.ProgressEventStatus _status)
{
    Debug.Log("Research failed! Status: " + _status);
}
```

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

### Get Localized Audio Clip - C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/localization/api

Retrieves a localized AudioClip using a key and a type for context. This is useful for dynamically loading audio assets based on the current language.

```csharp
public AudioClip GetLocalizedAudioClip(string _key, Type _type)
```

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

### Categorize Custom Data Object with Namespaces in C#

Source: https://giantgrey.gitbook.io/databrain/guides/add-data-objects

Shows how to organize custom data objects using namespaces in C#. This example places the EnemyData class within the 'Enemies' namespace and demonstrates creating a derived type 'Orc' also within the same namespace.

```csharp
using Databrain;

namespace Enemies
{
    public class EnemyData : DataObject
    {
        public int health;
        public float strength;
    }
}

namespace Enemies
{
    // Derived from EnemyData
    public class Orc : EnemyData
    {
        // Orc specific fields
    }
}
```

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

### Serialize Auto-Implemented Properties in C# for Unity

Source: https://giantgrey.gitbook.io/databrain/faq/databrain-faq

Shows how to use the `[field: SerializeField]` attribute in C# to serialize auto-implemented properties (get; set;) in Unity. This ensures that properties with hidden backing fields are correctly serialized by Unity's serializer.

```csharp
[field: SerializeField] public int Speed {get; set;}
```

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

### Get Runtime DataObject from Initial DataObject (C#)

Source: https://giantgrey.gitbook.io/databrain/guides/get-set-runtime-data

Demonstrates how to access and modify a runtime DataObject that was initially created in the editor. It ensures the data library is ready before retrieving the runtime object and then modifies its 'health' property.

```csharp
public class Enemy : MonoBehaviour
{
    public DataLibrary data;
    
    // Our data object
    [DataObjectDropdown("data")]   
    public EnemyData enemyData;
    
    public void Start()
    {
        // Before accessing the data we have to make sure the data library is ready
        data.RegisterInitializationCallback(Ready);     
    }
    
    // Data is ready
    void Ready()
    {
        // Get the runtime data object from the initial enemyData DataObject.      
        var _runtimeEnemyData = (enemyData.GetRuntimeDataObject() as EnemyData)
         // Modify the health value of the runtime data object.
        _runtimeEnemyData.health -= 10;
    }
}
```

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

### Build Techtree at Runtime - C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/techtree-legacy/techtree-uibuilder

This C# code demonstrates how to manually trigger the building of a techtree visualization using the TechtreeUIBuilder component in Unity. It shows how to call the `Build()` method, optionally specifying a techtree data object name to build.

```csharp
public class TechtreeExample : MonoBehaviour
{
    // Reference to the UIBuilder
    public TechtreeUIBuilder techtree;
    
    // Call to build the techtree
    public void BuildTechtree()
    {
        // Option 1
        techtree.Build();
        
        // Option 2. 
        // You can also pass a techtree data object name which should be 
        // built instead of the assigned techtree in the Techtree UIBuilder component.
        // techtree.Build("PlayerTechtree");
    }
}
```

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

### Get Achievement Score and Status

Source: https://giantgrey.gitbook.io/databrain/add-ons/stats/achievements

Retrieves the current score and unlocked status of an achievement.

```APIDOC
## GET /achievements/{achievementId}/status

### Description
Retrieves the current score and unlocked status for a given achievement.

### Method
GET

### Endpoint
/achievements/{achievementId}/status

### Parameters
#### Path Parameters
- **achievementId** (string) - Required - The unique identifier of the achievement.

#### Response
#### Success Response (200)
- **currentScore** (int) - The current score of the achievement.
- **isUnlocked** (boolean) - True if the achievement is unlocked, false otherwise.
```

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

### Get Techtree (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/techtree-legacy/api

Retrieves the entire techtree object based on its type and title. This function allows access to the complete structure and data of a specific techtree.

```csharp
public Techtree GetTechtree(Type _techtreeType, string _techtreeTitle)
```

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

### ShowNextDialogueText

Source: https://giantgrey.gitbook.io/databrain/add-ons/dialogue/api/idialogueuicontrol

This method is called every time a new dialogue text is requested.

```APIDOC
## ShowNextDialogueText(DialogueEventData dialogueEventData)

### Description
Called every time a new dialogue text is requested.

### Method
Not applicable (Method signature provided)

### Endpoint
Not applicable

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **dialogueEventData** (DialogueEventData) - Required - Data related to the dialogue event.

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

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

### Get Localized Sprite - C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/localization/api

Retrieves a localized Sprite using a key and a type for context. This function facilitates the display of language-specific 2D image assets.

```csharp
public Sprite GetLocalizedSprite(string _key, Type _type)
```

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

### Get Localized Texture - C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/localization/api

Retrieves a localized Texture2D using a key and a type for context. This method is designed for loading texture assets that vary by language.

```csharp
public Texture2D GetLocalizedTexture(string _key, Type _type)
```

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

### Get Localized Text - C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/localization/api

Retrieves localized text based on a key and optional parameters. Overloads support passing a type for context and dynamic parameters.

```csharp
public string GetLocalizedText(string _key, params Dictionary<string, object>[] _params)
public string GetLocalizedText(string _key, Type _type, params Dictionary<string, object>[] _params)
```

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

### Get Localized Game Object - C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/localization/api

Retrieves a localized GameObject using a key and a type for context. This allows for the dynamic instantiation or retrieval of game objects that are language-dependent.

```csharp
public GameObject GetLocalizedGameObject(string _key, Type _type)
```

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

### Save and Load Data at Runtime in C#

Source: https://giantgrey.gitbook.io/databrain/guides/runtime-save-and-load

This C# script demonstrates how to save and load data using the DataLibrary object in Databrain. It utilizes Unity's MonoBehaviour for game integration and System.IO.Path for creating file paths. The script includes methods for saving and loading, along with callbacks for when the operations are completed.

```csharp
public class SaveLoadManager : MonoBehaviour
{
    public DataLibrary data;
    public string filename = "savegame.json";
    
    void Start()
    {
        data.RegisterInitializationCallback(Ready);
    }
    
    void Ready()
    {
        data.OnLoaded += DataLoaded;
        data.OnSaved += DataSaved;
    }
    
    // Call this method to save the data
    public void Save()
    {
        // Create save path
        var path = System.IO.Path.Combine(Application.persistentDataPath, filename);
        // Save data
         data.Save(path);   
    }
    
    // Call this method to load data back
    public void Load()
    {
        // Create save path
        var path = System.IO.Path.Combine(Application.persistentDataPath, filename);
        // Load data
        data.Load(path);
    }
    
    // Called after data has been loaded
    void DataLoaded()
    {
        Debug.Log("Data loaded");
        
        // Do something with it
    }
    
    // Called after data has been saved
    void DataSaved()
    {
        Debug.Log("Data saved");
    }
}
```

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

### Get All Tech Nodes (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/techtree-legacy/api

Fetches a list of all techtree nodes belonging to a specified techtree, identified by its type and title. This method provides a comprehensive collection of all available research nodes.

```csharp
public List<Techtree.TechtreeNode> GetAllTechNodes(Type _techtreeType, string _techtreeTitle)
```

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

### Get Current XP Points (API)

Source: https://giantgrey.gitbook.io/databrain/add-ons/stats/progressions

The GetCurrentXP API function retrieves the current experience points accumulated within a progression. This value can be used for displaying progress or for other game logic.

```plaintext
GetCurrentXP
```

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

### Listen for Blackboard Variable Value Changes (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/blackboard

Illustrates how to register a listener for the onValueChanged event of a blackboard variable. This callback is triggered whenever the variable's value is updated, allowing for real-time reaction to changes.

```csharp
public class BlackboardExample : MonoBehaviour
{
    public DataLibrary data;

    [DataObjectDropdown("data")]
    public FloatVariable floatValue;
    
    public void Start()
    {
        data.RegisterInitializationCallback(Ready);
    }
    
    void Ready()
    {
        floatValue.onValueChanged.RegisterListener(FloatChanged);
    }
    
    void FloatChanged(BlackboardVariable _variable)
    {
        // Float value has been changed
        var _value = (_variable as FloatVariable).Value;
        Debug.Log("New value: " + _value);
    }
}
```

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

### Get Current Level Icon (API)

Source: https://giantgrey.gitbook.io/databrain/add-ons/stats/progressions

The GetLevelIcon API function retrieves the current level icon associated with a progression. This function returns the icon as a sprite, enabling its display in the user interface.

```plaintext
GetLevelIcon
```

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

### Create a Basic State Machine Action Node (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/logic/finite-state-machine

This C# code defines a basic structure for a State Machine Action Node. It includes methods for OnEnter, OnExit, and OnUpdate, which are called by the state machine controller at different points in the state's lifecycle. This serves as a template for custom state logic.

```csharp
public class MyStateAction : StateMachineActionNode
{
    public override void OnEnter()
    {
        // On Enter
    }

    public override void OnExit()
    {
        // On Exit
    }

    public override void OnUpdate()
    {
        // On update is called by the state machine controller node on every tick
    }
}
```

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

### Dropdown Attribute Usage for String and Integer Lists in C#

Source: https://giantgrey.gitbook.io/databrain/attributes/field-attributes

Provides examples of using the Dropdown attribute to create dropdown selections for both string and integer fields. It requires a list of options to be defined and referenced by the attribute.

```csharp
// string
private List<string> dropdownOptions = new List<string> { "A", "B", "C" };

[Dropdown("dropdownOptions")]
public string dropdown;

// integer
private List<int> dropdownIntOptions = new List<int> { 0, 1, 2 };

[Dropdown("dropdownIntOptions")]
public int dropdownNumber;
```

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

### ShowChoices

Source: https://giantgrey.gitbook.io/databrain/add-ons/dialogue/api/idialogueuicontrol

This method is called when choices are requested. It is used to build the UI choices list.

```APIDOC
## ShowChoices(DialogueEventData dialogueEventData)

### Description
Called when choices are requested. To build the UI choices list.

### Method
Not applicable (Method signature provided)

### Endpoint
Not applicable

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **dialogueEventData** (DialogueEventData) - Required - Data related to the dialogue event, including choices.

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

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

### Get Specific Tech Node (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/techtree-legacy/api

Retrieves a specific techtree node using its type, title, and node ID. The returned techtree node object contains properties indicating its research status, such as 'unlocked' or 'researched'.

```csharp
public Techtree.TechtreeNode GetTechNode(Type _techtreeType, string _techtreeTitle, string _techNodeID)
```

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

### Add XP Points and Trigger Level Up (API)

Source: https://giantgrey.gitbook.io/databrain/add-ons/stats/progressions

The AddXP API function adds experience points to the current progression. If the added XP points result in reaching a new level, the OnLevelUp event is automatically triggered.

```plaintext
AddXP
```

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

### Get Current Progression Level (API)

Source: https://giantgrey.gitbook.io/databrain/add-ons/stats/progressions

The GetCurrentLevel API function returns the current progression level. This allows developers to query the player's or item's current level within the defined progression system.

```plaintext
GetCurrentLevel
```

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

### Unity OnComplete Event Handler in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/logic/execute-graph

Shows how to integrate logic graph completion with Unity's event system. This C# method can be assigned to the LogicController's OnComplete event in the Unity inspector, allowing custom actions to be performed when the graph finishes execution, including accessing the result.

```csharp
public void UnityEventOnComplete(GraphData.GraphProcessingResult _result)
{
    // Graph is finished
    Debug.Log(_result.boolValue);
}
```

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

### Set Progress UI Controller (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/api/progresscontroller

This method allows setting an alternative Progress UI controller, useful for implementing different visual themes or behaviors for the progress display.

```csharp
progressController.SetUIController(themeObject1);
```

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

### Create New FSM Action Node in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/logic/finite-state-machine/create-custom-actions

This C# code snippet demonstrates the structure of a custom Finite State Machine (FSM) action node in Databrain. It includes essential Databrain node attributes for defining the node's appearance and behavior, as well as the core methods OnEnter, OnExit, and OnUpdate for implementing custom logic.

```csharp
using System;
using Databrain.Logic.Attributes;
using UnityEngine;

namespace Databrain.Logic.StateMachine
{
    [NodeTitle("MyStateAction")]
    [NodeCategory("StateMachine/States")]
    [NodeOutputs(new string[] {"Next"})]
    [NodeDescription("This is a node description")]
    [NodeSize(260, 100)]
    [NodeColor("#C2FAFF", new string[]{"#74AFE0","","",""})]
    [NodeIcon("fsmAction.png", "LogicResPath.cs")]
    [NodeInputConnectionType(new Type[] {typeof(Actions)})]
    public class MyStateAction : StateMachineActionNode
    {

        public override void OnEnter()
        {
            // On Enter
        }

        public override void OnExit()
        {
            // On Exit
        }

        public override void OnUpdate()
        {
            // On update is called by the state machine controller node on every tick
        }   
    }
}
```

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

### Load Progress Graph (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/api/progresscontroller

This method loads a Progress Graph. It can optionally take a graph name; if no name is provided, the currently assigned graph is loaded.

```csharp
progressController.LoadProgressGraph();

progressController.LoadProgressGraph("PlayerProgress");
```

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

### Custom Editor GUI for DataObjects with UI Toolkit (C#)

Source: https://giantgrey.gitbook.io/databrain/guides/custom-gui

Demonstrates how to override the EditorGUI method in a DataObject class to create a custom editor interface using Unity's UI Toolkit. This allows for a tailored inspector view within the Unity Editor. It's recommended to encapsulate editor-specific code within '#if UNITY_EDITOR' directives and hide default fields using the 'DataObjectHideAllFields' attribute.

```csharp
using UnityEngine.UIElements;
#if UNITY_EDITOR
using UnityEditor.UIElements;
#endif

[DataObjectHideAllFields]
public class EnemyData : DataObject
{
    public int health;
    public float speed;
    
    #if UNITY_EDITOR
    // Override CustomGUI to create custom GUI for this DataObject
    public override VisualElement EditorGUI(SerializedObject _serializedObject, DatabrainEditorWindow _editorWindow)
    {
        // Create a root container
        var _root = new VisualElement();
        
        // Lets add a label
        var _label = new Label();
        _label.text = "Enemy Data";
        _label.style.fontSize = 14;
        
        // Add label to the root
        _root.Add(_label);
        
        // Add both properties
        var _healthProp = new PropertyField();
        _healthProp.BindProperty(_serializedObject.FindProperty(nameof(health)));
        
        var _speedProp = new PropertyField();
        _speedProp.BindProperty(_serializedObject.FindProperty(nameof(speed)));
        
        _root.Add(_healthProp);
        _root.Add(_speedProp);
        
        // Return the main container
        return _root;
    }
    #endif
}
```

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

### Define Custom Blackboard Variable Type (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/blackboard

Demonstrates how to create a custom blackboard variable type by inheriting from BlackboardGenericVariable<T>. This allows support for custom data types beyond the defaults.

```csharp
public class BooleanVariable : BlackboardGenericVariable<bool> {}

public class EnumVariable : BlackboardGenericVariable<MyEnum>
{
    public enum MyEnum
    {
        A = 0,
        B = 1,
        C = 2
    }
}
```

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

### Direct Graph Execution in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/logic/execute-graph

Executes a logic graph directly from a DataObject. This method is suitable for graphs that do not rely on scene-dependent component references. The code initializes the graph execution and logs the boolean result upon completion.

```csharp
public class ExecuteGraph : MonoBehaviour
{
    public DataLibrary data;
    
    [DataObjectDropdown("data")]
    public Logic graph;
    public void Start()
    {
        data.OnDataInitialized += Ready;
    }
    
    void Ready()
    {
        graph.ExecuteGraph().OnComplete(result => 
        {
            // Get the result value from the return node on completion.
            Debug.Log("Graph complete. Result is: " + result.boolValue);
        });
    }
}
```

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

### ShowAssetPreview Attribute for Game Object Preview (C#)

Source: https://giantgrey.gitbook.io/databrain/attributes/field-attributes

The ShowAssetPreview attribute creates a preview window of an assigned game object. This attribute can be configured with optional width and height parameters to control the size of the preview.

```csharp
// Example usage (assuming a field named 'previewObject' of type GameObject is declared)
// [ShowAssetPreview(width = 100, height = 100)]
// public GameObject previewObject;
```

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

### Subscribe to Research Unlocked Event (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/api/progresscontroller

This snippet illustrates subscribing to the OnResearchUnlocked event, which is invoked when new research nodes become available. The callback logs the count of newly unlocked nodes.

```csharp
progressController.OnResearchUnlocked += OnResearchUnlocked;

void OnResearchUnlocked(List<ProgressNode>_eventData)
{
      Debug.Log("New nodes has been unlocked " + _eventData.Count);
}
```

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

### Reference a DataObject in MonoBehaviour (C#)

Source: https://giantgrey.gitbook.io/databrain/guides/get-initial-data

Demonstrates how to reference a custom DataObject (EnemyData) within a MonoBehaviour script. This allows for easy assignment in the Unity Inspector by dragging and dropping the DataObject from the Databrain editor.

```csharp
public class Enemy : Monobehaviour
{
    // Our data object 
    public EnemyData enemyData;
}
```

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

### Subscribe to Research Progress Event (C#)

Source: https://giantgrey.gitbook.io/databrain/add-ons/progress/api/progresscontroller

This code shows how to subscribe to the OnResearchProgress event, which continuously reports the current progress of a research. The handler logs the progress value.

```csharp
progressController.OnResearchProgress += ResearchProgress;

void ResearchProgress(float _value)
{
    Debug.Log("current progress: " + _value);
}
```

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

### Create DataObjects Outside Databrain Editor (C#)

Source: https://giantgrey.gitbook.io/databrain/separate-dataobjects

This C# code snippet demonstrates how to create a custom menu entry in the Unity Project context menu to instantiate ScriptableObjects that derive from Databrain's DataObject. Ensure your ScriptableObject inherits from DataObject and uses the CreateAssetMenu attribute.

```csharp
using UnityEngine;

// This will add an entry to the Project context menu.
// Right click in the project view and you'll see the entry Data / MyObject
[CreateAssetMenu(menuName = "Data/MyObject")]
public class MyObject : DataObject {}

```

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

### Handling Graph Return Values with OnComplete in C#

Source: https://giantgrey.gitbook.io/databrain/add-ons/logic/execute-graph

Illustrates how to retrieve and process the return value of a logic graph upon its completion. This code snippet specifically targets the boolean value returned by a graph, logging it to the console.

```csharp
void ExecuteManuallyWithOnComplete()
{
    logicController.ExecuteGraph().OnComplete(result =>
    {
        // Get the result value from the return node on completion.
        Debug.Log("Graph complete. Result is: " + result.boolValue);       
    });
}
```

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

### Dynamically Clone DataObject to Runtime Library (C#)

Source: https://giantgrey.gitbook.io/databrain/guides/add-data-objects-at-runtime

This C# script shows how to dynamically clone a DataObject to the runtime library at runtime using the CloneDataObjectToRuntime method. It initializes a DataLibrary reference, clones an existing EnemyData object, and then modifies its properties. The owner GameObject is passed to ensure correct association of the runtime clone.

```csharp
using UnityEngine;
using Databrain;

public class AddToRuntimeLibrary : MonoBehaviour
{
    // The data library reference
    public DataLibrary data;
    
    // The data object we want to clone and add to the runtime library
    public EnemyData enemyData;
    
    public void Start()
    {
        // Always make sure data is initialized before accessing it
        data.OnDataInitialized += Ready;
    }
    
    void Ready()
    {
        // Clone the data objects enemyData and add it to the runtime library
        var _clonedData = data.CloneDataObjectToRuntime(enemyData, this.gameObject);
        
        // We can now modify the runtime data
        (_clonedData as EnemyData).health = 100;
        
        // Get runtime clone associated to this game object
        // var _clonedData = enemyData.GetRuntimeDataObject(this.gameObject);
        
    }
}
```
Tokens:
Raw