Creating a sorting system

Managing Access with the Singleton Pattern

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

Spawning Enemies with the Prototype Pattern

Breaking down the Prototype pattern

Implementing shallow and deep object copying

Cloning prefabs

Creating a generic prototype component

Creating Items with the Factory Method Pattern

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

Building a Crafting System with the Abstract Factory Pattern

Breaking down the Abstract Factory pattern

Creating related and dependent products

Optional factory variations

Assembling Support Characters with the Builder Pattern

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

Managing Performance and Memory with Object Pooling

Breaking down the Object Pool pattern

Writing an Object Pool class

Object Pooling customizations

Leveraging Unity’s ObjectPool class

Binding Actions with the Command Pattern

Breaking down the Command pattern

Building a basic Command structure

Creating coupled commands

Implementing an undo/redo system

Decoupling Systems with the Observer Pattern

Breaking down the Observer pattern

Pattern strategies and optimizations

Using C# event types

UnityEvents and the Inspector

The final boss – drag-and-drop system

Controlling Behavior with the State Pattern

Breaking down the State pattern

Creating a turn-based battle system

Using a hierarchical state machine

Adapting for concurrent state machines

Storing state history

Adding Features with the Visitor Pattern

Breaking down the Visitor pattern

Creating a save system

Working with composite elements

Accounting for selective visitation

Swapping Algorithms with the Strategy Pattern

Breaking down the Strategy pattern

Creating a sorting system

Optimizing your strategies

Strategies the Unity way

Making Monsters with the Type Object Pattern

Breaking down the Type Object pattern

Creating monsters

Optimization, inheritance, and behavior

Creating ScriptableObject monsters

Taking Data Snapshots with the Memento Pattern

Breaking down the Memento pattern

Creating and restoring data snapshots

Working with MonoBehaviours

Memento pattern variations

Dynamic Upgrades with the Decorator Pattern

Breaking down the Decorator pattern

Building a simple Decorator

Adding customized behaviors

Using ScriptableObject Decorators

Converting Incompatible Classes with the Adapter Pattern

Breaking down the Adapter pattern

Building a controller adapter

Creating an object adapter class

Mapping properties in separate hierarchies

Simplifying Subsystems with the Façade Pattern

Breaking down the Façade pattern

Building a subsystem Façade

Adding multiple Façade methods

Upgrading Façades

Generating Terrains with the Flyweight Pattern

Breaking down the Flyweight pattern

Creating shareable terrains

Adding a Flyweight factory

Working with unshared Flyweights

Upgrading to ScriptableObjects

Flyweight or Type Object?

Global Access with the Service Locator Pattern

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

The patterns left out (but not forgotten)

The Road Ahead

SOLID principles and you

Resourceful resources

Getting involved