Rapid prototyping with ScriptableObjects

Rapid prototyping
in Unity using
ScriptableObjects

What I’ll talk about today
• What ScriptableObjects are

• How to create and use them

• Why they will make your life easier

• How they will make your designers happy

• Pros and cons

• Bonus: example project

Who I am
• Hi, my name is Giorgio Pomettini

• I teach programming and history of videogames at AIV

• I worked on several mobile projects in Unity

• Today it’s my birthday 🎂

Player Enemy
GameObject.Find("Enemy").GetComponent<Enemy>().Damage();

Player Enemy
Enemy 2
Enemy 3
Enemy 4UI
Menu
Boss
Sword

Player Enemy
Enemy 2
Enemy 3
Enemy 4UI
Menu
Boss
Sword
Game
Manager

What is a Singleton?
public class GameManager : MonoBehaviour
{
// Static instance of GameManager
// Which allows to be accessed from other scripts
public static GameManager Instance = null;
void OnAwake()
{
Instance = this;
}
}

What is a Singleton?
public class GameManager : MonoBehaviour
{
public static GameManager Instance = null;
public int Score;
void OnAwake()
{
Instance = this;
}
}
public class SampleUI : MonoBehaviour
{
public Text ScoreLabel;
void Update()
{
ScoreLabel.text = GameManager.Instance.Score.ToString();
}
}

Singleton Pros
• They are globally accessible

• They hold persistent data*

• They are easy to implement

Singleton Cons
• Rigid connection

• No polymorphism

• Hard to test

• There can be only one instance

What are ScriptableObjects
• It’s like a MonoBehaviour, but it’s not a Component

• Can not be attached to GameObjects

• Can be serialized (can be transformed into a format that
Unity can store and reconstruct later)
• Saved as .asset ﬁle

public class SampleScriptableObject : ScriptableObject
{
}
What are ScriptableObjects

public class PokemonEntry : ScriptableObject
{
public string Name;
public int BaseHP;
public int BaseAttack;
public int BaseDefense;
public int BaseSpeed;
}
Example
[CreateAssetMenu]

Example
public class Pokedex : MonoBehaviour
{
public PokemonEntry Entry;
void Start()
{
Debug.LogFormat("{0} has {1} Base HP", Entry.Name, Entry.BaseHP);
}
}
Output: Pikachu has 35 Base HP

Common use cases
• Game conﬁg ﬁles

• Cards

• Inventory

• Pokemon Enemy stats

• Any type of shared data that needs tweaking

C# Script C# Script
Serialized by Unity Serialized by Unity
Can use custom Editors Can use custom Editors
OnEnable/OnDisable callbacks OnEnable/OnDisable callbacks
Update and other callbacks No Update callbacks
Lives in scenes or prefabs Lives on disk or in memory
Data is reset when exiting Play Mode Stores data when exiting Play Mode
MonoBehaviour vs ScriptableObject

ScriptableObjects callbacks
• OnEnable()
• Called when instanced or loaded

• Also called after a script recompilation

• OnDestroy()
• Called after Object.Destroy()

• OnDisable()
• Called right before OnDestroy() when object is about to be destroyed

• Also called before script recompilation

// Create an instance
var pokemon = ScriptableObject.CreateInstance<PokemonEntry>();
// Save to disk
AssetDatabase.CreateAsset(pokemon, "Assets/MyPokemon.asset");
// Or keep it in memory
pokemon.hideFlags = HideFlags.HideAndDontSave;
How to create them
// Make .asset from project view
[CreateAssetMenu]

Beneﬁts
• Clean separation between data and code

• Can be created and used easily by designers

• Keeps data while editing in play mode

• They work well with version control systems such as Git

• Your scenes and prefabs will load faster (why?)

Enums
• Must change in code

• Diﬃcult to remove or reorder

• Solution: Pluggable Enums

• Empty ScriptableObjects that can be created and
assigned by designers

• Can hold additional data

• Supports null

Enums
[CreateAssetMenu]
public class PokemonStatus : ScriptableObject
{
}

Better Enums
[CreateAssetMenu]
public class PokemonType : ScriptableObject
{
public List<PokemonType> NoEffect;
public List<PokemonType> NotEffective;
public List<PokemonType> SuperEffective;
}

Better Enums
Normal attacks Ghost
Does the Ghost’s list of no eﬀects types contains Normal?
If so, the attack does no eﬀect
[Check other conditions]

Better Enums
public class PokemonTypesTester : MonoBehaviour
{
public PokemonType AttackingType;
public PokemonType DefendingType;
void Start()
{
string message = AttackingType.name;
if (DefendingType.NoEffect.Contains(AttackingType))
message += " has no effect on ";
else if (DefendingType.NotEffective.Contains(AttackingType))
message += " is not effective on ";
else if (DefendingType.SuperEffective.Contains(AttackingType))
message += " is super effective on ";
else
message += " has normal effect on ";
message += DefendingType.name;
Debug.Log(message);
}
} Output: Normal has no eﬀect on Ghost

ScriptableObjects
Architecture

• Designers can create and assign those variables

• They can plug them whenever they need it

• The value can change when the game is running

• Anything that references that value will get an update
Pluggable Variables
[CreateAssetMenu]
public class IntVariable : ScriptableObject
{
public int Value;
}

Pluggable Variables
public class Player : MonoBehaviour
{
public IntVariable Money;
public IntVariable Badges;
}
Use for values that needs to be shared, for instance:

• Score

• Player HP

• Timing data

Pluggable Variables
PlayerMoney
Player ItemShop
PlayerScreenUI
SafariZone

Pluggable Variables
[CreateAssetMenu]
public class FloatVariable : ScriptableObject
{
public float Value;
}
[CreateAssetMenu]
public class GameObjectList : ScriptableObject
{
List<GameObject> List;
}

UnityEvents
• Rigid connections (again)

• A button is referencing the object that responds to it

• Solution: Pluggable Events
• ScriptableObjects that sends messages to listeners
that can be created and assigned by designers

• Warning: They allocate (don’t invoke them in Update)
• They also can be a bit tricky to debug

Pluggable Events
OnPlayerDefeated
public class Player : MonoBehaviour
{
// Variables
public IntVariable Money;
public IntVariable Badges;
// Events
public GameEvent OnPlayerDefeated;
void Start()
{
OnPlayerDefeated.Raise();
}
}

Pluggable Events
OnPlayerDefeated
Player GameEventListener
OnPlayerDefeated.Raise();

[CreateAssetMenu]
public class GameEvent : ScriptableObject
{
private List<GameEventListener> eventListeners = new List<GameEventListener>();
public void Raise()
{
for (int i = eventListeners.Count - 1; i >= 0; i--)
eventListeners[i].OnEventRaised();
}
public void RegisterListener(GameEventListener listener)
{
if (!eventListeners.Contains(listener))
eventListeners.Add(listener);
}
public void UnregisterListener(GameEventListener listener)
{
if (eventListeners.Contains(listener))
eventListeners.Remove(listener);
}
}
Pluggable Events

Pluggable Events
public class GameEventListener : MonoBehaviour
{
public GameEvent Event;
public UnityEvent Response;
private void OnEnable()
{
Event.RegisterListener(this);
}
private void OnDisable()
{
Event.UnregisterListener(this);
}
public void OnEventRaised()
{
Response.Invoke();
}
}

OnPlayerDefeated
Player DecreaseMoney
GameOverScreen
TeleportPlayer
Pluggable Events

Designer-friendly FSMs
Patrol
ChaseAttack
Yes, ScriptableObjects can also have functions and not only data!

Designer-friendly FSMs
• Works like the State/Strategy Pattern

• You have diﬀerent behaviors in diﬀerent ScriptableObjects
and you swap them based on your needs

Unit Testing
• Have you tried testing a MonoBehaviour class?

• Yup, it’s almost impossible

• You often have tight dependencies

• You cannot instantiate them directly

• But you can do them with ScriptableObjects!

• You can make scripts to test them in isolation

• You can also easily create mock objects if needed

Wait, but was that a talk
about rapid prototyping?

Rapid prototyping
• Since ScriptableObjects are saved as .asset ﬁles, they’re
highly reusable between projects

• You can write scripts that accepts Pluggable Variables and
Pluggable Events so designers can “compose” behaviours
public class ImageFillSetter : MonoBehaviour
{
public FloatVariable Variable;
public float Min;
public float Max;
public Image Image;
private void Update()
{
// Sets image fill amount based on clamped value of FloatVariable
Image.fillAmount = Mathf.Clamp01(Mathf.InverseLerp(Min, Max, Variable.Value));
}
}

Frameworks
https://github.com/AdamRamberg/unity-atoms

Frameworks
https://github.com/DanielEverland/ScriptableObject-Architecture

References used
• Unite 2016 - Overthrowing the MonoBehaviour Tyranny in
a Glorious Scriptable Object Revolution (Richard Fine)
• Unite Austin 2017 - Game Architecture with Scriptable
Objects (Ryan Hipple)
• Unite '17 Seoul - ScriptableObjects What they are and
why to use them (Ian Dundore)
• Unity Blog - Making cool stuﬀ with ScriptableObjects
(Matt Shell)

• Mail: giorgio.pomettini@gmail.com

• Website: www.videogio.co

• Company: Accademia Italiana Videogiochi

• Twitter: @dreamquest

• Github: @pomettini

Rapid prototyping with ScriptableObjects

More Related Content

What's hot (20)

Similar to Rapid prototyping with ScriptableObjects (20)

More from Giorgio Pomettini (6)

Recently uploaded (20)

Rapid prototyping with ScriptableObjects