Game Development Patterns and Best Practices: Better Games, Less Hassle

Cover
Copyright
Credits
About the Authors
About the Reviewers
www.PacktPub.com
Customer Feedback
Table of Contents
Preface
Chapter 1: Introduction to Design Patterns
Chapter overview
Your objective
What are design patterns
Why you should plan for change
Understanding UML class diagrams
Relationships between classes
Inheritance
Aggregation
Composition
Implements
Separating the why and the how
Understanding the separation of concerns
An Introduction to interfaces
Polymorphism refresher
Understanding interfaces
The advantages of compartmentalizing code
The structure of the Mach5 engine
Mach5 core engines and systems
The app
The StageManager
The ObjectManager
The graphics engine
Tools and utilities
The problems with using design patterns in games
Setting up the project
Summary
Chapter 2: One Instance to Rule Them All - Singletons
Chapter overview
Your objective
An overview on class access specifiers
The static keyword
Static keyword inside a function
Static keyword in class definitions
Static as a file global variable
Pros and cons of global variables
What is a Singleton?
Keeping the single in Singleton
Deleting our object correctly
Learning about templates
Templatizing Singletons
Advantages/disadvantages of using only one instance
The Singleton in action - the Application class
Summary
Chapter 3: Creating Flexibility with the Component Object Model
Chapter overview
Your objectives
Why a monolithic game object is a bad design
The monolithic game object
The problem with object behavior
The benefits of the monolithic game object
Why inheritance hierarchies are inflexible
Organizing the code by what it does, not what it is
Avoiding the Diamond of Death
The Strategy pattern and the Decorator pattern
The Strategy pattern explained
The Decorator pattern explained
The Component Object Model explained
Implementing the Component Object Model
Implementing components
Creating and removing objects and components
Performance concerns
Summary
Chapter 4: Artificial Intelligence Using the State Pattern
Chapter overview
Your objectives
The State pattern explained
Introduction to State Machines
An overview of enumerations
Acting on states
Issues with conditionals
Expanding on the State Machine
The State pattern in action - the M5StateMachine class
The State pattern in action - StageManager
Issues with FSMs
Summary
Chapter 5: Decoupling Code via the Factory Method Pattern
Chapter overview
Your objective
The trouble with switch statements
The Dependency Inversion Principle
The Factory method pattern
The Static Factory
The Dynamic Factory
Creating our Stage Builders
The template builder
Creating the Dynamic Factory class
Using the Dynamic Factory
Creating a component and Object Factory
The Templated Factory
Architecting versus over-architecting
Summary
Chapter 6: Creating Objects with the Prototype Pattern
Your objectives
The trouble with using a factory for game objects
Using builders with objects
Solution - reading from files
The Prototype pattern explained
The virtual constructor
The problem with constructors
The benefits of a virtual constructor
We don't need to know the type
No need to subclass
It's easy to make exact copies
Examples of the clone method in Mach5
The Gfx and collider components
Cloning an object
Choosing a copy constructor
Covariant return types
Loading archetypes from a file
Archetype files
The object manager
Summary
Chapter 7: Improving Performance with Object Pools
Chapter overview
Your objectives
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
Chapter 8: Controlling the UI via the Command Pattern
Chapter overview
Your objectives
How can we control actions through buttons?
Callback functions
Repeated code in the component
The Command pattern explained
Two parameters and beyond
Pointers to member functions
Pointer to member command
The benefits of the command pattern
Treating a function call like an object
Physically decoupling the client and the function call
Temporal decoupling
Undo and redo
Easy UI with commands in Mach5
Using commands
Summary
Chapter 9: Decoupling Gameplay via the Observer Pattern
Chapter overview
Your objectives
How gameplay creeps into every system
Hardcoding requirements
Polling
The Observer pattern explained
The Subject and Observer
The Player
The Observers
Push versus Pull
Benefits of using the Observer pattern
Problems using the Observer pattern
Dangling references
Overuse
Implementing interfaces
When to notify
Summary
Chapter 10: Sharing Objects with the Flyweight Pattern
Chapter overview
Your objectives
Introductions to particles
Implementing particles in Mach5
Why memory is still an issue
Introduction to the Flyweight pattern
Transitioning to ParticleSystems
Creating different system types
Developing the ParticleFactory
Using the ParticleFactory
Summary
Chapter 11: Understanding Graphics and Animation
Chapter overview
Your objectives
Introduction to monitor refresh rates
What is a pixel?
The horizontal and vertical blank
Refresh rate
Double buffering
The back buffer
VSync
Triple buffering
LCD monitors
Time-based movement and animation
Frame-based movement
Time-based movement
Summary
Chapter 12: Best Practices
Chapter overview
Your objectives
Learning fundamental code quality techniques
Avoid magic numbers
White space
Indentation
Blank lines and spaces
Comments and self-documenting code
Commenting
Learning and understand the uses of the const keyword
Const function parameters
Const classes as parameters
Const member functions
Problems with const
Learning how iteration can improve your game and code design
The game development cycle
Production phase
Prototyping
Playtesting
Conducting a playtest
Iteration
Meeting milestones
Learning when to use scripting in a game
Introduction to assembly
Moving to higher-level programming languages
Introducing the compiler
Introduction to scripting languages
Using interpreters
Just in time compilation
Why use a scripting language?
When to use C++
Compiled versus scripting
Summary
Index