Book Image

Learning Design Patterns with Unity

By : Harrison Ferrone
Book Image

Learning Design Patterns with Unity

By: Harrison Ferrone

Overview of this book

Struggling to write maintainable and clean code for your Unity games? Look no further! Learning Design Patterns with Unity empowers you to harness the fullest potential of popular design patterns while building exciting Unity projects. Through hands-on game development, you'll master creational patterns like Prototype to efficiently spawn enemies and delve into behavioral patterns like Observer to create reactive game mechanics. As you progress, you'll also identify the negative impacts of bad architectural decisions and understand how to overcome them with simple but effective practices. By the end of this Unity 2023 book, the way you develop Unity games will change. You'll emerge not just as a more skilled Unity developer, but as a well-rounded software engineer equipped with industry-leading design patterns.

Related Content you might be interested in

Current Title:

Small book image
Learning Design Patterns with Unity
Harrison Ferrone
May, 2024 | 676 pages
Small book image
Learning C# by Developing Games with Unity
Mr. Harrison Ferrone
Nov, 2022 | 466 pages
Small book image
Game Development Patterns with Unity 2021
David Baron
Jul, 2021 | 246 pages
Small book image
Learning C# by Developing Games with Unity 2019
Mr. Harrison Ferrone
Mar, 2019 | 342 pages
Table of Contents (23 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Priming the System
Priming the System
A word about software architecture
What are design patterns?
Why use design patterns?
When to use design patterns
Common pitfalls
About the example projects
Summary
Further reading
2
Managing Access with the Singleton Pattern
Managing Access with the Singleton Pattern
Technical requirements
Breaking down the pattern
Updating a MonoBehavior into a persistent singleton
Creating a generic singleton
Adding thread safety to the generic singleton
Creating singletons as ScriptableObjects
Summary
Further reading
3
Spawning Enemies with the Prototype Pattern
Spawning Enemies with the Prototype Pattern
Technical requirements
Breaking down the Prototype pattern
Implementing shallow and deep object copying
Cloning prefabs
Creating a generic prototype component
Summary
Further reading
Join our community on Discord
4
Creating Items with the Factory Method Pattern
Creating Items with the Factory Method Pattern
Technical requirements
Breaking down the Factory Method pattern
Declaring our inventory products
Working with different factory class variations
Scaling factories with reflection and LINQ
Adding GameObjects to the mix
Summary
Further reading
Join our community on Discord
5
Building a Crafting System with the Abstract Factory Pattern
Building a Crafting System with the Abstract Factory Pattern
Technical requirements
Breaking down the Abstract Factory pattern
Creating related but independent products
Creating related and dependent products
Optional factory variations
Summary
Further reading
Join our community on Discord
6
Assembling Support Characters with the Builder Pattern
Assembling Support Characters with the Builder Pattern
Technical requirements
Breaking down the Builder pattern
Creating a base ally and builder interface
Adding concrete builders
Using a director class
Integrating GameObjects
Transitioning to a Fluent Builder structure
Summary
Further reading
7
Managing Performance and Memory with Object Pooling
Managing Performance and Memory with Object Pooling
Technical requirements
Breaking down the Object Pool pattern
Writing an Object Pool class
Object Pooling customizations
Leveraging Unity’s ObjectPool class
Summary
Further reading
Join our community on Discord
8
Binding Actions with the Command Pattern
Binding Actions with the Command Pattern
Technical requirements
Breaking down the Command pattern
Building a basic Command structure
Creating coupled commands
Implementing an undo/redo system
Summary
Further reading
Join our community on Discord
9
Decoupling Systems with the Observer Pattern
Decoupling Systems with the Observer Pattern
Technical requirements
Breaking down the Observer pattern
Pattern strategies and optimizations
Using C# event types
UnityEvents and the Inspector
The final boss – drag-and-drop system
Summary
Further reading
Join our community on Discord
10
Controlling Behavior with the State Pattern
Controlling Behavior with the State Pattern
Technical requirements
Breaking down the State pattern
Creating a turn-based battle system
Using a hierarchical state machine
Adapting for concurrent state machines
Storing state history
Summary
Further reading
11
Adding Features with the Visitor Pattern
Adding Features with the Visitor Pattern
Technical requirements
Breaking down the Visitor pattern
Creating a save system
Working with composite elements
Accounting for selective visitation
Summary
Further reading
Join our community on Discord
12
Swapping Algorithms with the Strategy Pattern
Swapping Algorithms with the Strategy Pattern
Technical requirements
Breaking down the Strategy pattern
Creating a sorting system
Optimizing your strategies
Strategies the Unity way
Summary
Further reading
Join our community on Discord
13
Making Monsters with the Type Object Pattern
Making Monsters with the Type Object Pattern
Technical requirements
Breaking down the Type Object pattern
Creating monsters
Optimization, inheritance, and behavior
Creating ScriptableObject monsters
Summary
Further reading
14
Taking Data Snapshots with the Memento Pattern
Taking Data Snapshots with the Memento Pattern
Technical requirements
Breaking down the Memento pattern
Creating and restoring data snapshots
Working with MonoBehaviours
Memento pattern variations
Summary
Further reading
Join our community on Discord
15
Dynamic Upgrades with the Decorator Pattern
Dynamic Upgrades with the Decorator Pattern
Technical requirements
Breaking down the Decorator pattern
Building a simple Decorator
Adding customized behaviors
Using ScriptableObject Decorators
Summary
Further reading
Join our community on Discord
16
Converting Incompatible Classes with the Adapter Pattern
Converting Incompatible Classes with the Adapter Pattern
Technical requirements
Breaking down the Adapter pattern
Building a controller adapter
Creating an object adapter class
Mapping properties in separate hierarchies
Summary
Further reading
17
Simplifying Subsystems with the Façade Pattern
Simplifying Subsystems with the Façade Pattern
Technical requirements
Breaking down the Façade pattern
Building a subsystem Façade
Adding multiple Façade methods
Upgrading Façades
Summary
Further reading
Join our community on Discord
18
Generating Terrains with the Flyweight Pattern
Generating Terrains with the Flyweight Pattern
Technical requirements
Breaking down the Flyweight pattern
Creating shareable terrains
Adding a Flyweight factory
Working with unshared Flyweights
Upgrading to ScriptableObjects
Flyweight or Type Object?
Summary
Further reading
19
Global Access with the Service Locator Pattern
Global Access with the Service Locator Pattern
Technical requirements
Breaking down the Service Locator pattern
Creating services and contracts
Building a Service Locator class
Adding a generic solution
Extending locator functionality
A word on scope
Summary
Further reading
Join our community on Discord
20
The Road Ahead
The Road Ahead
SOLID principles and you
The patterns left out (but not forgotten)
Resourceful resources
Getting involved
Summary
21
Other Books You May Enjoy
Other Books You May Enjoy
22
Index
Index

Optimization, inheritance, and behavior

The Type Object pattern focuses on reusing shared data between objects so we can do away with complicated class hierarchies and adapt for situations when we don’t know all the different objects we want down the line. With that in mind, let’s try and level up our design pattern implementation by:

  • Making things safer for ourselves and our team (by controlling access to the type and Typed Object classes)
  • Adding optional inheritance (still without class hierarchies)
  • Understanding our options for sharing behavior

Controlling allocation and initialization

There may come a time when an object’s allocation and initialization are big players in your performance and player experience. For those occasions, it’s ideal for there to be a single point of access where your monsters are being created. Not only is this safer (because it keeps your AudioManager from creating zombie hedgehogs by accident...

Previous Section
End of Section 5
Next Section