unity程序简易框架

1. 框架基本结构

2. 单例模式基类模块

2.1 BaseManager.cs

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

public class BaseManager<T> where T:new()
{
   
    private static T instance;

    public static T GetInstance()
    {
   
        if (instance == null)
            instance = new T();
        return instance;
    }
}

2.2 SingletonAutoMono.cs
继承这种自动创建的 单例模式基类 不需要我们手动去拖 或者 api去加了
想用他 直接 GetInstance就行了

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

public class SingletonAutoMono<T> : MonoBehaviour where T : MonoBehaviour
{
   
    private static T instance;

    public static T GetInstance()
    {
   
        if( instance == null )
        {
   
            GameObject obj = new GameObject();
            //设置对象的名字为脚本名
            obj.name = typeof(T).ToString();
            //让这个单例模式对象 过场景 不移除
            //因为 单例模式对象 往往 是存在整个程序生命周期中的
            DontDestroyOnLoad(obj);
            instance = obj.AddComponent<T>();
        }
        return instance;
    }
}

2.3 SingletonMon.cs
继承了 MonoBehaviour 的 单例模式对象 需要我们自己保证它的位移性

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

public class SingletonMono<T> : MonoBehaviour where T: MonoBehaviour
{
   
    private static T instance;

    public static T GetInstance()
    {
   
        //继承了Mono的脚本 不能够直接new
        //只能通过拖动到对象上 或者 通过 加脚本的api AddComponent去加脚本
        //U3D内部帮助我们实例化它
        return instance;
    }

    protected virtual void Awake()
    {
   
        instance = this as T;
    }
}

单例注意点:

1. 继承了Mono的脚本 不能够直接new
只能通过拖动到对象上 或者 通过 加脚本的api AddComponent去加脚本
U3D内部帮助我们实例化它

2. 一些生命周期函数和协程函数需要继承Mono对象

3. unity 过场景时会移除场景里的对象
DontDestroyOnLoad(obj);
让这个单例模式对象 过场景 不移除
因为 单例模式对象 往往 是存在整个程序生命周期中的

3. 缓存池模块

缓存池达到的效果

使用缓存池的目的，unity 的内存gc 是内存满才gc 一次,gc 消耗比较大
切换场景时类丢失但是不会真正的删除

PoolMgr.cs

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

/// <summary>
/// 抽屉数据  池子中的一列容器
/// </summary>
public class PoolData
{
   
    //抽屉中 对象挂载的父节点
    public GameObject fatherObj;
    //对象的容器
    public List<GameObject> poolList;

    public PoolData(GameObject obj, GameObject poolObj)
    {
   
        //给我们的抽屉 创建一个父对象 并且把他作为我们pool(衣柜)对象的子物体
        fatherObj = new GameObject(obj.name);
        fatherObj.transform.parent = poolObj.transform;
        poolList = new List<GameObject>() {
   };
        PushObj(obj);
    }

    /// <summary>
    /// 往抽屉里面 压都东西
    /// </summary>
    /// <param name="obj"></param>
    public void PushObj(GameObject obj)
    {
   
        //失活 让其隐藏
        obj.SetActive(false);
        //存起来
        poolList.Add(obj);
        //设置父对象
        obj.transform.parent = fatherObj.transform;
    }

    /// <summary>
    /// 从抽屉里面 取东西
    /// </summary>
    /// <returns></returns>
    public GameObject GetObj()
    {
   
        GameObject obj = null;
        //取出第一个
        obj = poolList[0];
        poolList.RemoveAt(0);
        //激活 让其显示
        obj.SetActive(true);
        //断开了父子关系
        obj.transform.parent = null;

        return obj;
    }
}

/// <summary>
/// 缓存池模块
/// 1.Dictionary List
/// 2.GameObject 和 Resources 两个公共类中的 API 
/// </summary>
public class PoolMgr : BaseManager<PoolMgr>
{
   
    //缓存池容器 （衣柜）
    public Dictionary<string, PoolData> poolDic = new Dictionary<string, PoolData>();

    private GameObject poolObj;

    /// <summary>
    /// 往外拿东西
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
    public void GetObj(string name, UnityAction<GameObject> callBack)
    {
   
        //有抽屉 并且抽屉里有东西
        if (poolDic.ContainsKey(name) && poolDic[name].poolList.Count > 0)
        {
   
            callBack(poolDic[name].GetObj());
        }
        else
        {
   
            //通过异步加载资源 创建对象给外部用
            ResMgr.GetInstance().LoadAsync<GameObject>(name, (o) =>
            {
   
                o.name = name;
                callBack(o);
            });

            //obj = GameObject.Instantiate(Resources.Load<GameObject>(name));
            //把对象名字改的和池子名字一样
            //obj.name = name;
        }
    }

    /// <summary>
    /// 换暂时不用的东西给我
    /// </summary>
    public void PushObj(string name, GameObject obj)
    {
   
        if (poolObj == null)
            poolObj = new GameObject("Pool");

        //里面有抽屉
        if (poolDic.ContainsKey(name))
        {
   
            poolDic[name].PushObj(obj);
        }
        //里面没有抽屉
        else
        {
   
            poolDic.Add(name, new PoolData(obj, poolObj));
        }
    }


    /// <summary>
    /// 清空缓存池的方法 
    /// 主要用在 场景切换时
    /// </summary>
    public void Clear()
    {
   
        poolDic.Clear();
        poolObj = null;
    }
}

测试脚本
PoolMgrTest用于缓存对象的生成，鼠标左键点击生成Cube，鼠标右键点击生成Sphere。

using UnityEngine;

public class PoolMgrTest : MonoBehaviour
{
   
    // Update is called once per frame
    void Update()
    {
   
        if (Input.GetMouseButtonDown(0))
        {
   
            PoolMgr.GetInstance().GetObj("Prefabs/Cube",(o)=> {
   
                Debug.Log(o.name + "加载成功！");
            });
        }
        if (Input.GetMouseButtonDown(1))
        {
   
            PoolMgr.GetInstance().GetObj("Prefabs/Sphere", (o) => {
   
                o.transform.position= new Vector3(2f,0,0);
                Debug.Log(o.name + "加载成功！");
            });
        }
    }
}

DelayPush用于控制缓存对象的消失，挂载到Cube和Sphere两个预制体上。

public class DelayPush : MonoBehaviour
{
   
    private void OnEnable()
    {
   
        Invoke("Push", 1);
    }

    void Push() {
   
        PoolMgr.GetInstance().PushObj(this.gameObject.name, this.gameObject);
    }
}

4. 事件中心模块

EventCenter.cs

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


public interface IEventInfo
{
   

}

public class EventInfo<T> : IEventInfo
{
   
    public UnityAction<T> actions;

    public EventInfo( UnityAction<T> action)
    {
   
        actions += action;
    }
}

public class EventInfo : IEventInfo
{
   
    public UnityAction actions;

    public EventInfo(UnityAction action)
    {
   
        actions += action;
    }
}


/// <summary>
/// 事件中心 单例模式对象
/// 1.Dictionary
/// 2.委托
/// 3.观察者设计模式
/// 4.泛型
/// </summary>
public class EventCenter : BaseManager<EventCenter>
{
   
    //key —— 事件的名字（比如：怪物死亡，玩家死亡，通关 等等）
    //value —— 对应的是 监听这个事件 对应的委托函数们
    private Dictionary<string, IEventInfo> eventDic = new Dictionary<string, IEventInfo>();

    /// <summary>
    /// 添加事件监听
    /// </summary>
    /// <param name="name">事件的名字</param>
    /// <param name="action">准备用来处理事件 的委托函数</param>
    public void AddEventListener<T>(string name, UnityAction<T> action