《游戏编程模式》学习笔记(五)原型模式 Prototype Pattern

原型的定义

用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

举个例子

假设我现在要做一款游戏,这个游戏里有许多不同种类的怪物,鬼魂,恶魔和巫师。这些怪物通过“生产者”进入这片区域,每种敌人有不同的生产者。

假设每种怪物都有不同的类,同时他们都继承怪兽这个基类,那么我们的代码就会是这样

class Monster
{
  // 代码……
};

class Ghost : public Monster {};
class Demon : public Monster {};
class Sorcerer : public Monster {};

为了能够产生这些怪物,我们需要不同的生产者类,这些类都继承spawner这个基类,那么我们就得写如下的代码:

class Spawner
{
public:
  virtual ~Spawner() {}
  virtual Monster* spawnMonster() = 0;
};

class GhostSpawner : public Spawner
{
public:
  virtual Monster* spawnMonster()
  {
    return new Ghost();
  }
};

class DemonSpawner : public Spawner
{
public:
  virtual Monster* spawnMonster()
  {
    return new Demon();
  }
};


// 你知道思路了……

那么这么一来,我们的架构就类似于这样:
《游戏编程模式》学习笔记(五)原型模式 Prototype Pattern_第1张图片
每个怪物类都有生产者类,得到平行的类结构
已经闻到臭味了……你的代码里有一堆特定的spawner,将来要是有一个新怪物,你就得多些一堆代码。 众多类,众多引用,众多冗余,众多副本,众多重复自我……

那么这个时候,原型模式就可以派上用场了! 我们来看看实现
原型模式提供了一个解决方案。 关键思路是一个对象可以产出与它自己相近的对象。 如果你有一个恶灵,你可以制造更多恶灵。 如果你有一个恶魔,你可以制造其他恶魔。 任何怪物都可以被视为原型怪物,产出其他版本的自己。

我们给基类Monster增加一个Clone()的方法

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

  // 其他代码……
};
每个怪兽子类提供一个特定实现,返回与它自己的类和状态都完全一样的新对象。就像这样
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了,我们只需要一个spawner()如下:

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

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

private:
  Monster* prototype_;
};

可以看到这个Spawner内部有一个Monster*类型的prototype,这就是原型,一个隐藏的怪物, 它唯一的任务就是被生产者当做模板,去产生更多一样的怪物, 有点像一个从来不离开巢穴的蜂后。
《游戏编程模式》学习笔记(五)原型模式 Prototype Pattern_第2张图片
当你要使用的时候,你只需要这么做:

Monster* ghostPrototype = new Ghost(15, 3);
Spawner* ghostSpawner = new Spawner(ghostPrototype);

这个模式的灵巧之处在于它不但拷贝原型的类,也拷贝它的状态。 这就意味着我们可以创建一个生产者,生产快速鬼魂,虚弱鬼魂,慢速鬼魂,而只需创建一个合适的原型鬼魂。

如果你还是觉得麻烦,懒得写Clone()方法的话,这里还有一种思路,使用生产函数来代替生产者类,我们这么写一个生产函数:

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

原型还可以做什么?

原型模式不仅仅可以应用在代码之中,我们还可以将其用在一些别的地方,比如数据存储中。
再举个例子,我们在游戏中经常使用Json来存储一些数据,比如怪物的各种属性。
所以游戏中的哥布林也许被定义为像这样的东西:

{
  "name": "goblin grunt",
  "minHealth": 20,
  "maxHealth": 30,
  "resists": ["cold", "poison"],
  "weaknesses": ["fire", "light"]
}

接下来,如果策划和你说,我还要别的哥布林,例如哥布林巫师,哥布林弓箭手,即使他们的很多属性都是一样的,我们还是不得不这么写:

{
  "name": "goblin wizard",
  "minHealth": 20,
  "maxHealth": 30,
  "resists": ["cold", "poison"],
  "weaknesses": ["fire", "light"],
  "spells": ["fire ball", "lightning bolt"]
}

{
  "name": "goblin archer",
  "minHealth": 20,
  "maxHealth": 30,
  "resists": ["cold", "poison"],
  "weaknesses": ["fire", "light"],
  "attacks": ["short bow"]
}

太重复了,我们讨厌重复,太多重复的数据意味着我们要话更多的时间去维护和管理,这是我们都不想看到的。
如果这是代码,我们会为“哥布林”构建抽象,并在三个哥布林类型中重用。 但是无能的JSON没法这么做。所以让我们把它做得更加巧妙些。
我们可以为对象添加"prototype"字段,记录委托对象的名字。 如果在此对象内没找到一个字段,那就去委托对象中查找。
这样,我们可以简化我们的哥布林JSON内容:

{
  "name": "goblin grunt",
  "minHealth": 20,
  "maxHealth": 30,
  "resists": ["cold", "poison"],
  "weaknesses": ["fire", "light"]
}

{
  "name": "goblin wizard",
  "prototype": "goblin grunt",
  "spells": ["fire ball", "lightning bolt"]
}

{
  "name": "goblin archer",
  "prototype": "goblin grunt",
  "attacks": ["short bow"]
}

这样不就好多了?只需在游戏引擎上多花点时间,你就能让设计者更加方便地添加不同的武器和怪物,而增加的这些丰富度能够取悦玩家。

这一节的内容有好多关于原型模式的思想方面的介绍,作者还介绍了原型模式在编程语言方面的应用,我认为这些都是暂时对游戏编程帮助不大,所以没有记录下来,有兴趣的同学请翻阅原文。

原文链接:https://gpp.tkchu.me/prototype.html

你可能感兴趣的:(游戏实用技术专栏,读书笔记,原型模式,游戏,学习)