游戏仍在开发中，还有很多功能未实现（试玩地址：方圆·齐物）

通用模块

1、事件的监听与广播
其核心为利用“字典+委托”的方式实现代码的高度解耦，应用场景示例：调用多个游戏对象相同功能的方法（如方法带有参数需要每个游戏对象方法的参数类型和数量都一致），并且方法无返回值。具体实现如下：

public delegate void CallBack(); public delegate void CallBack<T>(T arg); public delegate void CallBack<T, X>(T arg1, X arg2); public delegate void CallBack<T, X, Y>(T arg1, X arg2, Y arg3); ...... 

首先自定义委托，实现不同个数的参数，如果参数数量不需要那么多也可以直接使用内置的“Action”委托类型，其效果完全一致，只是内置的“Action”的参数数量有限制，自定义的话可以任意多个参数。

public enum EventType {       UpdateUserInfo,       UpdatePropInfo,       UpdateTitleInfo, ...... } 

然后定义实际需要用到的事件类型，用作字典中的“键”，这些枚举类型表示了具有相同功能的方法。

public class EventCenter { private static Dictionary<EventType, Delegate> m_EventTable = new Dictionary<EventType, Delegate>(); private static void OnListenerAdding(EventType eventType, Delegate callBack) { if (!m_EventTable.ContainsKey(eventType)) {             m_EventTable.Add(eventType, null); } Delegate d = m_EventTable[eventType]; if (d != null && d.GetType() != callBack.GetType()) { throw new Exception(string.Format("尝试为事件{0}添加不同类型的委托，当前事件所对应的委托是{1}，要添加的委托类型为{2}", eventType, d.GetType(), callBack.GetType())); } } private static void OnListenerRemoving(EventType eventType, Delegate callBack) { if (m_EventTable.ContainsKey(eventType)) { Delegate d = m_EventTable[eventType]; if (d == null) { throw new Exception(string.Format("移除监听错误：事件{0}没有对应的委托", eventType)); } else if (d.GetType() != callBack.GetType()) { throw new Exception(string.Format("移除监听错误：尝试为事件{0}移除不同类型的委托，当前委托类型为{1}，要移除的委托类型为{2}", eventType, d.GetType(), callBack.GetType())); } } else { throw new Exception(string.Format("移除监听错误：没有事件码{0}", eventType)); } } private static void OnListenerRemoved(EventType eventType) { if (m_EventTable[eventType] == null) {             m_EventTable.Remove(eventType); } } //no parameters public static void AddListener(EventType eventType, CallBack callBack) { OnListenerAdding(eventType, callBack);         m_EventTable[eventType] = (CallBack)m_EventTable[eventType] + callBack; } //Single parameters public static void AddListener<T>(EventType eventType, CallBack<T> callBack) { OnListenerAdding(eventType, callBack);         m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] + callBack; } //后面多个参数的做法相同...... //no parameters public static void RemoveListener(EventType eventType, CallBack callBack) { OnListenerRemoving(eventType, callBack);         m_EventTable[eventType] = (CallBack)m_EventTable[eventType] - callBack; OnListenerRemoved(eventType); } //single parameters public static void RemoveListener<T>(EventType eventType, CallBack<T> callBack) { OnListenerRemoving(eventType, callBack);         m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] - callBack; OnListenerRemoved(eventType); } //后面多个参数的做法相同...... //no parameters public static void Broadcast(EventType eventType) { Delegate d; if (m_EventTable.TryGetValue(eventType, out d)) { CallBack callBack = d as CallBack; if (callBack != null) { callBack(); } else { throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType)); } } } //single parameters public static void Broadcast<T>(EventType eventType, T arg) { Delegate d; if (m_EventTable.TryGetValue(eventType, out d)) {             CallBack<T> callBack = d as CallBack<T>; if (callBack != null) { callBack(arg); } else { throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType)); } } } //后面多个参数的做法相同...... } 

最后实现事件的监听、移除和广播，这里作几点说明：
·由于使用字典存储委托，而不同类型的委托参数不一致，故这里是用委托类型的基类“Delegate”作为字典的值，实际操作的时候需要转换为某个具体的委托类型（如上面已经定义过的CallBack、CallBack<T>等）。
·添加/移除委托事件的时候需要检查委托类型是否一致。

2、行为树
详细介绍参照链接: AI 行为树的工作原理.这里不过多赘述（主要还是因为都差不多没啥特别的），下面附上代码实现：

using System; using System.Collections.Generic; namespace MyBehaviorTree { //状态枚举类型 public enum BTNodeResult     {         Failure,         Success,         Running, } public enum BTNodeType     {         Condition,         Action,         Selector,         Sequence,         Parallel,         Decorator, } //一些初始化的静态方法 public class BT { public static ConditionNode ConditionNode(Func<bool> conditionFunc) { return new ConditionNode(conditionFunc); } public static ActionNode ActionNode(Action immediateAction) { return new ActionNode(immediateAction); } public static ActionNode ActionNode(Func<IEnumerator<BTNodeResult>> continuousAction) { return new ActionNode(continuousAction); } public static SelectorNode SelectorNode() { return new SelectorNode(); } public static SequenceNode SequenceNode() { return new SequenceNode(); } public static ParallelNode ParallelNode() { return new ParallelNode(); } public static InverseDecoratorNode InverseDecoratorNode(BaseNode childeNode) { return new InverseDecoratorNode(childeNode); } } /// <summary> /// 所有节点的基类 /// </summary> public abstract class BaseNode { public BTNodeType nodeType;//节点类型 public int nodeIndex; //在父节点的子节点列表里的索引号 public BaseNode(BTNodeType nodeType) { this.nodeType = nodeType; } public abstract BTNodeResult Execute(); //执行方法 } /// <summary> /// 组合节点类 /// </summary> public abstract class CombinerNode : BaseNode { protected List<BaseNode> childNodeList = new List<BaseNode>(); public CombinerNode(BTNodeType nodeType) : base(nodeType) { } public CombinerNode AddNode(params BaseNode[] nodes) { int startIndex = childNodeList.Count; for (int i = 0; i < nodes.Length; i++) {                 nodes[i].nodeIndex = startIndex + i;                 childNodeList.Add(nodes[i]); } return this; } } /// <summary> /// 条件节点 /// </summary> public class ConditionNode : BaseNode {         Func<bool> conditionFunc; public ConditionNode(Func<bool> conditionFunc) : base(BTNodeType.Condition) { this.conditionFunc = conditionFunc; } public override BTNodeResult Execute() { return conditionFunc() ? BTNodeResult.Success : BTNodeResult.Failure; } } /// <summary> /// 行为节点 /// </summary> public class ActionNode : BaseNode { Action immediateAction; //瞬时行为         Func<IEnumerator<BTNodeResult>> continuousAction;//持续行为         IEnumerator<BTNodeResult> coroutine; public ActionNode(Action immediateAction) : base(BTNodeType.Action) { this.immediateAction = immediateAction; } public ActionNode(Func<IEnumerator<BTNodeResult>> continuousAction) : base(BTNodeType.Action) { this.continuousAction = continuousAction; } public override BTNodeResult Execute() { if (immediateAction != null) { immediateAction(); return BTNodeResult.Success; } if (coroutine == null) {                 coroutine = continuousAction(); return BTNodeResult.Running; }             coroutine.MoveNext(); BTNodeResult result = coroutine.Current; if(result != BTNodeResult.Running) {                 coroutine = null; } return result; } } /// <summary> /// 选择节点 /// </summary> public class SelectorNode : CombinerNode { private BaseNode lastRunningNode; public SelectorNode() : base(BTNodeType.Selector) { } public override BTNodeResult Execute() { int index = 0; if (lastRunningNode != null) {                 index = lastRunningNode.nodeIndex; }             lastRunningNode = null; BTNodeResult resultType = BTNodeResult.Failure; for (int i = index; i < childNodeList.Count; i++) { BaseNode tempNode = childNodeList[i];                 resultType = tempNode.Execute(); if (resultType == BTNodeResult.Failure) { continue; } if (resultType == BTNodeResult.Success) { break; } if (resultType == BTNodeResult.Running) {                     lastRunningNode = tempNode; break; } } return resultType; } } /// <summary> /// 顺序节点 /// </summary> public class SequenceNode : CombinerNode { private BaseNode lastRunningNode; public SequenceNode() : base(BTNodeType.Sequence) { } public override BTNodeResult Execute() { int index = 0; if (lastRunningNode != null) {                 index = lastRunningNode.nodeIndex; }             lastRunningNode = null; BTNodeResult resultType = BTNodeResult.Failure; for (int i = index; i < childNodeList.Count; i++) { BaseNode tempNode = childNodeList[i];                 resultType = tempNode.Execute(); if (resultType == BTNodeResult.Failure) { break; } if (resultType == BTNodeResult.Success) { continue; } if (resultType == BTNodeResult.Running) {                     lastRunningNode = tempNode; break; } } return resultType; } } /// <summary> /// 并行节点 /// </summary> public class ParallelNode : CombinerNode { public ParallelNode() : base(BTNodeType.Parallel) { } public override BTNodeResult Execute() { int successCount = 0; int runningCount = 0; for (int i = 0; i < childNodeList.Count; i++) { BaseNode tempNode = childNodeList[i]; BTNodeResult tempResult = tempNode.Execute(); if(tempResult == BTNodeResult.Success) {                     successCount++; }else if (tempResult == BTNodeResult.Running) {                     runningCount++; } } if (runningCount > 0) { return BTNodeResult.Running; }else if (successCount > 0) { return BTNodeResult.Success; } else { return BTNodeResult.Failure; } } } /// <summary> /// 修饰节点(取反) /// </summary> public class InverseDecoratorNode : BaseNode { private BaseNode childNode; public InverseDecoratorNode(BaseNode childNode) : base(BTNodeType.Decorator) { this.childNode = childNode; } public override BTNodeResult Execute() { BTNodeResult tempResult = childNode.Execute(); if(tempResult == BTNodeResult.Failure) { return BTNodeResult.Success; } else { return BTNodeResult.Failure; } } } } 

3、自定义的工具类
说明见注释：

using System; using System.Collections.Generic; using UnityEngine; public class Utils { /// <summary> /// 在XOZ平面上旋转一个Vector3 /// </summary> public static Vector3 RotateVector3(Vector3 v3, float angle) {         angle = -angle; float x = v3.x * Mathf.Cos(Mathf.Deg2Rad * angle) - v3.z * Mathf.Sin(Mathf.Deg2Rad * angle); float z = v3.x * Mathf.Sin(Mathf.Deg2Rad * angle) + v3.z * Mathf.Cos(Mathf.Deg2Rad * angle); return new Vector3(x, 0, z); } /// <summary> /// 计算两个向量之间的夹角，带符号,n为旋转轴 /// </summary> public static float AngleSigned(Vector3 v1, Vector3 v2, Vector3 n) { return Mathf.Atan2(             Vector3.Dot(n, Vector3.Cross(v1, v2)),             Vector3.Dot(v1, v2)) * Mathf.Rad2Deg; } /// <summary> /// 计算给定的时期（不超过现在的时间）到现在过去了多久 /// </summary> public static string CalDateDeltaFromNow(DateTime dateTime) { TimeSpan timeSpan = DateTime.Now - dateTime; if(timeSpan.Days == 0) { return "今天"; } else if(timeSpan.Days < 7) { return timeSpan.Days + "天前"; } else if (timeSpan.Days < 30) { return timeSpan.Days / 7 + "周前"; } else if (timeSpan.Days < 365) { return timeSpan.Days / 30 + "月前"; } else { return timeSpan.Days / 365 + "年前"; } } /// <summary> /// 合并相同类型的道具 /// </summary> public static List<Prop> MergePropList(List<Prop> propList) { if(propList.Count <= 1) { return propList; }         Dictionary<int, int> keyValuePairs = new Dictionary<int, int>(); foreach(Prop ownedPropData in propList) { if (keyValuePairs.ContainsKey(ownedPropData.id)) {                 keyValuePairs[ownedPropData.id] += ownedPropData.num; } else {                 keyValuePairs.Add(ownedPropData.id, ownedPropData.num); } }         List<Prop> mergedPropList = new List<Prop>(); foreach(KeyValuePair<int,int> keyValuePair in keyValuePairs) {             mergedPropList.Add(new Prop(keyValuePair.Key, keyValuePair.Value)); } return mergedPropList; } /// <summary> /// 计算当前等级还需要多少经验才能升级 /// </summary> public static float CalNeededExp(int lv) { return 50.0f + lv * 50.0f; } } 

数据配置

除了用户数据以外的所有游戏数据都通过Json文件配置，Json文件的解析使用JSONObject插件，Asset Store里可免费下载，具体操作详见插件内说明（这个其实稍微用用就会了）。

资源加载

所有需要热更的资源都使用Addressables提供的方法加载（注：Addressables是对AssetBundle的封装，后面介绍热更的时候会详细说明），其余的直接在Inspector上引用。由于Addressables已经弃用了同步加载的方式故以后都需要通过异步的方式加载资源，这里可以选择使用回调或者异步/等待的方式（这里我选择了后面一个，因为用起来更方便点），下面是异步/等待方法的示例：

private async void LoadAsset(){ //这里T表示资源的类型，AssetName里对应Addressables里存的资源的名称（即地址） T asset = await Addressables.LoadAssetAsync<T>("AssetName").Task; } 

注意：一旦使用了异步/等待的操作需要十分小心代码的执行顺序。

用户数据操作

所有对用户数据的操作（读写）都封装在DataBase类里，对外提供相应操作的静态方法（因为不需要实例他），外部不直接访问用户数据对象（UserData）。此外用户数据使用序列化存储，反序列化读取。同时DataBase类还负责游戏数据的初始化工作和提供读取Json文件数据的方法。

场景异步加载

将需要跳转的场景名称先存在一个静态变量里，然后同步跳转到“场景加载中”的场景（这个场景里包含的东西很少，所以直接同步跳转速度也很快），在这个场景里异步加载真正需要跳转的场景（即之前在静态变量里存的场景名称）。这里如果要做一个加载的进度条的话需要注意获得到的加载进度最大只能到0.9，并且加载的进度只能导出程序后才能真正获取到，编辑器下运行会从0直接跳到0.9。

UI界面数据的显示与更新

这块是基于开头讲到的事件的监听与广播做的，下面举其中一个例子（其他地方都大同小异）：

上面两张图里分别是在主界面中和背包中用户金币和钻石数量的显示，他们的数据来源都相同，但控制显示的方法位于两个不同的脚本中，这时候利用事件的监听和广播就能很好的解耦。首先在主界面显示用户数据的脚本中定义一个更新数据显示的方法：

 public async void UpdateUserData() { ...... //钻石数量的显示         crystal.text = DataBase.GetCrystalNum().ToString(); //金币数量的显示         gold.text = DataBase.GetGoldNum().ToString(); ...... } 

然后将这个方法添加到事件监听中去（当然还得加上移除的代码，因为事件的监听和广播是全局的）：

 //这里定义了一个事件码（EvenType）UpdateUserInfo，用于统一更新用户的数据信息 private void Start() {         EventCenter.AddListener(Wzb.EventType.UpdateUserInfo, UpdateUserData); UpdateUserData(); } private void OnDestroy() {         EventCenter.RemoveListener(Wzb.EventType.UpdateUserInfo, UpdateUserData); } 

背包里显示的代码和上面类似，最后当需要更新用户数据的显示时只需调用以下代码即可：

EventCenter.Broadcast(Wzb.EventType.UpdateUserInfo); 

其他类似的情况都可以这么处理，这样既保证了单一原则又做到了高度解耦。

道具系统

首先需要定义道具的数据结构，我们的道具目前一共分为4类，类别0表示恢复药剂，类别1表示功能道具，类别2表示材料，类别3表示人格碎片（即角色碎片），以下为每类的数据结构（金币和钻石作为特殊的道具也一并放入其中，只不过没有类别，并且id为负数；xxxFileName表示相应资源的文件名（地址））：
·特殊的道具（目前只有金币和钻石）

·恢复药剂

·功能道具

·材料

·人格碎片

然后我们就能愉快的使用道具了（并不是），为了减少数据的冗余，用户数据里道具这部分只需存储相应的id和num就行了，具体要用到某个道具时通过DataBase读取详细的道具信息。

//因为要用序列化保存用户数据所以自定义的类要添加可序列化的标记，其他类似的类同理 [Serializable] public class Prop { //这里其实可以用属性封装一下但感觉也没啥用就懒得改了 public int id; public int num; public Prop(int id,int num) { this.id = id; this.num = num; } } 

背包系统

我们的背包长这个样子：

主要功能为物体分类显示、道具使用、丢弃、出售和放入仓库/背包（最后这个设定是因为背包有容量上限，目前设定是如果超出背包的容量上限则把超出部分的道具转发到系统邮件里，此时玩家需要清理一下背包空出位置才能将邮件里的道具取出来），下面详细介绍一下具体的功能实现：
首先是背包里道具的读取，这个目前的设定是按照格子的排列顺序依次按索引读取，道具信息的更新同样采用【UI界面数据的显示与更新】中的方法（后面涉及到类似的功能时就不再赘述了），每个格子对应的脚本都存有当前的道具信息，该脚本内容如下：

using UnityEngine; using UnityEngine.UI; using UnityEngine.AddressableAssets; public class PropInBag : MonoBehaviour { public Prop ownedPropData; public Image icon; public Text num; public static PropPos propPos; public static PropPos toPos; private void Start() {         EventCenter.AddListener(Wzb.EventType.UpdatePropInfo, UpdateInfo); UpdateInfo(); } private void OnDestroy() {         EventCenter.RemoveListener(Wzb.EventType.UpdatePropInfo, UpdateInfo); } public async void UpdateInfo() { if(ItemClassification.instance == null) { //在所有拥有的道具中依次按索引取出             ownedPropData = DataBase.GetOwnedPropByIndex(transform.GetSiblingIndex(), propPos); } else { //在筛选了的道具中依次按索引取出             ownedPropData = DataBase.GetOwnedPropByIndex(transform.GetSiblingIndex(),                             ItemClassification.instance.classTags, propPos); } if (ownedPropData != null) { //这里是因为显示num的文本还有个背景，下同                    num.transform.parent.gameObject.SetActive(true);             num.text = ownedPropData.num.ToString();              icon.gameObject.SetActive(true);             icon.sprite = await Addressables.LoadAssetAsync<Sprite> (DataBase.GetPropInfoById(ownedPropData.id)["iconFileName"].str).Task; } else {             icon.gameObject.SetActive(false);             icon.sprite = null; //没有道具信息时需要把num的背景给隐藏了             num.transform.parent.gameObject.SetActive(false);             num.text = ""; } } } 

道具信息的变量为引用类型，保证了不同地方访问到的都是相同的数据，其他的说明见注释（代码也很简单）。
分类显示使用的是Toggle ，也都是些基本的用法，代码如下：

using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; public class ItemClassification : MonoBehaviour { public static ItemClassification instance; public List<Toggle> toggles; public List<int> classTags; private void Awake() {         instance = this;         classTags = new List<int>(); for (int i = 0; i < toggles.Count; i++) { if (toggles[i].isOn) {                 classTags.Add(i); } } } public void UpdateItems(Toggle toggle) { int classTag = toggles.IndexOf(toggle); if(classTag >= 0) { if (toggle.isOn) {                 classTags.Add(classTag); } else {                 classTags.Remove(classTag); } }         EventCenter.Broadcast(Wzb.EventType.UpdatePropInfo); } } 

每次触发勾选事件时会广播道具信息更新的事件用来更新道具的显示。
使用、丢弃、出售和放入仓库/背包的具体逻辑也比较简单就不详细介绍了。然后由于前面那些操作需要显示数量确认的界面（如下图所示），

确认数量的代码如下：

using System; using UnityEngine; using UnityEngine.AddressableAssets; using UnityEngine.UI; //执行的操作类型 public enum CBType {     出售,     使用,     丢弃,     确认, } public class PropConfirmation : MonoBehaviour { public Text ok; public Text tip; public Text maxNum; public Slider slider; public Text currentNum; public Image propIcon; private CBType cbType; private Action<int> callback; private JSONObject propInfo; // Start is called before the first frame update public async void Open(CBType cbType, int num,JSONObject propInfo, Action<int> callback) { this.cbType = cbType; //确认后执行的方法使用Action委托封装，使得代码更加灵活 this.callback = callback; this.propInfo = propInfo; switch (cbType) { //出售的话还需要额外显示当前总的售价 case CBType.出售: {                     tip.text = "总价：" + propInfo["price"].n; break; } default: {                     tip.text = ""; break; } }         ok.text = cbType.ToString(); //这里由于确认界面的UI和背包的UI处于同一个Canvas下，而这两个的适配方式不一样（确认界面的UI比较特殊），所以需要单独适配 float rate = 0.5f * Screen.width / Screen.height; Vector2 newSize = GetComponent<RectTransform>().sizeDelta; if (rate > 1.0f) {             newSize.x *= rate; } else {             newSize.y /= rate; } GetComponent<RectTransform>().sizeDelta = newSize;              maxNum.text = num.ToString();         slider.maxValue = num;         slider.value = 0;         gameObject.SetActive(true);          propIcon.sprite = await Addressables.LoadAssetAsync<Sprite> (propInfo["iconFileName"].str).Task; } public void Cancel() { SetCallback(0); } public void Confirm() { SetCallback((int)slider.value); } private void SetCallback(int num) { callback(num);         gameObject.SetActive(false); } public void UpdateCurrentSliderNum() {         currentNum.text = slider.value.ToString(); switch (cbType) { case CBType.出售: { float totalPrice = slider.value * propInfo["price"].n;                     tip.text = "总价：" + totalPrice; break; } } } } 

一些重点已在注释里说明，这里关键点在于使用Action委托增加代码的灵活性（因为刚刚那些操作所需要的参数都相同所以才能用Action）。
最后由于是手游所以没有加移动道具位置的功能（明日方舟的仓库里的道具也是固定好位置的），感觉加了用处也不大，现在是按照道具获取的先后顺序依次排列的。

任务系统

邮件系统

消息提示

输入系统

角色操作

相机控制

Buff系统

游戏设置

对话系统

自定义UI交互反馈

美术资源的热更