The document discusses common patterns for developing games in Unity. It recommends using core application logic like a main controller to manage scenes and states like loading, unloading, and running. The main controller can use object pooling and state machines. Other patterns discussed include singleton controllers and pool-based objects. Pool-based objects preload a set number and are spawned from the pool by finding disabled objects to reuse. The document provides examples of implementing these patterns to help structure Unity games efficiently and robustly.

2. Architecting Games in
Unity
Common patterns for developing games in Unity

3. If this was your house, what would you do?

4. Broken Windows
•Fix the windows.
•In New York City, Albuquerque and The Netherlands, improving the
physical appearance of a neighbourhood has been shown to reduce
crime and increase quality of life.
•People are influenced by their environment:
• Social norms and conformity
• Routine monitoring

5. Ah, Freedom!
•Unity gives you a rich set of building blocks that can be used to
construct any type of game.
•Unity is flexible.
•There are hundreds of ways to build projects.
•And developers use ALL of them!

6. Architecture for Games
•But let's look at what you need
•And let's create a structure that can be reused for efficiency and
robustness

7. Good Architecture = Good Standards
•Use C#
•Naming conventions
• Use descriptive names
• Use standardized capitalization
• In Unity don’t be afraid of using spaces in names
•Logical folder structure
•Zero-tolerance for warnings and errors
•Zero-tolerance for runtime memory allocation

8. Core Application Logic
•Main Controller
• Base controller to manage high level application
• Uses public static methods so everyone can access it
• Uses Object.DontDestroyOnLoad so it is available throughout the project
•Scenes
• Other scenes are loaded on top of this.
• MainController loads and unloads other scenes and cleans up.

9. Main Controller – Reset State
•Call GC.Collect to try to reclaim some memory.

10. Main Controller – Preload State
•Start loading the level asynchronously and change state to Load

11. Main Controller – Load State
•Keep going until loading is done

12. Main Controller – Unload State
•Resources.UnloadUnusedAssets()
•Keep going until Unloading is done

13. Main Controller – Postload State
•Do things immediately after loading
•Update currentSceneName

14. Main Controller – Ready State
•Call GC.Collect to try to reclaim some memory.
• Avoid this if you have unused assets in the scene that may be used later.
•Do things just before beginning: e.g.: Get User Input to Start

15. Main Controller – Run State
•We stay here until currentLevelName != nextLevelName
•This can be changed by calling SwitchScene static public method on
the Main Controller from anywhere

16. Scene State Machine Implementation
•We can use a switch-case
• Gets difficult to maintain and read
•We can use delegates
• Unfortunately, setting a delegate allocates memory
•So we use an array of delegates.

17. Scene State Machine Implementation
•Example Implementation
• MainController, MenuController and GameController
• Let’s look at the Profiler too!

18. Implementing Gameplay
•Controllers manage the objects
•Inter-object communication
• Static public methods
• Temporary public instance methods
• Messages, events
•Most common are:
• Singletons
• “Pool” controllers

19. Singleton
•Only one of them in the game
•Static public methods
•Examples:
• Score
• Player
• World
• Game

20. Singleton
•Example Implementation

21. Pool Based Objects
•Numerous instances in the game
•Limited number at any one time
•Preload simultaneously used quantity and disable
•Static public method to “spawn” one finds first disabled one and
enables it
•Examples:
• Explosions
• Bullets
• Enemies
• Scenery

22. GameObjects are loaded from
storage and placed in a pool and
disabled.
Object Pool
Storage
Pool Based Objects

23. GameObjects are activated when
needed.
Object Pool
Storage
Pool Based Objects

24. GameObjects are deactivated
when no longer needed. This
returns them to the pool.
Object Pool
Storage
Pool Based Objects

25. Pool Based Objects
•Example Implementation

26. Download
•Find the Template.zip here:
http://goo.gl/8WZGxn

27. Best-Practices
•Use C#
•Naming conventions
•Logical folder structure
•Zero-tolerance for warnings and errors
•Zero-tolerance for runtime memory allocation

28. Thank You!
Rustum Scammell
Email: rus@unity3d.com
Skype: rustumscammell