Game Programming Patterns

https://gameprogrammingpatterns.com/
Admin
Game Programming Patterns is a collection of design patterns for game development that helps make...
Tokens:60,796
Snippets:833
Trust Score:9.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### Instantiating Bjorn with Player Input

Source: https://gameprogrammingpatterns.com/component.html

Example of creating a Bjorn instance with a PlayerInputComponent.

```cpp
Bjorn* bjorn = new Bjorn(new PlayerInputComponent());
```

--------------------------------

### Instantiating Bjorn with Demo Input

Source: https://gameprogrammingpatterns.com/component.html

Example of creating a Bjorn instance with a DemoInputComponent for demo mode.

```cpp
Bjorn* bjorn = new Bjorn(new DemoInputComponent());
```

--------------------------------

### Instantiating Spawner with Spawn Function

Source: https://gameprogrammingpatterns.com/prototype.html

Example of creating a Spawner instance for ghosts by passing the spawnGhost function.

```cpp
Spawner* ghostSpawner = new Spawner(spawnGhost);
```

--------------------------------

### Instantiating Template Spawner

Source: https://gameprogrammingpatterns.com/prototype.html

Example of creating a SpawnerFor instance for the Ghost type using C++ templates.

```cpp
Spawner* ghostSpawner = new SpawnerFor<Ghost>();
```

--------------------------------

### Initiate Scene Graph Rendering

Source: https://gameprogrammingpatterns.com/dirty-flag.html

Starts the rendering process for the entire scene graph by calling the `render` method on the root node with an origin transform.

```cpp
graph_->render(Transform::origin());

```

--------------------------------

### Component Update Methods

Source: https://gameprogrammingpatterns.com/data-locality.html

Illustrates the basic structure of AI, Physics, and Render components, each with an update or render method. These are examples of the Update Method pattern.

```cpp
class AIComponent
{
public:
  void update() { /* Work with and modify state... */ }

private:
  // Goals, mood, etc. ...
};

class PhysicsComponent
{
public:
  void update() { /* Work with and modify state... */ }

private:
  // Rigid body, velocity, mass, etc. ...
};

class RenderComponent
{
public:
  void render() { /* Work with and modify state... */ }

private:
  // Mesh, textures, shaders, etc. ...
};

```

--------------------------------

### Implement Simple Service Locator

Source: https://gameprogrammingpatterns.com/service-locator.html

A basic implementation of a service locator. It holds a static pointer to the service and provides methods to get and provide the service instance.

```cpp
class Locator
{
public:
  static Audio* getAudio() { return service_; }

  static void provide(Audio* service)
  {
    service_ = service;
  }

private:
  static Audio* service_;
};

```

--------------------------------

### Transition to Ducking State

Source: https://gameprogrammingpatterns.com/state.html

This example shows a standing state transitioning to a ducking state by creating and returning a new DuckingState object. It returns NULL if no state change occurs.

```C++
HeroineState* StandingState::handleInput(Heroine& heroine,
                                         Input input)
{
  if (input == PRESS_DOWN)
  {
    // Other code...
    return new DuckingState();
  }

  // Stay in this state.
  return NULL;
}

```

--------------------------------

### Input Handling for Move Commands

Source: https://gameprogrammingpatterns.com/command.html

Example of input handling code that creates `MoveUnitCommand` instances based on player input. Commands created here are intended for single use.

```cpp
Command* handleInput()
{
  Unit* unit = getSelectedUnit();

  if (isPressed(BUTTON_UP)) {
    // Move the unit up one.
    int destY = unit->y() - 1;
    return new MoveUnitCommand(unit, unit->x(), destY);
  }

  if (isPressed(BUTTON_DOWN)) {
    // Move the unit down one.
    int destY = unit->y() + 1;
    return new MoveUnitCommand(unit, unit->x(), destY);
  }

  // Other moves...

  return NULL;
}
```

--------------------------------

### Changing State using Static Instance

Source: https://gameprogrammingpatterns.com/state.html

Example of how a state can change the heroine's current state by assigning a static state instance to the heroine's state pointer. This also includes setting graphics.

```cpp
if (input == PRESS_B)
{
  heroine.state_ = &HeroineState::jumping;
  heroine.setGraphics(IMAGE_JUMP);
}
```

--------------------------------

### Superpower Methods Directly in Base Class

Source: https://gameprogrammingpatterns.com/subclass-sandbox.html

Example of adding sound-related methods directly to the Superpower base class. Consider this approach if the base class is not yet unwieldy.

```cpp
class Superpower
{
protected:
  void playSound(SoundId sound, double volume)
  {
    // Code here...
  }

  void stopSound(SoundId sound)
  {
    // Code here...
  }

  void setVolume(SoundId sound)
  {
    // Code here...
  }

  // Sandbox method and other operations...
};

```

--------------------------------

### Initiating the Update Cycle

Source: https://gameprogrammingpatterns.com/double-buffer.html

Slaps the 'harry' actor to start a chain reaction and then calls the 'stage.update()' method to process the frame.

```cpp
harry->slap();

stage.update();

```

--------------------------------

### UI Menu Sound Playback

Source: https://gameprogrammingpatterns.com/event-queue.html

Example of calling playSound from UI code to play a sound when a menu item is selected. This demonstrates a typical usage point.

```cpp
class Menu
{
public:
  void onSelect(int index)
  {
    Audio::playSound(SOUND_BLOOP, VOL_MAX);
    // Other stuff...
  }
};

```

--------------------------------

### Simple BASIC Loop

Source: https://gameprogrammingpatterns.com/introduction.html

A very basic BASIC program demonstrating an infinite loop. This was an early example of code encountered by the author, highlighting the challenges of syntax errors and the desire for shorter programs.

```basic
10 PRINT "BOBBY IS RADICAL!!!"
20 GOTO 10

```

--------------------------------

### Coupled Game Logic Example

Source: https://gameprogrammingpatterns.com/component.html

This code demonstrates tight coupling between different game domains (physics, rendering, sound) within a single conditional statement. Modifying this requires knowledge of all involved systems, making it error-prone and difficult to maintain, especially in concurrent environments.

```cpp
if (collidingWithFloor() && (getRenderState() != INVISIBLE))
{
  playSound(HIT_FLOOR);
}

```

--------------------------------

### Forwarding a Call to an External System

Source: https://gameprogrammingpatterns.com/subclass-sandbox.html

This example shows a base class operation that forwards a call to an external system. It's useful for encapsulating state within the base class that subclasses shouldn't directly access.

```cpp
void playSound(SoundId sound, double volume)
{
  soundEngine_.play(sound, volume);
}

```

--------------------------------

### Bullet and BulletManager Classes (Singleton-like)

Source: https://gameprogrammingpatterns.com/singleton.html

This example demonstrates a common anti-pattern where a manager class is created to handle operations for another class (Bullet). It's often mistakenly considered for a Singleton implementation.

```cpp
class Bullet
{
public:
  int getX() const { return x_; }
  int getY() const { return y_; }

  void setX(int x) { x_ = x; }
  void setY(int y) { y_ = y; }

private:
  int x_, y_;
};

class BulletManager
{
public:
  Bullet* create(int x, int y)
  {
    Bullet* bullet = new Bullet();
    bullet->setX(x);
    bullet->setY(y);

    return bullet;
  }

  bool isOnScreen(Bullet& bullet)
  {
    return bullet.getX() >= 0 &&
           bullet.getX() < SCREEN_WIDTH &&
           bullet.getY() >= 0 &&
           bullet.getY() < SCREEN_HEIGHT;
  }

  void move(Bullet& bullet)
  {
    bullet.setX(bullet.getX() + 5);
  }
};

```

--------------------------------

### Achievements System Implementing Observer

Source: https://gameprogrammingpatterns.com/observer.html

An example of a concrete observer, the Achievements system, which listens for events and reacts to them. It checks for specific conditions, like the hero falling off a bridge, to unlock achievements.

```cpp
class Achievements : public Observer
{
public:
  virtual void onNotify(const Entity& entity, Event event)
  {
    switch (event)
    {
    case EVENT_ENTITY_FELL:
      if (entity.isHero() && heroIsOnBridge_)
      {
        unlock(ACHIEVEMENT_FELL_OFF_BRIDGE);
      }
      break;

      // Handle other events, and update heroIsOnBridge_...
    }
  }

private:
  void unlock(Achievement achievement)
  {
    // Unlock if not already unlocked...
  }

  bool heroIsOnBridge_;
};
```

--------------------------------

### Arithmetic Expression Example

Source: https://gameprogrammingpatterns.com/bytecode.html

Illustrates a simple arithmetic expression that can be parsed and represented.

```plaintext
(1 + 2) * (3 - 4)

```

--------------------------------

### Creating a Spawner with a Prototype Instance

Source: https://gameprogrammingpatterns.com/prototype.html

Demonstrates how to instantiate a `Spawner` by providing it with a prototypal `Monster` object. This allows the spawner to create more monsters of that specific type and state.

```cpp
Monster* ghostPrototype = new Ghost(15, 3);
Spawner* ghostSpawner = new Spawner(ghostPrototype);
```

--------------------------------

### Instruction Handling with Stack Operations

Source: https://gameprogrammingpatterns.com/bytecode.html

Demonstrates how VM instructions like INST_SET_HEALTH, INST_PLAY_SOUND, and INST_SPAWN_PARTICLES use the pop() method to retrieve parameters from the stack.

```cpp
switch (instruction)
{
  case INST_SET_HEALTH:
  {
    int amount = pop();
    int wizard = pop();
    setHealth(wizard, amount);
    break;
  }

  case INST_SET_WISDOM:
  case INST_SET_AGILITY:
    // Same as above...

  case INST_PLAY_SOUND:
    playSound(pop());
    break;

  case INST_SPAWN_PARTICLES:
    spawnParticles(pop());
    break;
}

```

--------------------------------

### Singleton Instance Creation Logic

Source: https://gameprogrammingpatterns.com/singleton.html

Implements the static instance() method for the Singleton FileSystem. It uses preprocessor directives to conditionally instantiate the correct platform-specific subclass.

```cpp
FileSystem& FileSystem::instance()
{
  #if PLATFORM == PLAYSTATION3
    static FileSystem *instance = new PS3FileSystem();
  #elif PLATFORM == WII
    static FileSystem *instance = new WiiFileSystem();
  #endif

  return *instance;
}

```

--------------------------------

### Audio::playSound Implementation

Source: https://gameprogrammingpatterns.com/event-queue.html

The synchronous implementation of playSound, which loads, finds a channel, and starts the sound. This can block the caller.

```cpp
void Audio::playSound(SoundId id, int volume)
{
  ResourceId resource = loadSound(id);
  int channel = findOpenChannel();
  if (channel == -1) return;
  startSound(resource, channel, volume);
}

```

--------------------------------

### Use Service Locator to Access Audio

Source: https://gameprogrammingpatterns.com/service-locator.html

Demonstrates how to retrieve and use the audio service through the service locator. This code only depends on the abstract Audio interface.

```cpp
Audio *audio = Locator::getAudio();
audio->playSound(VERY_LOUD_BANG);

```

--------------------------------

### Demo Input Component Implementation

Source: https://gameprogrammingpatterns.com/component.html

A placeholder implementation for AI-driven input during demo mode. This component controls Bjorn automatically.

```cpp
class DemoInputComponent : public InputComponent
{
public:
  virtual void update(Bjorn& bjorn)
  {
    // AI to automatically control Bjorn...
  }
};
```

--------------------------------

### Accessing Singleton Instance

Source: https://gameprogrammingpatterns.com/singleton.html

This demonstrates the typical way to access a singleton instance. Be aware that this design can make it difficult to later support multiple instances.

```cpp
Log::instance().write("Some event.");

```

--------------------------------

### Direct Monster Instantiation (Before)

Source: https://gameprogrammingpatterns.com/type-object.html

Illustrates the older way of creating a Monster instance directly, passing the breed as an argument.

```cpp
Monster* monster = new Monster(someBreed);

```

--------------------------------

### Bytecode for Getting Wizard Health

Source: https://gameprogrammingpatterns.com/bytecode.html

A simple bytecode sequence to push a wizard's health onto the stack. It first pushes the wizard index.

```assembly
LITERAL 0
GET_HEALTH


```

--------------------------------

### Implement Basic Jump - C++

Source: https://gameprogrammingpatterns.com/state.html

Initial implementation for handling jump input. Lacks checks for air jumping.

```cpp
void Heroine::handleInput(Input input)
{
  if (input == PRESS_B)
  {
    yVelocity_ = JUMP_VELOCITY;
    setGraphics(IMAGE_JUMP);
  }
}
```

--------------------------------

### Define Breed Data with C++

Source: https://gameprogrammingpatterns.com/type-object.html

This class holds data for a monster breed, including its starting health and attack string. It serves as a data container for type-specific information.

```cpp
class Breed
{
public:
  Breed(int health, const char* attack)
  : health_(health),
    attack_(attack)
  {}

  int getHealth() { return health_; }
  const char* getAttack() { return attack_; }

private:
  int health_; // Starting health.
  const char* attack_; // Attack string.
};

```

--------------------------------

### Tree Class with All Data

Source: https://gameprogrammingpatterns.com/flyweight.html

This class represents a tree with all its data, including mesh, textures, position, and appearance parameters. It serves as a starting point before applying the Flyweight pattern.

```cpp
class Tree
{
private:
  Mesh mesh_;
  Texture bark_;
  Texture leaves_;
  Vector position_;
  double height_;
  double thickness_;
  Color barkTint_;
  Color leafTint_;
};

```

--------------------------------

### Spawner Class Hierarchy (Pre-Prototype)

Source: https://gameprogrammingpatterns.com/prototype.html

Illustrates a brute-force approach using a separate spawner class for each monster type, leading to a parallel class hierarchy. This method is verbose and redundant.

```cpp
class Spawner
{
public:
  virtual ~Spawner() {}
  virtual Monster* spawnMonster() = 0;
};

class GhostSpawner : public Spawner
{
public:
  virtual Monster* spawnMonster()
  {
    return new Ghost();
  }
};

class DemonSpawner : public Spawner
{
public:
  virtual Monster* spawnMonster()
  {
    return new Demon();
  }
};

// You get the idea...
```

--------------------------------

### Get Stat Bytecode Instruction

Source: https://gameprogrammingpatterns.com/bytecode.html

Adds instructions to read a wizard's stat. These instructions pop a wizard index from the stack and push the corresponding stat's value.

```c
case INST_GET_HEALTH:
{
  int wizard = pop();
  push(getHealth(wizard));
  break;
}

case INST_GET_WISDOM:
case INST_GET_AGILITY:
  // You get the idea...


```

--------------------------------

### Compile-Time Service Binding with Macros

Source: https://gameprogrammingpatterns.com/service-locator.html

This C++ snippet demonstrates how to use preprocessor macros for compile-time service location. It selects between debug and release implementations of a service based on the DEBUG macro. This approach offers high performance and guarantees service availability but lacks runtime flexibility.

```cpp
class Locator
{
public:
  static Audio& getAudio() { return service_; }

private:
  #if DEBUG
    static DebugAudio service_;
  #else
    static ReleaseAudio service_;
  #endif
};

```

--------------------------------

### Provide Concrete Service to Locator

Source: https://gameprogrammingpatterns.com/service-locator.html

Initializes and registers a concrete service implementation with the service locator. This is typically done during application startup.

```cpp
ConsoleAudio *audio = new ConsoleAudio();
Locator::provide(audio);

```

--------------------------------

### Process Pending Sound Play Requests

Source: https://gameprogrammingpatterns.com/event-queue.html

Iterates through pending messages, loads sound resources, finds an open channel, and starts playing the sound. Resets the pending count after processing.

```c++
class Audio
{
public:
  static void update()
  {
    for (int i = 0; i < numPending_; i++)
    {
      ResourceId resource = loadSound(pending_[i].id);
      int channel = findOpenChannel();
      if (channel == -1) return;
      startSound(resource, channel, pending_[i].volume);
    }

    numPending_ = 0;
  }

  // Other stuff...
};

```

--------------------------------

### Accessing Audio System

Source: https://gameprogrammingpatterns.com/service-locator.html

Illustrates two common but problematic ways to access a global service like an audio system, leading to tight coupling.

```cpp
// Use a static class?
AudioSystem::playSound(VERY_LOUD_BANG);

// Or maybe a singleton?
AudioSystem::instance()->playSound(VERY_LOUD_BANG);

```

--------------------------------

### Enabling Audio Logging via Decorator

Source: https://gameprogrammingpatterns.com/service-locator.html

Function to enable audio logging by decorating the existing audio service with LoggedAudio and updating the service locator.

```cpp
void enableAudioLogging()
{
  // Decorate the existing service.
  Audio *service = new LoggedAudio(Locator::getAudio());

  // Swap it in.
  Locator::provide(service);
}
```

--------------------------------

### Reset Charge Timer on State Change

Source: https://gameprogrammingpatterns.com/state.html

Modifies the input handling to reset the charge timer when the Heroine enters the ducking state. This ensures the timer starts correctly for new charge attacks.

```cpp
void Heroine::handleInput(Input input)
{
  switch (state_)
  {
    case STATE_STANDING:
      if (input == PRESS_DOWN)
      {
        state_ = STATE_DUCKING;
        chargeTime_ = 0;
        setGraphics(IMAGE_DUCK);
      }
      // Handle other inputs...
      break;

      // Other states...
  }
}

```

--------------------------------

### Goblin Data Models with Prototype Delegation

Source: https://gameprogrammingpatterns.com/prototype.html

Demonstrates using the 'prototype' field in JSON to delegate properties, reducing data duplication. The wizard and archer now inherit properties from the 'goblin grunt'.

```json
{
  "name": "goblin grunt",
  "minHealth": 20,
  "maxHealth": 30,
  "resists": ["cold", "poison"],
  "weaknesses": ["fire", "light"]
}

{
  "name": "goblin wizard",
  "prototype": "goblin grunt",
  "spells": ["fire ball", "lightning bolt"]
}

{
  "name": "goblin archer",
  "prototype": "goblin grunt",
  "attacks": ["short bow"]
}
```

--------------------------------

### Bytecode for Complex Expression Evaluation

Source: https://gameprogrammingpatterns.com/bytecode.html

Demonstrates the bytecode sequence for evaluating a complex expression involving getting stats, arithmetic operations, and setting a stat. The stack implicitly handles expression grouping.

```assembly
LITERAL 0    [0]            # Wizard index
LITERAL 0    [0, 0]         # Wizard index
GET_HEALTH   [0, 45]        # getHealth()
LITERAL 0    [0, 45, 0]     # Wizard index
GET_AGILITY  [0, 45, 7]     # getAgility()
LITERAL 0    [0, 45, 7, 0]  # Wizard index
GET_WISDOM   [0, 45, 7, 11] # getWisdom()
ADD          [0, 45, 18]    # Add agility and wisdom
LITERAL 2    [0, 45, 18, 2] # Divisor
DIVIDE       [0, 45, 9]     # Average agility and wisdom
ADD          [0, 54]        # Add average to current health
SET_HEALTH   []             # Set health to result


```

--------------------------------

### Update Loop with Fixed Iteration Count

Source: https://gameprogrammingpatterns.com/update-method.html

Cache the number of objects at the start of the loop to prevent updating newly added objects in the same frame. This is useful when objects are added during the update cycle and should not act immediately.

```cpp
int numObjectsThisTurn = numObjects_;
for (int i = 0; i < numObjectsThisTurn; i++)
{
  objects_[i]->update();
}

```

--------------------------------

### Initialize Unit with Grid Placement

Source: https://gameprogrammingpatterns.com/spatial-partition.html

The Unit constructor now initializes its position and immediately adds itself to the appropriate cell in the provided Grid using the Grid's add method.

```cpp
Unit::Unit(Grid* grid, double x, double y)
: grid_(grid),
  x_(x),
  y_(y),
  prev_(NULL),
  next_(NULL)
{
  grid_->add(this);
}

```

--------------------------------

### Executing a Delayed Command

Source: https://gameprogrammingpatterns.com/command.html

Demonstrates how to retrieve a command from the input handler and then execute it on a specific actor. This separates input processing from action execution.

```cpp
Command* command = inputHandler.handleInput();
if (command)
{
  command->execute(actor);
}
```

--------------------------------

### Notify Event in Physics System

Source: https://gameprogrammingpatterns.com/observer.html

This code snippet demonstrates how a physics system can notify other parts of the game when a significant event occurs, like an entity starting to fall. It decouples the notification from the specific recipient.

```cpp
void Physics::updateEntity(Entity& entity)
{
  bool wasOnSurface = entity.isOnSurface();
  entity.accelerate(GRAVITY);
  entity.update();
  if (wasOnSurface && !entity.isOnSurface())
  {
    notify(entity, EVENT_START_FALL);
  }
}
```

--------------------------------

### JSON Definition of Breeds with Inheritance

Source: https://gameprogrammingpatterns.com/type-object.html

Example JSON structure for defining game breeds, including attributes and parent-child relationships for inheritance. This format allows designers to easily tune attributes and manage breed data.

```json
{
  "Troll": {
    "health": 25,
    "attack": "The troll hits you!"
  },
  "Troll Archer": {
    "parent": "Troll",
    "health": 0,
    "attack": "The troll archer fires an arrow!"
  },
  "Troll Wizard": {
    "parent": "Troll",
    "health": 0,
    "attack": "The troll wizard casts a spell on you!"
  }
}

```

--------------------------------

### Initialize Particle Pool Free List

Source: https://gameprogrammingpatterns.com/object-pool.html

The constructor initializes the free list by linking all particles in the pool together. It sets the first available particle and then iterates through the pool, setting each particle's next pointer to the subsequent one, with the last particle pointing to NULL.

```cpp
ParticlePool::ParticlePool()
{
  // The first one is available.
  firstAvailable_ = &particles_[0];

  // Each particle points to the next.
  for (int i = 0; i < POOL_SIZE - 1; i++)
  {
    particles_[i].setNext(&particles_[i + 1]);
  }

  // The last one terminates the list.
  particles_[POOL_SIZE - 1].setNext(NULL);
}

```

--------------------------------

### Alternative Observer Registration

Source: https://gameprogrammingpatterns.com/observer.html

Demonstrates an alternative approach where observers register with an event object rather than the main system directly.

```cpp
physics.entityFell()
  .addObserver(this);

```

--------------------------------

### Implement Simple SkyLaunch Superpower

Source: https://gameprogrammingpatterns.com/subclass-sandbox.html

This C++ code shows a simple subclass `SkyLaunch` that inherits from `Superpower`. It overrides the `activate()` method to play a sound, spawn particles, and move the hero, demonstrating a basic usage of the provided operations.

```cpp
class SkyLaunch : public Superpower
{
protected:
  virtual void activate()
  {
    // Spring into the air.
    playSound(SOUND_SPROING, 1.0f);
    spawnParticles(PARTICLE_DUST, 10);
    move(0, 0, 20);
  }
};

```

--------------------------------

### Multiple Entities in Game Loop (Before Update Method)

Source: https://gameprogrammingpatterns.com/update-method.html

This code illustrates the complexity that arises when multiple entities' behaviors (skeleton and statues) are managed directly within the main game loop, leading to cluttered and hard-to-maintain code.

```csharp
// Skeleton variables...
Entity leftStatue;
Entity rightStatue;
int leftStatueFrames = 0;
int rightStatueFrames = 0;

// Main game loop:
while (true)
{
  // Skeleton code...

  if (++leftStatueFrames == 90)
  {
    leftStatueFrames = 0;
    leftStatue.shootLightning();
  }

  if (++rightStatueFrames == 80)
  {
    rightStatueFrames = 0;
    rightStatue.shootLightning();
  }

  // Handle user input and render game...
}
```

--------------------------------

### Centralized Access to Game Systems via Game Instance

Source: https://gameprogrammingpatterns.com/singleton.html

A single static instance of the Game class provides access to other systems like Log, FileSystem, and AudioPlayer. This reduces the number of globally accessible classes but increases coupling to the Game class.

```cpp
class Game
{
public:
  static Game& instance() { return instance_; }

  // Functions to set log_, et. al. ...

  Log&         getLog()         { return *log_; }
  FileSystem&  getFileSystem()  { return *fileSystem_; }
  AudioPlayer& getAudioPlayer() { return *audioPlayer_; }

private:
  static Game instance_;

  Log         *log_;
  FileSystem  *fileSystem_;
  AudioPlayer *audioPlayer_;
};

```

```cpp
Game::instance().getAudioPlayer().play(VERY_LOUD_BANG);

```

--------------------------------

### Controlled Monster Instantiation (After)

Source: https://gameprogrammingpatterns.com/type-object.html

Shows the new, controlled way to create a Monster instance using the Breed's factory method. This approach centralizes object creation logic within the Breed type object.

```cpp
Monster* monster = someBreed.newMonster();

```

--------------------------------

### Implement Concrete Audio Service

Source: https://gameprogrammingpatterns.com/service-locator.html

Provides a concrete implementation of the Audio interface. This class would contain the actual logic for interacting with a specific audio system.

```cpp
class ConsoleAudio : public Audio
{
public:
  virtual void playSound(int soundID)
  {
    // Play sound using console audio api...
  }

  virtual void stopSound(int soundID)
  {
    // Stop sound using console audio api...
  }

  virtual void stopAllSounds()
  {
    // Stop all sounds using console audio api...
  }
};

```

--------------------------------

### Null Object Implementation for Audio Service

Source: https://gameprogrammingpatterns.com/service-locator.html

Implements a null service provider for the Audio interface. Use this when a real service is not yet registered to prevent null pointer exceptions.

```cpp
class NullAudio: public Audio
{
public:
  virtual void playSound(int soundID) { /* Do nothing. */ }
  virtual void stopSound(int soundID) { /* Do nothing. */ }
  virtual void stopAllSounds()        { /* Do nothing. */ }
};
```

--------------------------------

### Platform-Specific File System Implementations

Source: https://gameprogrammingpatterns.com/singleton.html

Concrete implementations of the FileSystem interface for different platforms (PS3 and Wii). These classes contain platform-specific IO logic.

```cpp
class PS3FileSystem : public FileSystem
{
public:
  virtual char* readFile(char* path)
  {
    // Use Sony file IO API...
  }

  virtual void writeFile(char* path, char* contents)
  {
    // Use sony file IO API...
  }
};

```

```cpp
class WiiFileSystem : public FileSystem
{
public:
  virtual char* readFile(char* path)
  {
    // Use Nintendo file IO API...
  }

  virtual void writeFile(char* path, char* contents)
  {
    // Use Nintendo file IO API...
  }
};

```

--------------------------------

### Initial AIComponent with Hot and Cold Data

Source: https://gameprogrammingpatterns.com/data-locality.html

This C++ code shows an initial AIComponent structure containing both frequently accessed ('hot') and infrequently accessed ('cold') data. Including all data in the main structure can lead to cache misses.

```cpp
class AIComponent
{
public:
  void update() { /* ... */ }

private:
  Animation* animation_;
  double energy_;
  Vector goalPos_;
};


```

```cpp
class AIComponent
{
public:
  void update() { /* ... */ }

private:
  // Previous fields...
  LootType drop_;
  int minDrops_;
  int maxDrops_;
  double chanceOfDrop_;
};


```

--------------------------------

### Simple Bytecode Virtual Machine (C++)

Source: https://gameprogrammingpatterns.com/bytecode.html

A basic virtual machine class that interprets an array of bytecode instructions. It iterates through the bytecode and dispatches each instruction.

```cpp
class VM
{
public:
  void interpret(char bytecode[], int size)
  {
    for (int i = 0; i < size; i++)
    {
      char instruction = bytecode[i];
      switch (instruction)
      {
        // Cases for each instruction...
      }
    }
  }
};


```

--------------------------------

### Coupled Object and Pool Implementation (C++)

Source: https://gameprogrammingpatterns.com/object-pool.html

Demonstrates how to couple objects to the pool by making the pool a friend of the object and making the object's constructor private. This ensures objects are created and managed exclusively by the pool.

```cpp
class Particle
{
  friend class ParticlePool;

private:
  Particle()
  : inUse_(false)
  {}

  bool inUse_;
};

class ParticlePool
{
  Particle pool_[100];
};
```

--------------------------------

### Handle Input by Executing Commands in C++

Source: https://gameprogrammingpatterns.com/command.html

The input handling logic now checks for input and then calls the `execute` method on the associated `Command` object. This decouples input detection from the specific game actions.

```cpp
void InputHandler::handleInput()
{
  if (isPressed(BUTTON_X)) buttonX_->execute();
  else if (isPressed(BUTTON_Y)) buttonY_->execute();
  else if (isPressed(BUTTON_A)) buttonA_->execute();
  else if (isPressed(BUTTON_B)) buttonB_->execute();
}
```

--------------------------------

### Simplify Ducking State Transition

Source: https://gameprogrammingpatterns.com/state.html

With entry actions handled by the target state, the DuckingState's input handler now only needs to return the new state. The responsibility for setting graphics is moved to the StandingState's enter action.

```C++
HeroineState* DuckingState::handleInput(Heroine& heroine,
                                        Input input)
{
  if (input == RELEASE_DOWN)
  {
    return new StandingState();
  }

  // Other code...
}

```

--------------------------------

### Two-Stage Initialization

Source: https://gameprogrammingpatterns.com/subclass-sandbox.html

Initialize the object in the constructor without parameters, then call a separate `init()` method on the base class to provide state. Ensure `init()` is always called to avoid partial initialization.

```cpp
Superpower* power = new SkyLaunch();
power->init(particles);


```

```cpp
Superpower* createSkyLaunch(ParticleSystem* particles)
{
  Superpower* power = new SkyLaunch();
  power->init(particles);
  return power;
}


```

--------------------------------

### Static State Initialization

Source: https://gameprogrammingpatterns.com/subclass-sandbox.html

Make the required state static within the base class. Initialize the static member once for the entire class, allowing all instances to share the same state.

```cpp
class Superpower
{
public:
  static void init(ParticleSystem* particles)
  {
    particles_ = particles;
  }

  // Sandbox method and other operations...

private:
  static ParticleSystem* particles_;
};


```

--------------------------------

### Setting up Comedians in a Circle

Source: https://gameprogrammingpatterns.com/double-buffer.html

Initializes three 'Comedian' actors, sets them to face each other in a circular fashion, and adds them to the 'Stage'.

```cpp
Stage stage;

Comedian* harry = new Comedian();
Comedian* baldy = new Comedian();
Comedian* chump = new Comedian();

harry->face(baldy);
baldy->face(chump);
chump->face(harry);

stage.add(harry, 0);
stage.add(baldy, 1);
stage.add(chump, 2);

```

--------------------------------

### Concrete Jump Command Implementation

Source: https://gameprogrammingpatterns.com/command.html

A concrete implementation of the Command interface. This class defines how to execute a 'jump' action on a given GameActor by calling its jump() method.

```cpp
class JumpCommand : public Command
{
public:
  virtual void execute(GameActor& actor)
  {
    actor.jump();
  }
};
```

--------------------------------

### Skeleton Patrol Loop (Before Update Method)

Source: https://gameprogrammingpatterns.com/update-method.html

This code demonstrates a naive approach to animating a skeleton by using infinite loops, which locks the program and prevents any other game logic or rendering from occurring.

```csharp
while (true)
{
  // Patrol right.
  for (double x = 0; x < 100; x++)
  {
    skeleton.setX(x);
  }

  // Patrol left.
  for (double x = 100; x > 0; x--)
  {
    skeleton.setX(x);
  }
}
```

--------------------------------

### Implement Specific Commands in C++

Source: https://gameprogrammingpatterns.com/command.html

Concrete command classes that inherit from the base `Command` class. Each subclass implements the `execute` method to perform a specific game action, such as jumping or firing.

```cpp
class JumpCommand : public Command
{
public:
  virtual void execute() { jump(); }
};

class FireCommand : public Command
{
public:
  virtual void execute() { fireGun(); }
};
```

--------------------------------

### Define Standing State Entry Action

Source: https://gameprogrammingpatterns.com/state.html

This defines the entry action for the StandingState, setting the heroine's graphics to the standing image when entering this state. This encapsulates state-specific initialization.

```C++
class StandingState : public HeroineState
{
public:
  virtual void enter(Heroine& heroine)
  {
    heroine.setGraphics(IMAGE_STAND);
  }

  // Other code...
};

```

--------------------------------

### ParticlePool Create Method

Source: https://gameprogrammingpatterns.com/object-pool.html

Implements the `create` method for ParticlePool. It iterates through the particle array to find an available particle and initializes it. If no particles are available, no new particle is created.

```cpp
void ParticlePool::create(double x, double y,
                          double xVel, double yVel,
                          int lifetime)
{
  // Find an available particle.
  for (int i = 0; i < POOL_SIZE; i++)
  {
    if (!particles_[i].inUse())
    {
      particles_[i].init(x, y, xVel, yVel, lifetime);
      return;
    }
  }
}

```

--------------------------------

### VM Class Structure for Stack Machine

Source: https://gameprogrammingpatterns.com/bytecode.html

Defines the basic structure of the Virtual Machine (VM) including stack size and current stack pointer. Used for initializing the VM.

```cpp
class VM
{
public:
  VM()
  : stackSize_(0)
  {}

  // Other stuff...

private:
  static const int MAX_STACK = 128;
  int stackSize_;
  int stack_[MAX_STACK];
};

```
Tokens:
Raw