［翻译］Game Programming Patterns Chapter4: Prototype

我第一次听说“原型（Prototype）”这个词是在“设计模式”这本书里。现金好像每个人都在说起原型这个词，但实际上他们并不是在谈论设计模式。我们在这里的讨论将包含这些，并且我将展现给你一些其他更有趣的内容，比如“原型”这个术语本身与其出现后引出的概念。不过首先，让我们来回顾下原型模式。

    The first time I heard the word “prototype” was in Design Patterns. Today, it seems like everyone is saying it, but it turns out they aren’t talking about thedesign pattern. We’ll cover that here, but I’ll also show you other, more interesting places where the term “prototype” and the concepts behind it have popped up. But first, let’s revisit the original pattern.

The Prototype Design Pattern 原型设计模式

    我们假装自己正在开发一款《圣铠传说》类似的游戏。我们已经让各种妖魔鬼怪孵化在英雄的周围，争夺着英雄的新鲜血肉。这些令人厌恶的食客们通过“怪物孵化器”出现在场景区域，每一种不同的怪物孵化器产生一种怪物。

    Pretend we’re making a game in the style of Gauntlet. We’ve got creatures and fiends swarming around the hero, vying for their share of his flesh. These unsavory dinner companions enter the arena by way of “spawners”, and there is a different spawner for each kind of enemy.

   为了方便举例，我们就假设游戏中有“幽灵”，“恶魔”，“妖魔”等不同种类的怪物好了，如：

class Monster
{
  // Stuff...
};

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

A spawner constructs instances of one particular monster type. To support every monster in the game, we could brute-force it by having a spawner class for each monster class, leading to a parallel class hierarchy:

其实现方式如下：

Implementing it would look like this:

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();
  }
};
// You get the idea...

Unless you get paid by the line of code, this is obviously not a fun way to hack this together. Lots of classes, lots of boilerplate, lots of redundancy, lots of duplication, lots of repeating myself…

原型模式提供了一种解决方法。其核心思想是“一个对象能够产生出其他与其相仿的对象”。如果你有一个幽灵，你可以通过这个幽灵制作出更多的幽灵。如果你有一个魔鬼，你就能制作出其他魔鬼。如果怪物都能被看作是一个用来制作其自身的不同版本怪物的原型怪物。

The Prototype pattern offers a solution. The key idea is that an object can spawn other objects similar to itself. If you have one ghost, you can make more ghosts from it. If you have a demon, you can make other demons. Any monster can be treated as a prototypal monster used to generate other versions of itself.

为了实现这个模式，我们给出一个基类Monster, 包含一个虚方法clone():

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

  // Other stuff...
};

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

Once all our monsters support that, we no longer need a spawner class for each monster class. Instead, we define a single one:

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

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

It internally holds a monster, a hidden one whose sole purpose is to be used by the spawner as a template to stamp out more monsters like it, sort of like a queen bee who never leaves the hive.

为了创建一个幽灵的孵化器，我们创建一个幽灵的原型实例，然后再创建储存这个原型实例的孵化器。

To create a ghost spawner, we create a prototypal ghost instance and then create a spawner holding that prototype:

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

One neat part about this pattern is that it doesn’t just clone the class of the prototype, it clones its state too. This means we could make a spawner for fast ghosts, weak ghosts, or slow ghosts just by creating an appropriate prototype ghost.

我发现这是这个模式优雅而令人惊讶的地方。我自己实在想不到这一点，但现在我实在无法想象我不知道这个特性会是怎么样。

I find something both elegant and yet surprising about this pattern. I can’t imagine coming up with it myself, but I can’t imagine not knowing about it now that I do.

How well does it work?  原型模式效果如何？

Well, we don’t have to create a separate spawner class for each monster, so that’s good. But we do have to implement clone() in each monster class. That’s just about as much code as the spawners.

当你真正开始去编写一个正确的clone()函数时，会发现一些很不爽的语法陷阱。是要做深度clone还是浅度克隆？换句话说，如果一个魔鬼正拿着一把叉子，那么克隆出来的魔鬼也要拿着叉子么？

There are also some nasty semantic ratholes when you sit down to try to write a correct clone(). Does it do a deep clone or shallow one? In other words, if a demon is holding a pitchfork, does cloning the demon clone the pitchfork too?

而且，不仅仅是这种针对这个描述的问题的实现并没有真正节省我们多少代码量，事实上，这个问题本身就是一个编造出来的问题。我们肯定得为每一个怪物使用单独的类。现今的游戏引擎一定不是这么玩的。

Also, not only does this not look like it’s saving us much code in this contrived problem, there’s the fact that it’s a contrived problem. We had to take as a given that we have separate classes for each monster. These days, that’s definitelynot the way most game engines roll.

我们大多数人都知道管控一个巨大的类结构体是件麻烦事，这也是为什么我们要使用组件（Component）和类型对象（Type Object）来对不同的实体进行建模，而不依赖于干涉其类本身。

Most of us learned the hard way that big class hierarchies like this are a pain to manage, which is why we instead use patterns like Component and TypeObject to model different kinds of entities without enshrining each in its own class.

Spawn functions（孵化器函数）

即使我们真的给不同的怪物创建了不同的类，仍然存在许多其他途径来处理这个麻烦的问题。相比于给每一个怪物分别创建孵化器类，我们也能创建孵化器函数，比如这样：

Even if we do have different classes for each monster, there are other ways to decorticate this Felis catus. Instead of making separate spawner classes for each monster, we could make spawn functions, like so:

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

这样做相较于搞出一个构造某种怪物的类来说，冗余更少。创建完后，一个孵化器类可以简单地存储这个函数指针即可：

This is less boilerplate than rolling a whole class for constructing a monster of some type. Then the one spawner class can simply store a function pointer:

typedef Monster* (*SpawnCallback)();

class Spawner
{
public:
  Spawner(SpawnCallback spawn)
  : spawn_(spawn)
  {}
  Monster* spawnMonster()
  {
    return spawn_();
  }
private:
  SpawnCallback spawn_;
};

在创建幽灵孵化器的时候，就这么写：

To create a spawner for ghosts, you do:

Spawner* ghostSpawner = new Spawner(spawnGhost);

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

template <class T>
class SpawnerFor : public Spawner
{
public:
  virtual Monster* spawnMonster() { return new T(); }
};

Spawner* ghostSpawner = new SpawnerFor<Ghost>();