What is a Scriptable Object in Unity

June 07, 2024

Introduction

In Unity, Scriptable Object are powerful tools that can store data separate from game items. They fix a number of problems that come with regular C# classes and MonoBehaviors. Scriptable Object make it easier to handle data, streamline workflows, and boost performance.

What are Scriptable Object?

Scriptable Object in Unity are like storage containers for data that aren’t game items or scenes. They can hold a lot of data. Scriptable Object are asset files that you make, edit, and serialize right in the Unity Editor. MonoBehaviors, on the other hand, attach to GameObject.

Why Use Scriptable Object?

  1. Data Persistence: Scriptable Object persist independently of scenes. You can store data across multiple scenes without reloading or recreating it.

  2. Performance: Scriptable Object reduce memory usage by sharing data between multiple objects. This is useful for large data sets or frequently accessed data.

  3. Modular Design: Scriptable Object encourage a modular and decoupled code architecture. You define data in one place and reference it wherever needed.

  4. Ease of Editing: You can edit Scriptable Object in the Unity Editor, providing a user-friendly interface for modifying data without coding.

Creating Scriptable Object

Creating a Scriptable Object involves two main steps: defining the Scriptable Object class and creating instances of that class.

Step 1: Define the Scriptable Object Class

Here is an example of a simple Scriptable Object for a game item: 

using UnityEngine;

[CreateAssetMenu(fileName = "NewItem", menuName = "Inventory/Item")]
public class Item : ScriptableObject
{
    public string itemName;
    public Sprite itemIcon;
    public int itemID;
    public string description;
}

The CreateAssetMenu attribute allows you to create new instances of the Scriptable Object directly from the Unity Editor.

Step 2: Create an Instance of the Scriptable Object

  1. In the Unity Editor, go to Assets -> Create -> Inventory -> Item.

  2. This action creates a new asset file in your project directory.

  3. Select the newly created asset to edit its properties in the Inspector window.

Using Scriptable Object

Once created, you can use Scriptable Object in various ways. For instance, you can reference them in MonoBehaviours to manage game data: 

using UnityEngine;

public class ItemManager : MonoBehaviour
{
    public Item currentItem;

    void Start()
    {
        if (currentItem != null)
        {
            Debug.Log("Item Name: " + currentItem.itemName);
            Debug.Log("Item ID: " + currentItem.itemID);
        }
    }
}

In this example, the “ItemManager" class references a “currentItem" Scriptable Object.

This allows you to assign different items via the Unity Editor and access their data during runtime.

Advanced Uses of Scriptable Object

Scriptable Object are not limited to simple data storage. You can use them for:

  • Game Settings: Store configuration settings like audio levels, screen resolutions, or control mappings.

  • AI Configurations: Define behaviors and attributes for AI characters.

  • Level Data: Store data for levels such as enemy spawn points, collectible locations, or environmental parameters.

  • State Machines: Implement state machines for character states or game states using Scriptable Object to define state properties and transitions.

Conclusion

Scriptable Object are a great tool in Unity that makes managing and sharing data easy and organized. You can improve both speed and workflow by separating data from game object and using the Unity Editor’s features. Scriptable Object can make your project much more structured and easy to manage, whether you are making a simple inventory system or a complicated game architecture.