游戏开发模式一：组件模式（Component）

软件设计模式告诉我们，程序中不同的领域要保持隔离，也就是解耦。所以，我们不希望AI,物理引擎，渲染引擎，声音引擎，还有其他的事情影响到彼此，不能把他们放到同一个类里。

下面是一个反例：

?

if (collidingWithFloor() && (getRenderState() != INVISIBLE))

{

    playSound(HIT_FLOOR);

}

如果有人要修改这段代码，那么他就需要查看物理，绘图，和声音的代码以保证不会出错。更糟糕的情况是，你可能需要修改其他部分的代码！

 

解决的办法：

我们可以吧不同的领域分割城不同的组件，谈后需要的时候持有这些组件的实例，例如 InputComponent。

 

再看一个难一点的例子：

?

class Bjorn

{

public:

  void update(World& world, Graphics& graphics)

  {

    // Apply user input to hero's velocity.

    switch (Controller::getJoystickDirection())

    {

      case DIR_LEFT:  velocity_ -= WALK_ACCELERATION; break;

      case DIR_RIGHT: velocity_ += WALK_ACCELERATION; break;

    }

 

    // Modify position by velocity.

    x_ += velocity_;

    world.resolveCollision(volume_, x_, y_, velocity_);

 

    // Draw the appropriate sprite.

    Sprite* sprite = &spriteStand_;

    if (velocity_ < 0) sprite = &spriteWalkLeft_;

    else if (velocity_ > 0) sprite = &spriteWalkRight_;

 

    graphics.draw(*sprite, x_, y_);

  }

 

private:

  static const int WALK_ACCELERATION = 1;

 

  int velocity_;

  int x_, y_;

 

  Volume volume_;

 

  Sprite spriteStand_;

  Sprite spriteWalkLeft_;

  Sprite spriteWalkRight_;

};

Bjorn 有一个 update()方法每一帧被调用一次。它获取determine来决定方向，谈后他用物理引擎来处理位置，最后，它把Bjørn绘制到屏幕上。可以看到这里其实只做了很少的事情，但是却显得很复杂。


 

分割不同的领域：

首先让我们把input分离：

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

Bjorn的变化：

?

class Bjorn

{

public:

  int velocity;

  int x, y;

 

  virtual void update(World& world, Graphics& graphics)

  {

    input_.update(*this);

 

    // Modify position by velocity.

    x += velocity;

    world.resolveCollision(volume_, x, y, velocity);

 

    // Draw the appropriate sprite.

    Sprite* sprite = &spriteStand_;

    if (velocity < 0) sprite = &spriteWalkLeft_;

    else if (velocity > 0) sprite = &spriteWalkRight_;

 

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

  }

 

private:

  InputComponent input_;

 

  Volume volume_;

 

  Sprite spriteStand_;

  Sprite spriteWalkLeft_;

  Sprite spriteWalkRight_;

};

　　然后我们把其他的组件都分离：

?

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_;

};

　　现在Bjorn变得很简洁：

?

class Bjorn

{

public:

  int velocity;

  int x, y;

 

  virtual void update(World& world, Graphics& graphics)

  {

    input_.update(*this);

    physics_.update(*this, world);

    graphics_.update(*this, graphics);

  }

 

private:

  InputComponent    input_;

  PhysicsComponent  physics_;

  GraphicsComponent graphics_;

};

　　

现在我们已经把不同的组件都分开了，但是Bjorn依然知道这些行为的具体实现。我们将把我们的组件隐藏在借口背后，这样就需要把InputComponent变成一个抽象类：

?

class InputComponent

{

public:

  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;

};

我们将持有一个InputComponent的指针，

?

class Bjorn

{

public:

  int velocity;

  int x, y;

 

  Bjorn(InputComponent* input)

  : input_(input)

  {}

 

  virtual 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来实例化Bjorn：

?

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

　　来看看InputComponent的另一个实现：

?

class DemoInputComponent : public InputComponent

{

public:

  virtual void update(Bjorn& bjorn)

  {

    // AI to automatically control Bjorn...

  }

};

　　

 

好了，最后让我们看看最简介的一般实现：

我们有两个component：

?

class PhysicsComponent

{

public:

  virtual void update(GameObject& obj, World& world) = 0;

};

 

class GraphicsComponent

{

public:

  virtual void update(GameObject& obj, Graphics& graphics) = 0;

};

　　一个GameObject：

?

class GameObject

{

public:

  int velocity;

  int x, y;

 

  GameObject(InputComponent* input,

             PhysicsComponent* physics,

             GraphicsComponent* graphics)

  : input_(input),

    physics_(physics),

    graphics_(graphics)

  {}

 

  virtual void update(World& world, Graphics& graphics)

  {

    input_->update(*this);

    physics_->update(*this, world);

    graphics_->update(*this, graphics);

  }

 

private:

  InputComponent*    input_;

  PhysicsComponent*  physics_;

  GraphicsComponent* graphics_;

};