毕设总结分析
历经三个多月，终于将毕设完成并成功通过答辩，有了时间正好将我的毕设分析与总结一番。
虚拟校园养成游戏开发
项目结构的分析
项目结构分为两部分，一部分是Framework文件用于存储框架，另外一部分是Application用于系统的主要数据。
Framework部分
这一部分有四部分代码分别是Model、Controller、View、MVC。
Model存储数据
Controller存储命令
View 存储视图
MVC 提供给外界接口(外观模式)
Model层的代码与分析
/// Controller层的代码与分析
public abstract class Controller
{
public abstract void Execute(object param);//Execute-执行
}
分析：
该类作为Controller类，其中Execute方法是后续派生类都需执行的方法
View层
public abstract class View : MonoBehaviour//视图类才会继承MOnoBehavior
{
public abstract string Name { get; }//名字
public IList<string> interestedEvents;//事件列表
public abstract IList<string> GetInterestedEvents();//用字符串代替事件,得到事件
public abstract void HandleEvents(string eventName, object eventParam);//处理程序
}
分析：
1、继承MonoBehaviour可以避免重复继承
2、 public abstract string Name { get; }//名字
该字段用于继承View类后派生类识别字段
3、public IList<string> interestedEvents;//事件列表
用string字符串的方式将相应的事件保存在数组当中
4、public abstract IList<string> GetInterestedEvents();//用字符串代替事件,得到事件
通过string字符串转换为相应事件
5、 public abstract void HandleEvents(string eventName, object eventParam);//处理程序
eventName——事件的字段名
eventParam——事件传入数据
该方法执行相应的传入的字段名与数据，执行后面的程序。
MVC层
/// (view.GetInterestedEvents());
view.interestedEvents = view.GetInterestedEvents();//IList，获得事件
}
//获取模型
public T GetModel<T>()
where T : Model
{
foreach (Model m in models.Values)
{
if (m is T)
return (T)m;
}
return null;
}
//获取视图
public T GetView<T>()
where T : View
{
foreach (View v in views.Values)
{
if (v is T)
return (T)v;
}
return null;
}
//发送事件(控制器先响应，视图再响应)
//事件对应的处理者有两种：控制器(View=>controller);View(Model=>View)
//第一部分通过string由View进入Controller执行事件
public void SendEvent(string eventName, object eventParam)
{
//通过输入事件的string后，执行该事件，如果没有该事件，就循环views处理程序
if (ctrls.ContainsKey(eventName))//确定事件的string后，将ctrlType转换为Controller
{
Type ctrlType = ctrls[eventName];
var cb = Activator.CreateInstance(ctrlType) as Controller;
cb.Execute(eventName);//执行该事件
return;
}
foreach (var view in views)
{
if (view.Value.interestedEvents.Contains(eventName))
{
view.Value.HandleEvents(eventName, eventParam);
}
}
}
}
1、 public static MVC instance = new MVC();
private MVC() { }
将MVC单例化处理
过程如下：首先将声明一个公共的静态的MVC类的instance实例，然后通过private私有化MVC的构造函数，实现不让外界调用。
Unity官方提过了一个单例模式
public static MVC instance;
private void Awake()
{
instance = this;
}
Awake是Unity方法生存周期中最先被执行的方法，因此可以用来做单例模式，在游戏运行的最初的时刻便实现单例。
不过这个方法没有主动生成相应的类，如果要使用的话，建议可以改为
public static MVC instance=new MVC();
private void Awake()
{
instance = this;
}
这样就避免后续在主逻辑进行生成相应的MVC类
2、
//用字典存储MVC
public Dictionary<string, View> views = new Dictionary<string, View>();
public Dictionary<string, Model> models = new Dictionary<string, Model>();
public Dictionary<string, Type> ctrls = new Dictionary<string, Type>();//命令没有实体
上述的三个字典是用于Model、View、Controller的存储，通过string作为主键存储相应的数据。
字典的好处：字典便于数据的读取与更改
缺点：字典是无序的，如果进行一些排序操作，性能消耗会很大
3、
/// (view.GetInterestedEvents());
view.interestedEvents = view.GetInterestedEvents();//IList，获得事件
}
该方法用于注册视图
逻辑如下：
输入View类的view对象作为参数，通过ContainKey()方法判断字典中是否存在该视图，若存在便返回，不存在便将该视图存入views字典当中。
view.interestedEvents=view.GetInterestedEvents();获得View中的事件。
5、
//获取
public T GetModel<T>()
where T : Model
{
foreach (Model m in models.Values)
{
if (m is T)
return (T)m;
}
return null;
}
public T GetView<T>()
where T : View
{
foreach (View v in views.Values)
{
if (v is T)
return (T)v;
}
return null;
}
这两个方法是用于获取模型与视图，并通过泛型增强的方法的复用性。
6、
//发送事件(控制器先响应，视图再响应)
//事件对应的处理者有两种：控制器(View=>controller);View(Model=>View)
//第一部分通过string由View进入Controller执行事件
public void SendEvent(string eventName, object eventParam)
{
//通过输入事件的string后，执行该事件，如果没有该事件，就循环views处理程序
if (ctrls.ContainsKey(eventName))//确定事件的string后，将ctrlType转换为Controller
{
Type ctrlType = ctrls[eventName];
var cb = Activator.CreateInstance(ctrlType) as Controller;
cb.Execute(eventName);//执行该事件
return;
}
foreach (var view in views)
{
if (view.Value.interestedEvents.Contains(eventName))
{
view.Value.HandleEvents(eventName, eventParam);
}
}
}
}
该方法是MVC类的核心方法，用于逻辑的执行
逻辑如下：
第一部分，判断输入的字符串，获得该字符串所标志的命令(Controller类)，然后执行该类中的方法。
第二部分，循环views字典，通过view中的name确定相应的视图，然后执行该视图中的HandleEvent()方法。
背包模块
背包模块按照框架同样分为三部分
不过背包模块部分较为复杂，这里按照背包的具体功能进行分析。
1、背包创建与初始化
Model层
[Serializable]
public class BagPanel : Model
{
public static BagPanel instance;
private void Awake()
{
instance = this;
}
public override string Name
{
get { return "BagPanel"; }
}
public void OnBagPanel()
{
MVC.instance.SendEvent("OpenBagPanel", null);
}
}
Controller层
public class BagController : Controller
{
public override void Execute(object param)
{
MVC.instance.RegisterModel(new BagPanel());
Model mb = MVC.instance.models["BagPanel"];
BagPanel bp = mb as BagPanel;
bp.OnBagPanel();
}
}
View层
public class BagPanelView : View
{
public override string Name
{
get { return "BagPanelView"; }
}
public override IList<string> GetInterestedEvents()
{
return new string[] {
"OpenBagPanel",
};
}
public override void HandleEvents(string eventName, object eventParam)
{
switch (eventName)
{
case "OpenBagPanel":
{
this.gameObject.SetActive(true);
}
break;
}
}
代码分析：
1、通过MVC中的SendEvent方法传入参数。
例如、SendEvent("BagOPenEvent",null)方法
注意，需要提前注册响应的BagOPenEvent命令
例如，
MVC.instance.RegisterController("BagOPenEvent", typeof(BagController));
该方法以“BagOpenEvent”为字符串，通过typeof方法返回BagController类型对象
tip：typeof运算符返回作为其参数的任何类型的System.Type对象。
2、MVC中的SendEvent方法通过string得到BagController类的对象，并执行其中的Execute()方法。
3、BagController类中，在Execute()方法中先是注册了BagPanel模型，然后执行BagPanel中的OnBagPanel()方法。
4、OnBagPanel()方法中通过MVC中的SendEvent方法传入相应的BagView视图层中的事件字符串
5、MVC在判断所输入的参数非是Controller类，便会循环Views，从views中得到的view会再次通过Contains()方法确认输入的字段是否为该视图所拥有的事件字段。
当然循环Views前，也需要提前注册相应的View视图。
例如
MVC.instance.RegisterView(transform.Find("/GameRoot/Canvas/BagPanel").GetComponent<BagPanelView>());
这里有一个小知识点，Hierarchy层中没有启动的游戏物体，无法通过GameObjec.Find()获取，只能通过Transform获得，这是由于每一个游戏物体中必定都有transform组件。
6、在确认输入的参数为BagPanelView视图所拥有的事件后，SendEvent()方法便会执行BagPanelView类中的HandleEvents()方法处理该事件字符串所代表的处理程序。
7、在HandleEvents()方法中，使用Switch方法，在事件列表中确认“OpenBagpanel”事件字符串，然后启动this.gameObject.SetActice(true)方法，让背包显示。
switch (eventName)
{
case "OpenBagPanel":
{
this.gameObject.SetActive(true);
}
break;
}
2、背包物品的加载
Model层
[Serializable]
public class BagPanel : Model
{
[SerializeField]
private List<UsingItem> items = new List<UsingItem>();
public List<UsingItem> Items
{
get
{
return items;
}
set
{
items = value;
}
}
public void Load()
{
string fileName = Application.persistentDataPath + "\\bag.json";//获得文件路径
string s = File.ReadAllText(fileName);//读取所有数据送到json格式的字符串里面。
JsonUtility.FromJsonOverwrite(s, this);
}
public void ItemUpdate()
{
MVC.instance.SendEvent("BagItemLoad",null);
}
//删除数据
public void DeleteBag()
{
string fileName = Application.persistentDataPath + "\\bag.json";
File.Delete(fileName);
}
//保持数据
public void Save()
{
string s = JsonUtility.ToJson(this);//将Items的数据写成J转换为JSON并用字符串保持。
//Debug.Log(s);
File.WriteAllText(Application.persistentDataPath + "\\bag.json", s);//创建一个新的文本，并将JSON文件写入
}
}
Controller层
public class BagLoadController : Controller
{
public override void Execute(object param)
{
MVC.instance.RegisterModel(new BagPanel());
Model mb = MVC.instance.models["BagPanel"];
BagPanel bp = mb as BagPanel;
bp.Load();
}
}
View层
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class BagPanelView : View
{
public GameObject bagItemPrefab;
public Transform transContent;
public override string Name
{
get { return "BagPanelView"; }
}
public void Start()
{
MVC.instance.SendEvent("BagLoadEvent", null);
MVC.instance.SendEvent("ItemUpdateEvent", null);
}
public override IList<string> GetInterestedEvents()
{
return new string[] {
"OpenBagPanel",
"BagItemLoad"
};
}
public override void HandleEvents(string eventName, object eventParam)
{
switch (eventName)
{
case "OpenBagPanel":
{
this.gameObject.SetActive(true);
MVC.instance.SendEvent("ItemUpdateEvent", null);//背包物品加载
}
break;
case "BagItemLoad":
{
transContent = transform.Find("BagShow/Viewport/Content");
for (int i = 0; i < transContent.childCount; i++)//清空所有子对象
{
Destroy(transContent.GetChild(i).gameObject);//注意transform是不能删除的，要删只能删除整个对象
}
var bag = MVC.instance.GetModel<BagPanel>();//获得背包
foreach (var item in bag.Items)
{
var goItem = Instantiate(bagItemPrefab);
goItem.transform.SetParent(transContent);
//Debug.Log("背包物品");
goItem.GetComponent<BagItem>().SetItemData(item);
}
}
break;
}
}
}
}
代码分析：
1、在通过SendEvent()方法执行到BagLoadController类后，该类注册到BagPanel中的Load()方法。
Load()方法分析
public void Load()
{
string fileName = Application.persistentDataPath + "\\bag.json";//获得文件路径
string s = File.ReadAllText(fileName);//读取所有数据送到json格式的字符串里面。
JsonUtility.FromJsonOverwrite(s, this);
}
(1)获得系统的使用bag.json文件储存的数据，将其中的数据读取出来，实现背包的物品数据的初始化。
首先获得bag.json的文件路径，使用fileName保存为字符串字段
(2)使用File.ReadAllText()方法读取fileName字段中保存的bag.json文件，并通过string保存下来。
(3)使用JsonUtility.FromJsonOverwrite(s,this);,将具有json格式的字符串更新至BagPanel中的item数组当中。
JsonUnitiliy有3个方法：
第一个方法： public static string ToJson(object obj, bool prettyPrint);
作用：对象的序列化。即将对象转换成一个json字符串，并返回该字符串。
第一个参数为要转换的对象
第二个参数可以省略，省略时默认为false。关于作用，建议将自己的json打印到屏幕就可以一目了然。
第二个方法 ：public static T FromJson(string json);
作用：对象的反序列化。即将一个json字符串转换成一个对象，并返回对象。
参数为json。
第三个方法：public static void FromJsonOverwrite(string json, object objectToOverwrite);
作用：类似于第二个方法，第二个方法是将json转换成对象，并返回该对象，在该过程中需要创建一个新对象。
而这个方法，是将一个json的内容去覆盖或者说更新一个对象，过程中没有创建新的对象。这样会更加节省内存。
第一个参数是一个json
第二个是要被第一个参数去更新或者覆盖的对象。
该类中同时还具有Save()、Delete()方法用于删除和保存数据
//删除数据
public void DeleteBag()
{
string fileName = Application.persistentDataPath + "\\bag.json";
File.Delete(fileName);
}
//保持数据
public void Save()
{
string s = JsonUtility.ToJson(this);//将Items的数据写成J转换为JSON并用字符串保持。
//Debug.Log(s);
File.WriteAllText(Application.persistentDataPath + "\\bag.json", s);//创建一个新的文本，并将JSON文件写入
}
2、在背包数据读取后，执行背包数据更新的方法
MVC.instance.SendEvent("ItemUpdateEvent", null);
背包更新在背包打开后更新，在物品发生改变后也需要更新。
注意物品更新是在BagView视图中实现的。
更新方法
case "BagItemLoad":
{
transContent = transform.Find("BagShow/Viewport/Content");
for (int i = 0; i < transContent.childCount; i++)//清空所有子对象
{
Destroy(transContent.GetChild(i).gameObject);//注意transform是不能删除的，要删只能删除整个对象
}
var bag = MVC.instance.GetModel<BagPanel>();//获得背包
foreach (var item in bag.Items)
{
var goItem = Instantiate(bagItemPrefab);
goItem.transform.SetParent(transContent);
//Debug.Log("背包物品");
goItem.GetComponent<BagItem>().SetItemData(item);
}
}
break;
（1）通过transform.Find("BagShow/Viewport/Content")，找到tranContent即背包视图。
(2)清空tranContent层中所有的子对象，防止背包物品发生更改后，物品数据视图不能发生该有的变化
(3)获得背包，背包中的数据通过循环读取出来，然后生成对应的预制体对象，然后读取相应的数据显示在背包物品当中。
注意：foreach()方法只能读取，不能进行更改。
背包系统，我将其分为两个主要部分，一部分是数据的读取保存，一部分是数据在视图层上的显示。
存档模块
SaveSystem
public class SaveSystem
{
public static void SaveByJson(string saveFileName, object data)
{
var json = JsonUtility.ToJson(data);//将数据转换为JSON
var path = Path.Combine(Application.persistentDataPath, saveFileName);//可以适应多平台路径写法
File.WriteAllText(path,json);//创建一个新的文本，并将JSON文件写入
Debug.Log($"存档成功{path}" );
}
public static T LoadFromJson<T>(string saveFileName)//通过泛型设计方法
{
var path = Path.Combine(Application.persistentDataPath, saveFileName);//取得path路径
var json = File.ReadAllText(path);//通过path路径获取文件
var data = JsonUtility.FromJson<T>(json);//将可读的文件转换为JSON文件
return data;
//try
//{
// var json = File.ReadAllText(path);
// var data = JsonUtility.FromJson(json);
// return data;
//}
//catch (System.Exception exception)
//{
// Debug.LogError($"Failed to load data from{path}.\n{exception}");
//}
//return default;
}
public static void DeleteSaveFile(string saveFileName)//删除保存数据
{
var path = Path.Combine(Application.persistentDataPath, saveFileName);//将saveFileName的string与Application.persistentDataPath路径结合在一起
if (File.Exists(path))//检测该路径是否存在
{
File.Delete(path);//删除该路径
}
else
{
Debug.Log("无法删除");
}
}
}
商城系统
public class ShopPanelView : View
{
public GameObject shopItemPrefab;
public Transform transContent;
public Image Tip;
public void Start()
{
transContent= transform.Find("ShopShow/Viewport/Content");
}
public override string Name
{
get { return "ShopPanelView"; }
}
public override IList<string> GetInterestedEvents()
{
return new string[] {
"OpenShopPanel",
"Load"
};
}
public override void HandleEvents(string eventName, object eventParam)
{
switch (eventName)
{
case "OpenShopPanel":
{
for (int i = 0; i < transContent.childCount; i++)//清空所有子对象
{
Destroy(transContent.GetChild(i).gameObject);//注意transform是不能删除的，要删只能删除整个对象
}
this.gameObject.SetActive(true);
MVC.instance.SendEvent("ItemListEvent", null);
MVC.instance.SendEvent("ShopItemLoadEvent", null);
transform.Find("/GameRoot/Canvas/ShopPanel/Tooltip").gameObject.SetActive(false);
}
break;
case "Load":
{
var Shop = eventParam as ShopPanel;
foreach (var item in Shop.Items)
{
var goItem= Instantiate(shopItemPrefab);
goItem.transform.SetParent(transContent);
goItem.GetComponent<ShopItem>().SetItemData(item);
//goItem.GetComponent().OnData(item);
}
}
break;
}
}
public void OnBuyItem()
{
IEnumerable<Toggle> toggles= transContent.gameObject.GetComponent<ToggleGroup>().ActiveToggles();//此方法返回一个开关组中所有可以用foreach遍历的开关的集合
foreach (Toggle t in toggles)
{
if (t.isOn)
{
UsingItem item = t.transform.GetComponent<ShopItem>().item;
//int tq = t.transform.GetSiblingIndex();//取到该物体的游戏序号
if (Player.Money >= item.Price)
{
BuyItem(item);
Player.Money -= item.Price;
}
else
{
Tip.gameObject.SetActive(true);
}
}
}
}
public void BuyItem(UsingItem Item)
{
print(string.Format("准备买入第{0}个物品",Item));
UsingItem usingItem = Item as UsingItem;
MVC.instance.RegisterModel(new BagPanel());
Model mb = MVC.instance.models["BagPanel"];
BagPanel bp = mb as BagPanel;
bp.BuyItem(usingItem);
}
void Update()
{
Text t = transform.Find("/GameRoot/Canvas/提示/Money").GetComponent<Text>();
t.text = string.Format("金钱：{0}", Player.Money);
}
public void OnShowItemTooltip()
{
IEnumerable<Toggle> toggles = transContent.gameObject.GetComponent<ToggleGroup>().ActiveToggles();//此方法返回一个开关组中所有可以用foreach遍历的开关的集合
foreach (Toggle t in toggles)
{
if (t.isOn)
{
UsingItem item = t.transform.GetComponent<ShopItem>().item;
//int tq = t.transform.GetSiblingIndex();//取到该物体的游戏序号
ShowItemTooltip(item);
}
}
}
public void ShowItemTooltip(UsingItem Item)
{
print(string.Format("准备显示第{0}个物品", Item));
Tooltip.instance.Show(Item.ItemId, Resources.Load<Sprite>(Item.Path));
}
public void OnExit()
{
this.gameObject.SetActive(false);
Tip.gameObject.SetActive(false);
}
}
public class ShopPanel : Model
{
public static ShopPanel instance;
void Awake()
{
instance = this;
}
public override string Name
{
get { return "ShopPanel"; }
}
public void OnShopPanel()
{
MVC.instance.SendEvent("OpenShopPanel", null);
}
[SerializeField]
private List<UsingItem> items = new List<UsingItem>();
public List<UsingItem> Items
{
get
{
return items;
}
set
{
items = value;
}
}
public void Load()
{
var ShopItem = new ShopPanel();
ShopItem.Items.Add(new UsingItem(0, 1, 200, "德之书", null, "Book"));
ShopItem.Items.Add(new UsingItem(1, 2, 200, "智之书", null, "Book"));
ShopItem.Items.Add(new UsingItem(2, 3, 200, "体之书", null, "Book"));
ShopItem.Items.Add(new UsingItem(3, 4, 200, "美之书", null, "Book"));
ShopItem.Items.Add(new UsingItem(4, 4, 200, "劳之书", null, "Book"));
MVC.instance.SendEvent("Load",ShopItem);
}
public List<UsingItem> Datatt()
{
List<UsingItem> shItems = new List<UsingItem>();
shItems.Add(new UsingItem(0, 1, 200, "德之书", "传自思政老师的宝书，使用后可以增加一点德行", "Book"));
shItems.Add(new UsingItem(1, 2, 200, "智之书", "传自高数老师的宝书，传说中数学可以启迪人类，使用后可以增加一点智力", "Book"));
shItems.Add(new UsingItem(2, 3, 200, "体之书", "传自体育老师的武术秘籍，虽然无法让你成为一位武林高手，但却能让你更加耐打，使用后可以增加一点体能", "Book"));
shItems.Add(new UsingItem(3, 4, 200, "美之书", "传自美术老师的绘画本，帮助你认识美，感受美，使用后可以增加一点美值 ","Book"));
shItems.Add(new UsingItem(4, 4, 200, "劳之书", "传自班主任的点名本，劳动人民最光荣，使用后可以增加一点劳值", "Book"));
return shItems;
}
public UsingItem FindUsingItemByID(int id)
{
for (int i = 0; i < Datatt().Count; i++)
{
if (id == Datatt()[i].ItemId)
{
return Datatt()[i];
}
}
return null;
}
}
public class ShopController : Controller
{
public override void Execute(object param)
{
MVC.instance.RegisterModel(new ShopPanel());
Model mb = MVC.instance.models["ShopPanel"];
ShopPanel sp = mb as ShopPanel;
sp.OnShopPanel();
}
}
public class Tooltip : MonoBehaviour
{
public static Tooltip instance;
public Image icon;
public Text itemName, type, price ,propText, desc;
private CanvasGroup cg;
private void Awake()
{
instance = this;
gameObject.SetActive(false);
}
public void Show(int id, Sprite sprite)
{
this.gameObject.SetActive(true);
UsingItem item= MVC.instance.GetModel<ShopPanel>().FindUsingItemByID(id);
icon.sprite = sprite;
itemName.text = string.Format("物品名字：{0}",item.Name);
type.text = string.Format("类型：{0}",item.GetType().Name) ;//通过反射取得类名
price.text = string.Format("价格：{0}", item.Price.ToString());
desc.text = item.Des;
}
}
public class ShopItem : MonoBehaviour
{
public int id;
public Image sp;
public UsingItem item;
public ToggleGroup tg;
public Image checkmark;
public void Start()
{
tg = transform.Find("/GameRoot/Canvas/ShopPanel/ShopShow/Viewport/Content").gameObject.GetComponent<ToggleGroup>();
checkmark = gameObject.transform.Find("Checkmark").GetComponent<Image>();
AddCom();
}
public void AddCom()
{
if (!gameObject.GetComponent<Toggle>())
{
gameObject.AddComponent<Toggle>();
Toggle toggle = gameObject.GetComponent<Toggle>();
toggle.graphic = checkmark;
toggle.group = tg;
}
}
public void SetItemData(UsingItem item)
{
this.item = item;
id = item.ItemId;
var itemInfo = MVC.instance.GetModel<ItemList>().GetItem(item.ItemId);
//transform.Find("Name").GetComponent().text = itemInfo.Name.ToString();
transform.Find("Price").GetComponent<Text>().text = item.Price.ToString();
//transform.Find("Count").GetComponent().text = item.Count.ToString();
transform.Find("Icon").GetComponent<Image>().sprite = Resources.Load<Sprite>(item.Path);
}
}
以上便是我整个毕设比较重要的内容，由于时间有点久，一些细节已经有些记不住了，不过主要架构基本就这些了。