You're reading from Learning Design Patterns with Unity

Product type Book

Published in May 2024

Publisher Packt

ISBN-13 9781805120285

Pages 676 pages

Edition 1st Edition

Languages

Concepts

Game Design

Author (1):

Harrison Ferrone

Table of Contents (23) Chapters

Preface

1. Priming the System

2. Managing Access with the Singleton Pattern

3. Spawning Enemies with the Prototype Pattern

4. Creating Items with the Factory Method Pattern

5. Building a Crafting System with the Abstract Factory Pattern

6. Assembling Support Characters with the Builder Pattern

7. Managing Performance and Memory with Object Pooling

8. Binding Actions with the Command Pattern

9. Decoupling Systems with the Observer Pattern

10. Controlling Behavior with the State Pattern

11. Adding Features with the Visitor Pattern

12. Swapping Algorithms with the Strategy Pattern

13. Making Monsters with the Type Object Pattern

14. Taking Data Snapshots with the Memento Pattern

15. Dynamic Upgrades with the Decorator Pattern

16. Converting Incompatible Classes with the Adapter Pattern

17. Simplifying Subsystems with the Façade Pattern

18. Generating Terrains with the Flyweight Pattern

19. Global Access with the Service Locator Pattern

20. The Road Ahead

21. Other Books You May Enjoy

22. Index

The final boss – drag-and-drop system

Back at the 2017 Unite conference, there was a wonderful talk about building out your game architecture using scriptable objects. Unity has come a long way since then, but scriptable objects are still one of the most useful programming tools for encapsulating data in your games. In this last section, we’ll implement the drag-and-drop Observer pattern structure from the Unite conference to give you a starting point for more advanced Unity configurations.

You can find the Unite talk at https://www.youtube.com/watch?v=raQ3iHhE_Kk&t=0s&ab_channel=Unity and a brief write-up by Ryan Hipple at https://unity.com/how-to/architect-game-code-scriptable-objects.

Writing a ScriptableObject event

The strategy behind this implementation is to encapsulate a subject into a ScriptableObject, which should look familiar because it’s almost exactly what we did at the beginning of the chapter with our traditional...