ScriptableObjects for game data in Unity - Mini Project: Build & Apply

ScriptableObjects for game data

📖 Scenario: You are creating a simple game where you want to store data about different weapons. Instead of hardcoding the data, you will use Unity's ScriptableObjects to keep the weapon data separate and easy to manage.

🎯 Goal: Build a ScriptableObject in Unity to hold weapon data like name, damage, and range. Then create a script to use this data in the game.

📋 What You'll Learn

Create a ScriptableObject class called WeaponData with fields for weaponName (string), damage (int), and range (float).

Create an instance of WeaponData in the Unity Editor.

Create a MonoBehaviour script called WeaponUser that has a public WeaponData variable.

In WeaponUser, write code to print the weapon's name, damage, and range to the console.

💡 Why This Matters

🌍 Real World

ScriptableObjects help organize and reuse game data easily without hardcoding values. This makes your game easier to manage and extend.

💼 Career

Game developers use ScriptableObjects to separate data from logic, improving workflow and collaboration between designers and programmers.

1

Create the WeaponData ScriptableObject class

Create a public class called WeaponData that inherits from ScriptableObject. Add public fields: string weaponName, int damage, and float range. Add the [CreateAssetMenu] attribute with fileName = "NewWeaponData" and menuName = "Game Data/Weapon Data".

Unity

# Your code here to create WeaponData ScriptableObject class

Hint

Remember to use ScriptableObject as the base class and add the CreateAssetMenu attribute to make it easy to create instances in the editor.

2

Create a WeaponData asset in the Unity Editor

In the Unity Editor, create a new WeaponData asset by right-clicking in the Project window, then selecting Game Data > Weapon Data. Name it BasicSword and set weaponName to "Basic Sword", damage to 10, and range to 1.5.

Unity

using UnityEngine;

[CreateAssetMenu(fileName = "NewWeaponData", menuName = "Game Data/Weapon Data")]
public class WeaponData : ScriptableObject
{
    public string weaponName;
    public int damage;
    public float range;
}

// Create the WeaponData asset in the Unity Editor as instructed

Hint

This step is done in the Unity Editor, not in code. Make sure you create the asset and set the fields exactly as instructed.

3

Create WeaponUser script to use WeaponData

Create a public class called WeaponUser that inherits from MonoBehaviour. Add a public field WeaponData weaponData. In the Start() method, write code to print the weapon's name, damage, and range using Debug.Log.

Unity

using UnityEngine;

public class WeaponUser : MonoBehaviour
{
    public WeaponData weaponData;

    void Start()
    {
        // Your code here to print weapon data
    }
}

Hint

Use Debug.Log inside the Start() method to print the weapon data fields.

4

Assign WeaponData asset and test output

Attach the WeaponUser script to a GameObject in the scene. Assign the BasicSword WeaponData asset to the weaponData field in the Inspector. Run the game and observe the console output.

Unity

using UnityEngine;

// Attach WeaponUser to a GameObject and assign BasicSword asset
// Run the game to see output in console

Hint

Make sure you assign the ScriptableObject asset to the script in the Inspector before running the game.

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