六、事件管理中心

事件管理中心（观察者设计模式），这个模块能很大程度的减少代码的耦合度，减小代码之间的复杂性，是个非常重要的管理中心。

个人理解是，事件管理中心就是个广播站，他可以增加事件监听，然后当触发时，广播通知给所有监听的方法。如：玩家升级，需要通知给个人信息面板，主界面的玩家信息显示更新等级等等，同时通知给所有监听了这个“玩家升级”这个事件的地方。

• 框架基础
  EventCenter 事件中心，当前扩展使用，4个参数类型的方法监听，主要分为增加事件监听AddEventListener、触发事件EventTrigger、移除事件监听RemoveEventListener

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

public class EventCenter : SingletonBase<EventCenter>
{
    //字典中，key对应着事件的名字，
    //value对应的是监听这个事件对应的委托方法集
    private Dictionary<string, IEventFunc> dict_allEvent_zero = new Dictionary<string, IEventFunc>();
    private Dictionary<string, IEventFunc> dict_allEvent_one = new Dictionary<string, IEventFunc>();
    private Dictionary<string, IEventFunc> dict_allEvent_two = new Dictionary<string, IEventFunc>();
    private Dictionary<string, IEventFunc> dict_allEvent_three = new Dictionary<string, IEventFunc>();
    private Dictionary<string, IEventFunc> dict_allEvent_four = new Dictionary<string, IEventFunc>();

    //添加事件监听
    //第一个参数：事件的名字
    //第二个参数：处理事件的方法
    public void AddEventListener(string sName, UnityAction fun_temp) 
    {
        //有没有对应的事件监听
        //有的情况
        if (dict_allEvent_zero.ContainsKey(sName))
        {
            (dict_allEvent_zero[sName] as EventFuncList_Zero).AddEventFun(fun_temp);
        }
        //没有的情况
        else 
        {
            dict_allEvent_zero.Add(sName, new EventFuncList_Zero(fun_temp));
        }
    }

    //添加事件监听
    //第一个参数：事件的名字
    //第二个参数：处理事件的方法
    public void AddEventListener<T>(string sName, UnityAction<T> fun_temp) 
    {
        //有没有对应的事件监听
        //有的情况
        if (dict_allEvent_one.ContainsKey(sName))
        {
            (dict_allEvent_one[sName] as EventFuncList_One<T>).AddEventFun(fun_temp);
        }
        //没有的情况
        else 
        {
            dict_allEvent_one.Add(sName, new EventFuncList_One<T>(fun_temp));
        }
    }

        //添加事件监听
    //第一个参数：事件的名字
    //第二个参数：处理事件的方法
    public void AddEventListener<T0, T1>(string sName, UnityAction<T0, T1> fun_temp) 
    {
        //有没有对应的事件监听
        //有的情况
        if (dict_allEvent_two.ContainsKey(sName))
        {
            (dict_allEvent_two[sName] as EventFuncList_Two<T0, T1>).AddEventFun(fun_temp);
        }
        //没有的情况
        else 
        {
            dict_allEvent_two.Add(sName, new EventFuncList_Two<T0, T1>(fun_temp));
        }
    }

    //添加事件监听
    //第一个参数：事件的名字
    //第二个参数：处理事件的方法
    public void AddEventListener<T0, T1, T2>(string sName, UnityAction<T0, T1, T2> fun_temp) 
    {
        //有没有对应的事件监听
        //有的情况
        if (dict_allEvent_three.ContainsKey(sName))
        {
            (dict_allEvent_three[sName] as EventFuncList_Three<T0, T1, T2>).AddEventFun(fun_temp);
        }
        //没有的情况
        else 
        {
            dict_allEvent_three.Add(sName, new EventFuncList_Three<T0, T1, T2>(fun_temp));
        }
    }

    //添加事件监听
    //第一个参数：事件的名字
    //第二个参数：处理事件的方法
    public void AddEventListener<T0, T1, T2, T3>(string sName, UnityAction<T0, T1, T2, T3> fun_temp) 
    {
        //有没有对应的事件监听
        //有的情况
        if (dict_allEvent_four.ContainsKey(sName))
        {
            (dict_allEvent_four[sName] as EventFuncList_Four<T0, T1, T2, T3>).AddEventFun(fun_temp);
        }
        //没有的情况
        else 
        {
            dict_allEvent_four.Add(sName, new EventFuncList_Four<T0, T1, T2, T3>(fun_temp));
        }
    }

    /// <summary>
    /// 通过事件名字进行事件触发
    /// </summary>
    /// <param name="sName"></param>
    public void EventTrigger(string sName) 
    {
        //有没有对应的事件监听
        //有的情况（有人关心这个事件）
        if (dict_allEvent_zero.ContainsKey(sName))
        {
            //调用委托（依次执行委托中的方法）
            (dict_allEvent_zero[sName] as EventFuncList_Zero).Trigger();
        }
    }

    /// <summary>
    /// 通过事件名字进行事件触发
    /// </summary>
    /// <param name="sName"></param>
    public void EventTrigger<T>(string sName, T obj_temp) 
    {
        //有没有对应的事件监听
        //有的情况（有人关心这个事件）
        if (dict_allEvent_one.ContainsKey(sName))
        {
            //调用委托（依次执行委托中的方法）
            (dict_allEvent_one[sName] as EventFuncList_One<T>).Trigger(obj_temp);
        }
    }

    /// <summary>
    /// 通过事件名字进行事件触发
    /// </summary>
    /// <param name="sName"></param>
    public void EventTrigger<T0, T1>(string sName, T0 obj_temp1, T1 obj_temp2) 
    {
        //有没有对应的事件监听
        //有的情况（有人关心这个事件）
        if (dict_allEvent_two.ContainsKey(sName))
        {
            //调用委托（依次执行委托中的方法）
            (dict_allEvent_two[sName] as EventFuncList_Two<T0, T1>).Trigger(obj_temp1, obj_temp2);
        }
    }

    /// <summary>
    /// 通过事件名字进行事件触发
    /// </summary>
    /// <param name="sName"></param>
    public void EventTrigger<T0, T1, T2>(string sName, T0 obj_temp1, T1 obj_temp2, T2 obj_temp3) 
    {
        //有没有对应的事件监听
        //有的情况（有人关心这个事件）
        if (dict_allEvent_three.ContainsKey(sName))
        {
            //调用委托（依次执行委托中的方法）
            (dict_allEvent_three[sName] as EventFuncList_Three<T0, T1, T2>).Trigger(obj_temp1, obj_temp2, obj_temp3);
        }
    }

    /// <summary>
    /// 通过事件名字进行事件触发
    /// </summary>
    /// <param name="sName"></param>
    public void EventTrigger<T0, T1, T2, T3>(string sName, T0 obj_temp1, T1 obj_temp2, T2 obj_temp3, T3 obj_temp4) 
    {
        //有没有对应的事件监听
        //有的情况（有人关心这个事件）
        if (dict_allEvent_four.ContainsKey(sName))
        {
            //调用委托（依次执行委托中的方法）
            (dict_allEvent_four[sName] as EventFuncList_Four<T0, T1, T2, T3>).Trigger(obj_temp1, obj_temp2, obj_temp3, obj_temp4);
        }
    }

    /// <summary>
    /// 移除对应的事件监听
    /// </summary>
    /// <param name="sName"></param>
    /// <param name="fun_temp"></param>
    public void RemoveEventListener(string sName, UnityAction fun_temp) 
    {
        if (dict_allEvent_zero.ContainsKey(sName))
        {
            //移除这个委托
            (dict_allEvent_zero[sName] as EventFuncList_Zero).RemoveEventFun(fun_temp);
        }
    }

    /// <summary>
    /// 移除对应的事件监听
    /// </summary>
    /// <param name="sName"></param>
    /// <param name="fun_temp"></param>
    public void RemoveEventListener<T>(string sName, UnityAction<T> fun_temp) 
    {
        if (dict_allEvent_one.ContainsKey(sName))
        {
            //移除这个委托
            (dict_allEvent_one[sName] as EventFuncList_One<T>).RemoveEventFun(fun_temp);
        }
    }

        /// <summary>
    /// 移除对应的事件监听
    /// </summary>
    /// <param name="sName"></param>
    /// <param name="fun_temp"></param>
    public void RemoveEventListener<T0, T1>(string sName, UnityAction<T0, T1> fun_temp) 
    {
        if (dict_allEvent_two.ContainsKey(sName))
        {
            //移除这个委托
            (dict_allEvent_two[sName] as EventFuncList_Two<T0, T1>).RemoveEventFun(fun_temp);
        }
    }

        /// <summary>
    /// 移除对应的事件监听
    /// </summary>
    /// <param name="sName"></param>
    /// <param name="fun_temp"></param>
    public void RemoveEventListener<T0, T1, T2>(string sName, UnityAction<T0, T1, T2> fun_temp) 
    {
        if (dict_allEvent_three.ContainsKey(sName))
        {
            //移除这个委托
            (dict_allEvent_three[sName] as EventFuncList_Three<T0, T1, T2>).RemoveEventFun(fun_temp);
        }
    }

    /// <summary>
    /// 移除对应的事件监听
    /// </summary>
    /// <param name="sName"></param>
    /// <param name="fun_temp"></param>
    public void RemoveEventListener<T0, T1, T2, T3>(string sName, UnityAction<T0, T1, T2, T3> fun_temp) 
    {
        if (dict_allEvent_four.ContainsKey(sName))
        {
            //移除这个委托
            (dict_allEvent_four[sName] as EventFuncList_Four<T0, T1, T2, T3>).RemoveEventFun(fun_temp);
        }
    }

    /// <summary>
    /// 清空所有事件监听(主要用在切换场景时)
    /// </summary>
    public void Clear() 
    {
        dict_allEvent_zero.Clear();
        dict_allEvent_one.Clear();
        dict_allEvent_two.Clear();
        dict_allEvent_three.Clear();
        dict_allEvent_four.Clear();
    }
}