Draft/implement eventsystem

Assets/TierIV/Event/Scripts/BatteryObjectEvent.cs

@@ -0,0 +1,38 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using TierIV.Event;
+
+
+public class BatteryObjectEvent : MonoBehaviour
+{
+    // Start is called before the first frame update
+    void Start()
+    {
+    }
+
+    void OnEnable()
+    {
+        EventNotifier.Instance.SubscribeEvent(OnReceiveChargeEvent, "Charge");
+    }
+
+    void OnDisable()
+    {
+        EventNotifier.Instance.UnSubscribeEvent(OnReceiveChargeEvent);
+    }
+
+    void OnReceiveChargeEvent(EventArgsBase chargeEvent)
+    {
+        if (typeof(ChargeStationEvent.BatteryVolume).GetHashCode() != chargeEvent.TypeHash)
+        {
+            throw new System.ArgumentException(string.Format("different class hashcode {0}({1}) / {2}({3})",
+                typeof(ChargeStationEvent.BatteryVolume).GetHashCode(),
+                typeof(EventArgsBase).Name,
+                chargeEvent.TypeHash,
+                chargeEvent.GetType().Name
+            ));
+        }
+
+        // receive chargeEvent values to appropriate proces
+    }
+}

Assets/TierIV/Event/Scripts/ChargeStationEvent.cs

@@ -0,0 +1,33 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using TierIV.Event;
+
+public class ChargeStationEvent : MonoBehaviour
+{
+    public class BatteryVolume : EventArgsBase
+    {
+        public float parcentage;
+    }
+
+    BatteryVolume volume = new BatteryVolume { parcentage = 10f };
+
+    // Start is called before the first frame update
+    void Start()
+    {
+
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+
+    }
+
+    void OnTriggerStay(Collider target)
+    {
+        // send to event
+        EventNotifier.Instance.BroadcastEvent("Charge", volume);
+    }
+
+}

Assets/TierIV/Event/Scripts/EventArgsBase.cs

@@ -0,0 +1,15 @@
+
+public class EventArgsBase
+{
+    private int typeHash;
+
+    public int TypeHash
+    {
+        get { return typeHash; }
+    }
+
+    public EventArgsBase()
+    {
+        typeHash = this.GetType().GetHashCode();
+    }
+}

Assets/TierIV/Event/Scripts/EventNotifier.cs

@@ -0,0 +1,83 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace TierIV.Event
+{
+    public class EventNotifier
+    {
+        private static EventNotifier _instance = null;
+
+        public static EventNotifier Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new EventNotifier();
+                }
+
+                return _instance;
+            }
+        }
+
+        private EventNotifier()
+        {
+        }
+
+        public delegate void OnNotifyEvent(EventArgsBase text);
+        event OnNotifyEvent _notifyEvent;
+        Dictionary<string, OnNotifyEvent> _evt = new Dictionary<string, OnNotifyEvent>();
+
+        public void SubscribeEvent(OnNotifyEvent notifyEventHandler, string tag = "")
+        {
+            Debug.LogFormat("SubscribeEvent({0},{1})", notifyEventHandler, tag);
+            if (_evt.ContainsKey(tag))
+            {
+                _evt[tag] += notifyEventHandler;
+            }
+            else
+            {
+                _evt.Add(tag, notifyEventHandler);
+            }
+
+            _notifyEvent += notifyEventHandler;
+        }
+
+        public void UnSubscribeEvent(OnNotifyEvent notifyEventHandler)
+        {
+            foreach (var v in _evt)
+            {
+                var eh = v.Value;
+                eh -= notifyEventHandler;
+                _evt[v.Key] = eh;
+            }
+        }
+
+        public void BroadcastEvent(EventArgsBase value)
+        {
+            BroadcastEvent(null, value);
+        }
+
+        public void BroadcastEvent(string tag, EventArgsBase value)
+        {
+            List<OnNotifyEvent> handlerList = new List<OnNotifyEvent>();
+
+            // tag == null is all handler message send
+            if (tag == null)
+            {
+                handlerList.AddRange(_evt.Values);
+            }
+            else
+            {
+                handlerList.Add(_evt[tag]);
+            }
+
+            foreach (var handler in handlerList)
+            {
+                handler(value);
+            }
+        }
+    }
+}