UI框架商业手游开发（1）

1.  UI 框架 方便管理各种界面 主要包括几个大类 UIManger   UIBase  MessageCenter Sysdefine

ResourceManger 

2.UIManger  主要作用缓存所有UI窗体 路径 以及预设体名字 存储反向切换的窗体 UIManger是单利模式 

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class UIManger : MonoBehaviour {

    //单利  
    public static UIManger _Instance = null;
    //UI预设体的路径(参数  窗体的预设名字  路径)
    private Dictionary<string, string> _DicformsPath;
    //缓存所有的UI窗体
    private Dictionary<string, BaseUIForm> _DicALLUIForms;
    //当前显示的UI窗体
    private Dictionary<string, BaseUIForm> _DicCurrentShowUIForms;
    //定义栈的集合   存储反向切换的窗体类型
    private Stack<BaseUIForm> _StackCurrentUIForms;

    //UI根节点
    private Transform _Tracavans = null;
    //全屏幕节点
    private Transform _Tranormal = null;
    //固定显示节点
    private Transform _TraFixed = null;
    //弹出节点
    private Transform _TraPopup = null;
    //UI脚本管理节点
    private Transform _TraUIScripts = null;
    //初始化核心数据
    public void Awake()
    {
        //字段初始化
        _DicALLUIForms = new Dictionary<string, BaseUIForm>();
        _DicCurrentShowUIForms = new Dictionary<string, BaseUIForm>();
        _DicformsPath = new Dictionary<string, string>();
        _StackCurrentUIForms = new Stack<BaseUIForm>();
        //加载canvas  预设体
        InitRootCanvasLoading();
        //初始化加载Canvas 预设
        _Tracavans = GameObject.FindGameObjectWithTag(SysDefine.SYS_TAG_CANVAS).transform;
        _Tranormal = Unityhelp.FindChildNode(_Tracavans.gameObject, SysDefine.SYS_NORMAL_NODE);
        _TraFixed = Unityhelp.FindChildNode(_Tracavans.gameObject, SysDefine.SYS_FIXED_NODE);
        _TraPopup = Unityhelp.FindChildNode(_Tracavans.gameObject, SysDefine.SYS_POPUP_NODE);
        _TraUIScripts = Unityhelp.FindChildNode(_Tracavans.gameObject, SysDefine.SYS_SCRIPTMANGER_NODE);
        //把脚本作为UI窗体的子节点
        this.gameObject.transform.SetParent(_TraUIScripts, false);
        //场景转换防止销毁UI
        DontDestroyOnLoad(_Tracavans);
        //初始化  UI窗体 预设体 路径数据
        InitUIFormsPathData();

    }
//需要一个接口 IConfigManger类 后期加上

    private void InitUIFormsPathData()
    {
        IConfigManger configmanger = new ConfigMangerJson(SysDefine.SYS_PATH_UIFORMS_CONFIG_INFO);
        if (configmanger!=null)
        {
            _DicformsPath = configmanger.AppSetting;
        }

    }

    //显示打开UI窗体
    /// <summary>
    /// 加载判断UI窗体名称  加载到缓存的集合当中
    /// 根据不同的UI窗体的显示模式 分别做不同的处理
    /// </summary>
    public void ShowUIFroms(string   uiFormName)
    { 
        //UI基类
        BaseUIForm baseUIfrom=null;
        //参数检查
        if (string.IsNullOrEmpty(uiFormName)) return;
        baseUIfrom = LoadFormsToAllUIFormsCatch(uiFormName);
        if (baseUIfrom == null) return;

        //是否清空栈中的数据
        if (baseUIfrom.CurrentUITyPE.IsClearStack)
        {

            ClearStackArray();
        }

        switch (baseUIfrom.CurrentUITyPE.UIFor_ShowMode)
        {
            case UIForShowMode.Normal:
                //把窗体加载到“当前窗体”集合中
                LoadUIToCurrentCache(uiFormName);
                break;
            case UIForShowMode.ReverseChange:
                PushUIFormToStack(uiFormName);
                break;
            case UIForShowMode.HideOther:
                EnterUIFormsAndHideOther(uiFormName);
                break;
            default:
                break;
        }
    }
    /// <summary>
    /// 关闭上一个窗体
    /// </summary>
    /// <param name="uiFormName"></param>
    public void CloseUIForms(string uiFormName)
    {
        BaseUIForm baseUIForm;
        //参数检查
        if (string.IsNullOrEmpty(uiFormName)) return;
        _DicALLUIForms.TryGetValue(uiFormName, out baseUIForm);
        if (baseUIForm == null) return;
        //根据窗体不同的显示类型，分别作不同的关闭处理
        switch (baseUIForm.CurrentUITyPE.UIFor_ShowMode)
        {
            case UIForShowMode.Normal:
                //普通窗体关闭
                ExitUIForm(uiFormName);
                break;
            case UIForShowMode.ReverseChange:
                //反向切换窗体关闭
                PopUIForms(uiFormName);
                break;
            case UIForShowMode.HideOther:
                //隐藏其他窗口关闭
                ExitUIFormsAndDisplayOther(uiFormName);
                break;
            default:
                break;
        }


    }
    /// <summary>
    /// 退出指定UI窗体
    /// </summary>
    /// <param name="uiFormName"></param>
    private void ExitUIForm(string uiFormName)
    {
        BaseUIForm baseUIForm;
        _DicCurrentShowUIForms.TryGetValue(uiFormName, out baseUIForm);
        if (baseUIForm == null) return;
        //指定的ui窗口标记为隐藏状态  从集合移除
        baseUIForm.Hiding();
        _DicCurrentShowUIForms.Remove(uiFormName);
    }
    /// <summary>
    /// 反向切换
    /// </summary>
    /// <param name="uiFormName"></param>
    private void PopUIForms(string uiFormName)
    {
        //如果界面大于两个
        if (_StackCurrentUIForms.Count>=2)
        {
            //出站处理
            BaseUIForm topUIForm = _StackCurrentUIForms.Pop();
            //隐身处理
            topUIForm.Hiding();
            //出栈后下一个界面做重新显示处理
            BaseUIForm nextUIForms = _StackCurrentUIForms.Peek();
            nextUIForms.Redisplay();

        }
        else if (_StackCurrentUIForms.Count==1)
        {
            //出栈处理
                 BaseUIForm topUIForms = _StackCurrentUIForms.Pop();
            //做隐藏处理
            topUIForms.Hiding();
        }
    }

    private void ExitUIFormsAndDisplayOther(string strUIName)
    {
        BaseUIForm baseUIForm;                          //UI窗体基类
        //参数检查
        if (string.IsNullOrEmpty(strUIName)) return;
        _DicCurrentShowUIForms.TryGetValue(strUIName, out baseUIForm);
        if (baseUIForm == null) return;

        //当前窗体隐藏状态，且“正在显示”集合中，移除本窗体
        baseUIForm.Hiding();
        _DicCurrentShowUIForms.Remove(strUIName);

        //把“正在显示集合”与“栈集合”中所有窗体都定义重新显示状态。
        foreach (BaseUIForm baseUI in _DicCurrentShowUIForms.Values)
        {
            baseUI.Redisplay();
        }
        foreach (BaseUIForm staUI in _StackCurrentUIForms)
        {
            staUI.Redisplay();
        }
    }






    /// <summary>
    /// 是否清空栈的数据 
    /// </summary>
    private bool ClearStackArray()
    {
        if (_StackCurrentUIForms!=null&&_StackCurrentUIForms.Count>=1)
        {
           //清空数据
            _StackCurrentUIForms.Clear();
            return true;
        }
        return false;
    }


    /// <summary>
    /// UI窗体 入栈
    /// </summary>
    /// <param name="uiFormName"></param>
    private void PushUIFormToStack(string uiFormName)
    {
        BaseUIForm baseUIForm;
        //判断是否有其他窗体  有就冻结
        if (_StackCurrentUIForms.Count>0)
        {

            BaseUIForm topuiform = _StackCurrentUIForms.Peek();
            //栈顶元素做冻结处理
            topuiform.Freeze();

        }
        //判断 所有的Ui 窗体是否有指定的UI窗体  有就处理
        _DicALLUIForms.TryGetValue(uiFormName, out baseUIForm);
        if (baseUIForm != null)
        {
            //当前窗口显示状态
            baseUIForm.Display();
            _StackCurrentUIForms.Push(baseUIForm);
        }
        else {
            Debug.Log("baseUIForm==null,Please Check, 参数 uiFormName=" + uiFormName);
        }
    }
    /// <summary>
    /// 退出指定的UI窗体
    /// </summary>
    /// <param name="uiFormName"></param>
    private void EnterUIFormsAndHideOther(string struiFormName)
    {
        BaseUIForm baseUIForm;
        BaseUIForm baseUIFormFromALL;

        _DicCurrentShowUIForms.TryGetValue(struiFormName, out baseUIForm);
        if (baseUIForm != null) return;
        //把正在栈集合与正在显示的集合窗体全部隐藏
        foreach (BaseUIForm baseUI in _DicCurrentShowUIForms.Values)
        {
            baseUI.Hiding();
        }
        foreach (BaseUIForm staUI in _StackCurrentUIForms)
        {
            staUI.Hiding();
        }
        //把当前窗体加入到正在显示的集合中  且做显示处理
        _DicALLUIForms.TryGetValue(struiFormName, out baseUIFormFromALL);
        if (baseUIFormFromALL!=null)
        {
            _DicCurrentShowUIForms.Add(struiFormName, baseUIFormFromALL);
            //显示窗体
            baseUIFormFromALL.Display();

        }
    
  }


    //根据UI窗体名称  加载到缓存集合当中
    private BaseUIForm LoadFormsToAllUIFormsCatch(string uiFormName)
    {
        BaseUIForm baseuiresult = null;//加载的返回UI基类
        _DicALLUIForms.TryGetValue(uiFormName,out baseuiresult);
        //判断是否有窗体
        if (baseuiresult==null)
        {
            //加载指定路径名称的UI窗体
            baseuiresult = LoadUI(uiFormName);
        }
        return baseuiresult;
    }

    private BaseUIForm LoadUI(string uiFormName)
    {
        string strUIFromPathing = null;//UI窗体路径
        GameObject cloneprefabs = null;//创建克隆体
        BaseUIForm baseuiform = null;  //窗体基类
        //根据UI窗体名称 得到对应加载路径
        _DicformsPath.TryGetValue(uiFormName, out strUIFromPathing);
        if (!string.IsNullOrEmpty(strUIFromPathing))
        {
            cloneprefabs = ResMrg.GetInstance().LoadAsset(strUIFromPathing, false);
        }
        //设置克隆体的父节点
        if (_Tracavans != null && cloneprefabs != null)
        {
            baseuiform = cloneprefabs.GetComponent<BaseUIForm>();
            if (baseuiform == null)
            {
                Debug.Log("请先确认窗体预设对象上是否加载baseuifrom  子类脚本"+uiFormName);
                return null;
            }
            switch (baseuiform.CurrentUITyPE.UIFrom_Type)
            {
                //普通窗体
                case UIFormType.Normal:
                    cloneprefabs.transform.SetParent(_Tranormal, false);
                    break;
                //固定窗体节点
                case UIFormType.Fixed:
                    cloneprefabs.transform.SetParent(_TraFixed, false);
                    break;
                //弹出窗体节点
                case UIFormType.Popup:
                    cloneprefabs.transform.SetParent(_TraPopup, false);
                    break;
                default:
                    break;
            }
            //加载出来的预制体都设置隐藏
            cloneprefabs.SetActive(true);
            _DicALLUIForms.Add(uiFormName, baseuiform);
            return baseuiform;
        }
        else
        {
            Debug.Log("_TraCanvasTransfrom==null Or goCloneUIPrefabs==null!! ,Plese Check!, 参数uiFormName=" + uiFormName);
        }
        Debug.Log("出现不可预估的错误"+uiFormName);
        return null;
     

    }
    //初始化加载Cavas 预设体
    private void InitRootCanvasLoading()
    {
        ResMrg.GetInstance().LoadAsset(SysDefine.SYS_PATH_CANVAS,false);
    }

    private void LoadUIToCurrentCache(string uiFormName)
    {
        //UI窗体基类
        BaseUIForm baseUiForms=null;
        //从所有窗体集合中得到窗体
        BaseUIForm baseUIFormFromAllCache;
        //如果正在显示的集合中  存在整个UI 窗体 则直接返回
        _DicCurrentShowUIForms.TryGetValue(uiFormName, out baseUiForms);
        if (baseUiForms != null) return;
        //把当前窗体加载到正在显示的集合中

        _DicCurrentShowUIForms.TryGetValue(uiFormName, out baseUIFormFromAllCache);
        if (baseUIFormFromAllCache!=null)
        {
            _DicCurrentShowUIForms.Add(uiFormName, baseUIFormFromAllCache);
            //显示当前窗口
            baseUIFormFromAllCache.Display();

        }
    }

    //得到的实力
    public static UIManger GetInStance()
    {
        if (_Instance==null)
        {
            _Instance = new GameObject("_uimanger").AddComponent<UIManger>();

        }
        return _Instance;
    }
}