Inventory Custom Entries

In this tutorial, I want to show you how to extend the Game Creator inventory with custom entries. 
Prerequisites
Install Unity
Install IDE (I use Visual Studio 2019)
Import Game Creator
Import and enable the Inventory module
Game Creator Inventory
Before we begin, I want to talk a bit about the inventory of Game Creator. It is a module for Game Creator, which allows you to store items in it (as you would expect). It contains an item catalogue (the item store), a types section for the types of items you have, a recipes section for combining items to a new one and a settings section. All of these sections are saved in a database in your project. The database is nothing else than a serialized scriptable object of type DatabaseInventory, which derives from IDatabase. To display it within an editor window, you need to access this serialized object and transfer the values to the according property fields. I will cover this in a later tutorial when we make new editor windows step by step (one with scriptable objects, another without). 
Unity Editor Knowledge
In this tutorial we will, amother other things, change a script that derives from the Editorclass. Normally, when a script derives from Editor and you want to start building your project, the build will fail. This is because the class Editor is not available in built versions of the game, only in the Unity Editor. We have to place the script in a folder with the name Editor, so it doesn't get included in the built game. But why the name Editor? Unity uses so called Special folder names to tread a folder's content in a special way. See Unity Special Folders for more information. 
Script Architecture/Structure
In order to extend the inventory, we need to understand how the underlying script architecture. In the project window under Assets --> Plugins --> Game Creator --> Inventory, we have a bunch of folders. Animations are in the Animations folder, editor scripts in Editor folder, actions, conditions and many more scripts in Mono and so on. We need to change the following scripts: 
Filename
Folder
Usage
Derives from
Item.cs
/Mono/Items/
Defines the item object
Scriptable Object
ItemEditor.cs
/Editor/
Defines the Item Editor Window
Editor
The Item.cs defines the item object itself. This class is used when a new object of type Item is generated (like we do in the Inventory UI by clicking Create Item):  
This newly generated object will be stored in the database I mentioned in a previous chapter. A method inside the script ItemEditor.cs gets executed when you click on Inventory in the sidebar of the Game Creator Preferences window, basically reading the content of the database and displaying it. In the next chapter, we will take a look at the structure of these scripts. It is better to have a certain understanding of how the scripts are structured before we continue. 
Item.cs
This script contains the class Item, which contains the properties that can be set in the Inventory window and a method that allows us to create new item instances. It has properties like the name of the item, the description, if it can be sold, the price, item type and much more. There are two sections in this script. Properties and Constructor. Properties should be self-explanatory. If you open the script, we see that the Constructor (a method) section is only active in the Unity Editor. This is done with a so called define directive, here #if UNITY_EDITOR. These directives allow us to i.e. execute certain code only in the editor (like in this case), on certain platforms only (like Windows or MacOS) or when using certain Unity versions (like Unity 2020.1). Each of these define directives need an opening statement #if xxx and a closing statement #endif. 
1
#if UNITY_EDITOR
2
​
3
<Your code>
4
​
5
#endif
Copied!
ItemEditor.cs
This scripts however is much more complex. It not only contains constant variables, but static members and some methods as well. Again, we have two sections, Properties and Methods. When we open the script, we see that there are constant and static variables and a class before the Properties section. You might have heard of constant and static variables, but if not, they are not like normal variables. 
Constant variables are variables with a value that, once assigned at compile-time, will never change and cannot be changed. You can only assign primitive or C# builtin types, like string and float. 
Static members (i.e. variables and methods, in this case variables) are not accessible when you create a new instance of an object. They belong to the type of the object, not the instance of an object. Example: 
1
public class Inventory
2
{
3
    public static string name = "myName"; // static string variable
4
    public static string GetName() {...}  // static method with string return value
5
}
Copied!
If we create a new instance of the Inventoryclass, we won't be able to do the following: 
1
void MyMethod()
2
{
3
    Inventory myInventory  = new Inventory();
4
​
5
    Debug.Log(myInventory.name); // Doesn't work!
6
    myInventory.GetName();       // Doesn't work!
7
}
Copied!
We can only do this: 
1
void MyMethod()
2
{
3
    Debug.Log(Inventory.name); // Works!
4
    Inventory.GetName();       // Works!
5
}
Copied!
But back to the script. In the Properties section we have a bunch of SerializedProperty variables. A SerializedProperty is used when you want to access a value of a variable (property) of a serialized object. I will go deeper into this topic in a later tutorial. Finally, we have the Methods section of this class with all the methods. There are two particular methods to look for: OnEnable() and PaintContent()
For each item in the item database, a new object of type ItemEditor is instantiated and the method OnPreferencesWindowGUI of the same class gets called. When the objects gets instantiated, it automatically calls OnEnable(), what reads the variables of the underlying database item of type Item(which is now a serialized object) and sets the values of the ItemEditorserialized property variables to the according Item variable values (like itemName, sprite, price etc.). OnPreferencesWindowGUI does some more stuff, but also calls PaintContent(). This method paints the content of the window where the items are shown. Because we now have the serialized properties with the values of the item in the database, it is possible to simply add an EditorGUILayout.PropertyField with the serialized property as the value. Example: 
1
// The code is simplified and shortened for better understanding
2
​
3
private const string PROP_PREFAB = "prefab";
4
​
5
void OnEnable()
6
{
7
    this.spPrefab= serializedObject.FindProperty(PROP_PREFAB);
8
}
9
​
10
public void PaintContent()
11
{
12
    EditorGUILayout.PropertyField(this.spPrefab);
13
}
Copied!
Note: serializedObject refers to the item in the database and PROP_PREFAB to the variable. serializedObject.FindProperty(PROP_PREFAB) does nothing else than grab the value of the  item object like we would with GameObject prefab = item.prefab. 
Extending the inventory
Now that we have covered many things around the Game Creator inventory, we are ready to continue. For the start, let's add a string variable to the Item class (Item.cs). You can give any name you want. This is the first step to extend the inventory. Add it in the Properties section between the public GameObject prefab and public bool canBeSold variables. You can later put it anywhere in this section you like, but I do it this way for you to better understand. I include the previous and next one as well. 
1
public GameObject prefab;
2
​
3
public string myVariable; // I know, not a good name...
4
​
5
public bool canBeSold = true;
Copied!
Save it and jump over to the ItemEditor class (ItemEditor.cs). Here we do more things: 
1.Add a private constant string variable
2.Add a public SerializedProperty variable
3.Assign our SerializedProperty variable in OnEnable()
4.Add a EditorGUILayout.PropertyField to PaintContent()
Let's start with the first step. Add the private constant string variable in the same position you added your string variable in the Item class: 
1
private const string PROP_PREFAB = "prefab";
2
private const string PROP_MYVARIABLE = "myVariable";
3
private const string PROP_CANBESOLD = "canBeSold";
Copied!
Attention: The value of the constant string must be the same as the name of your added variable in the Item class! In my case, my variable is called myVariable, that's why the constant string must also be myVariable. 
The next thing we do is add a SerializedProperty variable to the Properties section: 
1
private SerializedProperty spPrefab;
2
private SerializedProperty spMyVariable;
3
private SerializedProperty spCanBeSold;
Copied!
Now we assign our SerializedProperty variable the value of the property value of the serialized object in the method OnEnable(): 
1
this.spPrefab = serializedObject.FindProperty(PROP_PREFAB);
2
this.spMyVariable = serializedObject.FindProperty(PROP_MYVARIABLE);
3
this.spCanBeSold = serializedObject.FindProperty(PROP_CANBESOLD);
Copied!
And finally we add a property field to the method that paints the content of the window, PaintContent(): 
1
EditorGUILayout.PropertyField(this.spPrefab);
2
​
3
EditorGUILayout.Space();
4
​
5
EditorGUILayout.PropertyField(this.spMyVariable);
6
​
7
EditorGUILayout.Space();
8
​
9
EditorGUILayout.PropertyField(this.spCanBeSold);
Copied!
If we switch back to Unity and let it compile, open the Game Creator Preferences window, go to the Inventory tab and create a new item. You should now see our newly added variable. 
You can add as many custom entries this way as you like. You can add i.e. weapons (from the Shooter module) or anything else. Have fun making games!
GC API Guides - Previous
Access Player Using HookPlayer
Next - GC API Guides
Accessing Scriptable Objects
Last modified 9mo ago
Copy link
Contents
Prerequisites
Game Creator Inventory
Unity Editor Knowledge
Script Architecture/Structure
Extending the inventory