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.