book

Learning Design Patterns with Unity

Name: Learning Design Patterns with Unity
Author: Harrison Ferrone
ISBN: 9781805120285

by Harrison Ferrone

May 2024

Intermediate to advanced

676 pages

13h 30m

English

Packt Publishing

Read now

Unlock full access

Preface
Who this book is forWhat this book coversTo get the most out of this bookGet in touch
Priming the System
A word about software architectureWhat are design patterns?The Gang of FourPattern categoriesCreational patternsBehavioral patternsStructural patternsWhy use design patterns?When to use design patternsCommon pitfallsAbout the example projectsClient codeOld vs new input systemArt assetsSummaryFurther reading
Managing Access with the Singleton Pattern
Technical requirementsBreaking down the patternDiagramming the patternPros and consUpdating a MonoBehavior into a persistent singletonPersisting the singleton between scenesTesting for duplicate managersCreating a generic singletonAdding thread safety to the generic singletonThread locking during lazy instantiationCreating singletons as ScriptableObjectsSummaryFurther reading
Spawning Enemies with the Prototype Pattern
Technical requirementsBreaking down the Prototype patternDiagraming the patternPros and consImplementing shallow and deep object copyingAdding a prototype interfaceMaking shallow object copiesMaking deep object copiesAdding a prototype factoryCloning prefabs Creating a generic prototype componentSummaryFurther readingJoin our community on Discord
Creating Items with the Factory Method Pattern
Technical requirementsBreaking down the Factory Method patternDiagramming the patternPros and consDeclaring our inventory productsAdding a product interfaceCreating concrete productsWorking with different factory class variationsAdding an abstract factory classBuilding a concrete factory Creating a concrete factory classBuilding a parameterized factory Creating a parameterized factory classScaling factories with reflection and LINQAdding GameObjects to the mixUpdating the Item classUpdating the Abstract Creator classUpdating the concrete factory Updating the reflection factory Extending products and factories with Scriptable ObjectsSummaryFurther readingJoin our community on Discord
Building a Crafting System with the Abstract Factory Pattern
Technical requirementsBreaking down the Abstract Factory patternDiagramming the patternPros and consCreating related but independent productsScripting product interfacesAdding concrete productsCreating abstract and Concrete Factory classesWriting a client class using only interfacesCreating related and dependent productsWriting dependent product abstract classesCreating concrete productsAdding abstract and Concrete Factory classesUpdating the clientOptional factory variationsParameterized factoriesCreating a factory of factoriesSummaryFurther readingJoin our community on Discord
Assembling Support Characters with the Builder Pattern
Technical requirementsBreaking down the Builder patternDiagramming the patternPros and cons Creating a base ally and builder interfaceScripting the product classDeclaring a common builder interfaceAdding concrete buildersUsing a director classIntegrating GameObjects Transitioning to a Fluent Builder structureSummaryFurther reading
Managing Performance and Memory with Object Pooling
Technical requirementsBreaking down the Object Pool patternDiagramming the patternPros and consWriting an Object Pool classCreating objects and filling the poolRetrieving pooled objectsReleasing pooled objectsResetting pooled objectsObject Pooling customizationsQueues over listsThread-safe poolsManaging different pooled objectsLeveraging Unity’s ObjectPool class SummaryFurther readingJoin our community on Discord
Binding Actions with the Command Pattern
Technical requirementsBreaking down the Command patternDiagramming the patternReusable versus single-use commandsPros and consBuilding a basic Command structureCreating reusable commandsAdding a receiverAdding an invoker classUsing an input listenerUpdating the clientCreating coupled commandsImplementing an undo/redo systemStacking commandsAdding an undo featureAdding a redo featureConfirming and clearing commandsSummaryFurther readingJoin our community on Discord
Decoupling Systems with the Observer Pattern
Technical requirementsBreaking down the Observer patternDiagramming the patternPros and consCreating a basic Observer structureWriting the abstract base objectsMaking the UI an observerSubscribing observers and publishing eventsPattern strategies and optimizationsChoosing a communication strategyListening for different state changesCleaning up hanging resourcesUsing C# event typesDelegates and eventsUpdating to Action typesUnityEvents and the InspectorAdding Unity eventsAdding UnityEvent parametersPersistent versus non-persistent events The final boss – drag-and-drop systemWriting a ScriptableObject eventCreating listenersCreating ScriptableObject event assetsInvoking the SOEventConnecting the systemPerformance considerationsPicking the right implementationSummaryFurther readingJoin our community on Discord

Controlling Behavior with the State Pattern
Technical requirementsBreaking down the State patternA little automata theoryDiagramming the patternPros and consCreating a turn-based battle system Defining abstract and base statesCreating a state machine Protecting transitioning statesSubclassing state machinesCreating concrete statesBase stateSetup statePlayer stateEnemy stateEnding statePutting it all togetherInitializing concrete statesUpdating the client Using a hierarchical state machineAdapting for concurrent state machinesUnrelated concurrent statesRelated concurrent statesStoring state historyPushing new statesReverting to previous statesSummaryFurther reading
Adding Features with the Visitor Pattern
Technical requirementsBreaking down the Visitor patternDiagramming the patternPros and consCreating a save systemStructuring the interfacesAdding a concrete visitorsAdding concrete elementsAdding an object structureWorking with composite elementsAccounting for selective visitationSummaryFurther readingJoin our community on Discord
Swapping Algorithms with the Strategy Pattern
Technical requirementsBreaking down the Strategy patternDiagramming the patternPros and consCreating a sorting systemDefining a strategy interfaceAdding concrete strategiesCreating a contextOptimizing your strategiesAdding interchangeable strategiesUsing default strategiesStrategies the Unity wayUpgrading to ScriptableObjectsSummaryFurther readingJoin our community on Discord
Making Monsters with the Type Object Pattern
Technical requirementsBreaking down the Type Object patternDiagramming the patternPros and consCreating monstersAdding a Type ObjectConfiguring monstersOptimization, inheritance, and behaviorControlling allocation and initializationAdding parent type objectsSharing behavior isn’t easyCreating ScriptableObject monstersSummaryFurther reading
Taking Data Snapshots with the Memento Pattern
Technical requirementsBreaking down the Memento patternDiagramming the patternPros and consCreating and restoring data snapshotsAdding the memento classSetting up the caretakerUpdating the originatorWiring up the clientWorking with MonoBehavioursMemento pattern variationsStoring memento historyBundling originator and caretakerManagers and ScriptableObject snapshotsPersisting dataSummaryFurther readingJoin our community on Discord
Dynamic Upgrades with the Decorator Pattern
Technical requirementsBreaking down the Decorator patternDiagramming the patternPros and consBuilding a simple DecoratorAdding a Component interfaceCreating a concrete ComponentUsing a base Decorator Building a concrete Decorator Chaining multiple Decorators Adding customized behaviorsUsing ScriptableObject DecoratorsStatic vs dynamic decoration in actionSummaryFurther readingJoin our community on Discord
Converting Incompatible Classes with the Adapter Pattern
Technical requirementsBreaking down the Adapter patternDiagramming the patternPros and consBuilding a controller adapter Defining a targetAdding the class adapterCreating an object adapter classMapping properties in separate hierarchiesSummaryFurther reading
Simplifying Subsystems with the Façade Pattern
Technical requirementsBreaking down the Façade patternDiagramming the patternPros and consBuilding a subsystem Façade Defining subsystem objectsInitializing subsystemsAdding a public Façade methodAdding multiple Façade methodsUpgrading FaçadesSummaryFurther readingJoin our community on Discord
Generating Terrains with the Flyweight Pattern
Technical requirementsBreaking down the Flyweight patternDiagramming the patternPros and consCreating shareable terrainsAdding a Flyweight interfaceExtracting extrinsic stateBuilding a concrete FlyweightAdding a Flyweight factoryWorking with unshared FlyweightsUpgrading to ScriptableObjectsFlyweight or Type Object? Summary Further reading
Global Access with the Service Locator Pattern
Technical requirementsBreaking down the Service Locator patternDiagramming the patternPros and consCreating services and contractsLogging and saving contractsPlanning for missing servicesBuilding a Service Locator class The Null Object patternAdding a generic solutionExtending locator functionalityInitializing services Explicitly registering servicesUnregistering servicesA word on scopeSingleton Service LocatorsGrouping servicesA service for every levelSummary Further readingJoin our community on Discord
The Road Ahead
SOLID principles and youThe patterns left out (but not forgotten)Resourceful resourcesGetting involvedSummary
Other Books You May Enjoy
Index

Content preview from Learning Design Patterns with Unity

12 Swapping Algorithms with the Strategy Pattern

In the last chapter, we used the Visitor pattern to apply different behavior to objects without changing the underlying object itself. In this chapter, we’re going to explore how the Strategy pattern lets us configure classes with interchangeable algorithms (or behaviors) at runtime. Not only is this a fantastic way to define different variants of a given algorithm but also your client code doesn’t need to worry about each algorithm’s internal state or data dependencies.

I love this pattern because we use strategies in real life all the time! Think of the moments before you leave the house – it’s always a good idea to check the weather to decide whether you need a coat if it’s cold, an umbrella ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Mastering Unity Game Development with C#

Publisher Resources

ISBN: 9781805120285

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Learning Design Patterns with Unity

by Harrison Ferrone

12

Swapping Algorithms with the Strategy Pattern

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.