unity实现自己的一个消息系统

  unity中应该至少有2类Event系统。一种是UnityEvent,这个用起来很方便，只要在脚本里定义了一个UnityEvent，就可以在面板通过拖拉的方式设置消息的响应者。但问题是如果是不能在面板拖来拖去的场合，就有点繁琐。而且假如有一大波新对象需要接收老信息，这个维护起来很是很繁琐的。还有一种是利用了Eventsystem的消息系统，但这个系统与ui系统整合，虽然仍然可以自定义消息，但是只要是同一个物体上挂接了多个同类消息的触发器，就会被全部执行这一点，在某些时候是很不方便的（比方说我们希望消息按照确定的响应顺序执行）为此，我决定写一个自己的消息系统，实现消息的自动注册，并且可以通过参数来控制响应顺序。只要物体上挂接了对应的sensor（listener），不管trigger在什么位置，都可以接收到对应的消息。这样整个消息系统里面有新的对象加入，都没有必要去维护老的代码。

  首先我们定义一个Event基类，因为不直接使用本类所以定义为abstract，并且提供一个区分事件ID接口来让子类实现。

//事件基类 派生的事件可以包含更多的数据结构
    //标识为abstract 防止直接使用该类
    public abstract class Event
    {
        abstract public int EventID
        {
            get;
        }
        GameObject _sender;
        public GameObject Sender
        {
            get { return _sender; }
            set { _sender = value; }
        }

        GameObject _target;
        public GameObject Target
        {
            get { return _target; }
            set { _target = value; }
        }

        //广播 标识该事件如何发送以及是否可以中途中断传递
        bool _need_broadCast = true;
        public bool BroadCarst
        {
            get { return _need_broadCast; }
            set { _need_broadCast = value; }
        }

        //重置属性  可覆写该函数以初始化自定义的事件数据
        virtual public void reset()
        {
            _sender = null;
            _target = null;
            _need_broadCast = true;
        }
    }

接下来是感知器。为了让管理中心能够管理所有的感知器，先设计一个基础的接口，继承compare接口是为了实现优先权的排序。

public interface BaseSensor : IComparable<BaseSensor>
    {
        //虚基础属性接口
        int Priority { get; set; }
        int EventID { get; }
        GameObject gb { get; }
        bool EnableSensor { get; set; }

        //消息处理接口
        void OnEvent<T>(T t) where T:Event;
    }

所有可用感知器应从一个模版派生。在start函数中调用EventCenter注册自身，这样我们就不用自己去研究接口的注册。

 public abstract class Sensor<T> : MonoBehaviour, BaseSensor where T : Event, new()
    {
        virtual public void Start()
        {
            EventCenter.Instance.RigisterSensor<T>(this);
        }

        /BaseSensor interface imp

        //是否激活
        bool _enableSensor = true;
        public bool EnableSensor
        {
            get { return _enableSensor; }
            set { _enableSensor = value; }
        }

        int priority = 0;
        public int Priority
        {
            get { return priority; }
            set { priority = value; }
        }

        int _eventid = 0;
        public int EventID
        {
            get
            {
                if (_eventid == 0)
                {
                    T t = new T();
                    _eventid = t.EventID;
                }
                return _eventid;
            }
        }

        GameObject BaseSensor.gb
        {
            get
            {
                return gameObject;
            }
        }

        ///

        public int CompareTo(BaseSensor other) { return other.Priority - priority; }

        /// ///

        abstract public void OnEvent<T>(T t) where T : Event;
    }

接下来是EventCenter的代码。使用字典及list来保存注册的感知器。使用sort保证按我们想要的顺序执行事件的处理。

 //事件中心
    public class EventCenter : Singleton<EventCenter>
    {
        Dictionary<int, List<BaseSensor>> _eventMap = new Dictionary<int, List<BaseSensor>>();

        //注册 如果已经注册返回FALSE
        public bool RigisterSensor<T>(Sensor<T> s) where T : Event, new()
        {
            if (s)
            {
                if (_eventMap.ContainsKey(s.EventID))
                {
                    List<BaseSensor> bs = _eventMap[s.EventID];
                    if (bs.Contains(s))
                        return false;
                    else
                    {
                        bs.Add(s);
                        bs.Sort();
                        Debug.Log("add list " + bs.Count + "  priority is " + s.Priority);
                        return true;
                    }
                }
                else
                {
                    List<BaseSensor> bs = new List<BaseSensor>();
                    _eventMap.Add(s.EventID, bs);
                    Debug.Log("add map " + s.EventID);
                    bs.Add(s);
                    bs.Sort();
                    Debug.Log("add list " + bs.Count + "  priority is " + s.Priority);
                    return true;
                }
            }
            return false;
        }
        //反注册 如果没有注册返回false
        public bool UnRigisterSensor<T>(Sensor<T> s) where T : Event, new()
        {
            if (s)
            {
                if (_eventMap.ContainsKey(s.EventID))
                {
                    List<BaseSensor> bs = _eventMap[s.EventID];
                    return bs.Remove(s);
                }
            }
            return false;
        }

        public void OnEvent<T>(T t) where T : Event
        {
            Debug.Log("on event  " + t.EventID);
            if (_eventMap.ContainsKey(t.EventID))
            {
                Debug.Log("has eventid");
                List<BaseSensor> bs = _eventMap[t.EventID];
                foreach (var item in bs)
                {
                    Debug.Log("deal sensor" + item.gb.GetHashCode() + " enablesensor  " + item.EnableSensor);
                    if (t.BroadCarst && item.EnableSensor)
                    {
                        item.OnEvent<T>(t);
                    }
                }
            }
        }

        ~EventCenter()
        {
            _eventMap = null;
        }
    }

触发器很简单。只需要脚本中调用EventCenter的onEvent即可。这里提供一个可以每帧自动循环检查触发条件的trigger基类。这个可以根据自身的需要写不同的触发器。

//帧循环触发器基类
    public abstract class Trigger<T> : MonoBehaviour where T : Event, new()
    {
        //保存一个事件信息的结构 用于发送
        private T t = new T();
        protected T EventData
        {
            get
            {
                t.reset();
                t.Sender = gameObject;
                return t;
            }
        }

        //检查触发条件（每帧循环）
        abstract protected bool Check();

        protected void fire()
        {
             EventCenter.Instance.OnEvent<T>(t);
        }

        // Update is called once per frame
        void Update()
        {
            //use monobehaviour enable
            if (enabled)
            {
                if (Check())
                    fire();
            }
        }
    }

这样整个自身的EventSystem就搭建完毕。使用时，应先定义一个自己的事件：

public class TestEvent : GD3.Event
{
    public override int EventID
    {
        get
        {
            return 1;
        }
    }
}

然后使用该Event派生对应的Trigger及Sensor.

public class TestTrigger : Trigger<TestEvent> {
    int i = 120;

    protected override bool Check()
    {
        i = i - 1;
        if (i <= 0)
        {
            Debug.Log("checked trigger happen");
            i = 120;
            TestEvent t = EventData;
            t.BroadCarst = true;
            return true;
        }
        else
            return false;
    }
}

public class TestSensor : GD3.Sensor<TestEvent> {
    static int p = 5;
    public override void Start()
    {
        this.Priority = p;    
        if (p == 6)
        {
            Debug.Log("p == 6");
            EnableSensor = false;
        }

        p = p + 1;
        base.Start();
        
    }

    public override void OnEvent<TestEvent>(TestEvent t)
    {
        Debug.Log("event on " + this.GetHashCode() + " p is " + Priority);
    }

}

最后将trigger及sensor脚本挂接到具体的物体上即可。只要写好了这2个脚本，随便挂接任何物体，都可以接收到对应的事件消息。

另附一个EventCenter使用的比较简单的单例模式。需要注意的是这个单例模版不能应用到任何一个unity的类型上面，只能是自己写的类，继承UNITY的也不行。

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

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

    public void destroy()
    {
        instance = default(T);
    }
}