《游戏编程模式》（2）

Chatper 2 命令模式

命令是一个具象化（实例化）的方法调用。

A command is a reified method call.

 

定义一个基类，命令的控制对象由参数传入：

class Command
{
public:
  virtual ~Command() {}
  virtual void execute(GameActor& actor) = 0;
};

 

为不同的游戏命令创建子类：

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

 

在输入处理中，为每个按钮存储一个指针，绑定一个命令，且可以灵活替换新的命令：

class InputHandler
{
public:
  void handleInput();
 
  // Methods to bind commands...
 
private:
  Command* buttonX_;
  Command* buttonY_;
  Command* buttonA_;
  Command* buttonB_;
};

 

现在，输入处理返回一个命令指针：

Command* InputHandler::handleInput()
{
  if (isPressed(BUTTON_X)) return buttonX_;
  if (isPressed(BUTTON_Y)) return buttonY_;
  if (isPressed(BUTTON_A)) return buttonA_;
  if (isPressed(BUTTON_B)) return buttonB_;
 
  // Nothing pressed, so do nothing.
  return NULL;
}

 

接收命令并让角色执行：

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

对游戏中的AI对象也可以简单地提供命令对象以供执行。

空对象模式：在这里可以提供一个什么都不做的命令。

 

撤销和重做：

execute中记录上一次的位置：

class Command
{
public:
  virtual ~Command() {}
  virtual void execute() = 0;
  virtual void undo() = 0;
};
class MoveUnitCommand : public Command
{
public:
  MoveUnitCommand(Unit* unit, int x, int y)
  : unit_(unit),
    xBefore_(0),
    yBefore_(0),
    x_(x),
    y_(y)
  {}
 
  virtual void execute()
  {
    // Remember the unit's position before the move
    // so we can restore it.
    xBefore_ = unit_->x();
    yBefore_ = unit_->y();
 
    unit_->moveTo(x_, y_);
  }
 
  virtual void undo()
  {
    unit_->moveTo(xBefore_, yBefore_);
  }
 
private:
  Unit* unit_;
  int xBefore_, yBefore_;
  int x_, y_;
};

多次撤销可以维护一个命令列表和对当前命令的一个引用。

 

 

Chapter 3 享元模式

将数据对象切分成两种类型：

1. 不属于单一实例对象并能被所有对象共享的数据；
2. 对每个对象都是唯一的数据。

 

地形类：

class Terrain
{
public:
  Terrain(int movementCost,
          bool isWater,
          Texture texture)
  : movementCost_(movementCost),
    isWater_(isWater),
    texture_(texture)
  {}
 
  int getMovementCost() const { return movementCost_; }
  bool isWater() const { return isWater_; }
  const Texture& getTexture() const { return texture_; }
 
private:
  int movementCost_;
  bool isWater_;
  Texture texture_;
};

 

使用指向地形对象的网格指针，相同地形的瓦片指向同一地形实例：

class World
{
public:
  World()
  : grassTerrain_(1, false, GRASS_TEXTURE),
    hillTerrain_(3, false, HILL_TEXTURE),
    riverTerrain_(2, true, RIVER_TEXTURE)
  {}
 
private:
  Terrain grassTerrain_;
  Terrain hillTerrain_;
  Terrain riverTerrain_;
 
Terrain* tiles_[WIDTH][HEIGHT];
  // Other stuff...
};

 

使用这些地形实例来绘制地面：

void World::generateTerrain()
{
  // Fill the ground with grass.
  for (int x = 0; x < WIDTH; x++)
  {
    for (int y = 0; y < HEIGHT; y++)
    {
      // Sprinkle some hills.
      if (random(10) == 0)
      {
        tiles_[x][y] = &hillTerrain_;
      }
      else
      {
        tiles_[x][y] = &grassTerrain_;
      }
    }
  }
 
  // Lay a river.
  int x = random(WIDTH);
  for (int y = 0; y < HEIGHT; y++) {
    tiles_[x][y] = &riverTerrain_;
  }
}

 

获得(x,y)下的地形及属性：

const Terrain& World::getTile(int x, int y) const
{
  return *tiles_[x][y];
}
int cost = world.getTile(2, 3).getMovementCost();

 

 

Chatper 4 观察者模式

观察者模式非常适合于一些不相关模块之间的通信（成就系统，新手引导）。

 

观察者：

class Observer
{
public:
  virtual ~Observer() {}
  virtual void onNotify(const Entity& entity, Event event) = 0;
};
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_;
};

 

被观察者：

class Subject
{
private:
  Observer* observers_[MAX_OBSERVERS];
  int numObservers_;
};
class Subject
{
public:
  void addObserver(Observer* observer)
  {
    // Add to array...
  }
 
  void removeObserver(Observer* observer)
  {
    // Remove from array...
  }
 
  // Other stuff...
};
class Subject
{
protected:
  void notify(const Entity& entity, Event event)
  {
    for (int i = 0; i < numObservers_; i++)
    {
      observers_[i]->onNotify(entity, event);
    }
  }
 
  // Other stuff...
};

 

单链表写法（避免造成动态内存分配）：

class Subject
{
  Subject()
  : head_(NULL)
  {}
 
  // Methods...
private:
  Observer* head_;
};
class Observer
{
  friend class Subject;
 
public:
  Observer()
  : next_(NULL)
  {}
 
  // Other stuff...
private:
  Observer* next_;
};
void Subject::addObserver(Observer* observer)
{
  observer->next_ = head_;
  head_ = observer;
}
void Subject::removeObserver(Observer* observer)
{
  if (head_ == observer)
  {
    head_ = observer->next_;
    observer->next_ = NULL;
    return;
  }
 
  Observer* current = head_;
  while (current != NULL)
  {
    if (current->next_ == observer)
    {
      current->next_ = observer->next_;
      observer->next_ = NULL;
      return;
    }
 
    current = current->next_;
  }
}
void Subject::notify(const Entity& entity, Event event)
{
  Observer* observer = head_;
  while (observer != NULL)
  {
    observer->onNotify(entity, event);
    observer = observer->next_;
  }
}

C#：event关键字，观察者成为一个代理。