Question

I am implementing a simple board game (Breakthrough) using OpenGL (plus GLUT and GLUI).

I’m thinking of implementing a Board class, which will have a vector<vector<Cell> > as one of its attributes. Cell represents a space in the game board. It can contain a GameObject. GameObject will be a pure abstract class. It mandates that its derivative classes implement render(), for example. Possible derivative classes will be:

• Blank, representing an empty space
• Pawn, representing a pawn (the only possible pieces in Breakthrough)

The board will be rendered by first rendering the board, then iterating through each Cell, getting its contents and calling render() for each of them.

The only possible way I can think of to achieving this is making the GameObject in Cell a pointer (board[y][x].getContents()->render(), where getContents() returns the GameObject*)

Is this the best way to do this? Is this an appropriate usage of pointers?

Answer 1

Let me promote my comment into an answer. This doesn’t mean that it’s in any sense complete, only that this allows me to spell out some code examples. My original comment:

That’s OK, though you probably would do better with a std::unique_ptr<GameObject> or a std::shared_ptr<GameObject> so you don’t get lost amids the manual lifetime management issues. Finally, how about a flat 1-D array accessible in strides?

Here’s how I might go about this:

#include <vector>
#include <memory>

struct GameObject { virtual void render() const = 0; virtual ~GameObject() { } };

class Cell
{
  std::unique_ptr<GameObject> m_go;

public:
  void render() const { m_go->render(); }
  Cell() : m_go(new BlankCell) { }
  // more functions to reassign the cell value etc.
};

class Board
{
  std::vector<Cell> m_board;
  std::size_t       m_length;

public:
  Board(std::size_t length) : m_board(length * length), m_length(length) { }
  Cell & cell(std::size_t i, std::size_t j) { return m_board(j + i * m_length); }
  Cell const & cell(std::size_t i, std::size_t j) const { return const_cast<Board*>(this)->cell(i, j); }
  // more...
}