游戏框架（框架入门篇）

《游戏框架》

##《游戏框架》发布说明：

++++“游戏框架”还是“游戏架构”，立钻哥哥还是以“游戏框架”来命名这个主题吧。

++++“游戏框架”作为整个游戏的框架，具有核心的地位，一个游戏的层次和后期维护性就取决于游戏框架。

++++《游戏框架》当然也是一个探索篇，作为这个分类的第一篇博文，还是先探索一段时间，后期根据需要再推出一个精品博文。

====>立钻哥哥带您学游戏框架。

##《游戏框架》目录：

#第一篇：框架入门篇

#第二篇：框架夯实篇

#第三篇：框架实战篇

#第四篇：框架进阶篇

#第五篇：框架高级实战篇

#第六篇：立钻哥哥带您学框架

#第一篇：框架入门篇

++第一篇：框架入门篇

++++第一章：框架概述

++++第二章：UI框架

++第一章：框架概述

++++1.1、Unity3D游戏客户端基础框架

++++1.2、立钻哥哥带您学游戏框架

###1.1、Unity3D游戏客户端基础框架

++1.1、Unity3D游戏客户端基础框架

++++一些通用的基础系统的框架搭建，其中包括：

--UI框架（UGUI+MVC）

--消息管理（Message Manager）

--网络层框架（Socket + Protobuf）

--表格数据（Protobuf）

--资源管理（Unity5.x的AssetBundle方案）

--热更框架（tolua）

++1.1.1、UI框架

++++编写UI框架的意义：

--打开、关闭、层级、页面跳转等管理问题集中化，将外部切换等逻辑交给UIManager处理。

--功能逻辑分散化，每个页面维护自身逻辑，依托于框架便于多人协同开发，不用关心跳转和显示关闭细节。

--通用性框架能够做到简单的代码复用和“项目经验”沉淀。

++++基于Unity3D和UGUI实现的简单的UI框架，实现内容：

--1、加载、显示、隐藏、关闭页面，根据标示获得相应界面实例；

--2、提供界面显示隐藏动画接口；

--3、单独界面层级，Collider，背景管理；

--4、根据存储的导航信息完成界面导航；

--5、界面通用对话框管理；

--6、便于进行需求和功能扩展；

++1.1.2、消息管理（Message Manager）

++++一个消息系统的核心功能：

--一个通用的事件监听器；

--管理各个业务监听的事件类型（注册和解绑事件监听器）；

--全局广播事件；

--广播事件所传参数数量和数据类型都是可变的（数量可以是0~3，数据类型是泛型）

++++消息管理设计思路：在消息系统初始化时将每个模块绑定的消息列表，根据消息类型分类（用一个string类型的数据类标识），即建立一个字典Dictionary<string, List<Model>>：每条消息触发时需要通知的模块列表：某条消息触发，遍历字典中绑定的模块列表。

++1.1.3、网络层框架（NetworkManager）

++++除了单机游戏，限制绝大多数的网游都是以强联网的方式实现的，选用Socket通信可以实时地更新玩家状态。

++++选定了联网方式后，还需要考虑网络协议定制的问题，Protobuf无疑是个比较好的选择，一方面是跨平台特性好，另一方面是数据量小可以节省通信成本。

++++Socket通信：联网方式、联网步骤，数据收发以及协议数据格式。（加入线程池管理已经用一个队列来管理同时发起的请求，让Socket请求和接收异步执行，基本的思路就是引入多线程和异步等技术。）

++++Protobuf网络框架主要用途是：数据存储（序列化和反序列化），功能类似xml和json等；制作网络通信协议等。（Protobuf不仅可以进行excel表格数据的导出，还能直接用于网络通信协议的定制。）

++++Protobuf是由Google公司发布的一个开源的项目，是一款方便而又通用的数据传输协议。（在Unity中可借助Protobuf来进行数据存储和网络协议两方面的开发。）

++1.1.4、表格数据

++++在游戏开发中，有很多数据是不需要通过网络层从服务器拉取下来的，而是通过表格配置的格式存储在本地。

++++游戏中的一个道具，通常服务器只下发该道具的ID（唯一标识）和LV（等级），然后客户端从本地数据中检索到该道具的具体属性值。（通常使用Excel表格来配置数据，可以使用Protobuf、JSON、XML等序列化和反序列化特性对表格数据转化。）

++1.1.5、资源管理（AssetBundle）

++++AssetBundle是Unity引擎提供的一种资源压缩文件，文件扩展名通常为unity3d或assetbundle。

++++对于资源的管理，其实是为热更新提供可能，Unity制作游戏的资源管理方式就通过AssetBundle工具将资源打成多个ab包，通过网络下载新的ab包来替换本地旧的包，从而实现热更的目的。

++++AssetBundle是Unity编辑器在编辑环境创建的一系列的文件，这些文件可以被用在项目的运行环境中。（包括的资源文件有：模型文件（models）、材质（materials）、纹理（textures）和场景（scenes）等。）

++++Editor打包AssetBundle：

//立钻哥哥：Editor打包AssetBundle

[MenuItem(“Assets/Build AssetBundles”)]

static void BuildAllAssetBundles(){

    BuildPipeline.BuildAssetBundles(Application.dataPath + “/AssetBundles”, BuildAssetBundleOptions.None, BuildTarget.StandaloneOSXIntel);

}

++1.1.6、热更新框架（tolua）

++++使用C#编写底层框架，使用lua编写业务逻辑，这是业内最常见的设计方式，还有一个非常成熟的热更新框架tolua。

++++通常可热更新的有：图片资源、UI预制和lua脚本，而处于跨平台的考虑，C#脚本是不允许进行热更的。

##第二章：UI框架

++第二章：UI框架

++++2.1、MVC

++++2.2、UIBase

++++2.3、UIManager

++++2.4、ResourceManager

++++2.5、Defines

++++2.6、Singleton

++++2.7、SingletonException

++++2.8、DDOLSingleton

++++2.9、GameController

++++2.10、CoroutineController

++++2.11、StartGame

++++2.12、TestOne

++++2.13、TestTwo

++++2.14、BaseController

++++2.15、BaseModel

++++2.16、BaseModule

++++2.17、ModuleManager

++++2.18、Message

++++2.19、MessageCenter

++++2.20、MessageType

++++2.21、EventTriggerListener

++++2.22、MethodExtension

++++2.23、TestOneModule

++++2.24、PropertyItem

++++2.25、IDynamicProperty

++++2.26、BaseActor

++++2.27、BaseScene

++++2.28、SceneManager

++++2.29、MailUI

++++2.30、MailRewardUI

++++2.31、MailModule

++++2.32、MailData

++++2.33、立钻哥哥带您学UI框架。

++UI框架前言

++++前端开发中实际上大量的编码工作都在UI编码上，基本上占前端编码的70%左右。一个良好的UI框架决定了前端的开发效率和后期的维护成本。

++UI框架涉及内容

++++1、BaseUI：UI界面的基类，定义了统一的UI功能接口（事件，开关，动画，声音）。

++++2、UIManager：管理UI的管理器，管理是否缓存UI对象，是否需要互斥UI对象，管理一些通用UI。

++++3、ResourceManager资源管理器，资源加载统一管理，资源加载方式选择（同步、异步、本地、AB、ObjPool、....），资源缓存，资源释放。

++++4、Singleton通用单例类的基类。

++++5、BaseModule逻辑模块基类，定义模块的通用功能，处理不同系统的数据逻辑。

++++6、ModuleManager：逻辑模块管理器，管理游戏内所有逻辑的注册注销等。

++++7、自定义事件系统：不同模块直接的通信，模块内界面和数据逻辑分离。

++++8、BaseScene：场景逻辑基类。

++++9、SceneManager： 管理项目所有场景切换，加载等。

++++10、CommonUI：项目中一些通用UI，继承BaseUI可重用UI。

++++11、NetWork：如何在我们的框架中添加网络模块。

###2.1、MVC

###2.1、MVC

++2.1、MVC

++++MVC全名是Model View Controller，是模型（model）-视图（view）-控制器（controller）的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方式组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。

++++【Model（模型）】：是应用程序中用于处理应用程序数据逻辑的部分。（通常模型对象负责在数据库中存取数据。）

++++【View（视图）】：是应用程序中处理数据显示的部分。（通常视图是依据模型数据创建的。）

++++【Controller（控制器）】：是应用程序中处理用户交互的部分。（通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。）

++2.1.1、MVC模式设计流程

++++【抽象Model层】=>【为Model提供一套增删改查的方法】=>【Controller层，把我们的需求（问题）转化成增删改查】=>【将Model层的信息，以一种用户可以接受的形式表现到View层。】

++2.1.2、PureMVC

++++PureMVC是经典MVC设计框架的一个变种：“纯粹的MVC框架”。（是基于MVC模式建立的轻量级应用框架。）

###2.2、BaseUI

###2.2、BaseUI

++2.2、BaseUI

++++UIBase是UI的公共基类。（定义了统一的UI功能接口（事件、开关、动画、声音）等。）

++++Scripts/YanlzFramework/BaseClass/BaseUI.cs

++2.2.1、一个简单UI代码参考（没有BaseUI）

//立钻哥哥：一个简单UI代码参考：一个Panel上点击一个按钮进行Panel切换

using UnityEngine;

using System.Collections;

using UnityEngine.UI;

 

public class TestOne: MonoBehaviour{

    private Button bth;

 

    void Start(){

        btn = transform.Find(“Panel/Button”).GetComponent<Button>();

        btn.onClick.AddListener(OnClickBtn);

    }

 

    private void OnClickBth(){

        GameObject go = Instantiate<GameObject>(Resource.Load<GameObject>”Prefabs/TestTwo”);

        TestTwo testTwo= go.GetComponent<TestTwo>();

        if(null == testTwo){

            testTwo= go.AddComponent<TestTwo>();

        }

 

        Close();

    }

 

    private void Close(){

        Destroy(gameObject);

    }

}

++2.2.1、BaseUI.cs（UI公共基类）

//立钻哥哥：UI的公共基类（Scripts/YanlzFramwork/BaseClass/BaseUI.cs）

using UnityEngine;

using System.Collections;

 

namespace YanlzFramework{

    public abstract class BaseUI : MonoBehaviour{

 

        #region Cache gameObject &transform

        private GameObject _cacheGameObject;

        public GameObject CacheGameObject{

            get{

                if(null == _cacheGameObject){

                    _cacheGameObject = this.gameObject;

                }

 

                return _cacheGameObject;

            }

        }

 

        private Transform _cacheTransform;

        public Transform CacheGameObject{

            get{

                if(null == _cacheTransform){

                    _cacheTransform = this.transform;

                }

 

                return _cacheTransform;

            }

        }

        #endregion

 

        #region EnumObjectState & UI Type

        protected EnumObjectState _state = EnumObjectState.None;

        public event StateChangeEvent StateChanged;

 

        public EnumObjectState State{

            protected get{

                return this._state;

            }

 

            set{

                EnumObjectState oldState = this._state;

                this._state = value;

        

                if(null != StateChanged){

                    StateChanged(this, this._state, oldState);  //立钻哥哥：调用事件

                }

            }

 

            public abstract EnumUIType GetUIType();

 

            #endregion

 

            void Awake(){

                this.State = EnumObjectState.Initial;

                OnAwake();

            }

 

            //Use this for initialization

            void Start(){

                OnStart();

            }

 

            //Update is called once per frame

            void Update(){

                if(this._state == EnumObjectState.Ready){

                    OnUpdate(Time.deltaTime);

                }

            }

 

            public void Release(){

                this.State = EnumObjectState.Closing;

                GameObject.Destroy(this.CacheGameObject);

                OnRelease();

            }

 

            void OnDestroy(){

                this.State = EnumObjectState.None;

            }

 

 

            protected virtual void OnAwake(){

                this.State = EnumObjectState.Loading;

                this.OnPlayOpenUIAudio();    //播放音乐

            }

 

            protected virtual void OnStart(){ }

 

            protected virtual void OnUpdate(float delatTime){ }

 

            protected virtual void OnRelease(){

                this.State = EnumObjectState.None;

                this.OnPlayCloseUIAudio();    //关闭音乐

            }

 

            protected virtual void OnLoadData(){  }

 

            //播放打开界面音乐

            protected virtual void OnPlayOpenUIAudio(){ }

 

            //播放关闭界面音乐

            protected virtual void OnPlayCloseUIAudio(){ }

 

            protected virtual void SetUI(params object[] uiParams){

                this.State = EnumObjectState.Loading;

            }

 

            public virtual void SetUIParam(params object[] uiParams){

            }

 

            protected virtual void OnLoadData(){

            }

 

            public void SetUIWhenOpening(params object[] uiParams){

                SetUI(uiParams);

 

                //StartCoroutine(AsyncOnLoadData());    //立钻哥哥：异步加载

               CoroutineController.Instance.StartCoroutine(AsyncOnLoadData());

            }

 

            private IEnumerator AsyncOnLoadData(){

                yield return new WaitForSecond(0);

 

                if(this.State == EnumObjectState.Loading){

                    this.OnLoadData();

                    this.State = EnumObjectState.Ready;

                }

            }

        }

    }

}

###2.3、UIManager

###2.3、UIManager

++2.3、UIManager

++++UIManager：UI管理类。（管理是否缓存UI对象，是否需要互斥UI对象，管理一些通用UI等。）

++++Scripts/YanlzFramework/Manager/UIManager.cs

++2.3.1、UIManager.cs（UI管理类）

//立钻哥哥：UIManager.cs（UI管理类）（Scripts/YanlzFramework/Manager/UIManager.cs）

using System;

 

namespace YanlzFramework{

    public class UIManager : Singleton<UIManager>{

        #region UIInfoData class

        class UIInfoData{

            public EnumUIType UIType{  get;  private set;  }

            public Type ScriptType {  get;  private set;  }

            public string Path{  get;  private set;  }

            public object[] UIParams{  get;  private set;  }

 

            public UIInfoData(EnumUIType _uiType, string _path, params object[] _uiParams){

                this.UIType = _uiType;

                this.Path = _path;

                this.UIParams = _uiParams;

                this.ScriptType = UIPathDefines.GetUIScriptByType(this.UIType);

            }

        }

        #endregion

 

        private Dictionary<EnumUIType, GameObject> dicOpenUIs = null;

 

        private Stack<UIInfoData> stackOpenUIs = null;

 

        public override void Init(){

            dicOpenUIs = new Dictionary<EnumUIType, GameObject>();

            statckOpenUIs = new Stack<UIInfoData>();

        }

 

        //获取指定UI

        public T GetUI<T>(EnumUIType _uiType) where T : BaseUI{

            GameObject _retObj = GetUIObject(_uiType);

            if(_retObj != null){

                return _retObj.GetComponent<T>();

            }

 

            return null;

        }

 

        public GameObject GetUIObject(EnumUIType _uiType){

            GameObject _retObj = null;

            if(!dicOpenUIs.TryGetValue(_uiType, out _retObj)){

                throw new Exception(“立钻哥哥：_dicOpenUIs TryGetValue Failure! _uiType: ” + _uiType.ToString());

            }

 

            return _retObj;

        }

 

        #region Preload UI Prefab By EnumUIType

 

        public void PreloadUI(EnumUIType[] _uiTypes){

            for(int i = 0;  i < _uiTypes.Length;  i++){

                PreloadUI(_uiTypes[i]);

            }

        }

 

        //立钻哥哥：预先加载UI资源

        public void PreloadUI(EnumUIType _uiType){

            string path = UIPathDefines.GetPrefabPathByType(_uiType);

            Resource.Load(path);

            //ResManager.Instance.ResourcesLoad(path);

        }

 

        #endregion

 

        #region Open UI By EnumUIType

 

        //打开界面

        public void OpenUI(EnumUIType[] _uiTypes){

            OpenUI(false, _uiTypes, null);

        }

 

        public void OpenUI(EnumUIType _uiType, params object[] _uiParams){

            EnumUIType[] _uiTypes = new EnumUIType[1];

            _uiTypes[0] = _uiType;

    

            OpenUI(false, _uiTypes, _uiParams);

        }

 

        public void OpenUICloseOthers(EnumUIType[] _uiTypes){

            OpenUI(true, _uiTypes, null);

        }

 

        public void OpenUICloseOthers(EnumUIType _uiType, params object[] _uiParams){

            EnumUIType[] _uiTypes = new EnumUIType[1];

            _uiTypes[0] = _uiType;

    

            OpenUI(true, _uiTypes, _uiParams);

        }

 

        //打开UI

        public void OpenUI(bool _isCloseOthers, EnumUIType[] _uiTypes, params object[] _uiParams){

            //立钻哥哥：Close Other UI

            if(_isCloseOthers){

                CloseUIAll();    //立钻哥哥：关闭其他UI

            }

 

            //push _uiTypes in stack

            for(int i = 0;  i < _uiTypes.Length;  i++){

                EnumUIType _uiType = _uiTypes[i];

                if(dicOpenUIs.ContainsKey(_uiType)){

                    string _path = UIPathDefines.GetPrefabsPathByType(_uiType);

                    stackOpenUIs.Push(new UIInfoData(_uiType, _path, _uiParams));

                }

            }

 

            //Open UI

            if(stackOpenUIs.Count > 0){

                //GameController.Instance.StartCoroutine();    //立钻哥哥：

                CoroutineController.Instance.StartCoroutine(AsynLoadData());

            }

        }

 

        #endregion

 

        private IEnumerator<int> AsyncLoadData(){

            UIInfoData _uiInfoData = null;

            UnityEngine.Object _prefabObj = null;

            GameObject _uiObject = null;

    

            if(stackOpenUIs != null && stackOpenUIs.Count > 0){

                do{

                    _uiInfoData = stackOpenUIs.Pop();

                    _prefabObj = Resource.Load(_uiInfoData.Path);

            

                    if(_prefabObj != null){

                        _uiObject = MonoBehaviour.Instantiate(_prefabObj) as GameObject;

                        BaseUI _baseUI = _uiObject.GetComponent<BaseUI>();

             

                        if(null == _baseUI){

                            _baseUI = _uiObject.AddComponent(_uiInfoData.ScriptType) as BaseUI;

                        }

                

                        if(null != _baseUI){

                            _baseUI.SetUIWhenOpening(_uiInfoData.UIParams);

                        }

                        dicOpenUIs.Add(_uiInfoData.UIType, _uiObject);

                    }

                }while(stackOpenUIs.Count > 0);

            }

 

            yield return 0;

        }

 

        #region Close UI By EnumUIType

 

        public void CloseUIAll(){

            List<EnumUIType> _keyList = new List<EnumUIType> (dicOpenUIs.Keys);

            foreach(EnumUIType _uiType in _keyList){

                GameObject _uiObj = dicOpenUIs[_uiType];

                CloaseUI(_uiType, _uiObj);

            }

            //CloseUI(_listKey.ToArray());   //立钻哥哥：利用数组关闭

 

            dicOpenUIs.Clear();

         }

 

        public void CloseUI(EnumUIType[] _uiTypes){

            for(int i=0;  i <_uiTypes.Length; i++){

                CloseUI(_uiTypes[i]);

            }

        }

 

        public void CloseUI(EnumUIType _uiType, GameObject _uiObj){

            //GameObject _uiObj = GetUIObject(_uiType);

 

            if(null == _uiObj){

                dicOpenUIs.Remove(_uiType);

 

            }else{

                BaseUI _baseUI = _uiObj.GetComponent<BaseUI>();

 

               if(null == _baseUI){

                    GameObject.Destroy(_uiObj);

                    dicOpenUIs.Remove(_uiType);

                }else{

                    _baseUI.StateChanged += CloseUIHandle;  //立钻哥哥：添加委托

                    _baseUI.Release();

                }

            }

        }

 

        private void CloseUIHandle(object sender, EnumObjectState newState, EnumObjectState oldState){

            if(newState == EnumObjectState.Closing){

                   BaseUI _baseUI = sender as BaseUI;

                    dicOpenUIs.Remove(_baseUI.GetUIType());

                    _baseUI.StateChanged -= CloseUIHandle;

            }

        }

 

        #endregion

 

    }

}

###2.4、ResManager

###2.4、ResManager

++2.4、ResManager

++++ResManager：资源管理器，资源加载统一管理。（资源加载方式选择（同步、异步、本地、AB、ObjPool、....），资源缓存，资源释放等。）

++++Scripts/YanlzFramework/Manager/ResManager.cs

++2.4.1、ResManager.cs（资源管理器）（版本2）

//立钻哥哥：ResMananger.cs（资源管理器）（YanlzFramework/Manager.ResManager.cs）

using System;

using UnityEngine;

using System.Collection.Generic;

 

namespace YanlzFramework{

    //立钻哥哥：资源信息

    public class AssetInfo{

        private UnityEngine.Object _Object;

        public Type AssetType{  get;  set;  }

        public string Path{  get;  set;  }

        public int RefCount{  get;  set;  }

        public bool IsLoaded{

            get{

                return null != _Object;

            }

        }

 

        public UnityEngine.Object AssetObject{

            get{

                if(null == _Object){

                    //_Object = Resources.Load(Path);

                    _ResourcesLoad();

                }

 

                return _Object;

            }

        }

 

        public IEnumerator GetCoroutineObject(Action<UnityEngine.Object> _loaded){

            while(true){

                yield return null;

 

                if(null == _Object){

                    //yield return null;

 

                    //_Object = Resources.Load(Path);

                    _ResourcesLoad();

 

                    yield return null;

                }

 

                if(null != _loaded){

                     _loaded(_Object);

                }

 

                yield break;

            }

        }

 

        private void _ResourcesLoad(){

            try{

                _Object = Resource.Load(Path);

                if(null == _Object){

                    Debug.Log(“立钻哥哥：Resources Load Failure! Path: ” + Path);

                }

            }catch(Exception e){

                Debug.Log(e.ToString());

            }

        }

 

        public IEnumerator GetAsyncObject(Action<UnityEngine.Object> _loaded){

            return GetAsyncObject(_loaded, null);

        }

 

        public IEnumerator GetAsyncObject(Action<UnityEngine.Object> _loaded, Action<float> _progress){

            //立钻哥哥：have Object

            if(null != _Object){

                _loaded(_Object);

                yield break;

            }

 

            //Object null. Not Load Resources

            ResourceRequest _resRequest = Resources.LoadAsync(Path);

            while(_resRequest.progress < 0.9){

                if(null != _progress){

                    _progress(_resRequest.progress);

                }

 

                yield return null;

            }

 

            while(!_resRequest.isDone){

                if(null != _progress){

                    _progress(_resRequest.progress);

                }

 

                yield return null;

            }

 

            ///???

            _Object = _resRequest.asset;

            if(null != _loaded){

                _loaded(_Object);

            }

 

            yield return _resRequest;

        }

    }

 

    //立钻哥哥：ResManger：资源管理器

    public class ResManager : Singleton<ResManager>{

        private Dictionary<string, GameObject> dicAssetInfo = null;

 

        public override void Init(){

            //Resources.Load();

            //Resources.LoadAsync();

            //Resources.LoadAll();

            //Resources.LoadAssetAtPath();

            dicAssetInfo = new Dictionary<string, AssetInfo>();

            Debug.Log(“立钻哥哥：ResManager : Singleton<ResManager> Init”);

        }

 

        #region Load Resource & Instantiate Object

 

        public UnityEngine.Object LoadInstance(string _path){

            UnityEngine.Object _obj = Load(_path);

 

            //MonoBehaviour.Instantiate();

            return Instantiate(_obj);

        }

        #endregion

 

        private UnityEngine.Object Instantiate(UnityEngine.Object _obj){

            return Instantiate(_obj, null);

        }

 

        private UnityEngine.Object Instantiate(UnityEngine.Object _obj, Action<UnityEngine.Object> _loaded){

                UnityEngine.Object _retObj = null;

                if(null != _obj){

                    _retObj = MonoBehaviour.Instantiate(_obj);

                    if(null != _retObj){

                        if(null != _loaded){

                            _loaded(_retObj);

                        }else{

                            Debug.LogError(“立钻哥哥：null _loaded.”);

                       }

                       return _retObj;

 

                  }else{

                      Debug.LogError(“立钻哥哥：Error：null Instantiate _retObj.”);

                  }

 

              }else{

                 Debug.LogError(“立钻哥哥：Error：null Resources Load return _obj.”);

             }

        }

 

        #region Load Resource

 

        public UnityEngine.Object Load(string _path){

            AssetInfo _assetInfo = GetAssetInfo(_path);

            if(null != _assetInfo){

                return _assetInfo.AssetObject;

            }

 

             return null;

        }

        #endregion

 

        #region Load Coroutine Resources

 

        public void LoadCoroutine(string _path, Action<UnityEngine.Object> _loaded){

            AssetInfo _assetInfo = GetAssetInfo(_path, _loaded);

                if(null != _assetInfo){

                    CoroutineController.Instance.StartCoroutine(_assetInfo.GetCoroutineObject(_loaded));

                }

         }

        #endregion

 

        #region Load Async Resources

 

        public void LoadAsync(string _path, Action<UnityEngine.Object> _loaded){

            LoadAsync(_path, _loaded, null);

         }

 

        public void LoadAsync(string _path, Action<UnityEngine.Object> _loaded, Action<float> _progress){

            AssetInfo _assetInfo = GetAssetInfo(_path, _loaded);

            if(null != _assetInfo){

                CoroutineController.Instance.StartCoroutine(_assetInfo.GetAsyncObject(_loaded, _progress));

            }

        }

        #endregion

 

 

        private AssetInfo GetAssetInfo(string _path){

            return GetAssetInfo(_path, null);

        }

 

        private AssetInfo GetAssetInfo(string _path, Action<UnityEngine.Object> _loaded){

            if(string.IsNullOrEmpty(_path)){

                Debug.LogError(“立钻哥哥：Error: null _path name.”);

                if(null != _loaded){

                    _loaded(null);

                }

            }

 

            // Load Res ....

           AssetInfo _assetInfo = null;

           if(!dicAssetInfo.TryGetValue(_path, out _assetInfo)){

                _assetInfo = new AssetInfo();

                _assetInfo.Path = _path;

                dicAssetInfo.Add(_path, _assetInfo);

            }

            _assetInfo.RefCount++;

 

            return _assetInfo;

        }

 

    }

}

###2.5、Defines

###2.5、Defines

++2.5、Defines

++++Defines：自定义空间和类。

++++Scripts/YanlzFramework/Defines/Defines.cs

++2.5.1、Defines.cs

//立钻哥哥：自定义空间和类（Scripts/YanlzFramework/Defines/Defines.cs）

using System;

 

namespace YanlzFramework{

 

    #region 全局委托Global delegate

    public delegate void StateChangeEvent(Object sender, EnumObjectState newState, EnumObjectSate oldState);

    public delegate void MessageEvent(Message message);

    public delegate void OnTouchEventHandle(GameObject_sender, object _args, params object[] _params);

    public delegate void PropertyChangedHandle(BaseActor actor, int id, object oldValue, object newValue);

 

 

    #endregion

 

    #region 全局枚举对象 Global enum

    public enum EnumObjectState{

        None,

        Initial,

        Loading,

        Read,

        Disabled,

        Closing

    }

 

    public enum EnumUIType : int{

        None = -1,

        TestOne,

        TestTwo,

    }

 

    public enum EnumTouchEventType{

        OnClick,

        OnDoubleClick,    //立钻哥哥：双击

        OnDown,

        OnUp,

        OnEnter,

        OnExit,

        OnSelect,

        OnUpdateSelect,

        OnDeSelect,

        OnDrag,

        OnDragEnd,

        OnDrop,

        OnScroll,

        OnMove,

    }

 

    public enum EnumPropertyType : int{

        RoleName = 1,   //立钻哥哥：角色名

        Sex,    //性别

        RoleID,    //Role ID

        Gold,    //宝石（元宝）

        Coin,    //金币（铜板）

        Level,    //等级

        Exp,    //当前经验

 

        AttackSpeed,    //攻击速度

        HP,    //当前HP

        HPMax,    //生命最大值

        Attack,    //普通攻击（点数）

        Water,    //水系攻击（点数）

        Fire,    //火系攻击（点数）

    }

 

    public enum EnumActorType{

        None = 0,

        Role,

        Monster,

       NPC,

    }

 

    public enum EnumSceneType{

        None = 0,

        StartGame,

        LoadingScene,

        LoginScene,

        MainScene,

        CopyScene,

        PVPScene,

        PVEScene,

    }

 

    #endregion

 

    public class UIPathDefines{

        public const string UI_PREFAB = “Prefabs/”;    //UI预设

        public const string UI_CONTROLS_PREFAB = “UIPrefab/Control/”;   //UI小控件预设

        public const string UI_SUBUI_PREFAB = “UIPrefab/SubUI/”;  //UI子页面预设

        public const string UI_IOCN_PATH = “UI/Icon/”;    //icon路径

 

        public static string GetPrefabsPathByType(EnumUIType _uiType){

            string _path = string.Empty;

            switch(_uiType){

                case EnumUIType.TestOne:{

                    _path = UI_PREFAB + “TestUIOne”;

                    break;

                }

 

                case EnumUIType.TestTwo:{

                    _path = UI_PREFAB + “TestUITwo”;

                    break;

                }

 

                default:{

                    Debug.Log(“立钻哥哥：Not Find EnumUIType! Type: ” + uiType.ToString());

                    break;

                }

 

                return _path;

            }

        }

 

        public static System.Type GetUIScriptByType(EnumUIType _uiType){

            System.Type _scriptType = null;

            switch(_uiType){

                case EnumUIType.TestOne:{

                    _scriptType = typeof(TestOne);

                    break;

                }

 

                case EnumUIType.TestTwo:{

                     _scriptType = typeof(TestTwo);

                    break;

                }

 

               default:{

                    Debug.Log(“立钻哥哥：Not Find EnumUIType! Type: ” + _uiType.ToString());

                    break;

                }

            }

 

            return _scriptType;

        }

 

    }

 

 

    public class Defines{

        public Defines(){

        }

    }

}

###2.6、Singleton

###2.6、Singleton

++2.6、Singleton

++++Singleton：单例基类。

++++Scripts/YanlzFramework/Common/Singleton/Singleton.cs

++2.6.1、Singleton.cs（单例基类）

//立钻哥哥：Singleton.cs（单例基类）（YanlzFramework/Common/Singleton/Singleton.cs）

using System;

 

namespace YanlzFramework{

    public abstract class Singleton<T> where T : class, new() {

        public Singleton(){

            protected static T _Instance = null;

            public static T Instance{

                get{

                    if(null == _Instance){

                        _Instance = new T();

                    }

 

                    return _Instance;

                }

            }

        }

 

        protected Singleton(){

            if(null != _Instance){

                throw new SingletonException(“立钻哥哥：This ” + (typeof(T)).ToString() + “ Singleton Instance is not null !!!”);

            }

 

            Init();

        }

 

        public virtual void Init(){

        }

    }

}

###2.7、SingletonException

###2.7、SingletonException

++2.7、SingletonException

++++SingletonException：异常类。

++++Scripts/YanlzFramework/Common/Singleton/SingletonException.cs

++2.7.1、SingletonException.cs

//立钻哥哥：SingletonException.cs（异常类）（YanlzFramework/.../SingletonException.cs）

using System;

 

namespace YanlzFramework{

    public class SingletonException : Exception{

        public SingletonException(string msg) : base(msg){

        }

    }

}

###2.8、DDOLSingleton

###2.8、DDOLSingleton

++2.8、DDOLSingleton

++++DDOLSingleton：继承MonoBehaviour的单例基类。

++++Scripts/YanlzFramework/Common/Singleton/DDOLSingleton.cs

++2.8.1、DDOLSingleton.cs（继承MonoBehaviour的单例基类）

//立钻哥哥：DDOLSingleton.cs（Scripts/YanlzFramework/.../DDOLSingleton.cs）

using UnityEngine;

using System.Collections;

 

public class DDOLSingleton<T> : MonoBehaviour where T : DDOLSingleton<T>{

    protected static T _Instance = null;

 

    public static T Instance{

        get{

            if(null == _Instance){

                GameObject go = GameObject.Find(“DDOLGameObject”);

                if(null == go){

                    go = new GameObject(“DDOLGameObject”);  

                    DontDestroyOnLoad(go);  //立钻哥哥：创建对象，过场不销毁

                }

 

               _Instance = go.AddComponent<T>();

            }

 

            return _Instance;

        }

    }

 

    //Raises the application quit event.

    private void OnApplicationQuit(){

        _Instance = null;

    }

}

###2.9、GameController

###2.9、GameController

++2.9、GameController

++++GameController：游戏控制器。

++++Scripts/YanlzFramework/Manager/GameController.cs

++2.9.1、GameController.cs（游戏控制器）

//立钻哥哥：GameController.cs（YanlzFramework/Manager/GameController.cs）

using UnityEngine;

using System.Collections;

 

public class GameController : DDOLSingleton<GameController>{

}

###2.10、CoroutineController

###2.10、CoroutineController

++2.10、CoroutineController

++++CoroutineController：非继承MonoBehaviour使用协程管理器。

++++Scripts/YanlzFramework/Manager/CoroutineController.cs

++2.10.1、CoroutineController.cs（协程管理器）

//立钻哥哥：协程管理器：（YanlzFramework/Manager/CoroutineController.cs）

using UnityEngine;

using System.Collections;

 

public class CoroutineController : DDOLSingleton<CoroutineController>{

}

###2.11、StartGame

###2.11、StartGame

++2.11、StartGame

++++StartGame：游戏开始控制。

++++Scripts/GameLogic/StartGame.cs

++2.11.1、StartGame.cs（开始游戏）

//立钻哥哥：开始游戏：（Scripts/GameLogic/StartGame.cs）

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

using YanlzFramework;   //立钻哥哥：自己的框架命名空间

 

//public class StartGame : MonoBehaviour{

public class GameController : DDOLSingleton<StartGame>{

    //Use this for initialization

    void Start(){

        //RegisterAllMoudles();    //立钻哥哥：模拟GameController：注册模块

        ModuleManager.Instance.RegisterAllModules();    //立钻哥哥：

 

        SceneManager.Instance.RegisterAllScene();    //立钻哥哥：注册场景

 

        //GameObject go = Instantiate(Resource.Load<GameObject>(“Prefabs/TestUIOne”));

        UIManager.Instance.OpenUI(EnumUIType.TestOne);    //立钻哥哥

     

        TestResManager();    //立钻哥哥：测试ResManager功能

 

        StartCoroutine(AutoUpdateGold());    //立钻哥哥：测试金币更新

        StartCoroutine(NetAutoUpdateGold());    //立钻哥哥：模拟网络金币更新

    }

 

    void TestResManager(){

        float time = System.Enviroment.TickCount;

        for(int i = 1;  i < 1000;  i++){

            GameObject go = null;

            go = Instantiate(Resoureces.Load<GameObject>(“Prefabs/Cube”));  //1

            go = ResManager.Instance.LoadInstance(“Prefabs/Cube”) as GameObject; //2

 

            //3、异步加载

            ResManager.Instance.LoadAsyncInstance(“Prefabs/Cube”, (_obj)=>{

                go = _obj as GameObject;

               go.transform.position = UnityEngine.Random.insideUnitSphere * 20;

           });

 

            //4、协程加载

           ResManager.Instance.LoadCoroutineInstance(“Prefabs/Cube”, (_obj)=>{

                go = _obj as GameObject;

                go.transform.position = UnityEngine.Random.insideUnitSphere * 20;

            });

 

            //go.transform.position = UnityEngine.Random.insideUnitCircle * 20;

           go.transform.position = UnityEngine.Random.insideUnitSphere * 20;

       }

 

       Debug.Log(“立钻哥哥：Times: ” + (System.Environment.TickCout - time) * 1000);

    }

 

    private IEnumerator<int> AsyncLoadData(){

    }

 

    private IEnumerator AutoUpdateGold(){

        int gold = 0;

        while(true){

            gold++;

            yield return new WaitForSeconds(1.0f);

 

            Message message = new Message(“AutoUpdateGold”, this);

            message [“gold”] = gold;

            message .Send();

        }

    }

 

    private IEnumerator NetAutoUpdateGold(){

        int gold = 0;

        while(true){

            gold++;

            yield return new WaitForSeconds(1.0f);

 

            Message message = new Message(MessageType.Net_MessageTestOne, this);

            message [“gold”] = gold;

 

            //message .Send();

            //MessageCenter.Instance.SendMessage(NetMessageType.Net_MessageTestOne, this, null, gold);

            MessageCenter.Instance.SendMessage(message);    //立钻哥哥：

        }

    }

 

    //立钻哥哥：模拟GameController中的功能：注册模块

    private void RegisterAllModules(){

        //TestOneModule testOneModule = new TestOneModule();

        //testOneModule.Load();

        LoadModule(typeof(TestOneModule));

    }

 

    private void LoadModule(Type moduleType){

        BassModule bm = System.Activator.CreateInstance(moduleType) as BaseModule;

        bm.Load();

    }

 

}

###2.12、TestOne

###2.12、TestOne

++2.12、TestOne

++++TestOne：第一个UI测试界面。

++++Scripts/GameLogic/UI/TestOne.cs

++2.12.1、TestOne.cs（第一个UI测试界面）

//立钻哥哥：第一个UI测试界面：（Scripts/GameLogic/UI/TestOne.cs）

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

using YanlzFramework;    //立钻哥哥：自己的框架命名空间

 

public class TestOne : BaseUI{

    private Button btn;

    private Text text;    //立钻哥哥：分数更新测试

 

    private TestOneModule oneModule;

 

    #region implemented abstract members of BaseUI

    public override EnumUIType GetUIType(){

        return EnumUIType.TestOne;

    }

    #endregion

 

    //Use this for initialization

    void Start(){

        //btn = transform.Find(“Panel/Button”).GetComponent<Button>();

        //btn.onClick.AddListener(OnClickBtn);

 

        text = transform.Find(“Panel/Text”).GetComponent<Text>();    //分数更新测试

    //EventTriggerListener.Get(transform.Find(“Panel/Button”).gameObject).SetEventHandle(EnumTouchEventType.OnClick, Close);

        EventTriggerListener listener = EventTriggerListener.Get(transform.Find(“Panel/Button”).gameObject);

        //listener.SetEventHandle(EnumTouchEventType.OnClick, Close);

        listener.SetEventHandle(EnumTouchEventType.OnClick, Close, 1, “1234”);

 

        oneModule = ModuleManager.Instance.Get<TestOneModule>();

        text.text = “Gold: ” + oneModule.Gold;

    }

 

    public override OnAwake(){

        MessageCenter.Instance.AddListener(“AutoUpdateGold”, UpdateGold);

        base.OnAwake();

    }

 

    protected override void OnRelease(){

        MessageCenter.Instance.RemoveListener(“AutoUpdateGold”, UpdateGold);

        base.OnRelease();

    }

 

    private void UpdateGold(Message message){

        int gold = (int)message[“gold”];

        Debug.Log(“立钻哥哥：TestOne UpdateGold: ” + gold);

 

        text.text = “Gold: ” + gold;    //立钻哥哥：分数更新测试

    }

 

    private void OnClickBtn(){

        //GameObject go = Instantiate(Resources.Load<GameObject>(“Prefabs/TestUITwo”));

        UIManager.Instance.OpenUICloseOthers(EnumUIType.TestTwo);

 

        //Close();    //立钻哥哥：UIManager统一处理

    }

 

    private void Close(){

        Destroy(gameObject);

    }

 

    private void Close(GameObject _sender, objcet _args, params object[] _params){

        int i = (int) _params[0];

        string s = (string) _params[1];

        Debug.Log(i);

        Debug.Log(s);

    

        UIManager.Instance.OpenUICloseOthers(EnumUIType.TestTwo);

    }

}

###2.13、TestTwo

###2.13、TestTwo

++2.13、TestTwo

++++TestOne：第一个UI测试界面。

++++Scripts/GameLogic/UI/TestOne.cs

++2.13.1、TestTwo.cs（第二个UI测试界面）

//立钻哥哥：第一个UI测试界面：（Scripts/GameLogic/UI/TestTwo.cs）

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

using YanlzFramework;    //立钻哥哥：自己的框架命名空间

 

public class TestOne : BaseUI{

    private Button btn;

 

    #region implemented abstract members of BaseUI

    public override EnumUIType GetUIType(){

        return EnumUIType.TestTwo;

    }

    #endregion

 

    //Use this for initialization

    void Start(){

        btn = transform.Find(“Panel/Button”).GetComponent<Button>();

        btn.onClick.AddListener(OnClickBtn);

    }

 

    protected override void OnWake(){

        Message.Instance.AddListener(“AutoUpdateGold”, UpdateGold);

        base.OnAwake();

    }

 

    protected override void OnRelease(){

        MessageCenter.Instance.RemoveListener(“AutoUpdateGold”, UpdateGold);

        base.OnRelease();

    }

 

    private void UpdateGold(Message message){

        int gold = (int)message[“gold”];

        Debug.Log(“立钻哥哥：TestTwo UpdateGold: ” + gold);

    }

 

    private void OnClickBtn(){

        //GameObject go = Instantiate(Resources.Load<GameObject>(“Prefabs/TestUIOne”));

        UIManager.Instance.OpenUICloseOthers(EnumUIType.TestOne);

 

        //Close();    //立钻哥哥：UIManager统一处理

    }

 

    private void Close(){

        Destroy(gameObject);

    }

}

###2.14、BaseController

###2.14、BaseController

++2.14、BaseController

++++BaseModule：控制器基类。

++++Scripts/YanlzFramework/BaseClass/BaseController.cs

++2.14.1、BaseController.cs（控制器基类）

//立钻哥哥：控制器基类：（Srcipts/YanlzFramework/BaseClass/BaseController.cs）

using System;

 

namespace YanlzFramework{

    public class BaseController{

        public BaseController(){

        }

    }

}

###2.15、BaseModel

###2.15、BaseModel

++2.15、BaseModel

++++BaseModel

 

        //Close();    //立钻哥哥：UIManager统一处理

    }

 

    private void Close(){

        Destroy(gameObject);

    }

}

###2.14、BaseController

###2.14、BaseController

++2.14、BaseController

++++BaseModule：控制器基类。

++++Scripts/YanlzFramework/BaseClass/BaseController.cs

++2.14.1、BaseController.cs（控制器基类）

//立钻哥哥：控制器基类：（Srcipts/YanlzFramework/BaseClass/BaseController.cs）

using System;

 

namespace YanlzFramework{

    public class BaseController{

        public BaseController(){

        }

    }

}

###2.15、BaseModel

###2.15、BaseModel

++2.15、BaseModel

++++BaseModel：模型基类。

++++Scripts/YanlzFramework/BaseClass/BaseModel.cs

++2.15.1、BaseModel.cs（模型基类）

//立钻哥哥：模型基类：（Scripts/YanlzFramework/BaseClass/BaseModel.cs）

using System;

 

namespace YanlzFramework{

    public class BaseModel{

        public BaseModel(){

        }

    }

}

###2.16、BaseModule

###2.16、BaseModule

++2.16、BaseModule

++++BaseModule：数据逻辑处理模块基类。

++++Scripts/YanlzFramework/BaseClass/BaseModule.cs

++2.16.1、BaseModule.cs

//立钻哥哥：数据逻辑处理模块基类：（YanlzFramework/BaseClass/BaseModule.cs）

using System;

 

namespace YanlzFramework{

    public class BaseModule{

        public enum EnumRegisterMode{

            NotRegister,

            AutoRegister,

            AlreadyRegister,

        }

 

        private EnumObjectState state 、BaseModule

++++BaseModule：数据逻辑处理模块基类。

++++Scripts/YanlzFramework/BaseClass/BaseModule.cs

++2.16.1、BaseModule.cs

//立钻哥哥：数据逻辑处理模块基类：（YanlzFramework/BaseClass/BaseModule.cs）

using System;

 

namespace YanlzFramework{

    public class BaseModule{

        public enum EnumRegisterMode{

            NotRegister,

            AutoRegister,

            AlreadyRegister,

        }

 

        private EnumObjectState state = EnumObjectState.Initial;

        public EnumObjectState State{

            get{

                return state;

            }

 

            set{

                if(state == value){

                    return;

                }

 

               EnumObjectState oldState = state;

               state = value;

 

               if(null != StateChanged){

                   StateChanged(this, state, oldState);

               }

 

              OnStateChanged(state, oldState);

           }

        }

 

        public event StateChangedEvent StateChanged;

 

        protected virtual void OnStateChanged(EnumObjectState newState, EnumObjectState oldState){

namespace YanlzFramework{

    public class BaseModule{

        public enum EnumRegisterMode{

            NotRegister