TongOuO

Unity游戏基本框架

个人总结笔记，参考自B站各教程，希望对他人也有所帮助，对我自己也方便复习。
感谢唐老狮的教学

目录

文件夹管理
单例模式基类
- - 单例模式介绍
  - Unity中的单例模式
  - C#中泛型的知识
  - 继承MonoBehaviour的单例基类模式
缓存池模块
- - 常见数据结构的使用情景
  - PoolMgr
  - 对缓存池的优化
  - 缓存池模块结合资源加载模块
事件中心模块
- - 对事件中心的优化以及避免装箱拆箱
公共Mono模块
场景切换模块
- - Unity协程
资源加载模块
- - unity委托
输入输出模块
- - 关于引用类型和值类型装箱拆箱的复习
音效管理模块
UGUI学习
- - - 三种GUI的区别
    - OnGUI手机移动端空间用来调试
    - 文本
    - IMAGE
    - Raw image
UI模块
- - 面板UI基类BasePanel
  - UI管理器UIManager

文件夹管理

Resources文件夹加载资源（其中所有东西最终都会被打包不管有没有用到）
Scripts文件夹放置相关代码
- ProjectBase工程基础文件
  - Base单例模式基类
  - Pool文件夹
Scenes场景资源放置一些保存好的场景
ArtRes文件夹直接将外部资源导入于此（减少游戏包大小）

单例模式基类

作用：减少单例模式重复代码的书写
作为管理者不继承Monobehaviour

单例模式介绍

一个类只有一个实例，而且自行实例化并向整个系统提供这个实例
使用单例模式可以减少资源消耗
饿汉式：唯一实例在类加载时立即进行实例化
懒汉式：在类加载时不进行实例化，在第一次使用时进行实例化
双重检查锁解决线程问题
BV1af4y1y7sS

Unity中的单例模式

一个静态成员变量类型是自身
公共的静态成员方法/属性
Unity小游戏中一般不考虑双锁线程问题所以只需要简单写懒汉式即可
基础代码

public class GameManager
{
    private static GameManager instance;
    public static GameManager Getinstance()
    {
        if(instance == null)
        instance = new GameManager();
        return instance;
    }

}

升级版2.0加入泛型

public class BaseManager where T:new()
{
    private static T instance;
    public static T Getinstance()
    {
        if(instance == null)
        instance = new T();
        return instance;
    }

}

它的子类管理类只需要继承自他然后把自身的类型传进去即可

public class GameManager :BaseManager

C#中泛型的知识

BV1A4411F7fj
泛型的作用

跨类型的可复用的代码：继承和泛型
继承->基类
泛型->带有类型占位符的模板

Generic types泛型类型

开放类型和封闭类型

泛型方法

泛型方法中需要引用泛型参数
补充：ref和out基本一样，即代替了c中指针的部分作用，区别是即在使用ref，和不使用修饰符的时候，必须要传递一个有值的参数。ref和out几乎就只有一个区别，那就是out可以使用未赋值的变量。
原因是out应该是在方法内部做了分配地址的操作，然后把地址赋给外部的变量。但是ref的话是直接传递外部地址进方法。
声明泛型类型

可以有多个泛型参数

Typeof可以实现将未绑定的泛型类型存在
default方法可以获得泛型类型的默认值
泛型的约束

继承MonoBehaviour的单例基类模式

Unity中不适用new的方法创建实例（继承了mono的脚本）
只能通过拖动到对象上或者通过加脚本api Addcomponent去加脚本
U3D内部帮我们实现他
引用：最后总结一下Awake和Start的异同点：
相同点：
1）两者都是对象初始化时调用的，都在Update之前，场景中的对象都生成后才会调用Awake，Awake调用完才会调用Start，所有Start调用完才会开始Update。
2）两者在对象生命周期内都只会被调用一次，即初始化时被调用，之后即使是在被重新激活之后也不会再次被调用。
不同点：
1）Awake函数在对象初始化之后立刻就会调用，换句话说，对象初始化之后第一调用的函数就是Awake；而Start是在对象初始化后，第一次Update之前调用的，
在 Start中进行初始化不是很安全，因为它可能被其他自定义的函数抢先。
2）Awake不管脚本是否enabled都会被调用；而Start如果对象被SetAcive(false)或者enabled= false了是不会被调用的。
3）如果对象（GameObject）本身没激活，那么Awake，Start都不会调用。

单例模式mono基础代码

public class NewBehaviourScript : MonoBehaviour
{
    private static NewBehaviourScript instance;
    public static NewBehaviourScript GetInstance()
    {
        return instance;
    }
    void Awake()
    {
        instance = this;
    }

}

采用instance方法而不用addcomponent方法是因为挂载后再instance=this的方法可以解决重复问题用新的顶掉旧的，而addcomponent多挂一遍就会多加一个不太行。
单例模式mono基类代码

public class SingletonMono : MonoBehaviour where T : MonoBehaviour
{
    private static T instance;
    public static T GetInstance()
    {
        return instance;
    }
  protected virtual  void Awake()
    {
        instance = this as T;
    }
}

采用virtual虚函数子类保证子类可以对Awake进行重写
子类再用protected override进行重写Awake
继承了Monobehaviour的单例模式对象需要我们自己保证其唯一性
升级版AutoSingletonMono继承这种单例模式的不需要直接去拖直接Getinstance就好了

public class SingletonAutoMono : 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();
        }
        return instance;
    }
}

缓存池模块

缓存池模块本质上是一个抽屉来存储暂时没有用的东西供给以后用
原理是减少GC次数减少卡顿短期增加内存
从而实现手动GC而减少卡顿

常见数据结构的使用情景

Array
需要处理的元素数量确定并且需要使用下标时可以考虑，不过建议使用List

ArrayList
不推荐使用，建议用List

List泛型List
需要处理的元素数量不确定时通常建议使用

LinkedList
链表适合元素数量不固定，需要经常增减节点的情况，2端都可以增减

Queue
先进先出的情况

Stack
后进先出的情况

Dictionary
需要键值对，快速操作

PoolMgr

用dictionary键值对来对应存储相应的种类名字与list对应
用list而不用数组方便管理和动态存储
定义字典（类名-list）
public Dictionary poolDic = new Dictionary();

定义存入和取出函数
取出函数写法：
判断有无对应name下的缓存模块
如果没有直接进行实例化将name作为路径传入
如果有直接取出第0个obj并且移除位于list中的obj
并且进行object激活
存入函数写法
存入也就是销毁物体
如果缓存池中无name对应list创建name和list，如果已经有list就加上这个obj
Invoke复习
Invoke(“SendMsg”, 5); 它的意思是：5 秒之后调用 SendMsg() 方法
Invoke(); 不能接受含有参数的方法；
Invoke() 也支持重复调用：InvokeRepeating(“SendMsg”, 2 , 3);
CancelInvoke();取消调用
注意：常用OnEnable函数（当对象激活时会进入声明周期函数）代替Start函数因为反复调用的时候Start函数只会进行第一次

public class PoolMgr : BaseManager
{
    public Dictionary> poolDic  = new Dictionary>();
    public GameObject Getobj(string name)
    {
        GameObject obj = null;
        if ( poolDic.ContainsKey(name)&& poolDic[name].Count >0)
        {
            obj =poolDic[name][0]; 
            poolDic[name].RemoveAt(0);
        }
        else
        {
            obj= GameObject.Instantiate(Resources.Load(name));
            obj.name = name;//很关键：把对象名改成池子名字一样防止因clone导致的错误

        }
        obj.SetActive(true);
        return obj;
    }

    public void PushObj(string name,GameObject obj )
    {
        obj.SetActive(false);
        if(poolDic.ContainsKey(name))
        {
            poolDic[name].Add(obj);
        }
        else
        {
            poolDic.Add(name,new List(){obj});
        }
    }
}

对缓存池的优化

增加一个Pool父物体，将缓存池中的子物体存储于其中，在get的时候解除父子关系调出，在false的时候进入父子关系
在切换场景的时候原先的物体已经清除了但原先内存上的关联关系仍然没有被清除所以会产生错误，解决的方法是新增clear方法。

    public void clear()
    {
        poolDic.Clear();
        poolObj= null;
    }

再给Pool物体区分的更细节（这里先省略一下，以后再补，有点难以理解而且我暂时没用到不太需要）
}

public class PoolData
{
    public GameObject fatherObj;
    public List poolList;
    public PoolData(GameObject obj,GameObject poolObj)
    {
        fatherObj   = new GameObject(obj.name);
        fatherObj.transform.parent=poolObj.transform;
        poolList = new List(){obj };
    }
}

缓存池模块结合资源加载模块

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
/// 
/// 抽屉数据  池子中的一列容器
/// 
public class PoolData
{
    //抽屉中 对象挂载的父节点
    public GameObject fatherObj;
    //对象的容器
    public List poolList;
    public PoolData(GameObject obj, GameObject poolObj)
    {
        //给我们的抽屉 创建一个父对象 并且把他作为我们pool(衣柜)对象的子物体
        fatherObj = new GameObject(obj.name);
        fatherObj.transform.parent = poolObj.transform;
        poolList = new List() {};
        PushObj(obj);
    }
    /// 
    /// 往抽屉里面 压都东西
    /// 
    /// 
    public void PushObj(GameObject obj)
    {
        //失活 让其隐藏
        obj.SetActive(false);
        //存起来
        poolList.Add(obj);
        //设置父对象
        obj.transform.parent = fatherObj.transform;
    }
    /// 
    /// 从抽屉里面 取东西
    /// 
    /// 
    public GameObject GetObj()
    {
        GameObject obj = null;
        //取出第一个
        obj = poolList[0];
        poolList.RemoveAt(0);
        //激活 让其显示
        obj.SetActive(true);
        //断开了父子关系
        obj.transform.parent = null;
        return obj;
    }
}
/// 
/// 缓存池模块
/// 1.Dictionary List
/// 2.GameObject 和 Resources 两个公共类中的 API 
/// 
public class PoolMgr : BaseManager
{
    //缓存池容器 （衣柜）
    public Dictionary poolDic = new Dictionary();
    private GameObject poolObj;
    /// 
    /// 往外拿东西
    /// 
    /// 
    /// 
    public void GetObj(string name, UnityAction callBack)
    {
        //有抽屉 并且抽屉里有东西
        if (poolDic.ContainsKey(name) && poolDic[name].poolList.Count > 0)
        {
            callBack(poolDic[name].GetObj());
        }
        else
        {
            //通过异步加载资源 创建对象给外部用
            ResMgr.GetInstance().LoadAsync(name, (o) =>
            {
                o.name = name;
                callBack(o);
            });
            //obj = GameObject.Instantiate(Resources.Load(name));
            //把对象名字改的和池子名字一样
            //obj.name = name;
        }
    }
    /// 
    /// 换暂时不用的东西给我
    /// 
    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));
        }
    }
    /// 
    /// 清空缓存池的方法 
    /// 主要用在 场景切换时
    /// 
    public void Clear()
    {
        poolDic.Clear();
        poolObj = null;
    }

事件中心模块

制作成就系统
任务记录
达成某种条件等等

减少代码量，减少复杂性,降低程序的耦合度
核心思路：设置事件中心将事件加进去事件发生时通知监听者
原理：基于字典和委托
KEY–事件的名字（玩家死亡，怪物死亡）
value–监听这个事件的对应的委托函数们
因为委托可以通过+=和-=所以可以有很多委托
需要事件的监听方法：两个参数，事件名和其监听者的委托函数
事件触发函数：得到哪个函数被触发了参数是name 找到委托函数并且触发

public class EventCenter : BaseManager
{
    private Dictionary eventDic =new Dictionary();
    public void AddEventListener(string name,UnityAction action)
    {
        if(eventDic.ContainsKey(name))
        {
            eventDic[name]+=action;
        }
        else
        {
            eventDic.Add(name,action);
        }

    }
    public void EventTrigger(string name)
    {
        if(eventDic.ContainsKey(name))
        {
            eventDic[name]();
        }

    }
}

事件中心会由开始到程序结束都存在
将UnityAction中传入Object参数增强事件系统的通用性

public class EventCenter : BaseManager
{
    private Dictionary> eventDic =new Dictionary>();
    public void AddEventListener(string name,UnityAction