架构设计目录一
游戏资源管理
对于一个游戏来说，游戏中资源的数量、大小是必须要去考虑的问题，因为一个游戏品质的好坏都是通过美术资源来表现的。所以管理这些资源的工作，作为开发者的我们是必须要好好考量的。对于游戏资源管理，一般的做法是封装几个接口来用于资源的加载，假如说只是做个 Demo，这样做是没有问题的，但是如果是做产品，其中资源的量是非常大的，如果资源的加载不恰当，会出现各种问题。而且游戏开发讲究的是团队协作，不同的人会有不同的需求，简单的封装几个接口不一定能满足需求，如果没有一个统一的资源架构管理，代码会出现各种接口版本，最后会出现大量的冗余代码，这样对游戏产品运行效率会产生影响。
另外，还要考虑游戏资源的动态更新，主要是为了减少游戏包体的大小。Unity 为用户提供了 AssetBundle 的方式打包资源，方便用户将资源打包后上传到资源服务器，在游戏启动时会通过本地存放资源的 MD5 码的文本文件与服务器上保存资源最新的 MD5 码的文本文件作对比，根据其资源对应的 MD5 码的不同，将最新的资源下载到本地使用，将资源文件代替本地的资源文件，同时更新MD5 码的文本文件，。我们在封装资源管理类时，也要从产品的角度考虑资源管理的问题。
下面开始介绍一下如何进行资源管理的代码封装，需要大家对资源管理的封装有一个比较完善的思考，代码模块如下图所示：
为什么这么设计呢？我们在游戏开发的时候，对于 Unity 的资源来说，每个资源都是一个 GameObject，但是单独的 GameObject 显然不能满足需求，因为资源既可以是 Prefab，也可以是 Scene，还可以是 Asset 文件。这当中就会涉及到不同的资源类型，那么如何表示这些资源类型呢？假如测试的时候是使用 prefab，但在正式发布时采用的是 asset，那如果不做分类，在游戏发布时还要去修改接口，这就非常麻烦了。如果设计一个通用的接口，对于资源类型可以使用枚举来进行表示，就可以解决一些不必要的麻烦。
ResourceUnit
首先来设计一个 ResourceUnit 的模块，它可以理解为资源的基本单位，也是程序封装的资源基本单位，ResourceUnit 类的代码如下所示：
public enum ResourceType
{
ASSET,
PREFAB,
LEVELASSET,
LEVEL,
}
这就是我们所定义的资源枚举，每一个加载的资源都是一个 ResourceUnit，下面继续完善：
public class ResourceUnit : IDisposable
{
private string mPath;
private Object mAsset;
private ResourceType mResourceType;
private List<ResourceUnit> mNextLevelAssets;
private AssetBundle mAssetBundle;
private int mReferenceCount;
internal ResourceUnit(AssetBundle assetBundle, int assetBundleSize, Object asset, string path, ResourceType resourceType)
{
mPath = path;
mAsset = asset;
mResourceType = resourceType;
mNextLevelAssets = new List<ResourceUnit>();
mAssetBundle = assetBundle;
mAssetBundleSize = assetBundleSize;
mReferenceCount = 0;
}
public List<ResourceUnit> NextLevelAssets
{
get
{
return mNextLevelAssets;
}
internal set
{
foreach (ResourceUnit asset in value)
{
mNextLevelAssets.Add(asset);
}
}
}
public int ReferenceCount
{
get
{
return mReferenceCount;
}
}
//增加引用计数
public void addReferenceCount()
{
++mReferenceCount;
foreach (ResourceUnit asset in mNextLevelAssets)
{
asset.addReferenceCount();
}
}
//减少引用计数
public void reduceReferenceCount()
{
--mReferenceCount;
foreach (ResourceUnit asset in mNextLevelAssets)
{
asset.reduceReferenceCount();
}
if (isCanDestory())
{
Dispose();
}
}
public bool isCanDestory() { return (0 == mReferenceCount); }
public void Dispose()
{
ResourceCommon.Log("Destory " + mPath);
if (null != mAssetBundle)
{
//mAssetBundle.Unload(true);
mAssetBundle = null;
}
mNextLevelAssets.Clear();
mAsset = null;
}
}
ResourceUnit 同时还实现了对资源的引用计数，这种设计思想跟内存的使用比较像，这样便于程序知道对于加载的资源什么时候销毁，什么时候能够继续使用，它还声明了一些变量，比如资源的名字等。
ResourceCommon
另外，要加载资源，还要知道资源的加载路径，其次要知道资源的类型。我们通常会使用一个类专门用于资源路径的设置，包括获取资源文件夹、资源路径、获取资源文件以及获取 AssetBundle 包体文件的大小等等。该类的代码实现如下所示：
public class ResourceCommon
{
public static string textFilePath = Application.streamingAssetsPath;
public static string assetbundleFilePath = Application.dataPath + "/assetbundles/";
public static string assetbundleFileSuffix = ".bytes";
public static string DEBUGTYPENAME = "Resource";
//根据资源路径获取资源名称
public static string getResourceName(string resPathName)
{
int index = resPathName.LastIndexOf("/");
if (index == -1)
return resPathName;
else
{
return resPathName.Substring(index + 1, resPathName.Length - index - 1);
}
}
//获取文件名字
public static string getFileName(string fileName)
{
int index = fileName.IndexOf(".");
if (-1 == index)
throw new Exception("can not find .!!!");
return fileName.Substring(0, index);
}
//获取文件名字
public static string getFileName(string filePath, bool suffix)
{
if (!suffix)
{
string path = filePath.Replace("\\", "/");
int index = path.LastIndexOf("/");
if (-1 == index)
throw new Exception("can not find .!!!");
int index2 = path.LastIndexOf(".");
if (-1 == index2)
throw new Exception("can not find /!!!");
return path.Substring(index + 1, index2 - index - 1);
}
else
{
string path = filePath.Replace("\\", "/");
int index = path.LastIndexOf("/");
if (-1 == index)
throw new Exception("can not find /!!!");
return path.Substring(index + 1, path.Length - index - 1);
}
}
//获取文件夹
public static string getFolder(string path)
{
path = path.Replace("\\", "/");
int index = path.LastIndexOf("/");
if (-1 == index)
throw new Exception("can not find /!!!");
return path.Substring(index + 1, path.Length - index - 1);
}
//获取文件后缀
public static string getFileSuffix(string filePath)
{
int index = filePath.LastIndexOf(".");
if (-1 == index)
throw new Exception("can not find Suffix!!! the filePath is : " + filePath);
return filePath.Substring(index + 1, filePath.Length - index - 1);
}
//获取文件
public static void getFiles(string path, bool recursion, Dictionary<string, List<string>> allFiles, bool useSuffix, string suffix)
{
if (recursion)
{
string[] dirs = Directory.GetDirectories(path);
foreach (string dir in dirs)
{
if (getFolder(dir) == ".svn")
continue;
getFiles(dir, recursion, allFiles, useSuffix, suffix);
}
}
string[] files = Directory.GetFiles(path);
foreach (string file in files)
{
string fileSuffix = getFileSuffix(file);
if (fileSuffix == "meta" || fileSuffix == "dll")
continue;
if (useSuffix && fileSuffix != suffix)
continue;
string relativePath = file.Replace("\\", "/");
relativePath = relativePath.Replace(Application.dataPath, "");
string fileName = getFileName(file, true);
if (allFiles.ContainsKey(fileName))
{
allFiles[fileName].Add(relativePath);
}
else
{
List<string> list = new List<string>();
list.Add(relativePath);
allFiles.Add(fileName, list);
}
}
}
//检查文件夹
public static void CheckFolder(string path)
{
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
}
//获取文件路径
public static string getPath(string filePath)
{
string path = filePath.Replace("\\", "/");
int index = path.LastIndexOf("/");
if (-1 == index)
throw new Exception("can not find /!!!");
return path.Substring(0, index);
}
//获取本地路径
public static string getLocalPath(string path)
{
string localPath = string.Format("{0}/{1}", Application.persistentDataPath, path);
if (!File.Exists(localPath))
{
if (Application.platform == RuntimePlatform.Android)
{
localPath = string.Format("{0}/{1}", Application.streamingAssetsPath, path);
}
else if (Application.platform == RuntimePlatform.WindowsEditor || Application.platform == RuntimePlatform.WindowsPlayer)
{
localPath = string.Format("file://{0}/{1}", Application.streamingAssetsPath, path);
}
return localPath;
}
return "file:///" + localPath;
}
//获取AssetBundles文件字节
public static byte[] getAssetBundleFileBytes(string path, ref int size)
{
string localPath;
//Andrio跟IOS环境使用沙箱目录
if (Application.platform == RuntimePlatform.Android || Application.platform == RuntimePlatform.IPhonePlayer)
{
localPath = string.Format("{0}/{1}", Application.persistentDataPath, path + ResourceCommon.assetbundleFileSuffix);
}
//Window下使用assetbunlde资源目录
else
{
localPath = ResourceCommon.assetbundleFilePath + path + ResourceCommon.assetbundleFileSuffix;
}
Debug.Log(localPath);
//首先检测沙箱目录中是否有更新资源
if (File.Exists(localPath))
{
try
{
FileStream bundleFile = File.Open(localPath, FileMode.Open, FileAccess.Read);
byte[] bytes = new byte[bundleFile.Length];
bundleFile.Read(bytes, 0, (int)bundleFile.Length);
size = (int)bundleFile.Length;
bundleFile.Close();
return bytes;
}
catch (Exception e)
{
Debug.LogError(e.Message);
return null;
}
}
//原始包中
else
{
TextAsset bundleFile = Resources.Load(path) as TextAsset;
if (null == bundleFile)
Debug.LogError("load : " + path + " bundleFile error!!!");
size = bundleFile.bytes.Length;
return bundleFile.bytes;
}
}
｝
｝
Request
上面的类封装了资源模块所通用的一些接口，以便于我们在开发中使用。在游戏处理资源的过程中，还需要考虑一个问题，那就是程序在请求资源时，要知道资源是在加载过程当中，还是已经卸载完成了。通常在程序中会使用一个枚举值去进行设置，通知程序该资源的使用状态，同时会使用委托函数进行具体的回调操作，比如资源加载完成，我要知道什么时候它加载完成了。根据这些想法，我们用一个类来实现，也就是 Request 类，代码实现如下：
//资源请求类型
public enum RequestType
{
LOAD,
UNLOAD,
LOADLEVEL,
UNLOADLEVEL,
}
class Request
{
internal string mFileName; //请求资源相对Assets/完整路径名称
internal ResourceType mResourceType;
//委托回调函数
internal ResourcesManager.HandleFinishLoad mHandle;
internal ResourcesManager.HandleFinishLoadLevel mHandleLevel;
internal ResourcesManager.HandleFinishUnLoadLevel mHandleUnloadLevel;
internal RequestType mRequestType;
internal ResourceAsyncOperation mResourceAsyncOperation;
//构造函数
internal Request(string fileName, ResourceType resourceType, ResourcesManager.HandleFinishLoad handle, RequestType requestType, ResourceAsyncOperation operation)
{
mFileName = fileName;
mResourceType = resourceType;
mHandle = handle;
mRequestType = requestType;
mResourceAsyncOperation = operation;
}
//构造函数
internal Request(string fileName, ResourceType resourceType, ResourcesManager.HandleFinishLoadLevel handle, RequestType requestType, ResourceAsyncOperation operation)
{
mFileName = fileName;
mResourceType = resourceType;
mHandleLevel = handle;
mRequestType = requestType;
mResourceAsyncOperation = operation;
}
}
ResourceAsyncOperation
在场景与场景之间进行切换过渡时，尤其对于比较大的资源加载，通常使用一个进度条来进行过渡，为此在框架中封装了一个通用的资源过渡类，代码实现如下：
public class ResourceAsyncOperation
{
internal RequestType mRequestType;
internal int mAllDependencesAssetSize;
internal int mLoadDependencesAssetSize;
internal bool mComplete;
public AsyncOperation asyncOperation;
internal ResourceUnit mResource;
internal ResourceAsyncOperation(RequestType requestType)
{
mRequestType = requestType;
mAllDependencesAssetSize = 0;
mLoadDependencesAssetSize = 0;
mComplete = false;
asyncOperation = null;
mResource = null;
}
public bool Complete
{
get
{
return mComplete;
}
}
//资源加载进度
public int Prograss
{
get
{
if (mComplete)
return 100;
else if (0 == mLoadDependencesAssetSize)
return 0;
else
{
//使用assetbundle
if (ResourcesManager.Instance.UsedAssetBundle)
{
if (RequestType.LOADLEVEL == mRequestType)
{
int depsPrograss = (int)(((float)mLoadDependencesAssetSize / mAllDependencesAssetSize) * 100);
int levelPrograss = asyncOperation != null ? (int)((float)asyncOperation.progress * 100.0f) : 0;
return (int)(depsPrograss * 0.8) + (int)(levelPrograss * 0.2);
}
else
{
return (int)(((float)mLoadDependencesAssetSize / mAllDependencesAssetSize) * 100);
}
}
//不使用
else
{
if (RequestType.LOADLEVEL == mRequestType)
{
int levelPrograss = asyncOperation != null ? (int)((float)asyncOperation.progress * 100.0f) : 0;
return levelPrograss;
}
else
{
return 0;
}
}
}
}
}
}
ResourcesManager
关于资源管理的架构思想，基本已经完成了，接下来就要考虑如何使用了。不能直接使用它们，因为它们既不是单例，也不是静态类，没有提供对外的接口，那怎么办呢？管理类就出现了，我们可以使用管理类提供对外的接口，也就是 ResourceManager 类，它通常是单例模式，我们把游戏中的单例分为两种：一种是继承 mono 的单例，一种是不继承 mono 的。我们设计的资源管理类是可以挂接到对象上的，这主要是为了资源更新时使用的。管理类它可以加载资源、销毁资源等等。它的内容实现代码如下：
public class ResourcesManager : UnitySingleton<ResourcesManager>
{
//是否通过assetbundle加载资源
public bool UsedAssetBundle = false;
private bool mInit = false;
private int mFrameCount = 0;
private Request mCurrentRequest = null;
private Queue<Request> mAllRequests = new Queue<Request>();
//保存读取的Resource信息
private Dictionary<string, string> mResources = new Dictionary<string, string>();
//加载的资源信息
private Dictionary<string, ResourceUnit> mLoadedResourceUnit = new Dictionary<string, ResourceUnit>();
public delegate void HandleFinishLoad(ResourceUnit resource);
public delegate void HandleFinishLoadLevel();
public delegate void HandleFinishUnLoadLevel();
public void Init()
{
mInit = true;
}
public void Update()
{
if (!mInit)
return;
if (null == mCurrentRequest && mAllRequests.Count > 0)
handleRequest();
++mFrameCount;
if (mFrameCount == 300)
{
mFrameCount = 0;
}
}
private void handleRequest()
{
//使用assetbundle打包功能
if (UsedAssetBundle)
{
mCurrentRequest = mAllRequests.Dequeue();
//相对Asset的完整资源路径
string fileName = mCurrentRequest.mFileName;
switch (mCurrentRequest.mRequestType)
{
case RequestType.LOAD:
{
switch (mCurrentRequest.mResourceType)
{
case ResourceType.ASSET:
case ResourceType.PREFAB:
{
if (mLoadedResourceUnit.ContainsKey(fileName))
{
mCurrentRequest.mResourceAsyncOperation.mComplete = true;
mCurrentRequest.mResourceAsyncOperation.mResource = mLoadedResourceUnit[fileName] as ResourceUnit;
if (null != mCurrentRequest.mHandle)
mCurrentRequest.mHandle(mLoadedResourceUnit[fileName] as ResourceUnit);
handleResponse();
}
}
break;
case ResourceType.LEVELASSET:
case ResourceType.LEVEL:
}
}
break;
case RequestType.UNLOAD:
{
if (!mLoadedResourceUnit.ContainsKey(fileName))
Debug.LogError("can not find " + fileName);
else
{
}
handleResponse();
}
break;
case RequestType.LOADLEVEL:
{
StartCoroutine(_loadLevel(fileName, mCurrentRequest.mHandleLevel, ResourceType.LEVEL, mCurrentRequest.mResourceAsyncOperation));
}
break;
case RequestType.UNLOADLEVEL:
{
if (!mLoadedResourceUnit.ContainsKey(fileName))
Debug.LogError("can not find level " + fileName);
else
{
if (null != mCurrentRequest.mHandleUnloadLevel)
mCurrentRequest.mHandleUnloadLevel();
}
handleResponse();
}
break;
}
}
//不使用打包
else
{
mCurrentRequest = mAllRequests.Dequeue();
switch (mCurrentRequest.mRequestType)
{
case RequestType.LOAD:
{
switch (mCurrentRequest.mResourceType)
{
case ResourceType.ASSET:
case ResourceType.PREFAB:
{
//暂时不处理，直接使用资源相对路径
}
break;
case ResourceType.LEVELASSET:
{
}
break;
case ResourceType.LEVEL:
{
}
break;
}
}
break;
case RequestType.UNLOAD:
{
handleResponse();
}
break;
case RequestType.LOADLEVEL:
{
StartCoroutine(_loadLevel(mCurrentRequest.mFileName, mCurrentRequest.mHandleLevel, ResourceType.LEVEL, mCurrentRequest.mResourceAsyncOperation));
}
break;
case RequestType.UNLOADLEVEL:
{
if (null != mCurrentRequest.mHandleUnloadLevel)
mCurrentRequest.mHandleUnloadLevel();
handleResponse();
}
break;
}
}
}
private void handleResponse()
{
mCurrentRequest = null;
}
//传入Resources下相对路径名称 例如Resources/Game/Effect1 传入Game/Effect1
public ResourceUnit loadImmediate(string filePathName, ResourceType resourceType, string archiveName = "Resources")
{
//使用assetbundle打包
if (UsedAssetBundle)
{
//添加Resource
string completePath = "Resources/" + filePathName;
//加载本身预制件
ResourceUnit unit = _LoadImmediate(completePath, resourceType);
return unit;
}
//不使用
else
{
Object asset = Resources.Load(filePathName);
ResourceUnit resource = new ResourceUnit(null, 0, asset, null, resourceType);
return resource;
}
}
//加载场景
public ResourceAsyncOperation loadLevel(string fileName, HandleFinishLoadLevel handle, string archiveName = "Level")
{
{
ResourceAsyncOperation operation = new ResourceAsyncOperation(RequestType.LOADLEVEL);
mAllRequests.Enqueue(new Request(fileName, ResourceType.LEVEL, handle, RequestType.LOADLEVEL, operation));
return operation;
}
}
private IEnumerator _loadLevel(string path, HandleFinishLoadLevel handle, ResourceType resourceType, ResourceAsyncOperation operation)
{
//使用assetbundle打包
if (UsedAssetBundle)
{
//加载场景assetbundle
int scenAssetBundleSize = 0;
byte[] binary = ResourceCommon.getAssetBundleFileBytes(path, ref scenAssetBundleSize);
AssetBundle assetBundle = AssetBundle.LoadFromMemory(binary);
if (!assetBundle)
Debug.LogError("create scene assetbundle " + path + "in _LoadImmediate failed");
//添加场景大小
operation.mLoadDependencesAssetSize += scenAssetBundleSize;
AsyncOperation asyncOperation = SceneManager.LoadSceneAsync(ResourceCommon.getFileName(path, false));
operation.asyncOperation = asyncOperation;
yield return asyncOperation;
handleResponse();
operation.asyncOperation = null;
operation.mComplete = true;
operation.mResource = null;
if (null != handle)
handle();
}
//不使用
else
{
ResourceUnit level = new ResourceUnit(null, 0, null, path, resourceType);
//获取加载场景名称
string sceneName = ResourceCommon.getFileName(path, true);
AsyncOperation asyncOperation = Application.LoadLevelAsync(sceneName);
operation.asyncOperation = asyncOperation;
yield return asyncOperation;
handleResponse();
operation.asyncOperation = null;
operation.mComplete = true;
if (null != handle)
handle();
}
}
//单个资源加载
ResourceUnit _LoadImmediate(string fileName, ResourceType resourceType)
{
//没有该资源，加载
if (!mLoadedResourceUnit.ContainsKey(fileName))
{
//资源大小
int assetBundleSize = 0;
byte[] binary = ResourceCommon.getAssetBundleFileBytes(fileName, ref assetBundleSize);
AssetBundle assetBundle = AssetBundle.LoadFromMemory(binary);
if (!assetBundle)
Debug.LogError("create assetbundle " + fileName + "in _LoadImmediate failed");
Object asset = assetBundle.LoadAsset(fileName);
if (!asset)
Debug.LogError("load assetbundle " + fileName + "in _LoadImmediate failed");
ResourceUnit ru = new ResourceUnit(assetBundle, assetBundleSize, asset, fileName, resourceType);
//添加到资源中
mLoadedResourceUnit.Add(fileName, ru);
return ru;
}
else
{
return mLoadedResourceUnit[fileName];
}
}
｝
LoadUiResource
资源管理类到这里还没有完成，因为还没有 UI 资源的处理。比如要把一个 UI 资源动态的挂接到父物体的下面，该怎么处理，所以在资源管理框架中会有专用于处理 UI 资源的类。该类主要作用是提供了加载 UI 资源的接口，同时会将资源放到字典中便于统一处理。该类代码实现如下：
public class LoadUiResource
{
public static GameObject LoadRes(Transform parent,string path)
{
if(CheckResInDic(path))
{
if(GetResInDic(path) != null){
return GetResInDic(path);
}
else{
LoadResDic.Remove(path);
}
}
GameObject objLoad = null;
ResourceUnit objUnit = ResourcesManager.Instance.loadImmediate(path, ResourceType.PREFAB);
if (objUnit == null || objUnit.Asset == null)
{
Debug.LogError("load unit failed" + path);
return null;
}
objLoad = GameObject.Instantiate(objUnit.Asset) as GameObject;
objLoad.transform.parent = parent;
objLoad.transform.localScale = Vector3.one;
objLoad.transform.localPosition = Vector3.zero;
LoadResDic.Add(path,objLoad);
return objLoad;
}
//创建窗口子对象，不加入资源管理
public static GameObject AddChildObject(Transform parent, string path)
{
GameObject objLoad = null;
ResourceUnit objUnit = ResourcesManager.Instance.loadImmediate(path, ResourceType.PREFAB);
if (objUnit == null || objUnit.Asset == null)
{
Debug.LogError("load unit failed" + path);
return null;
}
objLoad = GameObject.Instantiate(objUnit.Asset) as GameObject;
objLoad.transform.parent = parent;
objLoad.transform.localScale = Vector3.one;
objLoad.transform.localPosition = Vector3.zero;
return objLoad;
}
//删除所有的孩子
public static void ClearAllChild(Transform transform)
{
while (transform.childCount > 0)
{
GameObject.DestroyImmediate(transform.GetChild(0).gameObject);
}
transform.DetachChildren();
}
public static void ClearOneChild(Transform transform,string name)
{
for (int i = 0; i < transform.childCount; i++)
{
if (transform.GetChild(i).gameObject.name == name)
{
GameObject.DestroyImmediate(transform.GetChild(i).gameObject);
}
}
}
//删除加载
public static void DestroyLoad(string path)
{
if(LoadResDic == null || LoadResDic.Count == 0)
return;
GameObject obj = null;
if (LoadResDic.TryGetValue(path, out obj) && obj != null)
{
GameObject.DestroyImmediate(obj);
LoadResDic.Remove(path);
//System.GC.Collect();
}
}
public static void DestroyLoad(GameObject obj)
{
if(LoadResDic == null || LoadResDic.Count == 0)
return;
if(obj == null)
return;
foreach(string key in LoadResDic.Keys)
{
GameObject objLoad;
if(LoadResDic.TryGetValue(key,out objLoad) && objLoad == obj)
{
GameObject.DestroyImmediate(obj);
LoadResDic.Remove(key);
break;
}
}
}
//获取在目录中的资源
public static GameObject GetResInDic(string path)
{
if(LoadResDic == null || LoadResDic.Count == 0)
return null;
GameObject obj = null ;
if(LoadResDic.TryGetValue(path,out obj))
{
return obj;
}
return null;
}
//检查资源是否存在
public static bool CheckResInDic(string path)
{
if(LoadResDic == null || LoadResDic.Count == 0)
return false;
return LoadResDic.ContainsKey(path);
}
public static void Clean()
{
if(LoadResDic == null || LoadResDic.Count == 0)
return;
for(int i = LoadResDic.Count - 1;i >=0;i--)
{
GameObject obj = LoadResDic.ElementAt(i).Value ;
if( obj != null)
{
GameObject.DestroyImmediate(obj);
}
}
LoadResDic.Clear();
}
public static Dictionary<string,GameObject> LoadResDic = new Dictionary<string, GameObject>();
}
自定义消息分发
首先 Unity 引擎为开发者提供的消息分发函数有这些：SendMessage、SendMessageUpwards、BroadcastMessage，它们可以实现简单的消息发送。那么为什么不选择它们，因为它们的执行效率相对委托来说是比较低的，而且扩展性方面也不好，比如要使用很多的参数来进行传递的话，它们就很难满足我们的需求，游戏开发还会有更多的类似需求。所以我们放弃它们，选择使用委托自己去封装消息分发。
举一个需求说明的例子，当玩家杀怪获取掉落下来的道具时，玩家的经验值加1。这是一个非常基础的功能需求，这类需求充斥着游戏的各处。最初我们可以不使用事件系统，直接在 OnTriggerEnter 方法中给玩家的生命值加1，但是，这将使得检测碰撞的这块代码直接引用了玩家属性管理的代码，也就是代码的紧耦合。而且，在后面的开发中，我们又想让玩家接到道具的同时还要在界面上显示一个图标，这时又需要在这里引用界面相关的代码。后来，又希望能播放一段音效……，这样随着需求的增加，其中的逻辑会越来越复杂。解决此问题的好办法就是，在 OnTrigerEnter 中加入消息分发函数，这样具体的操作就在另一个类的函数中进行，可以降低耦合性。
在网络游戏中，我们也会遇到服务器发送给客户端角色信息后，客户端接收到消息后，会将得到的角色信息在 UI 上显示出来。如果不用事件系统对其进行分离，那么网络消息跟 UI 就会混在一起了。这样随着逻辑的需求增加，耦合性会越来越大，最后会导致项目很难维护。所以我们必须要使用事件系统来解耦合各个模块。
事件分类
游戏中会有很多种事件，事件的分类表示我们可以采用字符串或者采用枚举值，事件分类枚举代码：
public enum EGameEvent
{
eWeaponDataChange = 1,
ePlayerShoot = 2,
//UI
eLevelChange = 3,
eBloodChange = 4,
ePowerChange = 5,
eSkillInit = 6,
eSkillUpdate = 7,
eBuffPick = 8,
eTalent = 9,
//data
eBlood = 10,
eMp = 11,
eScore = 12,
ePower = 13,
eTalentUpdate = 14,
ePickBuff = 15,
eGameEvent_LockTarget,
//Login
eGameEvent_LoginSuccess, //登陆成功
eGameEvent_LoginEnter,
eGameEvent_LoginExit,
eGameEvent_RoleEnter,
eGameEvent_RoleExit,
//Play
eGameEvent_PlayEnter,
eGameEvent_PlayExit,
ePlayerInput,
eActorDead,
}
保存事件
这些事件分类还可以继续扩展，事件系统贯穿于整个游戏，从 UI 界面、数据、战斗等等。我们的事件系统实现主要分为三步：事件监听、事件分发、事件移除，使用字典 Dictionary 用于保存事件和委托。
static public Dictionary<EGameEvent, Delegate> mEventTable = new Dictionary<EGameEvent, Delegate>();
模版类
事件系统中的委托，也是需要封装的。委托该如何封装？我们使用的委托函数的参数可能会有多个，而且不同的委托函数对应的类型可能也是不同的，比如 GameObject、float、int 等等。针对这些需求，唯一能解决问题的就是模版类，回调函数对应的代码如下，从无参数到可以有五个参数：
public delegate void Callback();
public delegate void Callback<T>(T arg1);
public delegate void Callback<T, U>(T arg1, U arg2);
public delegate void Callback<T, U, V>(T arg1, U arg2, V arg3);
public delegate void Callback<T, U, V, X>(T arg1, U arg2, V arg3, X arg4);
事件监听
首先封装监听函数：
//无参数
static public void AddListener(EGameEvent eventType, Callback handler) {
OnListenerAdding(eventType, handler);
mEventTable[eventType] = (Callback)mEventTable[eventType] + handler;
}
//一个参数
static public void AddListener<T>(EGameEvent eventType, Callback<T> handler) {
OnListenerAdding(eventType, handler);
mEventTable[eventType] = (Callback<T>)mEventTable[eventType] + handler;
}
//两个参数
static public void AddListener<T, U>(EGameEvent eventType, Callback<T, U> handler) {
OnListenerAdding(eventType, handler);
mEventTable[eventType] = (Callback<T, U>)mEventTable[eventType] + handler;
}
//三个参数
static public void AddListener<T, U, V>(EGameEvent eventType, Callback<T, U, V> handler) {
OnListenerAdding(eventType, handler);
mEventTable[eventType] = (Callback<T, U, V>)mEventTable[eventType] + handler;
}
//四个参数
static public void AddListener<T, U, V, X>(EGameEvent eventType, Callback<T, U, V, X> handler) {
OnListenerAdding(eventType, handler);
mEventTable[eventType] = (Callback<T, U, V, X>)mEventTable[eventType] + handler;
}
每个函数都是比较简单的，从没有参数，到最多四个参数的函数，这些函数都调用了函数 OnListenerAdding 用于将事件和委托寸放到字典中：
static public void OnListenerAdding(EGameEvent eventType, Delegate listenerBeingAdded) {
if (!mEventTable.ContainsKey(eventType)) {
mEventTable.Add(eventType, null );
}
Delegate d = mEventTable[eventType];
if (d != null && d.GetType() != listenerBeingAdded.GetType()) {
throw new ListenerException(string.Format("Attempting to add listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being added has type {2}", eventType, d.GetType().Name, listenerBeingAdded.GetType().Name));
}
}
事件移除
监听函数有了，对应的就是移除监听函数，移除就是从 Dictionary 字典中将其移除掉，它跟监听函数是一一对应的，函数如下：
//无参数
static public void RemoveListener(EGameEvent eventType, Callback handler) {
OnListenerRemoving(eventType, handler);
mEventTable[eventType] = (Callback)mEventTable[eventType] - handler;
OnListenerRemoved(eventType);
}
//一个参数
static public void RemoveListener<T>(EGameEvent eventType, Callback<T> handler) {
OnListenerRemoving(eventType, handler);
mEventTable[eventType] = (Callback<T>)mEventTable[eventType] - handler;
OnListenerRemoved(eventType);
}
//两个参数
static public void RemoveListener<T, U>(EGameEvent eventType, Callback<T, U> handler) {
OnListenerRemoving(eventType, handler);
mEventTable[eventType] = (Callback<T, U>)mEventTable[eventType] - handler;
OnListenerRemoved(eventType);
}
//三个参数
static public void RemoveListener<T, U, V>(EGameEvent eventType, Callback<T, U, V> handler) {
OnListenerRemoving(eventType, handler);
mEventTable[eventType] = (Callback<T, U, V>)mEventTable[eventType] - handler;
OnListenerRemoved(eventType);
}
//四个参数
static public void RemoveListener<T, U, V, X>(EGameEvent eventType, Callback<T, U, V, X> handler) {
OnListenerRemoving(eventType, handler);
mEventTable[eventType] = (Callback<T, U, V, X>)mEventTable[eventType] - handler;
OnListenerRemoved(eventType);
}
这些函数都调用了函数 OnListenerRemoving 和 OnListenerRemoved：
static public void OnListenerRemoving(EGameEvent eventType, Delegate listenerBeingRemoved) {
if (mEventTable.ContainsKey(eventType)) {
Delegate d = mEventTable[eventType];
if (d == null) {
throw new ListenerException(string.Format("Attempting to remove listener with for event type \"{0}\" but current listener is null.", eventType));
} else if (d.GetType() != listenerBeingRemoved.GetType()) {
throw new ListenerException(string.Format("Attempting to remove listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being removed has type {2}", eventType, d.GetType().Name, listenerBeingRemoved.GetType().Name));
}
} else {
throw new ListenerException(string.Format("Attempting to remove listener for type \"{0}\" but Messenger doesn't know about this event type.", eventType));
}
}
static public void OnListenerRemoved(EGameEvent eventType) {
if (mEventTable[eventType] == null) {
mEventTable.Remove(eventType);
}
}
事件分发
如何触发监听函数呢，那就要说到广播函数了，它与监听和移除也是一一对应的：
//无参数
static public void Broadcast(EGameEvent eventType) {
OnBroadcasting(eventType);
Delegate d;
if (mEventTable.TryGetValue(eventType, out d)) {
Callback callback = d as Callback;
if (callback != null) {
callback();
} else {
throw CreateBroadcastSignatureException(eventType);
}
}
}
//一个参数
static public void Broadcast<T>(EGameEvent eventType, T arg1) {
OnBroadcasting(eventType);
Delegate d;
if (mEventTable.TryGetValue(eventType, out d)) {
Callback<T> callback = d as Callback<T>;
if (callback != null) {
callback(arg1);
} else {
throw CreateBroadcastSignatureException(eventType);
}
}
}
//两个参数
static public void Broadcast<T, U>(EGameEvent eventType, T arg1, U arg2) {
OnBroadcasting(eventType);
Delegate d;
if (mEventTable.TryGetValue(eventType, out d)) {
Callback<T, U> callback = d as Callback<T, U>;
if (callback != null) {
callback(arg1, arg2);
} else {
throw CreateBroadcastSignatureException(eventType);
}
}
}
//三个参数
static public void Broadcast<T, U, V>(EGameEvent eventType, T arg1, U arg2, V arg3) {
OnBroadcasting(eventType);
Delegate d;
if (mEventTable.TryGetValue(eventType, out d)) {
Callback<T, U, V> callback = d as Callback<T, U, V>;
if (callback != null) {
callback(arg1, arg2, arg3);
} else {
throw CreateBroadcastSignatureException(eventType);
}
}
}
//四个参数
static public void Broadcast<T, U, V, X>(EGameEvent eventType, T arg1, U arg2, V arg3, X arg4) {
OnBroadcasting(eventType);
Delegate d;
if (mEventTable.TryGetValue(eventType, out d)) {
Callback<T, U, V, X> callback = d as Callback<T, U, V, X>;
if (callback != null) {
callback(arg1, arg2, arg3, arg4);
} else {
throw CreateBroadcastSignatureException(eventType);
}
}
}
}
这样整个事件系统就封装完成了，那么如何使用呢，首先需要先添加监听，将监听函数放在对应的类中：
EventCenter.AddListener(EGameEvent.eGameEvent_GamePlayEnter, Show);
在要使用的地方，可以播放此消息：
EventCenter.Broadcast(EGameEvent.eGameEvent_GamePlayEnter);
对象池
对象池就是放置物体对象的池子，是一个虚拟的用于存储对象的 Dictionary 或者是 List、Stack 等数据存储。
对象池主要是针对游戏中频繁生成、频繁销毁的对象而设立的，目的是优化内存。如果对象频繁的生成，就表示它每次生成都要从内存中去申请空间，而每次释放就会导致很多的内存碎片，当再去生成大物体对象时，会导致程序运行的卡顿，因为没有一个整体的内存供加载的物体使用。而使用对象池可以避免这些问题的产生，优化内存。
对象池可以把这些频繁生成的对象先放置到 Dictionary 中，在生成的时候使用，先在 Dictionary 中查找，如果找到，就可以将其显示出来，再根据需求对其进行操作。
而如果找不到，就需要重新生成，然后将其放置到 Dictionary 中，方便下次使用。当然这些对象也不是永久存放在 Dictionary 中的，我们会对其设置一个缓存时间，如果长时间不用就将其清除掉，也就是从 Dictionary 中删除掉。这样就可以避免频繁的操作内存。
上面是一张对象池模块的实现框架图。先介绍一下传统的对象池设计，传统的设计，一般会使用两个队列，一个用于存储正在使用的对象，另一个存储使用过的或者没被使用的对象。这种设计方式，如果只是做个简单的 Demo 是可以的，但是如果做产品就不能这么简单的设计了。要考虑的问题比较多，比如设置了对象池中对象的缓存时间，还有要生成不同类型的对象池等。
对象池类型
我们首先定义游戏需要使用对象生成的对象池类型，这个可以使用枚举值表示：
public enum PoolObjectType
{
POT_Effect,
POT_MiniMap,
POT_Entity,
POT_UITip,
POT_XueTiao,
}
该枚举定义了特效、小地图、实体、UI 提示框、还有血条这些需要使用对象池的游戏类型。
对象信息
还要考虑这些游戏对象包含哪些信息，比如可以通过名字或者 ID 查找对象池中的对象，还有每个对象应该有自己的缓存时间，对象是属于哪种对象池等等属性，这些可以使用结构体或者类来定义：
public class PoolGameObjectInfo
{
public string name;
//缓存时间
public float mCacheTime= 0.0f;
//缓存物体类型
public PoolObjectType type;
//可以重用
public bool mCanUse = true;
//重置时间
public float mResetTime = .0f;
}
以上结构是对象池中的对象信息的定义，每个对象都对应着自己的对象信息，使用字典存放：
//GameObject缓存池
public class PoolInfo
{
//缓存队列
public Dictionary<GameObject, PoolGameObjectInfo> mQueue = new Dictionary<GameObject, PoolGameObjectInfo>();
}
这个类定义的是池信息，每个对象池对应着自己的信息，另外再定义存储对象池信息的字典，通过名字进行区分，我们将其也用 Dictionary 字典存放：
public class GameObjectPool : Singleton<GameObjectPool>
{
private Dictionary<String, PoolInfo> mPoolDic = new Dictionary<String, PoolInfo>();
}
获取对象
下面开始设计接口。在生成对象池对象时，首先要获取一下，看看以前是否生成过，如果已经生成过，那就直接拿来，否则就要重新加载资源进行创建，该函数主要是用于获取是否已经存在对象池的物体，同时判断一下该物体是否可以使用，该函数只对内，不对外：
//取得可用对象
private bool TryGetObject(PoolInfo poolInfo, out KeyValuePair<GameObject, PoolGameObjectInfo> objPair)
{
if (poolInfo.mQueue.Count > 0)
{
foreach (KeyValuePair<GameObject, PoolGameObjectInfo> pair in poolInfo.mQueue)
{
GameObject go = pair.Key;
PoolGameObjectInfo info = pair.Value;
if (info.mCanUse)
{
objPair = pair;
return true;
}
}
}
objPair = new KeyValuePair<GameObject, PoolGameObjectInfo>();
return false;
}
接着编写创建对象池物体的函数：
//获取缓存物体
public GameObject GetGO(String res)
{
//有效性检查
if (null == res)
{
return null;
}
//查找对应pool，如果没有缓存
PoolInfo poolInfo = null;
KeyValuePair<GameObject, PoolGameObjectInfo> pair;
if (!mPoolDic.TryGetValue(res, out poolInfo) || !TryGetObject(poolInfo, out pair))
{
//新创建
ResourceUnit unit = ResourcesManager.Instance.loadImmediate(res, ResourceType.PREFAB);
if (unit.Asset == null)
{
Debug.Log("can not find the resource" + res);
}
return GameObject.Instantiate(unit.Asset) as GameObject;
}
//出队列数据
GameObject go = pair.Key;
PoolGameObjectInfo info = pair.Value;
poolInfo.mQueue.Remove(go);
//使有效
EnablePoolGameObject(go, info);
//返回缓存Gameobjec
return go;
}
该函数首先判断对象是否在 Dictionary 中，如果不在字典中，就直接生成一个实例化对象。
显示对象
如果已经创建则调用函数 EnablePoolGameObject 将物体设置为 true：
public void EnablePoolGameObject(GameObject go, PoolGameObjectInfo info)
{
if (info.type == PoolObjectType.POT_Effect)
{
go.SetActive(true);
go.transform.parent = null;
}
else if (info.type == PoolObjectType.POT_MiniMap)
{
go.SetActive(true);
go.transform.parent = null;
}
else if (info.type == PoolObjectType.POT_Entity)
{
go.SetActive(true);
go.transform.parent = null;
}
else if (info.type == PoolObjectType.POT_UITip)
{
go.SetActive(true);
go.transform.parent = null;
}
else if (info.type == PoolObjectType.POT_XueTiao)
{
}
info.mCacheTime = 0.0f;
}
上面的函数就是将隐藏的对象设置为 true 将其显示出来，另外，我们还要知道对象的存放位置，还有在使用时判断其是否还有用，如果还有用，就将其隐藏掉，没有用就删除掉。
释放对象
public void ReleaseGO(String res, GameObject go, PoolObjectType type)
{
//获取缓存节点,设置为不可见位置
if (objectsPool == null)
{
objectsPool = new GameObject("ObjectPool");
objectsPool.AddComponent<Canvas>();
objectsPool.transform.localPosition = new Vector3(0, -5000, 0);
}
if (null == res || null == go)
{
return;
}
PoolInfo poolInfo = null;
//没有创建
if (!mPoolDic.TryGetValue(res, out poolInfo))
{
poolInfo = new PoolInfo();
mPoolDic.Add(res, poolInfo);
}
PoolGameObjectInfo poolGameObjInfo = new PoolGameObjectInfo();
poolGameObjInfo.type = type;
poolGameObjInfo.name = res;
//无效缓存物体
DisablePoolGameObject(go, poolGameObjInfo);
//保存缓存GameObject,会传入相同的go, 有隐患
poolInfo.mQueue[go] = poolGameObjInfo;
}
上面的函数可以用于批量生成对象，比如从配置文件中加载的特效、物体等。先将其隐藏掉，如果使用时就调用 GetGo 函数，ReleaseGO 负责将生成的对象隐藏掉，而 GetGo 函数负责将已生成的对象显示出来，如果没有就直接实例化出来。
更新缓存时间
另外因为加了缓存时间，所以要在每一帧中去判断缓存的物体，看看这些物体的缓存时间是否有效，无效就删除掉，这是要在 Update 函数中判断的：
public void OnUpdate()
{
//每隔0.1更新一次
mTotalTime += Time.deltaTime;
if (mTotalTime <= 0.1f)
{
return;
}
else
{
mTotalTime = 0;
}
float deltaTime = Time.deltaTime;
//遍历数据
foreach(PoolInfo poolInfo in mPoolDic.Values)
{
//死亡列表
mDestoryPoolGameObjects.Clear();
foreach (KeyValuePair<GameObject, PoolGameObjectInfo> pair in poolInfo.mQueue)
{
GameObject obj = pair.Key;
PoolGameObjectInfo info = pair.Value;
info.mCacheTime += deltaTime;
float mAllCachTime = mCachTime;
//POT_UITip,缓存3600秒
if (info.type == PoolObjectType.POT_UITip)
mAllCachTime = 3600;
//缓存时间到
if (info.mCacheTime >= mAllCachTime)
{
mDestoryPoolGameObjects.Add(obj);
}
//拖尾重置计时
if (!info.mCanUse)
{
info.mResetTime += deltaTime;
if (info.mResetTime > 1.0f)
{
info.mResetTime = .0f;
info.mCanUse = true;
obj.SetActive(false);
}
}
}
//移除
for(int k=0; k < mDestoryPoolGameObjects.Count; k++)
{
GameObject obj = mDestoryPoolGameObjects[k];
GameObject.DestroyImmediate(obj);
poolInfo.mQueue.Remove(obj);
}
}
}
以上整个对象池的设计就完成了