C++ Game Development Cookbook

C++ Game Development Cookbook

By : Druhin Mukherjee

Buy this Book

C++ Game Development Cookbook

By: Druhin Mukherjee

Buy this Book

Overview of this book

C++ is one of the preferred languages for game development as it supports a variety of coding styles that provides low-level access to the system. C++ is still used as a preferred game programming language by many as it gives game programmers control of the entire architecture, including memory patterns and usage. However, there is little information available on how to harness the advanced features of C++ to build robust games. This book will teach you techniques to develop logic and game code using C++. The primary goal of this book is to teach you to create high-quality games using C++ game programming scripts and techniques, regardless of the library or game engine you use. It will show you how to make use of the object-oriented capabilities of C++ so you can write well-structured and powerful games of any genre. The book also explores important areas such as physics programming and audio programming, and gives you other useful tips and tricks to improve your code. By the end of this book, you will be competent in game programming using C++, and will be able to develop your own games in C++.

C++ Game Development Cookbook

Credits

About the Author

About the Reviewer

www.PacktPub.com

Preface

Free Chapter

Game Development Basics

Introduction

Installing an IDE on Windows

Choosing the right source control tool

Using call stacks for memory storage

Using recursions cautiously

Using pointers to store memory addresses

Casting between different datatypes

Managing memory more effectively using dynamic allocation

Using bitwise operations for advanced checks and optimization

Object-Oriented Approach and Design in Games

Introduction

Using classes for data encapsulation and abstraction

Using polymorphism to reuse code

Using copy constructors

Use operator overloading to reuse operators

Use function overloading to reuse functions

Using files for input and output

Creating your first simple game

Templates – when to use them

Data Structures in Game Development

Introduction

Using more advanced data structures

Using linked lists to store data

Using stacks to store data

Using queues to store data

Using trees to store data

Using graphs to store data

Using STL lists to store data

Using STL maps to store data

Using STL hash tables to store data

Algorithms for Game Development

Introduction

Using sorting techniques to arrange items

Using searching techniques to look for an item

Finding the complexity of an algorithm

Finding the endian-ness of a device

Using dynamic programming to break down a complex problem

Using greedy algorithms to solve problems

Using divide and conquer algorithms to solve problems

Event-Driven Programming – Making Your First 2D Game

Introduction

Starting to make a Windows game

Using Windows classes and handles

Creating your first window

Adding keyboard and mouse controls with text output

Using Windows resources with GDI

Using dialogs and controls

Using sprites

Using animated sprites

Design Patterns for Game Development

Introduction

Using the singleton design pattern

Using the factory method

Using the abstract factory method

Using the observer pattern

Using the flyweight pattern

Using the strategy pattern

Using the command design pattern

Creating an advanced game using design patterns

Organizing and Backing Up

Introduction

Versions of source control

Installing a versioning client

Selecting a host to save your data

Adding source control – committing and updating your code

Resolving conflicts

Creating a branch

AI in Game Development

Introduction

Adding artificial intelligence to a game

Using heuristics in a game

Using a Binary Space Partition Tree

Creating a decision making AI

Adding behavioral movements

Using neural network

Using genetic algorithms

Using other waypoint systems

Physics in Game Development

Introduction

Using physics rules in your game

Making things collide

Installing and integrating Box2D

Making a basic 2D game

Making a 3D game

Creating a particle system

Using ragdoll in your game

Multithreading in Game Development

Introduction

Concurrency in games – creating a thread

Joining and detaching a thread

Passing arguments to a thread

Avoiding deadlocks

Data race and mutex

Writing a thread-safe class

Networking in Game Development

Introduction

Understanding the different layers

Selecting the appropriate protocol

Serializing the packets

Using socket programming in games

Sending the data

Receiving the data

Dealing with lag

Using synchronized simulation

Using area of interest filtering

Using local perception filter

Audio in Game Development

Introduction

Installing FMOD

Adding background music

Adding sound effects

Creating a sound effect manager

Dealing with multiple sound file names

Tips and Tricks

Introduction

Effectively commenting your code

Using bit fields in a struct

Writing a sound technical design document

Using the const keyword to optimize your code

Using bit shift operators in an enum

Using the new lambda function of C++ 11

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Using call stacks for memory storage

The main reason why C++ is still the preferred language for most game developers is that you handle memory yourself and control the allocation and de-allocation of memory to a great extent. For that reason, we need to understand the different memory spaces that are provided to us. When data is "pushed" onto the stack, the stack grows. As data is "popped" off the stack, the stack shrinks. It is not possible to pop a particular piece of data off the stack without first popping off all data placed on top of it. Think of this as a series of compartments aligned top to bottom. The top of the stack is whatever compartment the stack pointer happens to point to (this is a register).

Each compartment has a sequential address. One of those addresses is kept in the stack pointer. Everything below that magic address, known as the top of the stack, is considered to be on the stack. Everything above the top of the stack is considered to be off the stack. When data is pushed onto the stack, it is placed into a compartment above the stack pointer, and then the stack pointer is moved to the new data. When data is popped off the stack, the address of the stack pointer is changed by moving it down the stack.

Getting ready

You need to have a working copy of Visual Studio installed on your Windows machine.

How to do it...

C++ is probably one of the best programming languages out there and one of the main reasons for that is that it is also a low level language, because we can manipulate memory. To understand memory handling, it is very important to understand how memory stacks work:

Open Visual Studio.
Create a new C++ project.
Select Win32 Console Application.
Add a source file called main.cpp or anything that you want to name the source file.

Add the following lines of code:

#include <iostream>
#include <conio.h>

using namespace std;

int countTotalBullets(int iGun1Ammo, int iGun2Ammo)
{
    return iGun1Ammo + iGun2Ammo;
}

int main()
{
    int iGun1Ammo = 3;
    int iGun2Ammo = 2;
    int iTotalAmmo = CountTotalBullets(iGun1Ammo, iGun2Ammo);

    cout << "Total ammunition currently with you is"<<iTotalAmmo;

    _getch();
}

How it works…

When you call the function CountTotalBullets, the code branches to the called function. The parameters are passed in and the body of the function is executed. When the function completes, a value is returned and the control returns to the calling function.

But how does it really work from a compiler's point of view? When you begin your program, the compiler creates a stack. The stack is a special area of memory allocated for your program in order to hold the data for each function in your program. A stack is a Last In First Out (LIFO) data structure. Imagine a deck of cards; the last card put on the pile will be the first card taken out.

When your program calls CountTotalBullets, a stack frame is established. A stack frame is an area of the stack set aside to manage that function. This is very complex and different on different platforms, but these are the essential steps:

The return address of CountTotalBullets is put on the stack. When the function returns, it will resume executing at this address.
Room is made on the stack for the return type you have declared.
All arguments to the function are placed on the stack.
The program branches to your function.
Local variables are pushed onto the stack as they are defined.

C++ Game Development Cookbook

By : Druhin Mukherjee

C++ Game Development Cookbook

By: Druhin Mukherjee

Overview of this book

Related Content you might be interested in

Current Title:

C++ Game Development Cookbook

Using call stacks for memory storage

Getting ready

How to do it...

How it works…