《游戏编程模式》（6）

Chapter 14 组件模式

允许一个单一的实体跨越多个不同域而不会导致耦合。

为实现两个类之间的代码共享，应该让他们拥有同一个类的实例，而不是继承同一个类。

使用情境：

1. 有一个涉及多个域的类。但希望这些域保持解耦；
2. 这个类很庞大；
3. 希望定义许多共享不同能力的对象。

分割不同的域：

class InputComponent
{

public:
  void update(Bjorn& bjorn)
  {
    switch (Controller::getJoystickDirection())
    {
      case DIR_LEFT:
        bjorn.velocity -= WALK_ACCELERATION;
        break;
 
      case DIR_RIGHT:
        bjorn.velocity += WALK_ACCELERATION;
        break;
    }
  } 

private:
  static const int WALK_ACCELERATION = 1;

};

class PhysicsComponent
{

public:
  void update(Bjorn& bjorn, World& world)
  {
    bjorn.x += bjorn.velocity;
    world.resolveCollision(volume_,
        bjorn.x, bjorn.y, bjorn.velocity);
  }
 
private:
  Volume volume_;

}; 

class GraphicsComponent
{

public:
  void update(Bjorn& bjorn, Graphics& graphics)
  {
    Sprite* sprite = &spriteStand_;
    if (bjorn.velocity < 0)
    {
      sprite = &spriteWalkLeft_;
    }
    else if (bjorn.velocity > 0)
    {
      sprite = &spriteWalkRight_;
    } 

    graphics.draw(*sprite, bjorn.x, bjorn.y);
  }

private:
  Sprite spriteStand_;
  Sprite spriteWalkLeft_;
  Sprite spriteWalkRight_;

};

最后的GameObject类：

class GameObject
{

public:
  int velocity;
  int x, y; 

  void update(World& world, Graphics& graphics)
  {
    input_.update(*this);
    physics_.update(*this, world);
    graphics_.update(*this, graphics);
  } 

private:
  InputComponent input_;
  PhysicsComponent physics_;
  GraphicsComponent graphics_;

};

 

更进一步，抽象出InputComponent为基类，使得GameObject可以连接不同的Input组件：

class InputComponent
{
public:
  virtual ~InputComponent() {}
  virtual void update(Bjorn& bjorn) = 0;
};

class PlayerInputComponent : public InputComponent
{

public:
  virtual void update(Bjorn& bjorn)
  {
    switch (Controller::getJoystickDirection())
    {
      case DIR_LEFT:
        bjorn.velocity -= WALK_ACCELERATION;
        break;

      case DIR_RIGHT:
        bjorn.velocity += WALK_ACCELERATION;
        break;
    }
  } 

private:
  static const int WALK_ACCELERATION = 1;

};

class DemoInputComponent : public InputComponent
{

public:
  virtual void update(Bjorn& bjorn)
  {
    // AI to automatically control Bjorn...
  }
};

其他组件也是如此：

class PhysicsComponent
{
public:
  virtual ~PhysicsComponent() {}
  virtual void update(GameObject& obj, World& world) = 0;
};

class GraphicsComponent
{
public:
  virtual ~GraphicsComponent() {}
  virtual void update(GameObject& obj, Graphics& graphics) = 0;
};

class BjornPhysicsComponent : public PhysicsComponent
{
public:
  virtual void update(GameObject& obj, World& world)
  {
    // Physics code...
  }
};

class BjornGraphicsComponent : public GraphicsComponent
{
public:
  virtual void update(GameObject& obj, Graphics& graphics)
  {
    // Graphics code...
  }
};

然后是更灵活的GameObject类：

class GameObject
{

public:
  int velocity;
  int x, y;
 
  GameObject(InputComponent* input,
             PhysicsComponent* physics,
             GraphicsComponent* graphics)
  : input_(input),
    physics_(physics),
    graphics_(graphics)
  {}

  void update(World& world, Graphics& graphics)
  {
    input_->update(*this);
    physics_->update(*this, world);
    graphics_->update(*this, graphics);
  }

private:
  InputComponent* input_;
  PhysicsComponent* physics_;
  GraphicsComponent* graphics_;

};

GameObject* createBjorn()
{
  return new GameObject(new PlayerInputComponent(),
                        new BjornPhysicsComponent(),
                        new BjornGraphicsComponent());
}

 

 

Chapter 15 事件队列

对消息或事件的发送与受理进行时间上的解耦。

事件队列给接受端的控制权：延迟处理、聚合请求或完全抛弃。发送端所能做的就是往队列里投递消息，无法有实时反馈的预期。

避免A到B到A的事件循环：不要在处理事件端的代码里再发送事件。

 

Audio类：

class Audio
{

public:
  static void init()
  {
    head_ = 0;
    tail_ = 0;
  }

  // Methods...

private:
  static int head_;
  static int tail_; 

  static const int MAX_PENDING = 16;

  static PlayMessage pending_[MAX_PENDING];
};

void Audio::playSound(SoundId id, int volume)
{
  // Walk the pending requests.
  for (int i = head_; i != tail_;
       i = (i + 1) % MAX_PENDING)
  {
    if (pending_[i].id == id)
    {
      // Use the larger of the two volumes.
      pending_[i].volume = max(volume, pending_[i].volume);
 
      // Don't need to enqueue.
      return;
    }
  }

  assert((tail_ + 1) % MAX_PENDING != head_);

  // Add to the end of the list.
  pending_[tail_].id = id;
  pending_[tail_].volume = volume;
  tail_ = (tail_ + 1) % MAX_PENDING;
} 

void Audio::update()
{
  // If there are no pending requests, do nothing.
  if (head_ == tail_) return;

  ResourceId resource = loadSound(pending_[head_].id);
  int channel = findOpenChannel();
  if (channel == -1) return;
  startSound(resource, channel, pending_[head_].volume); 

  head_ = (head_ + 1) % MAX_PENDING;
}

1. 环状缓冲区；
2. PlaySound只做元素入列，首先要判断是否有重复的，如果有就标记音量高的那个，tail增长时取余；
3. Update做元素取出，首先判断是否有待取元素，head增长时取余。

 

Chapter 16 服务定位器

为某服务提供一个全局访问入口来避免使用者与该服务具体实现类之间产生耦合。

 

Audio服务：

class Audio
{

public:
  virtual ~Audio() {}

  virtual void playSound(int soundID) = 0;
  virtual void stopSound(int soundID) = 0;
  virtual void stopAllSounds() = 0;

};

Audio服务提供器：

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...
  }
};

包含空服务的定位器：

class Locator
{

public:
  static void initialize() { service_ = &nullService_; }
 
  static Audio& getAudio() { return *service_; }
 
  static void provide(Audio* service)
  {
    if (service == NULL)
    {
      // Revert to null service.
      service_ = &nullService_;
    }
    else
    {
      service_ = service;
    }
  } 

private:
  static Audio* service_;
  static NullAudio nullService_;

};

注册一个服务提供器：

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

使用：

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

调用playSound()的代码对ConsoleAudio一无所知，它只知道Audio的抽象接口。Locator与ConsoleAudio也没有耦合，代码里唯一知道具体实现类的地方，是提供这个服务的代码。

 

空服务：

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

getAudio返回一个引用而不是指针，因为在C++里理论上一个引用不会为NULL，返回一个引用提示了使用者任何时候都能期望得到一个有效的对象。

空服务可以保证在Locator初始化之前使用它的安全性，也可以用来实现暂时禁用服务：

Locator::provide(NULL);

 

日志装饰器：

class LoggedAudio : public Audio
{

public:
  LoggedAudio(Audio &wrapped)
  : wrapped_(wrapped)
  {} 

  virtual void playSound(int soundID)
  {
    log("play sound");
    wrapped_.playSound(soundID);
  }

  virtual void stopSound(int soundID)
  {
    log("stop sound");
    wrapped_.stopSound(soundID);
  } 

  virtual void stopAllSounds()
  {
    log("stop all sounds");
    wrapped_.stopAllSounds();
  }

private:
  void log(const char* message)
  {
    // Code to log message...
  } 

  Audio &wrapped_;

};

 

1. 如果服务被限制在游戏的一个单独域中，那就把服务的作用域限制到类中

    eg.获取网络访问的服务就可能应该被限制在联网的类中

2.广泛使用的服务，作用域为全局域

    eg.日志服务应该是全局的