1.
Ryan Hipple
Principal Engineer
Schell Games

2.
Schell Games
VR / AR
Theme Parks
Transformational Games

3.
Game Architecture with
Scriptable Objects

4.
Engineering
Pillars
Modular
Editable
Debuggable

5.
Modular
Systems not directly dependent on each other
Scenes are clean slates
Prefabs work on their own
Components!

6.
Editable
Focus on data
Change the game without code
Emergent Design
Change at runtime

7.
Debuggable
Test in isolation (modularity)
Debug views and features
Never fix a bug you do not understand

8.
Engineering
Pillars
Modular
Editable
Debuggable

9.
Scriptable Object Basics

10.
Primer
Serializable Unity Class
Similar to MonoBehaviour, no Transform
Saved as .asset file

11.
Simple Use Cases
Game config files
Inventory
Enemy stats
AudioCollection

12.
Architecture

13.
Singleton Benefits
Access anything from anywhere
Persistent State
Easy to understand
Consistent pattern
Easy to “plan”
*Lies
*

14.
Singleton Problems
Rigid Connections / Not Modular
No Polymorphism
Not Testable
Dependency Nightmare
Single Instance!

15.
Solutions
Reduce need for global managers
Inversion of Control
Example: Dependency Injection
Objects are given dependencies
Single responsibility principle

16.
Modular Data

17.
Enemy Prefab Example
EnemyManager.Instance.MoveSpeed?
Hard reference
Dependency on manager being loaded
EnemyConfig ScriptableObject reference?
Lumps all part of the enemy stats together
Limits extension / modularity
Better?

18.
ScriptableObject Variables
[CreateAssetMenu]
public class FloatVariable : ScriptableObject
{
public float Value;
}

19.
ScriptableObject Variables
Hitpoints
Damage Amounts
Timing Data
public class DumbEnemy : MonoBehaviour
{
public FloatVariable MaxHP;
public FloatVariable MoveSpeed;
}

20.
Float Reference
[Serializable]
public class FloatReference
{
public bool UseConstant = true;
public float ConstantValue;
public FloatVariable Variable;
public float Value
{
get { return UseConstant ? ConstantValue :
Variable.Value; }
}
}

21.
Float Variable
public class DumbEnemy : MonoBehaviour
{
public FloatVariable MaxHP;
public FloatVariable MoveSpeed;
}
public class DumbEnemy : MonoBehaviour
{
public FloatReference MaxHP;
public FloatReference MoveSpeed;
}

22.
Float Variable Secrets
[CreateAssetMenu]
public class FloatVariable : ScriptableObject
{
public float Value;
}

23.
PlayerHPPlayer
EnemyAI
HealthUI
Audio
System

24.
Demo!

25.
Event Architecture

26.
Event Architecture
Modularize systems
Reuse in other projects
Isolates Prefabs
Optimize, only execute when needed
Highly debuggable

27.
UnityEvent
*Serialized Function Call
*

28.
UnityEvent Advantages
Editor hook-ups
Less code, fewer assumptions
Pass Arguments
Extend UnityEvent<T>
Static / dynamic arguments

29.
UnityEvent Problems
Rigid bindings
Button hard references what responds to it
Limited serialization
Garbage allocation

30.
Making Our Own Events
Data driven
Designer authorable
Debuggable

31.
Making Our Own Events
[CreateAssetMenu]
public class GameEvent : ScriptableObject
{
private List<GameEventListener> listeners =
new List<GameEventListener>();
public void Raise()
{
for(int i = listeners.Count -1; i >= 0; i--)
listeners[i].OnEventRaised();
}
public void RegisterListener(GameEventListener listener) ...
public void UnregisterListener(GameEventListener listener) ...
}

32.
Making Our Own 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(); }
}

33.
Demo!

34.
Scriptable Objects vs ...

35.
Singleton Manager Goals
Track all enemies in a scene
Understand player
Issue commands

36.
Singleton Manager Problems
Race conditions
Rigid singleton
Only one

37.
Runtime Sets
Keep track of a list of objects in the scene
Avoid race conditions
More flexible than Unity tags, singleton

38.
Runtime Sets
public abstract class RuntimeSet<T> : ScriptableObject
{
public List<T> Items = new List<T>();
public void Add(T t)
{
if (!Items.Contains(t)) Items.Add(t);
}
public void Remove(T t)
{
if (Items.Contains(t)) Items.Remove(t);
}
}

39.
Runtime Sets
Buildings placed in an RTS
Renderers for special effects
Items on a map

40.
Demo!

41.
Enums
Must change in code
Difficult to remove / reorder
Can’t hold additional data

42.
Demo!

43.
Asset Based Systems

44.
Generic Systems
System is ScriptableObject Asset in project
Reference directly with inspector
No code lookup
No scene-only references
Like AudioMixer / AudioMixerGroup

45.
Inventory
ScriptableObject Master List
ScriptableObject per item
Use different inventories in different scenes

46.
InventoryPlayer
Inventory Example
Equip
Screen
NPC
Save
System

47.
Demo!

48.
Engineering
Pillars
Modular
Editable
Debuggable

49.
Thank you!
Ryan Hipple
@roboryantron