Book Image

Game Development Patterns with Unity 2021 - Second Edition

By : David Baron
Book Image

Game Development Patterns with Unity 2021 - Second Edition

By: David Baron

Overview of this book

This book is written for every game developer ready to tackle the bigger picture and start working with advanced programming techniques and design patterns in Unity. Game Development Patterns with Unity 2021 is an introduction to the core principles of reusable software patterns and how to employ them to build components efficiently. In this second edition, you'll tackle design patterns with the help of a practical example; a playable racing game prototype where you’ll get to apply all your newfound knowledge. Notable updates also include a game design document (GDD), a Unity programming primer, and the downloadable source code of a complete prototype. Your journey will start by learning about overall design of the core game mechanics and systems. You’ll discover tried-and-tested software patterns to code essential components of a game in a structured manner, and start using classic design patterns to utilize Unity's unique API features. 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 book, the way you develop Unity games will change – you’ll adapt a more structured, scalable, and optimized process that will help you take the next step in your career.

Related Content you might be interested in

Current Title:

Small book image
Game Development Patterns with Unity 2021 - Second Edition
David Baron
Jul, 2021 | 246 pages
Small book image
Hands-On Game Development Patterns with Unity 2019
David Baron
Mar, 2019 | 242 pages
Small book image
Building an RPG with Unity 2018
Vah Karamian
Jul, 2018 | 366 pages
Table of Contents (22 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Code in Action
Download the color images
Conventions used
Get in touch
Share Your Thoughts
1
Sections 1: Fundamentals
Sections 1: Fundamentals
Free Chapter
2
Before We Begin
Before We Begin
Notes about the new edition
The philosophy of the book
What are design patterns?
Which subjects aren't covered in this book?
The game project
Summary
3
The Game Design Document
The Game Design Document
The design document
Game overview
Unique selling points
Minimum requirements
Game synopsis
Game objectives
Game rules
Game loop
Game environment
Camera, control, character (3Cs)
Camera
Character
Character description
Character metrics
Character states
Controller
Game ingredients
Superbikes
Pickups
Obstacles
Weaponry
Game systems
Game menu
Game HUD
Summary
Further reading
4
A Short Primer to Programming in Unity
A Short Primer to Programming in Unity
What you should already know
C# language features
Unity engine features
Summary
Further reading
5
Section 2: Core Patterns
Section 2: Core Patterns
6
Implementing a Game Manager with the Singleton
Implementing a Game Manager with the Singleton
Technical requirements
Understanding the Singleton pattern
Benefits and drawbacks
Designing a Game Manager
Implementing the Game Manager
Testing the Game Manager
Summary
7
Managing Character States with the State Pattern
Managing Character States with the State Pattern
Technical requirements
An overview of the State pattern
Defining character states
Implementing the State pattern
Implementing the State pattern
Testing the State pattern implementation
Benefits and drawbacks of the State pattern
Reviewing alternative solutions
Summary
8
Managing Game Events with the Event Bus
Managing Game Events with the Event Bus
Technical requirements
Understanding the Event Bus pattern
Benefits and drawbacks of the Event Bus pattern
When to use the Event Bus
Managing global race events
Implementing a Race Event Bus
Testing the Race Event Bus
Reviewing the Event Bus implementation
Reviewing some alternative solutions
Summary
9
Implement a Replay System with the Command Pattern
Implement a Replay System with the Command Pattern
Technical requirements
Understanding the Command pattern
Benefits and drawbacks of the Command pattern
When to use the Command pattern
Designing a replay system
Implementing a replay system
Implementing the replay system
Testing the replay system
Reviewing the implementation
Reviewing alternative solutions
Summary
10
Optimizing with the Object Pool Pattern
Optimizing with the Object Pool Pattern
Technical requirements
Understanding the Object Pool pattern
Benefits and drawbacks of the Object Pool pattern
When to use the Object Pool pattern
Implementing the Object Pool pattern
Steps for implementing the Object Pool pattern
Testing the Object Pool implementation
Reviewing the Object Pool implementation
Reviewing alternative solutions
Summary
11
Decoupling Components with the Observer Pattern
Decoupling Components with the Observer Pattern
Technical requirements
Understanding the Observer pattern
Benefits and drawbacks of the Observer pattern
When to use the Observer pattern
Decoupling core components with the Observer pattern
Implementing the Observer pattern
Testing the Observer pattern implementation
Reviewing alternative solutions
Summary
12
Implementing Power-Ups with the Visitor Pattern
Implementing Power-Ups with the Visitor Pattern
Technical requirements
Understanding the Visitor pattern
Benefits and drawbacks of the Visitor pattern
Designing a power-up mechanic
Implementing a power-up mechanic
Implementing the power-up system
Testing the power-up system implementation
Reviewing the power-up system implementation
Summary
13
Implementing a Drone with the Strategy Pattern
Implementing a Drone with the Strategy Pattern
Technical requirements
Understanding the Strategy pattern
Benefits and drawbacks of the Strategy pattern
When to use the Strategy pattern
Designing an enemy drone
Implementing an enemy drone
Steps to implementing an enemy drone
Testing the enemy drone implementation
Reviewing the enemy drone implementation
Reviewing alternative solutions
Summary
14
Using the Decorator to Implement a Weapon System
Using the Decorator to Implement a Weapon System
Technical requirements
Understanding the Decorator pattern
Benefits and drawbacks of the Decorator pattern
When to use the Decorator pattern
Designing a weapon system
Implementing a weapon system
Implementing the weapon system
Testing the weapon system
Reviewing the weapon system
Reviewing alternative solutions
Summary
15
Implementing a Level Editor with Spatial Partition
Implementing a Level Editor with Spatial Partition
Technical requirements
Understanding the Spatial Partition pattern
When to use the Spatial Partition pattern
Designing a level editor
Implementing a level editor
Steps for implementing a level editor
Using the level editor
Reviewing the level-editor implementation
Reviewing alternative solutions
Summary
16
Section 3: Alternative Patterns
Section 3: Alternative Patterns
17
Adapting Systems with an Adapter
Adapting Systems with an Adapter
Technical requirements
Understanding the Adapter pattern
Benefits and drawbacks of the Adapter pattern
When to use the Adapter pattern
Implementing the Adapter pattern
Implementing the Adapter pattern
Testing the Adapter pattern implementation
Summary
18
Concealing Complexity with a Facade Pattern
Concealing Complexity with a Facade Pattern
Technical requirements
Understanding the Facade pattern
Benefits and drawbacks
Designing a bike engine
Implementing a bike engine
Testing the engine facade
Reviewing alternative solutions
Summary
19
Managing Dependencies with the Service Locator Pattern
Managing Dependencies with the Service Locator Pattern
Technical requirements
Understanding the Service Locator pattern
Benefits and drawbacks of the Service Locator pattern
When to use the Service Locator pattern
Implementing a Service Locator pattern
Testing the Service Locator pattern
Reviewing alternative solutions
Summary
20
About Packt
About Packt
Why subscribe?
21
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts

Reviewing some alternative solutions

Event systems and patterns are a vast topic, and it's a subject matter we can't cover in depth in this book. Therefore, we have prepared a shortlist of patterns to consider when implementing an event system or mechanism, but keep in mind that there's a lot more out there, and we encourage you as a reader to continue exploring the topic beyond the limited scope of this book:

  • Observer: An oldie but goodie pattern in which an object (subject) maintains a list of objects (observers) and notifies them of an internal state change. It's a pattern to consider when you need to establish a one-to-many relationship between a group of entities.
  • Event Queue: This pattern permits us to store events generated by publishers in a queue and forward them to their subscribers at a convenient time. This approach decouples the temporal relationship between publishers and subscribers.
  • ScriptableObjects: It's possible to create an event...
Previous Section
End of Section 10
Next Section