游戏开发设计模式之原型模式 & unity3d JSON的使用（unity3d 示例实现）

命令模式：游戏开发设计模式之命令模式（unity3d 示例实现）

对象池模式：游戏开发设计模式之对象池模式（unity3d 示例实现）

实现原型模式

原型模式带来的好处就是，想要构建生成任意独特对象的生成类，只需要一个生成类和一个原型即可。
当我们有一个抽象的敌人Monster类就有很多继承它的各种各样的敌人，人类、动物、龙等等，如果我们想为每个敌人做一个生成器父类Spawner，也会有与monster对应数量的子类，也许就会这样：



这样就会产生类的数量变多，而且这些类的功能是重复的。
开始的spawner类可能是这样的：

using UnityEngine;
using System.Collections;

public class Spawner : MonoBehaviour {
public GameObject createPerson(GameObject Person)
{
return Instantiate(Person);
}
public GameObject createAnimal(GameObject Animal)
{
return Instantiate(Animal);
}
public GameObject createDragon(GameObject Dragon)
{
return Instantiate(Dragon);
}
}

上面的代码可见我们有重复的方法，而且随着敌人子类增多这种重复代码会越来越多。
我们可以视所有怪兽为一个原型，让Spawner类只生成这个原型，通过改变这个原型来生产不同的怪兽。
再进一步，我们可以让这个原型有一个生成自己的方法，就不需要在Spawner类中new了只需要在Spawner类调用原型的方法就可以，我们做一个monster生成（克隆）自己的方法clone（）。

using UnityEngine;
using System.Collections;

public class Monster : MonoBehaviour {
public string MonsterName;
public int attack;
public int defense;
public string weapon;

// Use this for initialization
/*   virtual public Monster clone()
{
return this;
}*/
public  GameObject clone()
{
return Instantiate(this.gameObject) as GameObject;
}
}

这里存在一个深复制和浅复制的问题，C#数据类型大体分为值类型(valuetype)与引用类型
(referencetype)。对于值类型数据，复制的时候直接将数据复制给另外的变量，
而对于引用型变量而言，复制时，其实只是复制了其引用。复制引用的方式叫浅复制，而逐一复制被复制对象的数据成员的方式称为深复制。
unity的Instantiate就是深复制GameObject
如果你想浅复制clone函数为：

virtual public Monster clone()
{
return this;
}

浅复制返回它本身的引用，如果你想深复制，就Instantiate一个新的：

public  GameObject clone()
{
return Instantiate(this.gameObject) as GameObject;
}

再看看子类

using UnityEngine;
using System.Collections;

public class AnimalMonster : Monster
{
public AnimalMonster()
{
MonsterName = "Animal";
attack = 8;
defense = 15;
weapon = "tooth";
}

}

这样每个敌人子类都有一个clone方法，就不需要每个都配一个Spawner类了，一个Spawner就可以。

using UnityEngine;
using System.Collections;

public class Spawner : MonoBehaviour {
Monster prototype;
// Use this for initialization
public void setPrototype(Monster _prototype)
{
this.prototype = _prototype;
}

public  GameObject createMonster()
{
return prototype.clone();
}
}

创建他们的方法也很简单，设置原型，create。

spawner.setPrototype(People);
spawner.createMonster();
spawner.setPrototype(Animal);
spawner.createMonster();

克隆出的属性值都和原型相同，如果当前怪兽处在某种状态，比如，中毒、虚弱、灼烧，也可以被复制下来。
再进一步，我们可以通过构造函数实例化不同的spawner对象来代替不同的spawner子类，使spawner实体专一化的生成某种怪兽
u

sing UnityEngine;
using System.Collections;

public class Spawner : MonoBehaviour {
Monster prototype;
// Use this for initialization
public Prototype(Monster _prototype)
{
this.prototype = _prototype;
}

public  GameObject createMonster()
{
return prototype.clone();
}
}

Spawner PersonSpawner = new Spawner(People);
Spawner AnimalSpawner = new Spawner(Animal);
PersonSpawner.createMonster();
AnimalSpawner.createMonster();

利用泛型类实现原型模式

再进一步，我们可以建立一个SpawnerFor泛型类来更加专一的生成某种怪兽，SpawnerFor泛型类继承自Spawner类

using UnityEngine;
using System.Collections;

public class SpawnerFor<T> : Spawner
where T : Monster
{
T prototype;
}

Spawner s1;
Spawner s2;
void Start()
{
s1 = new SpawnerFor<PersonMonster>();
s2 = new SpawnerFor<AnimalMonster>();
s1.setPrototype(People);
s2.setPrototype(Animal);
s1.createMonster();
s2.createMonster();
}

如果不是返回gameobject，就要写一个这样的方法：

public GameObject createMonster()
{
return new T();
}

关于First Class type

最好的办法是把类型当做参数付给了生成类，这种类型叫做First Class类型，这样把要生成的怪兽的类型作为参数付给Spawner，Spawner就知道原型是要生成这种类型的参数了。
我们把类型分为三类：
First Class。该类型可以作为函数的参数和返回值，也可以赋给变量。
Second Class。该类型可以作为函数的参数，但不能从函数返回，也不能赋给变量。
Third Class。该类型作为函数参数也不行
也就是说First Class type可以把类型看作是对象来赋值、返回值等等。
但是在C++和C#中类的类型都不是First Class type，所以需要进行一些操作，像上面的方法那样。

实现结果

对原型进行数据建模

我们通过数据建模data modeling把代码变成实在的数据。
通
过这种方法我们不需要Monster的子类了，因为Monster里的属性都是相同的，我们只需要一个Monster类和一个存了各种敌人的数据的文件即
可。这种方式的好处在数据量大的游戏中尤为明显，省去大量代码。我们首先需要把每个怪兽的属性都储存起来，然后能提供给Spawner读取，这就是序列化
与反序列化。
也通过序列化和反序列化对原型进行数据建模。使用JSON，XML等等都可以，此处博主用JSON实现
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。易于人阅读和编写，同时也易于机器解析和生成(网络传输速率)。
JSON
有简易的语法，XML有范的标签形式，JSON和XML有一个很大的区别在于有效数据率。JSON作为数据包格式传输的时候具有更高的效率，这是因为
JSON不像XML那样需要有严格的闭合标签，这就让有效数据量与总数据包比大大提升，从而减少同等数据流量的情况下，网络的传输压力

具体可以查看写得很全很详细

我们可以在代码中生成JSON，也可以自己在txt中编写，大概的格式是这样的

{
"MonsterName": "Person",
"attack": 10,
"defense": 10,
"weapon": "Sword"
}

上面是本文的例子，但是如果敌人类是这样的：

{
"MonsterName": "dwarf saber",
"HP": 10,
"characteristic": "DEF up",
"weapon": "sword",
"attacks": ["hack","chop"]
}
{
"MonsterName": "dwarf archer",
"HP": 10,
"characteristic": "DEF up",
"weapon": "bow",
"attacks": ["shoot","sight"]

}
{
"MonsterName": "dwarf caster",
"HP": 10,
"characteristic": "DEF up",
"weapon": "wand",
"magic": ["fire ball","ice storm"]

}

好吧，虽然在矮人中caster这个职阶并不常见（武器想写破尽万法之符来着，但是fate里没有矮人英雄啊。。矮人还是多出现在欧洲风游戏里= =；）

可
以明显发现里面的HP，characteristic属性是一样的，因为都是矮人，矮人本身的特性都是一样的，这里我们就出现了重复，解决方法就是使用享
元模式，把相同的单拿出来，或者放在最普通的“原怪兽”或者是一个比较简单的怪兽里，再在其他怪兽中加一个这个原模型方便取值，这里博主把它放在矮人平民
中。享元模式可以节省大量空间和读取时间：

{
"MonsterName": "dwarf civilian",
"HP": 10,
"characteristic": "DEF up",
}
{
"MonsterName": "dwarf saber",
"prototype": "dwarf civilian",
"weapon": "sword",
"attacks": ["hack","chop"]
}
{
"MonsterName": "dwarf archer",
"prototype": "dwarf civilian",
"weapon": "bow",
"attacks": ["shoot","sight"]

}
{
"MonsterName": "dwarf caster",
"prototype": "dwarf civilian",
"weapon": "wand",
"magic": ["fire ball","ice storm"]
}

也可以实现道具和武器的多元化，比如一把“火焰剑”就可以视为一把长剑，和附加伤害，还有一个好听的名字：

{
"Name": "FireBlaze",
"prototype": "long sword",
" additionalDamage ": 10
}

长剑中就包含了剑类所有的基本属性，比如基础伤害，武器相克效果，等等等。。这就是细微的改变带来丰富的变化！

接下来要说JSON在unity中的代码实现，
分为在txt中写入数据叫做序列化，和读取数据叫做反序列化，
首先我们需要LitJson.dll（文章最后github链接中含有本文测试所有游戏代码和LitJson.dll）
在类前面需要：

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using LitJson;
using System.IO;
#if UNITY_EDITOR
using UnityEditor;
#endif

在.net中的解析方式，在unity中用最后一种

主要类	命名空间
DataContractJsonSerializer	System.Runtime.Serialization.Json
JavaScriptSerializer	System.Web.Script.Serialization
JsonArray、JsonObject、JsonValue	System.Json
JsonConvert、JArray、JObject、JValue、JProperty	Newtonsoft.Json

先看写入文件方法：

void WriteJsonToFile(string path, string fileName)
{
System.Text.StringBuilder strB = new System.Text.StringBuilder();
JsonWriter jsWrite = new JsonWriter(strB);
jsWrite.WriteObjectStart();
jsWrite.WritePropertyName("Monster");//Monster为对象数组名

jsWrite.WriteArrayStart();//对象数组

jsWrite.WriteObjectStart();
jsWrite.WritePropertyName("MonsterName");
jsWrite.Write("Person");
jsWrite.WritePropertyName("attack");
jsWrite.Write(10);
jsWrite.WritePropertyName("defense");
jsWrite.Write(10);
jsWrite.WritePropertyName("weapon");
jsWrite.Write("Sword");
jsWrite.WriteObjectEnd();
jsWrite.WriteObjectStart();
jsWrite.WritePropertyName("MonsterName");
jsWrite.Write("Animal");
jsWrite.WritePropertyName("attack");
jsWrite.Write(8);
jsWrite.WritePropertyName("defense");
jsWrite.Write(15);
jsWrite.WritePropertyName("weapon");
jsWrite.Write("tooth");
jsWrite.WriteObjectEnd();
jsWrite.WriteObjectStart();
jsWrite.WritePropertyName("MonsterName");
jsWrite.Write("Dragon");
jsWrite.WritePropertyName("attack");
jsWrite.Write(100);
jsWrite.WritePropertyName("defense");
jsWrite.Write(200);
jsWrite.WritePropertyName("weapon");
jsWrite.Write("fire breath");
jsWrite.WriteObjectEnd();

jsWrite.WriteArrayEnd();
jsWrite.WriteObjectEnd();
Debug.Log(strB);
//创建文件目录
DirectoryInfo dir = new DirectoryInfo(path);
if (dir.Exists)
{
Debug.Log("This file is already exists");
}
else
{
Directory.CreateDirectory(path);
Debug.Log("CreateFile");
#if UNITY_EDITOR
AssetDatabase.Refresh();
#endif
}
//把json数据写到txt里
StreamWriter sw;
if (File.Exists(fileName))
{
//如果文件存在，那么就向文件继续附加（为了下次写内容不会覆盖上次的内容)
sw = File.AppendText(fileName);
Debug.Log("appendText");
}
else
{
//如果文件不存在则创建文件
sw = File.CreateText(fileName);
Debug.Log("createText");
}
sw.WriteLine(strB);
sw.Close();
#if UNITY_EDITOR
AssetDatabase.Refresh();
#endif

}

然后是读出，读出方法我们放在Spawner类里

Monster ReadJsonFromTXT(string name)
{
//解析json
Monster monster = new Monster();
JsonData jd = JsonMapper.ToObject(txt.text);
print(jd.IsArray);
JsonData monsterData = jd["Monster"];
print(monsterData.IsArray);
//打印一下数组
for (int i = 0; i < monsterData.Count; i++)
{
if (name == monsterData[i]["MonsterName"].ToString())
{
monster.MonsterName = monsterData[i]["MonsterName"].ToString();
monster.attack = int.Parse(monsterData[i]["attack"].ToString());
monster.defense = int.Parse(monsterData[i]["defense"].ToString());
monster.weapon = monsterData[i]["weapon"].ToString();
}
}

return monster;
}

写好的JSON可以在这个网站中测试http://www.bejson.com/，这是博主生成的JSON

实现结果

JSON测试结果，成功生成Monster

总结

基本的好处就是对象可以深复制自己，可以很方便有无差错的生成实体，并且把本来大量的类和与之对应的生成类（而且还会随着扩充增加！），缩小成一个原型类， 一个生成类，一个数据文件，减少了大量重复的，甚至不重复的代码量！数据文件可以根据实际情况选择xml或者是JSON或者是别的。
进一步考虑，玩家们都喜欢丰富的游戏，像这样可以对数据进行微小的改动就会产生很多变化，代码量花费很少，还能产生丰富的游戏世界，何乐而不为？

测试用全部代码及dll文件已共享至GitHub

命令模式：游戏开发设计模式之命令模式（unity3d 示例实现）

对象池模式：游戏开发设计模式之对象池模式（unity3d 示例实现）

博主近期渲染：最近用unity5弄的一些渲染



---- by wolf96