《游戏编程模式》学习笔记（五）原型模式 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();}
};// 你知道思路了……

那么这么一来，我们的架构就类似于这样：
在这里插入图片描述
每个怪物类都有生产者类，得到平行的类结构
已经闻到臭味了……你的代码里有一堆特定的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，这就是原型，一个隐藏的怪物，它唯一的任务就是被生产者当做模板，去产生更多一样的怪物，有点像一个从来不离开巢穴的蜂后。
在这里插入图片描述
当你要使用的时候，你只需要这么做：

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"]
}