《游戏编程模式》（5）

Chatper 11 字节码

通过将行为编码成虚拟机指令，而使其具备数据的灵活性。

 

解释器模式（慢）：

class Expression
{

public:
  virtual ~Expression() {}
  virtual double evaluate() = 0;

};

class NumberExpression : public Expression
{

public:
  NumberExpression(double value)
  : value_(value)
  {}
 
  virtual double evaluate()
  {
    return value_;
  }

private:
  double value_;

};

class AdditionExpression : public Expression
{

public:
  AdditionExpression(Expression* left, Expression* right)
  : left_(left),
    right_(right)
  {}

  virtual double evaluate()
  {
    // Evaluate the operands.
    double left = left_->evaluate();
    double right = right_->evaluate();
 
    // Add them.
    return left + right;
  } 

private:
  Expression* left_;
  Expression* right_;

};

 

字节码模式：

当你的游戏需要定义大量行为，可以指定一套指令集，虚拟机逐条执行指令栈上的这些指令。通过组合指令，即可完成很多高级指令。

enum Instruction
{
  INST_SET_HEALTH = 0x00,
  INST_SET_WISDOM = 0x01,
  INST_SET_AGILITY = 0x02,
  INST_GET_HEALTH = 0x03,
  INST_GET_WISDOM = 0x04,
  INST_GET_AGILITY = 0x05,
  INST_PLAY_SOUND = 0x06,
  INST_SPAWN_PARTICLES = 0x07,
  INST_LITERAL = 0x08,
  INST_ADD = 0X09,
};

class VM
{

public:
  VM()
  : stackSize_(0)
  {}
 
  void interpret(char bytecode[], int size)
  {
    for (int i = 0; i < size; i++)
    {
      char instruction = bytecode[i];
      switch (instruction)
      {
         case INST_SET_HEALTH:
         {
              int amount = pop();
              int wizard = pop();
              setHealth(wizard, amount);
              break;
         } 

         case INST_SET_WISDOM:
         case INST_SET_AGILITY:
         // Same as above... 

         case INST_GET_HEALTH:
         {
              int wizard = pop();
              push(getHealth(wizard));
              break;
         } 

         case INST_GET_WISDOM:
         case INST_GET_AGILITY:
         // You get the idea...

         case INST_PLAY_SOUND:
              playSound(SOUND_BANG);
              break;

         case INST_SPAWN_PARTICLES:
              spawnParticles(PARTICLE_FLAME);
              break;

         case INST_LITERAL:
         {
              // Read the next byte from the bytecode.
              int value = bytecode[++i];
              push(value);
              break;
         }
 
         case INST_ADD:
         {
              int b = pop();
              int a = pop();
              push(a + b);
              break;
         }
    }
  } 

private:
     void push(int value)
     {
         // Check for stack overflow.
         assert(stackSize_ < MAX_STACK);
         stack_[stackSize_++] = value;
     }

     int pop()
     {
         // Make sure the stack isn't empty.
         assert(stackSize_ > 0);
         return stack_[--stackSize_];
     }

     static const int MAX_STACK = 128;
     int stackSize_;
     int stack_[MAX_STACK]; 

};

 

指令的组合：

setHealth(0, getHealth(0) + (getAgility(0) + getWisdom(0)) / 2);

翻译为：

LITERAL 0    [0]            # Wizard index
LITERAL 0    [0, 0]         # Wizard index
GET_HEALTH   [0, 45]        # getHealth()
LITERAL 0    [0, 45, 0]     # Wizard index
GET_AGILITY  [0, 45, 7]     # getAgility()
LITERAL 0    [0, 45, 7, 0]  # Wizard index
GET_WISDOM   [0, 45, 7, 11] # getWisdom()
ADD          [0, 45, 18]    # Add agility and wisdom
LITERAL 2    [0, 45, 18, 2] # Divisor
DIVIDE       [0, 45, 9]     # Average agility and wisdom
ADD          [0, 54]        # Add average to current health
SET_HEALTH   []             # Set health to result

 

基于栈的虚拟机：

1．  指令小（通常一字节）；

2．  指令数多

基于寄存器的虚拟机：

1. 指令大（Lua虚拟机每个指令占用32位，6位存储指令类型，剩下的存储参数）；
2. 指令数少

值的表示：

1. 坚持使用单一数据类型 or
2. 使用带标签的联合体

enum ValueType
{
  TYPE_INT,
  TYPE_DOUBLE,
  TYPE_STRING
}; 

struct Value
{
  ValueType type;

  union
  {
    int    intValue;
    double doubleValue;
    char*  stringValue;
  };
};

 

Chatper Twelve 子类沙盒

使用基类提供的操作集合来定义子类中的行为。

扁平的继承树比起长纵深的继承树更易用。 

使用情境：

1. 有一个带有大量子类的基类；
2. 基类能够提供所有子类可能需要的操作集合；
3. 希望更简便地共享子类之间重复的代码；
4. 使子类和程序其他模块的耦合最小化。 

基类：

class Superpower
{

public:
  virtual ~Superpower() {}
 
protected:
  virtual void activate() = 0;
 
  double getHeroX()
  {
    // Code here...
  }

  double getHeroY()
  {
    // Code here...
  }

  double getHeroZ()
  {
    // Code here...
  }
 
  void move(double x, double y, double z)
  {
    // Code here...
  } 

  void playSound(SoundId sound, double volume)
  {
    // Code here...
  } 

  void spawnParticles(ParticleType type, int count)
  {
    // Code here...
  }

};

Activate()就是沙盒函数，子类必须重写这个抽象虚函数。Move()或许和物理引擎有关，playSound()或许和声音模块有关，在基类中实现使得所有的耦合都有SuperPower这个基类来承担。

子类：

class SkyLaunch : public Superpower
{

protected:
  virtual void activate()
  {
    if (getHeroZ() == 0)
    {
      // On the ground, so spring into the air.
      playSound(SOUND_SPROING, 1.0f);
      spawnParticles(PARTICLE_DUST, 10);
      move(0, 0, 20);
    }
    else if (getHeroZ() < 10.0f)
    {
      // Near the ground, so do a double jump.
      playSound(SOUND_SWOOP, 1.0f);
      move(0, 0, getHeroZ() - 20);
    }
    else
    {
      // Way up in the air, so do a dive attack.
      playSound(SOUND_DIVE, 0.7f);
      spawnParticles(PARTICLE_SPARKLES, 1);
      move(0, 0, -getHeroZ());
    }
  }

};

 

设计决策：

需要提供什么操作（多少操作）

1. 仅被少数子类使用的操作不必加入基类；
2. 不修改任何状态的方法调用，不具备侵入性，是个安全的耦合；

避免臃肿的基类：

把相关操作分流到辅助类

class SoundPlayer
{
  void playSound(SoundId sound, double volume)
  {
    // Code here...
  }
 
  void stopSound(SoundId sound)
  {
    // Code here...
  } 

  void setVolume(SoundId sound)
  {
    // Code here...
  }
};

class Superpower
{

protected:
  SoundPlayer& getSoundPlayer()
  {
    return soundPlayer_;
  } 

  // Sandbox method and other operations...
 
private:
  SoundPlayer soundPlayer_;

};

 

基类如何获取所需状态：

分段初始化：

构造函数不传参，在第二步传递所需参数

Superpower* createSkyLaunch(ParticleSystem* particles)
{
  Superpower* power = new SkyLaunch();
  power->init(particles);
  return power;
}

 

状态静态化

class Superpower
{

public:
  static void init(ParticleSystem* particles)
  {
    particles_ = particles;
  } 

  // Sandbox method and other operations...
 
private:
  static ParticleSystem* particles_;

};

静态变量Particle_不必为每个SuperPower实例所存储，可以减少内存占用。

  

Chatper 13 类型对象

通过创建一个类来支持新类型的灵活创建，其每个实例都代表一个不同的类型对象。

 

类型对象：

class Breed
{

public:
  Breed(int health, const char* attack)
  : health_(health),
    attack_(attack)
  {}

  Monster* newMonster() { return new Monster(*this); } 

  int getHealth() { return health_; }
  const char* getAttack() { return attack_; } 

private:
  int health_; // Starting health.
  const char* attack_;

};

使用类型对象的类：

class Monster
{
  friend class Breed; 

public:
  const char* getAttack() { return breed_.getAttack(); }
 
private:
  Monster(Breed& breed)
  : health_(breed.getHealth()),
    breed_(breed)
  {}
 
  int health_; // Current health.
  Breed& breed_;

};

这样创建一个怪物：

Monster* monster = someBreed.newMonster();

Monster的构造函数是private，不能直接调用。友元类Breed绕开了这个限制，可以直接访问，这意味着newMonster方法是创建Monster的唯一方法。

 

通过继承共享数据

基种族：

class Breed
{

public:
  Breed(Breed* parent, int health, const char* attack)
    : health_(health),
      attack_(attack)
  {
      // Inherit non-overridden attributes.
      if (parent != NULL)
      {
        if (health == 0) health_ = parent->getHealth();
        if (attack == NULL) attack_ = parent->getAttack();
      }
  }

  int         getHealth() { return health_; }
  const char* getAttack() { return attack_; }

private:
  Breed*      parent_;
  int         health_; // Starting health.
  const char* attack_;

};

 

类型能否改变

怪物死的时候，尸体能变成会动的僵尸：

1. 类型不变

创建新的僵尸怪物，拷贝原怪物属性，然后删除。有新对象创建，编码和理解较简单，易于调试。

1. 类型可变

简单赋值或修改属性即可。减少对象创建，但新类型需要符合对象现在的状态。