ScriptableObjects for game data in Unity - Step-by-Step Execution

Concept Flow - ScriptableObjects for game data

Create ScriptableObject class

↓

Create asset instance in Editor

↓

Assign data in asset

↓

Reference asset in game scripts

↓

Use data at runtime

↓

Game behavior based on data

This flow shows how you create a ScriptableObject class, make an asset in Unity Editor, assign data, then use it in game scripts to control behavior.

Execution Sample

Unity

using UnityEngine;

[CreateAssetMenu(menuName = "Game/EnemyData")]
public class EnemyData : ScriptableObject {
    public string enemyName;
    public int health;
}

Defines a ScriptableObject class to hold enemy data like name and health.

Execution Table

Step	Action	Code/Editor	Result/State
1	Define ScriptableObject class	public class EnemyData : ScriptableObject {...}	EnemyData type created
2	Create asset in Editor	Right-click > Create > Game > EnemyData	EnemyData asset file created
3	Assign data in asset	enemyName = "Goblin", health = 50	Asset stores Goblin data
4	Reference asset in script	public EnemyData enemyData;	Script can access asset data
5	Use data at runtime	Debug.Log(enemyData.enemyName);	Prints 'Goblin' in console
6	Modify asset data	health = 75	Asset data updated, affects all references
7	Exit	Game runs using asset data	Game uses centralized data for enemies

💡 Execution stops after game uses ScriptableObject data for behavior

Variable Tracker

Variable	Start	After Step 3	After Step 6	Final
enemyName	null	"Goblin"	"Goblin"	"Goblin"
health	0	50	75	75
enemyData	null	reference to asset	reference to asset	reference to asset

Key Moments - 3 Insights

Why does changing the ScriptableObject asset affect all game objects using it?

Because all references point to the same asset instance, so changing the asset updates data everywhere (see execution_table step 6).

Can I create ScriptableObject instances at runtime like normal classes?

Usually no; ScriptableObjects are created as assets in Editor to hold shared data (see concept_flow step 2).

How do I access ScriptableObject data in my game scripts?

By creating a public variable referencing the asset and assigning it in the Inspector (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution_table, what is the enemyName value after step 3?

A "Orc"

B "Goblin"

C null

D "Dragon"

💡 Hint

Check the 'Result/State' column at step 3 in execution_table.

At which step does the health value change from 50 to 75?

A Step 3

B Step 4

C Step 6

D Step 5

💡 Hint

Look at variable_tracker for health changes and execution_table step 6.

If you create a new ScriptableObject asset, what must you do to use it in a script?

A Assign it to a public variable in the Inspector

B Call new EnemyData() in code

C Nothing, it auto-links

D Write data directly in the script

💡 Hint

See execution_table step 4 about referencing assets in scripts.

Concept Snapshot

ScriptableObjects hold shared game data as assets.
Create a class inheriting ScriptableObject.
Make asset in Editor, assign data.
Reference asset in scripts via public variables.
Changing asset updates all references.
Used for centralized, reusable data.

Full Transcript

ScriptableObjects are special data containers in Unity used to store game data like enemy stats. First, you create a class that inherits from ScriptableObject. Then, in the Unity Editor, you create an asset of this class and fill in the data, such as enemy name and health. In your game scripts, you add a public variable to reference this asset and assign it in the Inspector. At runtime, your game uses this data to control behavior. If you change the asset data, all game objects using it see the update because they share the same asset instance. This approach helps keep data centralized and easy to manage.

Practice

1. What is the main purpose of using ScriptableObjects in Unity game development?

easy

A. To create visual effects in the game

B. To store game data separately from code for easy reuse and editing

C. To handle player input events

D. To manage network connections

Solution

1. Step 1: Understand ScriptableObjects role

   ScriptableObjects are designed to hold data independently from scripts, making data reusable and editable without changing code.

2. Step 2: Compare with other options

   Visual effects, input handling, and network management are unrelated to ScriptableObjects' main use.

3. Final Answer:

   To store game data separately from code for easy reuse and editing -> Option B

4. Quick Check:

   ScriptableObjects = Data storage and reuse [OK]

Hint: ScriptableObjects separate data from code for reuse [OK]

Common Mistakes:

• Thinking ScriptableObjects handle game logic
• Confusing ScriptableObjects with MonoBehaviour scripts
• Assuming ScriptableObjects manage input or graphics

2. Which of the following is the correct way to make a ScriptableObject asset creatable from the Unity Editor menu?

easy

A. [CreateAssetMenu()]
public class GameData : MonoBehaviour {}

B. [CreateMenuAsset(fileName = "NewData")]
public class GameData : MonoBehaviour {}

C. [CreateAssetMenu(fileName = "NewData", menuName = "Game/Data")]
public class GameData : ScriptableObject {}

D. [CreateAssetMenu(fileName = "NewData")]
public class GameData : GameObject {}

Solution

1. Step 1: Identify correct attribute usage

   The correct attribute is [CreateAssetMenu] with optional parameters like fileName and menuName, applied to a class inheriting from ScriptableObject.

2. Step 2: Check class inheritance and syntax

   Only [CreateAssetMenu(fileName = "NewData", menuName = "Game/Data")] public class GameData : ScriptableObject {} uses ScriptableObject as base class and correct attribute syntax. Others use wrong attributes or base classes.

3. Final Answer:

   [CreateAssetMenu(fileName = "NewData", menuName = "Game/Data")] public class GameData : ScriptableObject {} -> Option C

4. Quick Check:

   CreateAssetMenu + ScriptableObject = [CreateAssetMenu(fileName = "NewData", menuName = "Game/Data")] public class GameData : ScriptableObject {} [OK]

Hint: Use [CreateAssetMenu] on ScriptableObject class [OK]

Common Mistakes:

• Using MonoBehaviour instead of ScriptableObject
• Wrong attribute name like CreateMenuAsset
• Missing inheritance from ScriptableObject

3. Given this ScriptableObject class and usage, what will be printed in the console?

using UnityEngine;

[CreateAssetMenu(fileName = "EnemyData", menuName = "Game/Enemy")]
public class EnemyData : ScriptableObject {
    public int health = 100;
}

public class Enemy : MonoBehaviour {
    public EnemyData data;
    void Start() {
        Debug.Log($"Enemy health: {data.health}");
    }
}

medium

A. Enemy health: 100

B. Enemy health: 0

C. NullReferenceException error

D. Enemy health: undefined

Solution

1. Step 1: Understand ScriptableObject default value

   The EnemyData ScriptableObject has a public int health initialized to 100.

2. Step 2: Check usage in Enemy class

   The Enemy class references EnemyData and logs its health value in Start(). If data is assigned in editor, health is 100.

3. Final Answer:

   Enemy health: 100 -> Option A

4. Quick Check:

   ScriptableObject field health = 100 [OK]

Hint: Default values in ScriptableObjects show when assigned [OK]

Common Mistakes:

• Assuming health is zero without asset assignment
• Expecting runtime initialization instead of default
• Confusing ScriptableObject with null reference

4. What is wrong with this ScriptableObject usage code?

public class PlayerData : ScriptableObject {
    public int score;
}

public class Player : MonoBehaviour {
    public PlayerData data = new PlayerData();
    void Start() {
        Debug.Log(data.score);
    }
}

medium

A. You cannot use 'new' to create ScriptableObject instances

B. Missing [CreateAssetMenu] attribute

C. score variable must be private

D. MonoBehaviour cannot have ScriptableObject fields

Solution

1. Step 1: Check ScriptableObject instantiation

   ScriptableObjects cannot be created with 'new'. They must be created with ScriptableObject.CreateInstance or as assets.

2. Step 2: Analyze other options

   Missing CreateAssetMenu is not an error, score can be public, and MonoBehaviour can have ScriptableObject fields.

3. Final Answer:

   You cannot use 'new' to create ScriptableObject instances -> Option A

4. Quick Check:

   Use CreateInstance, not new [OK]

Hint: Never use 'new' with ScriptableObjects [OK]

Common Mistakes:

• Trying to instantiate ScriptableObject with 'new'
• Confusing CreateAssetMenu as required for all ScriptableObjects
• Thinking public fields must be private

5. You want to create a reusable game item data system using ScriptableObjects that allows you to define multiple items with different stats and share them across scenes. Which approach is best?

hard

A. Use static variables in a class to hold all item stats

B. Create a MonoBehaviour script with public variables and attach it to each item prefab

C. Store item data in PlayerPrefs and load it at runtime

D. Create a ScriptableObject class for item data, use [CreateAssetMenu], create assets for each item, and reference them in scene objects

Solution

1. Step 1: Identify best data storage method

   ScriptableObjects allow creating asset files for each item, reusable and editable independently from scenes.

2. Step 2: Compare alternatives

   MonoBehaviour scripts tie data to objects, PlayerPrefs is for player settings, static variables lack flexibility and serialization.

3. Final Answer:

   Create a ScriptableObject class for item data, use [CreateAssetMenu], create assets for each item, and reference them in scene objects -> Option D

4. Quick Check:

   ScriptableObjects for reusable shared data [OK]

Hint: Use ScriptableObject assets for reusable game data [OK]

Common Mistakes:

• Using MonoBehaviour for shared data causes duplication
• Storing game data in PlayerPrefs is not suitable
• Static variables do not serialize or edit easily