《游戏编程模式》（3）

Chatper 5 原型模式

核心思想是一个对象可以生成与自身相似的其他对象。

 

基类Monster，有一个抽象方法clone：

class Monster
{
public:

  virtual ~Monster() {}
  virtual Monster* clone() = 0;

  // Other stuff...
};

 

子类的clone实现：

class Ghost : public Monster {
public:

  Ghost(int health, int speed)
  : health_(health),
    speed_(speed)
  {} 

  virtual Monster* clone()
  {
    return new Ghost(health_, speed_);
  }

private:
  int health_;
  int speed_;
};

 

通用的Spawner类：

class Spawner
{

public:
  Spawner(Monster* prototype)
  : prototype_(prototype)
  {}

  Monster* spawnMonster()
  {
    return prototype_->clone();
  }

private:
  Monster* prototype_;
};

 

这样用：

Monster* ghostPrototype = new Ghost(15, 3);
Spawner* ghostSpawner = new Spawner(ghostPrototype);
Monster* newGhost = Spawner->spawnMonster();

 

生成器函数和孵化函数指针：

Monster* spawnGhost()
{
  return new Ghost();
}
typedef Monster* (*SpawnCallback)();

class Spawner
{
public:
  Spawner(SpawnCallback spawn)
  : spawn_(spawn)
  {}

  Monster* spawnMonster()
  {
    return spawn_();
  }

private:
  SpawnCallback spawn_;

};

 

这样用：

Spawner* ghostSpawner = new Spawner(spawnGhost);
Monster* newGhost = ghostSpawner->spawnMonster();

 

Chatper 6 单例模式

确保一个类只有一个实例，并为其提供一个全局访问入口。

 

class FileSystem
{
public:
  static FileSystem& instance()
  {
    static FileSystem *instance = new FileSystem();
    return *instance;
  } 

private:
  FileSystem() {}

};

1. 延迟初始化
2. C++11保证局部静态变量的初始化只进行一次
3. 多线程安全
4. 私有构造函数

 

继承单例（多平台）：

class FileSystem
{
public:

  static FileSystem& instance();
 
  virtual ~FileSystem() {}

  virtual char* readFile(char* path) = 0;
  virtual void  writeFile(char* path, char* contents) = 0;
 
protected:
  FileSystem() {}

};

class PS3FileSystem : public FileSystem
{

public:
  virtual char* readFile(char* path)
  {
    // Use Sony file IO API...
  }

  virtual void writeFile(char* path, char* contents)
  {
    // Use sony file IO API...
  }
};

class WiiFileSystem : public FileSystem
{

public:
  virtual char* readFile(char* path)
  {
    // Use Nintendo file IO API...
  }

  virtual void writeFile(char* path, char* contents)
  {
    // Use Nintendo file IO API...
  }

};

 

Instance的编译跳转实现：

FileSystem& FileSystem::instance()
{

#if PLATFORM == PLAYSTATION3
    static FileSystem *instance = new PS3FileSystem();
#elif PLATFORM == WII
    static FileSystem *instance = new WiiFileSystem();
#endif 

  return *instance;
}

 

单例的缺陷：

1. 全局变量，单例就是一个全局状态，只是被封装到了类中；
2. 延迟初始化可能导致掉帧和卡顿，可能导致内存布局碎片化。 

通过将全局对象类包装在现有类里来减少全局对象数量：

class Game
{

public:
  static Game& instance() { return instance_; }
 
  // Functions to set log_, et. al. ...
 
  Log& getLog() { return *log_; }

  FileSystem&  getFileSystem()  { return *fileSystem_; }

  AudioPlayer& getAudioPlayer() { return *audioPlayer_; }
 
private:
  static Game instance_; 
  Log *log_;
  FileSystem  *fileSystem_;
  AudioPlayer *audioPlayer_;

};

Game::instance().getAudioPlayer().play(VERY_LOUD_BANG);

 

Chatper 7 状态模式

允许一个对象在其内部状态改变时改变自身的行为，对象看起来好像是在修改自身类。

复杂的分支和可变的状态是两种最容易出错的代码。

状态、输入和转换：

1．  拥有一组数目较小的状态，可以在这组状态之间切换；

2．  同一时刻只能处于一种状态；

3．  响应用户输入和游戏事件

 

定义一个接口，enter函数定义一些进入状态时的处理，exit函数定义一些状态改变前的处理：

class HeroineState
{

public:
  virtual ~HeroineState() {}
  virtual void handleInput(Heroine& heroine, Input input) {}
  virtual void update(Heroine& heroine) {} 

  virtual void enter(Heroine& heroine) {}
  virtual void exit(Heroine& heroine) {}

};

 

每一个状态都继承这个状态接口：

class DuckingState : public HeroineState
{

public:
  DuckingState()
  : chargeTime_(0)
  {}

  virtual void handleInput(Heroine& heroine, Input input) {
    if (input == RELEASE_DOWN)
    {
      // Change to standing state...
      heroine.setGraphics(IMAGE_STAND);
    }
  }

  virtual void update(Heroine& heroine) {
    chargeTime_++;
    if (chargeTime_ > MAX_CHARGE)
    {
      heroine.superBomb();
    }
  } 

private:
  int chargeTime_;

};

 

主角类中有一个指针指向当前状态：

class Heroine
{

public:
  virtual void handleInput(Input input)
  {
    state_->handleInput(*this, input);
  }
 
  virtual void update()
  {
    state_->update(*this);
  }

  // Other methods...

private:
  HeroineState* state_;

};

 

静态状态（省CPU省内存）：

class HeroineState
{

public:
  static StandingState standing;
  static DuckingState ducking;
  static JumpingState jumping;
  static DivingState diving; 

  // Other code...
};

if (input == PRESS_B)
{
  heroine.state_ = &HeroineState::jumping;
  heroine.setGraphics(IMAGE_JUMP);
}

 

实例化状态（handleInput方法返回后删除原状态）：

void Heroine::handleInput(Input input)
{
  HeroineState* state = state_->handleInput(*this, input);
  if (state != NULL)
  {
    delete state_;
    state_ = state;

    // Call the enter action on the new state.
    state_->enter(*this); 
  }
}

HeroineState* StandingState::handleInput(
  Heroine& heroine, Input input)
{
  if (input == PRESS_DOWN)
  {
    // Other code...
    return new DuckingState();
  }

  // Stay in this state.
  return NULL;
}

 

并发状态机（当两种状态没什么关系时）：

class Heroine
{

  // Other code...
 
private:
  HeroineState* state_;
  HeroineState* equipment_;

};

void Heroine::handleInput(Input input)
{
  state_->handleInput(*this, input);
  equipment_->handleInput(*this, input);
}

如果两种状态有一些联系（不能太多），需要对某些状态处理进行干预，可以做一些简单的if判断并特殊处理下。

 

层次状态机：

一个状态有父状态，如果子状态不处理就交给他的父状态处理。用来处理可能包含的大量相似状态。

class OnGroundState : public HeroineState
{

public:
  virtual void handleInput(Heroine& heroine, Input input)
  {
    if (input == PRESS_B)
    {
      // Jump...
    }
    else if (input == PRESS_DOWN)
    {
      // Duck...
    }
  }
};

class DuckingState : public OnGroundState
{

public:
  virtual void handleInput(Heroine& heroine, Input input)
  {
    if (input == RELEASE_DOWN)
    {
      // Stand up...
    }
    else
    {
      // Didn't handle input, so walk up hierarchy.
      OnGroundState::handleInput(heroine, input);
    }
  }
};

 

下推自动机：

 

 

开火时push Firing，结束后pop掉开火状态，状态机自动返回开火前的状态。