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

How can we control actions through buttons?

In Chapter 3, Improving on the Decorator Pattern with the Component Object Model, we implemented game objects. Now that we have them, it seems trivial to create buttons on the screen. In fact, in genres such as real-time strategy, there is no difference between clickable buttons and game objects. The player can click on any unit or building and give them orders.

At first thought, our buttons could just be game objects. They both have a position, scale, and texture, and that texture will be drawn to the screen. Depending on the game, you might draw your buttons using orthographic projection while the objects will be drawn using perspective projection. However, the differences go deeper than that.

At its core, a button has an action that needs to be performed when it is clicked or selected. This behavior is usually simple; it doesn't require creating an entire state machine class. It does however, require a little thought so we don't end up hardcoding...

Previous Section
End of Section 3
Next Section