009 == Unity 事件系统加强版

结构：
	public struct SafeAction  			---对系统的Action加工
	public static class EventsExtension             ---对系统Event扩展
	
	外界一个事件中心控制
	namespace GameEvent
	

============事件系统==================

结构：
	public struct SafeAction  			---对系统的Action加工
	public static class EventsExtension ---对系统Event扩展
	
	外界一个事件中心控制
	namespace GameEvent
	

using System;

namespace Utils
{
    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction
    {
        Action act;

        //implicit:数据类型的隐式转换
        public static implicit operator Action(SafeAction a)
        {
            return a.act;
        }

        //安全转换
        public static implicit operator SafeAction(Action a)
        {
            SafeAction res = new SafeAction();
            res.act = a;
            return res;
        }


        //operator:运算符重载
        public static SafeAction operator +(SafeAction a, Action b)
        {
            a.act -= b;
            SafeAction res = new SafeAction();
            res.act = a.act + b;

            return res;
        }

        public static SafeAction operator -(SafeAction a, Action b)
        {
            SafeAction res = new SafeAction();
            res.act = a.act - b;
            return res;
        }


        //调用Invoke=================================
        public void SafeInvoke()
        {
            act.SafeInvoke();
        }

        //对象池是否为空
        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        //置空
        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T>
    {
        Action<T> act;

        public static implicit operator Action<T>(SafeAction<T> a)
        {
            return a.act;
        }

        public static implicit operator SafeAction<T>(Action<T> a)
        {
            SafeAction<T> res = new SafeAction<T>();
            res.act = a;
            return res;
        }
        public static SafeAction<T> operator +(SafeAction<T> a, Action<T> b)
        {
            a.act -= b;
            SafeAction<T> res = new SafeAction<T>();
            res.act = a.act + b;

            return res;
        }

        public static SafeAction<T> operator -(SafeAction<T> a, Action<T> b)
        {
            SafeAction<T> res = new SafeAction<T>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param)
        {
            act.SafeInvoke(param);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T, T2>
    {
        Action<T, T2> act;

        public static implicit operator Action<T, T2>(SafeAction<T, T2> a)
        {
            return a.act;
        }

        public static implicit operator SafeAction<T, T2>(Action<T, T2> a)
        {
            SafeAction<T, T2> res = new SafeAction<T, T2>();
            res.act = a;
            return res;
        }

        public static SafeAction<T, T2> operator +(SafeAction<T, T2> a, Action<T, T2> b)
        {
            a.act -= b;
            SafeAction<T, T2> res = new SafeAction<T, T2>();
            res.act = a.act + b;

            return res;
        }

        public static SafeAction<T, T2> operator -(SafeAction<T, T2> a, Action<T, T2> b)
        {
            SafeAction<T, T2> res = new SafeAction<T, T2>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param, T2 param2)
        {
            act.SafeInvoke(param, param2);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T, T2, T3>
    {
        Action<T, T2, T3> act;

        public static implicit operator Action<T, T2, T3>(SafeAction<T, T2, T3> a)
        {
            return a.act;
        }

        public static implicit operator SafeAction<T, T2, T3>(Action<T, T2, T3> a)
        {
            SafeAction<T, T2, T3> res = new SafeAction<T, T2, T3>();
            res.act = a;
            return res;
        }
        public static SafeAction<T, T2, T3> operator +(SafeAction<T, T2, T3> a, Action<T, T2, T3> b)
        {
            a.act -= b;
            SafeAction<T, T2, T3> res = new SafeAction<T, T2, T3>();
            res.act = a.act + b;

            return res;
        }

        public static SafeAction<T, T2, T3> operator -(SafeAction<T, T2, T3> a, Action<T, T2, T3> b)
        {
            SafeAction<T, T2, T3> res = new SafeAction<T, T2, T3>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param, T2 param2, T3 param3)
        {
            act.SafeInvoke(param, param2, param3);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T, T2, T3, T4>
    {
        Action<T, T2, T3, T4> act;

        public static implicit operator Action<T, T2, T3, T4>(SafeAction<T, T2, T3, T4> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeAction<T, T2, T3, T4>(Action<T, T2, T3, T4> a)
        {
            SafeAction<T, T2, T3, T4> res = new SafeAction<T, T2, T3, T4>();
            res.act = a;
            return res;
        }
        
        public static SafeAction<T, T2, T3, T4> operator +(SafeAction<T, T2, T3, T4> a, Action<T, T2, T3, T4> b)
        {
            a.act -= b;
            SafeAction<T, T2, T3, T4> res = new SafeAction<T, T2, T3, T4>();
            res.act = a.act + b;
            return res;
        }

        public static SafeAction<T, T2, T3, T4> operator -(SafeAction<T, T2, T3, T4> a, Action<T, T2, T3, T4> b)
        {
            SafeAction<T, T2, T3, T4> res = new SafeAction<T, T2, T3, T4>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param, T2 param2, T3 param3, T4 param4)
        {
            act.SafeInvoke(param, param2, param3,param4);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T, T2, T3, T4, T5>
    {
        Action<T, T2, T3, T4, T5> act;

        public static implicit operator Action<T, T2, T3, T4, T5>(SafeAction<T, T2, T3, T4, T5> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeAction<T, T2, T3, T4, T5>(Action<T, T2, T3, T4, T5> a)
        {
            SafeAction<T, T2, T3, T4, T5> res = new SafeAction<T, T2, T3, T4, T5>();
            res.act = a;
            return res;
        }
        public static SafeAction<T, T2, T3, T4, T5> operator +(SafeAction<T, T2, T3, T4, T5> a, Action<T, T2, T3, T4, T5> b)
        {
            a.act -= b;
            SafeAction<T, T2, T3, T4, T5> res = new SafeAction<T, T2, T3, T4, T5>();
            res.act = a.act + b;
            return res;
        }

        public static SafeAction<T, T2, T3, T4, T5> operator -(SafeAction<T, T2, T3, T4, T5> a, Action<T, T2, T3, T4, T5> b)
        {
            SafeAction<T, T2, T3, T4, T5> res = new SafeAction<T, T2, T3, T4, T5>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param, T2 param2, T3 param3, T4 param4, T5 param5)
        {
            act.SafeInvoke(param, param2, param3, param4, param5);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T>
    {
        Func<T> act;

        public static implicit operator Func<T>(SafeFunc<T> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeFunc<T>(Func<T> a)
        {
            SafeFunc<T> res = new SafeFunc<T>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T> operator +(SafeFunc<T> a, Func<T> b)
        {
            a.act -= b;
            SafeFunc<T> res = new SafeFunc<T>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T> operator -(SafeFunc<T> a, Func<T> b)
        {
            SafeFunc<T> res = new SafeFunc<T>();
            res.act = a.act - b;
            return res;
        }

        public T SafeInvoke()
        {
            return act.SafeInvoke();
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T, T2>
    {
        Func<T, T2> act;

        public static implicit operator Func<T, T2>(SafeFunc<T, T2> a)
        {
            return a.act;
        }
        public static implicit operator SafeFunc<T, T2>(Func<T, T2> a)
        {
            SafeFunc<T, T2> res = new SafeFunc<T, T2>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T, T2> operator +(SafeFunc<T, T2> a, Func<T, T2> b)
        {
            a.act -= b;
            SafeFunc<T, T2> res = new SafeFunc<T, T2>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T, T2> operator -(SafeFunc<T, T2> a, Func<T, T2> b)
        {
            SafeFunc<T, T2> res = new SafeFunc<T, T2>();
            res.act = a.act - b;
            return res;
        }

        public T2 SafeInvoke(T param)
        {
            return act.SafeInvoke(param);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T, T2, T3>
    {
        Func<T, T2, T3> act;

        public static implicit operator Func<T, T2, T3>(SafeFunc<T, T2, T3> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeFunc<T, T2, T3>(Func<T, T2, T3> a)
        {
            SafeFunc<T, T2, T3> res = new SafeFunc<T, T2, T3>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T, T2, T3> operator +(SafeFunc<T, T2, T3> a, Func<T, T2, T3> b)
        {
            a.act -= b;
            SafeFunc<T, T2, T3> res = new SafeFunc<T, T2, T3>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T, T2, T3> operator -(SafeFunc<T, T2, T3> a, Func<T, T2, T3> b)
        {
            SafeFunc<T, T2, T3> res = new SafeFunc<T, T2, T3>();
            res.act = a.act - b;
            return res;
        }

        public T3 SafeInvoke(T param, T2 param2)
        {
            return act.SafeInvoke(param, param2);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T, T2, T3, T4>
    {
        Func<T, T2, T3, T4> act;

        public static implicit operator Func<T, T2, T3, T4>(SafeFunc<T, T2, T3, T4> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeFunc<T, T2, T3, T4>(Func<T, T2, T3, T4> a)
        {
            SafeFunc<T, T2, T3, T4> res = new SafeFunc<T, T2, T3, T4>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T, T2, T3, T4> operator +(SafeFunc<T, T2, T3, T4> a, Func<T, T2, T3, T4> b)
        {
            a.act -= b;
            SafeFunc<T, T2, T3, T4> res = new SafeFunc<T, T2, T3, T4>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T, T2, T3, T4> operator -(SafeFunc<T, T2, T3, T4> a, Func<T, T2, T3, T4> b)
        {
            SafeFunc<T, T2, T3, T4> res = new SafeFunc<T, T2, T3, T4>();
            res.act = a.act - b;
            return res;
        }

        public T4 SafeInvoke(T param, T2 param2, T3 param3)
        {
            return act.SafeInvoke(param, param2, param3);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T, T2, T3, T4, T5>
    {
        Func<T, T2, T3, T4, T5> act;

        public static implicit operator Func<T, T2, T3, T4, T5>(SafeFunc<T, T2, T3, T4, T5> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeFunc<T, T2, T3, T4, T5>(Func<T, T2, T3, T4, T5> a)
        {
            SafeFunc<T, T2, T3, T4, T5> res = new SafeFunc<T, T2, T3, T4, T5>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T, T2, T3, T4, T5> operator +(SafeFunc<T, T2, T3, T4, T5> a, Func<T, T2, T3, T4, T5> b)
        {
            a.act -= b;
            SafeFunc<T, T2, T3, T4, T5> res = new SafeFunc<T, T2, T3, T4, T5>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T, T2, T3, T4, T5> operator -(SafeFunc<T, T2, T3, T4, T5> a, Func<T, T2, T3, T4, T5> b)
        {
            SafeFunc<T, T2, T3, T4, T5> res = new SafeFunc<T, T2, T3, T4, T5>();
            res.act = a.act - b;
            return res;
        }

        public T5 SafeInvoke(T param, T2 param2, T3 param3, T4 param4)
        {
            return act.SafeInvoke(param, param2, param3, param4);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }
}


using UnityEngine;
using System.Collections;
using System;
namespace Utils
{
    public delegate void Action<T, T2, T3, T4, T5>(T obj, T2 obj2, T3 obj3, T4 obj4, T5 obj5);
    public static class EventsExtension
    {           
        //无返回值
        public static void SafeInvoke(this Action evt)
        {
            if (evt != null)
                evt();
        }
        public static void SafeInvoke<T>(this Action<T> evt, T arg)
        {
            if (evt != null)
                evt(arg);
        }
        public static void SafeInvoke<T, T2>(this Action<T, T2> evt, T arg, T2 arg2)
        {
            if (evt != null)
                evt(arg, arg2);
        }
        public static void SafeInvoke<T, T2, T3>(this Action<T, T2, T3> evt, T arg, T2 arg2, T3 arg3)
        {
            if (evt != null)
                evt(arg, arg2, arg3);
        }
        public static void SafeInvoke<T, T2, T3, T4>(this Action<T, T2, T3, T4> evt, T arg, T2 arg2, T3 arg3, T4 arg4)
        {
            if (evt != null)
                evt(arg, arg2, arg3, arg4);
        }

        public static void SafeInvoke<T, T2, T3, T4, T5>(this Action<T, T2, T3, T4, T5> evt, T arg, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            if (evt != null)
                evt(arg, arg2, arg3, arg4, arg5);
        }

        //有返回值
        public static T SafeInvoke<T>(this Func<T> evt)
        {
            if (evt != null)
                return evt();
            else
                return default(T);
        }
        public static T2 SafeInvoke<T, T2>(this Func<T, T2> evt, T arg)
        {
            if (evt != null)
                return evt(arg);
            else
                return default(T2);
        }
        public static T3 SafeInvoke<T, T2, T3>(this Func<T, T2, T3> evt, T arg, T2 arg2)
        {
            if (evt != null)
                return evt(arg, arg2);
            else
                return default(T3);
        }
        public static T4 SafeInvoke<T, T2, T3, T4>(this Func<T, T2, T3, T4> evt, T arg, T2 arg2, T3 arg3)
        {
            if (evt != null)
                return evt(arg, arg2, arg3);
            else
                return default(T4);
        }
        public static T5 SafeInvoke<T, T2, T3, T4, T5>(this Func<T, T2, T3, T4, T5> evt, T arg, T2 arg2, T3 arg3, T4 arg4)
        {
            if (evt != null)
                return evt(arg, arg2, arg3, arg4);
            else
                return default(T5);
        }
    }

}

================事件中心=================================
using UnityEngine;
using System.Collections;
using Utils;
using System;

//1: 定义事件
//2：给事件注入方法(可以多个方法)
//3：调用事件

namespace GameEvent
{
    public static class UI//ui模块事件
    {
        public static SafeFunc<int> EventRuturnOne;
        
    }
    public static class Map//地图模块事件
    {
       
    }
    public static class Player//人物模块事件
    {
        //等级发生变化之后的事件
        public static SafeAction<int> EventLevelChange;
        
    }
}

==============================================================
实例：
	实现当人物等级 提升，相应的人物头顶等级，左上角头像UI人物等级
	属性面板的属性值，怪物生成的个数随等级增加个数也增加

 GameEvent.Player.EventLevelChange += updateLevel;

	//UI界面，头像等都有这个个函数
    void updateLevel(int level)
    {
        text.text = level.ToString();
    }	
	
 GameEvent.Player.EventLevelChange += createMonsterOnMap;
	//怪物生成
	private void createMonsterOnMap(int level)
    {
        StartCoroutine(createMonster(level));
    }
    IEnumerator createMonster(int level)
    {
        for(int i=0;i<level*2;i++)
        {
            //产生怪物（解决思路，要对象池）
            GameObject.Instantiate(prefabEnemy);//比较消耗性能
            yield return new WaitForSeconds(0.2f);
        }
    }