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

Further reading

  • Generics open up a whole new world of programming possibilities (which is why I included a generic solution in this chapter), but I’d recommend reading up on the topic at https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/generics.
  • ScriptableObjects are the perfect way to create data containers in your Unity projects (and we’ll use them in almost every chapter going forward), but I’d also recommend checking out the documentation at https://docs.unity3d.com/Manual/class-ScriptableObject.html.
  • Multithreading is a bit of an advanced topic outside the scope of this book, but being able to perform multiple operations at the same time is a useful tool in your toolbox. If you want to know more about this topic, head over to the documentation at https://learn.

Leave a review!

Enjoying this book? Help readers like you by leaving an Amazon review. Scan the QR code below to get a free eBook of your choice.

...
Previous Section
End of Chapter 2
Next Chapter