Question

I’m trying to create a basic Pacman game in C++ (I’ll use Java syntax in this question as this is somewhat easier to demonstrate), but I can’t find a good design option.

So far I have 4 classes:
– Monster: Can be subclassed for monster-specific behaviour and contains all logic for the monsters
– Player: Contains player-logic
– Map: Contains a 2d array representing the map. This array specifies which positions are walls or Pacman food
– Game: contains a Player, a Map and a list of Monsters.

To keep it simple:

public class Game {
  Player player;
  Map map;
  ArrayList<Monster> monsters;

  public Game() {
    player = new Player();
    map = new Map();
    monsters = new ArrayList<Monster();
    monsters.add(new ScaryMonster());
    monsters.add(new DumpMonster());
  }

  public void update() {
    player.update();
    map.update();

    for (Monster monster: monsters) {
      monster.update();
    }

  public void draw() {
    map.draw();
    player.draw();

    for (Monster monster: monsters) {
      monster.draw();
  }
}

So all I have to do now is to create a Game object and call update() and draw() on it every time. Very simple. But it doesn’t work.

Assume I call update() on the player-object and the player (which is the Pacman ofcourse) hits food. In that case, the map-object should get notified of this (and the position) to remove the food from the 2d-array. Assume the player kills a monster, the position of the monster should get changed (the Monster class has a “position field”). And you can imagine a lot more of these situations.

An option would be to pass the map and monster object as parameters in the update() and draw() method of the player object. And to pass the player and monster objects as parameters in the method calls of map. But that surely doesn’t sound like a good OO design.

What’s a good OO way to solve this? I was thinking about using the Observer pattern (so Game is the subject, player, map and monsters are observers), but that doesn’t make any sense: that way the observers will have to let the subject know of any changes, which is obviously not the correct way of using this.

Any tips would be very welcome.

Thank you very much 🙂

Answer 1

Why don’t you try mapping actions?

Every action has a reaction. So let’s say the pacman hits food. That’s an action, “hitting food”, which in turn has a reaction (notifying the map, or the food, or whatever you like) that the food is not there any longer.

Now imagine the pacman hits a monster, that’s another action… what would be the reaction to that? Well it might cause the monster to get dead (a call to the BeDeath method :P) or it could cause the pacman to get death… whatever it is it allow you to chain actions to reactions in the game.

That means the logic of the game, the rules would be in the game class, who in addition already knows all the elements needed and can communicate with each one.

Edit: A simple example (very simple, as the game gets more complex you’ll need to think better about actions and reactions structure)

public void IGameInfo
{
  List<Monster> Monsters {get;}
  Pacman Pacman {get;}
  Map Map {get;}
}

public void ComputeReactions()
{
  foreach (actionChecker in Actions)
  {
    actionChecker.Check(gameInfo);
  }
}

public void ComputeDotEaten(IGameInfo gameInfo)
{
  foreach (dot in gameInfo.Map.Dots)
    if (pacman.location == dot.location)
      dot.MarkEaten();
}

public void ComputeMonsterEaten(IGameInfo gameInfo)
{
  foreach (Monster in gameInfo.monsters)
    if (gameInfo.pacman.location == gameInfo.monster.location &&
        gameInfo.pacman.Invulnerable)
      monster.MarkDeath();
    else
      Game.EndGame();
}

Or if you like you could also map the reactions

public void ComputeDotEaten(IGameInfo gameInfo)
{
  foreach (dot in gameInfo.Map.Dots)
    if (pacman.location == dot.location)
      Reactions["DotEaten"].Execute(dot);
}

Note that for that to work all you reactions must share a common signature (i.e, taking an array of objects that are cast to the expected parameters)