Chapter 1, Introduction to Design Patterns, introduces the concept of design patterns and how they can benefit our projects. We also dive into learning about the advantages of compartmentalizing our code and set up a sample project that we can use to build upon in the book.

Chapter 2, One Instance to Rule Them All – Singletons, discusses the well-known singleton pattern, explaining common arguments for and against having a single instance that’s accessible globally within our game.

Chapter 3, Creating Flexibility with the Component Object Model, explores how to create a large amount of different game object types while minimizing code duplication.

Chapter 4, Artificial Intelligence Using the State Pattern, shows the usage of states to allow a game object to change its behavior and functionality due to different stimuli in your game. We discuss and apply how we can use this concept in both player behavior and artificial intelligence.

Chapter 5, Decoupling Code via the Factory Method Pattern, explains how we separate our specific game objects from our game engine.  This will allow us to reuse all or at least part of our game engine for future games.

Chapter 6, Creating Objects with the Prototype Pattern, covers another way to reduce dependencies within our game engine.  We learn how to create objects through their base classes.  In addition, we cover how to read object data from a file.

Chapter 7, Improving Performance with Object Pools, covers a way to improve memory costs in our games by reusing objects that we’ve created dynamically by making use of a manager to control what is and isn’t being used at the moment.

Chapter 8, Controlling the UI via the Command Pattern, discusses how to create reusable actions that can be utilized for UI button clicks or input devices such as keyboard or controller.

Chapter 9, Decoupling Gameplay via the Observer Pattern, explains multiple ways that classes can communicate and share data without using global variables. 

Chapter 10, Sharing Objects with the Flyweight Pattern, discusses how we can design our objects to be as lightweight as possible by separating data that can and can't be shared. We use this knowledge to create a particle system which produces smaller objects developed to simulate things like fire, explosions, and smoke.

Chapter 11, Understanding Graphics and Animation, provides a low-level explanation of how graphics and rendering work so that you are better able to implement it in your game.

Chapter 12, Best Practices, covers a number of topics that will improve your code and game projects in the future, touching on things like how to improve your code quality, use the const keyword correctly, how iteration is a great way to improve game and code design, and when you should consider adding scripting to your game.

To write code, all you really need is a text editor, but for serious development you'll need to use an IDE (Integrated Developer Environment). We use Microsoft Visual Studio 2015 and C++ in this book using a Windows computer but, the concepts taught can be used within any programming language as well. For those of you that do not have Visual Studio installed, but are using Windows we do go over how to install the free Visual Studio Community version and set it up with our project in Chapter 1, Introduction to Design Patterns.

This book is for anyone who wants to learn how to write better, cleaner code.  While design patterns in general do not require any specific programming language, the examples in this book are written in C++.  Readers will get much more out of this book if they are already familiar with C++ and STL containers.  The project that is included with this book was written and compiled using Microsoft Visual Studio 2015, so familiarity with that IDE will be very helpful as well.

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "I’m going to update the ChasePlayerComponent class that already exists in the EngineTest project."

A block of code is set as follows:

class Animal
{
  public:
    virtual void Speak(void) const //virtual in the base class
    {
      //Using the Mach 5 console print
      M5DEBUG_PRINT("...\n");
    }
};

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

class StaticExamples
{
  public:
    static float classVariable;

    static void StaticFunction()
    {
// Note, can only use static variables and functions within 
      // static function
      std::string toDisplay = "\n I can be called anywhere! 
      classVariable value: " + 
      std::to_string(classVariable);

      printf(toDisplay.c_str());
    }

    void InFunction()
    {
      static int enemyCount = 0;

      // Increase the value of enemyCount
      enemyCount += 10;

      std::string toDisplay = "\n Value of enemyCount: " + 
      std::to_string(enemyCount);

      printf(toDisplay.c_str());
   }
};

New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: "In order to download new modules, we will go to Files | Settings | Project Name | Project Interpreter."

Feedback from our readers is always welcome. Let us know what you think about this book-what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of. To send us general feedback, simply e-mail [email protected], and mention the book's title in the subject of your message. If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.