# Variables Access Accessing variables is done though the `VariablesManager` static class. {% hint style="info" %} To use it make sure you include the namespace `GameCreator.Variables`. {% endhint %} Variables follow a very simple convention. Accessing global variables is done through the `GetGlobal` and `SetGlobal` static methods. Homonymously, accessing local variables is done through the `GetLocal` and `SetLocal` methods. ## Global Variables Global Variables have a wide application scope and their values are shared between all scenes. ### Get Global Variables Accessing a global variable can be done specifying the return type or by requesting a generic object and later explicitly casting it to a usable type. {% hint style="success" %} Despite having two methods for getting and setting global variables, it's highly recommended explicitly specifying the type. Otherwise casting errors might arise. {% endhint %} ```csharp public static object GetGlobal(string name) ``` ### Set Global Variables Setting a global variable value also very easy. ```csharp public static void SetGlobal(string name, object value) ``` ### Exist Global Variables You can also check if a global variable has been defined. ```csharp public static bool ExistsGlobal(string name) ``` ## Local Variables Local variables pretty much work the same way as global variables. The difference is that they need a target object from where to start looking for the variable's value. ### Get Local Variables If the `inChildren` property is set to `true`, then the variable will be depth-search through the `target` game object and its children. {% hint style="warning" %} Depth searching through a target and its children comes at a small performance cost. {% endhint %} ```csharp public static object GetLocal(GameObject target, string name, bool inChildren = false) ``` ### Set Local Variables Setting a local variable value is as easy as getting them: ```csharp public static void SetLocal(GameObject target, string name, object value, bool inChildren = false) ``` ### Exist Local Variables Checking if a local variable exists is done exactly like with global variables ```csharp public static bool ExistsLocal(GameObject target, string name, bool inChildren = false) ``` ## List Variables **List Variables** code syntax is a bit different from the **Local** and **Global Variables**. Instead of setting or getting a single variable, you insert a variable into an array-placed collection of variables. ### Get List Variables Get the element of a **List Variables** based on the `ListVariables.Position` enum. ```csharp public static Variable GetListItem(ListVariables list, ListVariables.Position position, int index = 0) ``` The **`ListVariables.Position`** enum has the following options: * **Index:** Access by zero-based index. Requires an extra parameter with an index * **First:** Access the first element * **Last:** Access the last element * **Previous:** Access the previous element based on the iterator's value * **Current:** Access the element pointed by the iterator's value * **Next:** Access the next element based on the iterator's value * **Random:** Access a random position ### Set List Variables Insert or remove an element of a **List Variables** object. A List Variable cannot update its value. ```csharp public static void ListPush(ListVariables target, int index, object value) ``` ```csharp public static void ListPush(ListVariables target, ListVariables.Position position, object value) ``` {% hint style="info" %} If you want to add a new element using an index, use: **`ListPush(target, index, value);`** However, if you want to add a new element using one of the dynamic pointers provided by Game Creator (First, Last, Random, Next, Current, ...) use the second method **`ListPush(target, ListVariables.Position.Random, value);`** {% endhint %} ```csharp public static void ListRemove(GameObject target, ListVariables.Position position) ``` ## Examples Here are some common examples. Let's say you have a Global Variable called **`player-score`** stored in as a **Number**. **Number** type variables are **`floats`**. ```csharp public float GetPlayerScore() { object result = VariablesManager.GetGlobal("player-score"); return (float)result; } ``` Notice how **`GetGlobal`** returns an **`object`**. This means that the result can be anything: from a **`float`**, a **string**, a **`Game Object`** or even **`null`**! You have to know beforehand the type of the variable you're trying to access and use an explicit cast to transform an object into the type you want; in this case, a **`float`**. Now let's say we want to increase the previous variable each time the player wins the game. ```csharp public void IncreasePlayerScore() { float score = this.GetPlayerScore(); VariablesManager.SetGlobal("player-score", score + 1); } ``` Using the previous method, we can easily get the current player's score and call the **`SetGlobal`** method to store the current score plus 1. ## TypeProperties When integrating Game Creator with your custom scripts you'll want to make use of both constant variable values (float, strings, ...) and Game Creator Variables. This is where TypeProperties come to play. Instead of declaring a public float value so you can set up its value in the Inspector, use a NumberProperty. It will allow you to choose between a constant value, a local variable or a global variable. This is better explained with an example. Imagine you have a script where you need to use a string value that references the player's name. You would normally write: ```csharp public class Player : MonoBehaviour { public string playerName = "John"; public void Awake() { Debug.Log(playerName); } } ``` And in the Inspector this component would display as a textfield where you can modify the `playerName` property. Using TypeProperty (`StringProperty` in this case) you can define in edit-mode whether if `playerName` variable will use a constant value or any other Game Creator variable value. ```csharp public class Player : MonoBehaviour { public StringProperty playerName = new StringProperty("John"); public void Awake() { Debug.Log(playerName.GetValue(gameObject)); } } ``` If the user has decided to use a **constant value** `"John"` as the `playerName` value, `playerName.GetValue(gameObject)` will return a string with `"John".` If the user uses a **Global Variable** or a **Local Variable** for `playerName`, using `playerName.GetValue(gameObject)` will return the Global/Local variable's value. The *Game Object* parameter passed is optional. It is used to reference the Invoker object in case the property is set to use as the target the Invoker option. --- # Agent Instructions: 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: ``` GET https://docs.gamecreator.one/game-creator/systems/game-creator-api/variables-access.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.