Book Image

Game Development Patterns and Best Practices

By : John P. Doran, Matt Casanova
Book Image

Game Development Patterns and Best Practices

By: John P. Doran, Matt Casanova

Overview of this book

You’ve learned how to program, and you’ve probably created some simple games at some point, but now you want to build larger projects and find out how to resolve your problems. So instead of a coder, you might now want to think like a game developer or software engineer. To organize your code well, you need certain tools to do so, and that’s what this book is all about. You will learn techniques to code quickly and correctly, while ensuring your code is modular and easily understandable. To begin, we will start with the core game programming patterns, but not the usual way. We will take the use case strategy with this book. We will take an AAA standard game and show you the hurdles at multiple stages of development. Similarly, various use cases are used to showcase other patterns such as the adapter pattern, prototype pattern, flyweight pattern, and observer pattern. Lastly, we’ll go over some tips and tricks on how to refactor your code to remove common code smells and make it easier for others to work with you. By the end of the book you will be proficient in using the most popular and frequently used patterns with the best practices.

Related Content you might be interested in

Current Title:

Small book image
Game Development Patterns and Best Practices
John P. Doran | Matt Casanova
Apr, 2017 | 394 pages
Small book image
Hands-On Game Development Patterns with Unity 2019
David Baron
Mar, 2019 | 242 pages
Table of Contents (19 chapters)
Title Page
Title Page
Credits
Credits
About the Authors
About the Authors
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Customer Feedback
Customer Feedback
Preface
Preface
Free Chapter
1
Introduction to Design Patterns
Introduction to Design Patterns
Chapter overview
Your objective
Why you should plan for change
Separating the why and the how
An Introduction to interfaces
The advantages of compartmentalizing code
The problems with using design patterns in games
Setting up the project
Summary
2
One Instance to Rule Them All - Singletons
One Instance to Rule Them All - Singletons
Chapter overview
Your objective
An overview on class access specifiers
The static keyword
Pros and cons of global variables
What is a Singleton?
Learning about templates
Templatizing Singletons
Advantages/disadvantages of using only one instance
The Singleton in action - the Application class
Summary
3
Creating Flexibility with the Component Object Model
Creating Flexibility with the Component Object Model
Chapter overview
Why a monolithic game object is a bad design
Why inheritance hierarchies are inflexible
The Strategy pattern and the Decorator pattern
The Component Object Model explained
Performance concerns
Summary
4
Artificial Intelligence Using the State Pattern
Artificial Intelligence Using the State Pattern
Chapter overview
Summary
5
Decoupling Code via the Factory Method Pattern
Decoupling Code via the Factory Method Pattern
Chapter overview
Your objective
The Dependency Inversion Principle
The Factory method pattern
Creating a component and Object Factory
Architecting versus over-architecting
Summary
6
Creating Objects with the Prototype Pattern
Creating Objects with the Prototype Pattern
Your objectives
The Prototype pattern explained
Examples of the clone method in Mach5
Loading archetypes from a file
Summary
7
Improving Performance with Object Pools
Improving Performance with Object Pools
Chapter overview
Why you should care about memory
The Object Pool pattern explained
Implementing a basic object pool
Operator overloading in C++
Building the object pool for Mach5
Issues with object pools
Summary
8
Controlling the UI via the Command Pattern
Controlling the UI via the Command Pattern
Chapter overview
How can we control actions through buttons?
The Command pattern explained
The benefits of the command pattern
Easy UI with commands in Mach5
Summary
9
Decoupling Gameplay via the Observer Pattern
Decoupling Gameplay via the Observer Pattern
Chapter overview
How gameplay creeps into every system
The Observer pattern explained
Benefits of using the Observer pattern
Summary
10
Sharing Objects with the Flyweight Pattern
Sharing Objects with the Flyweight Pattern
Chapter overview
Introductions to particles
Implementing particles in Mach5
Why memory is still an issue
Introduction to the Flyweight pattern
Transitioning to ParticleSystems
Summary
11
Understanding Graphics and Animation
Understanding Graphics and Animation
Chapter overview
Introduction to monitor refresh rates
Double buffering
Triple buffering
LCD monitors
Time-based movement and animation
Summary
12
Best Practices
Best Practices
Chapter overview
Learning fundamental code quality techniques
Learning and understand the uses of the const keyword
Learning how iteration can improve your game and code design
Learning when to use scripting in a game
Summary

Summary

In this chapter, we focused a lot on creating flexible code. Since we are using the Component Object Model with our game objects, we want to make sure that, as our objects change, they handle that change well. This means we don't want to modify lots of other files as we playtest and balance our objects.

We said at the beginning of this chapter that the goal for our game objects is to completely define them in a file. Since we are using components in our objects, we want to define the components that are used by the objects within the file as well. By defining objects in a file, our programmers are free to work on other code and the designers can work on balance and play testing without fear of breaking the game or introducing bugs.

After looking at a simple example of the Prototype pattern, we looked at how it is used in the Mach5 Engine. We saw both the M5Component class and the M5Object use a Clone method to make copying objects easy. These of course, were used by the M5ObjectManager...

Previous Section
End of Chapter 6
Next Chapter