Event Bus (#23)

* Changes Made
+ Persistent Inventory Items Saving
+ Bag Refactored from SO to Serializable Class
+ Custom Json Serializer for SOs using Addressable
+ Small Utils Edits and Bug Fixes

* Changes Made
+ Lighting regenerated for game scene
+ Small modifications and added burst project settings files

* Refactored Functions in to states (just renames)

* Updated Unity version to v2022 LTS

* checkpoint

* checkpoint, refactored StateStatus enum to a bool IsEnabled

* added refactored and tested new state transitions

* pooling abstraction implemented, moved SerializableVector3.cs to Data package to fix core dependency compile error

* implemented spawner to hit effect on weapons

* Changes made
- Added serialized dictionary as an attribute to Generic Dictionary
- More improvements to Spawner

* checkpoint

* finished #16

* small DeSpawn fix for Spawner.cs

* EventBus implemented

* EventBus.cs implemented/refactored into Project

* namespace and class renames

* revert from merge

Author: rob1997

Packages/com.ekaka.character/Runtime/Damage/DefaultDeath.cs renamed to Packages/com.ekaka.character/Runtime/Damage/DefaultDeathHandler.cs

@@ -2,11 +2,11 @@
 
 namespace Character.Damage
 {
-    public class DefaultDeath : Death
+    public class DefaultDeathHandler : DeathHandler
     {
         public override void Apply(DamageData damage)
         {
-            Destroy(damage.Damagable.Obj);
+            Destroy(damage.Damageable.Obj);
         }
     }
 }

Packages/com.ekaka.character/Runtime/Damage/DefaultDeath.cs.meta renamed to Packages/com.ekaka.character/Runtime/Damage/DefaultDeathHandler.cs.meta

@@ -2,14 +2,14 @@
 using System.Collections.Generic;
 using System.Linq;
 using Core.Game;
-using Core.Utils;
+using Core.Common;
 using Damage.Main;
 using Sensors.Main;
 using UnityEngine;
 
 namespace Character.Main
 {
-    public abstract class Actor : MonoBehaviour, IDamagable
+    public abstract class Actor : MonoBehaviour, IDamageable
     {
         #region Ready
 
@@ -110,7 +110,7 @@ protected virtual void Start()
 
             else
             {
-                GameManager.Instance.OnReady += Initialize;
+                EventBus<GameManagerReady>.Subscribe(Initialize);
             }
         }
 
@@ -135,9 +135,9 @@ protected virtual void Initialize()
 
             #region Damagable
 
-            IDamagable damagable = this;
+            IDamageable damageable = this;
 
-            damagable.InitializeDamagable();
+            damageable.InitializeDamagable();
 
             #endregion
 

Packages/com.ekaka.character/Runtime/Main/Actor.cs

@@ -4,11 +4,11 @@
 using System.Linq;
 using System.Reflection;
 using System.Text.RegularExpressions;
-using Core.Utils;
+using Core.Common;
 using UnityEditor;
 using UnityEngine;
 
-namespace Editor.Core
+namespace Core.Editor
 {
     public static class BaseEditor
     {

Packages/com.ekaka.core/Editor/BaseEditor.cs

@@ -1,12 +1,12 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using Core.Utils;
+using Core.Common;
 using UnityEditor;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
-namespace Editor.Core
+namespace Core.Editor
 {
     [CustomPropertyDrawer(typeof(ObjectTypeAttribute))]
     public class ObjectTypePropertyDrawer : PropertyDrawer

Packages/com.ekaka.core/Editor/ObjectTypePropertyDrawer.cs

@@ -1,10 +1,10 @@
 using System.Collections;
 using System.Collections.Generic;
-using Core.Utils;
+using Core.Common;
 using UnityEditor;
 using UnityEngine;
 
-namespace Editor.Core
+namespace Core.Editor
 {
     [CustomPropertyDrawer(typeof(SceneListAttribute))]
     public class SceneListPropertyDrawer : PropertyDrawer

Packages/com.ekaka.core/Editor/SceneListPropertyDrawer.cs

@@ -1,9 +1,9 @@
 using System.Dynamic;
-using Core.Utils;
+using Core.Common;
 using UnityEditor;
 using UnityEngine;
 
-namespace Editor.Core
+namespace Core.Editor
 {
     [CustomPropertyDrawer(typeof(SerializedDictionaryAttribute), true)]
     public class SerializedDictionaryPropertyDrawer : PropertyDrawer

Packages/com.ekaka.core/Editor/SerializedDictionaryPropertyDrawer.cs

@@ -3,11 +3,11 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using Core.Utils;
+using Core.Common;
 using UnityEditor;
 using UnityEngine;
 
-namespace Editor.Core
+namespace Core.Editor
 {
     [CustomPropertyDrawer(typeof(ShowIfAttribute))]
     public class ShowIfPropertyDrawer : PropertyDrawer

Packages/com.ekaka.core/Editor/ShowIfPropertyDrawer.cs

@@ -1,12 +1,11 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using Core.Utils;
-using Editor.Core;
+using Core.Common;
 using UnityEditor;
 using UnityEngine;
 
-namespace Editor.Core
+namespace Core.Editor
 {
     [CustomPropertyDrawer(typeof(TagMask))]
     public class TagMaskPropertyDrawer : PropertyDrawer

Packages/com.ekaka.core/Editor/TagMaskPropertyDrawer.cs

@@ -4,7 +4,7 @@
 using System.Linq;
 using UnityEngine;
 
-namespace Core.Utils
+namespace Core.Common
 {
     [Serializable]
     public class ClipOverride

Packages/com.ekaka.core/Runtime/Utils.meta renamed to Packages/com.ekaka.core/Runtime/Common.meta

@@ -0,0 +1,253 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Core.Common
+{
+    public abstract class EventBase<TDelegate, TConcrete> where TDelegate : Delegate where TConcrete : EventBase<TDelegate, TConcrete>, new()
+    {
+        private readonly HashSet<TDelegate> _listeners = new HashSet<TDelegate>();
+
+        protected TDelegate eventHandler;
+
+        private readonly List<TDelegate> _oneTimeListeners = new List<TDelegate>();
+        
+        protected static TConcrete Instance { get; private set; } = new TConcrete();
+        
+        protected virtual void AddListener(TDelegate handler)
+        {
+            if (_listeners.Contains(handler))
+            {
+                throw new InvalidOperationException("Attempting to subscribe a method that is already subscribed.");
+            }
+
+            _listeners.Add(handler);
+        }
+
+        protected virtual void RemoveListener(TDelegate handler)
+        {
+            if (!_listeners.Contains(handler))
+            {
+                throw new InvalidOperationException("Attempting to unsubscribe a method that is not subscribed.");
+            }
+
+            _listeners.Remove(handler);
+            
+            if (_oneTimeListeners.Contains(handler))
+            {
+                _oneTimeListeners.Remove(handler);
+            }
+        }
+
+        private void ListenOneTime(TDelegate handler)
+        {
+            AddListener(handler);
+            
+            _oneTimeListeners.Add(handler);
+        }
+        
+        protected virtual void ClearOneTimeListeners()
+        {
+            foreach (TDelegate listener in _oneTimeListeners.ToList())
+            {
+                RemoveListener(listener);
+            }
+            
+            _oneTimeListeners.Clear();
+        }
+        
+        /// <summary>
+        /// Subscribe to event.
+        /// </summary>
+        /// <param name="handler">Listener method subscribing to event.</param>
+        public static void Subscribe(TDelegate handler)
+        {
+            Instance.AddListener(handler);
+        }
+        
+        /// <summary>
+        /// Subscribe to event for a single call.
+        /// </summary>
+        /// <param name="handler">Listener method subscribing to event.</param>
+        public static void SubscribeOneTime(TDelegate handler)
+        {
+            Instance.ListenOneTime(handler);
+        }
+        
+        /// <summary>
+        /// Unsubscribe from event.
+        /// </summary>
+        /// <param name="handler">Listener method unsubscribing to event.</param>
+        public static void Unsubscribe(TDelegate handler)
+        {
+            Instance.RemoveListener(handler);
+        }
+        
+        /// <summary>
+        /// Try to Unsubscribe from event.
+        /// This won't throw an exception if the listener is not subscribed.
+        /// </summary>
+        /// <param name="handler">Listener method subscribed to event.</param>
+        public static void TryUnsubscribe(TDelegate handler)
+        {
+            try
+            {
+                Instance.RemoveListener(handler);
+            }
+            catch (InvalidOperationException)
+            {
+                Debug.LogWarning("Attempting to unsubscribe a method that is not subscribed.");
+            }
+        }
+    }
+
+    public class EventBus<T> : EventBase<Action<T>, EventBus<T>> where T : IEventParams
+    {
+        private readonly Dictionary<Action, Action<T>> _actionMap = new Dictionary<Action, Action<T>>();
+
+        private readonly List<Action> _oneTimeListeners = new List<Action>();
+        
+        protected override void AddListener(Action<T> handler)
+        {
+            base.AddListener(handler);
+
+            eventHandler += handler;
+        }
+        
+        private void AddListener(Action handler)
+        {
+            if (_actionMap.ContainsKey(handler))
+            {
+                throw new InvalidOperationException("Attempting to subscribe a method that is already subscribed.");
+            }
+            
+            void Handler(T arg)
+            {
+                handler();
+            }
+
+            eventHandler += Handler;
+            
+            _actionMap.Add(handler, Handler);
+        }
+
+        private void ListenOneTime(Action handler)
+        {
+            AddListener(handler);
+            
+            _oneTimeListeners.Add(handler);
+        }
+        
+        /// <summary>
+        /// Subscribe to event.
+        /// </summary>
+        /// <param name="handler">Listener method subscribing to event.</param>
+        public static void Subscribe(Action handler)
+        {
+            Instance.AddListener(handler);
+        }
+        
+        /// <summary>
+        /// Subscribe to event for a single call.
+        /// </summary>
+        /// <param name="handler">Listener method subscribing to event.</param>
+        public static void SubscribeOneTime(Action handler)
+        {
+            Instance.ListenOneTime(handler);
+        }
+        
+        protected override void RemoveListener(Action<T> handler)
+        {
+            base.RemoveListener(handler);
+
+            eventHandler -= handler;
+        }
+        
+        private void RemoveListener(Action handler)
+        {
+            if (_actionMap.TryGetValue(handler, out Action<T> action))
+            {
+                _actionMap.Remove(handler);
+                
+                if (_oneTimeListeners.Contains(handler))
+                {
+                    _oneTimeListeners.Remove(handler);
+                }
+                
+                eventHandler -= action;
+            }
+
+            else
+            {
+                throw new InvalidOperationException("Attempting to unsubscribe a method that is not subscribed.");
+            }
+        }
+
+        /// <summary>
+        /// Unsubscribe from event.
+        /// </summary>
+        /// <param name="handler">Listener method subscribed to event.</param>
+        public static void Unsubscribe(Action handler)
+        {
+            Instance.RemoveListener(handler);
+        }
+        
+        /// <summary>
+        /// Try to Unsubscribe from event.
+        /// This won't throw an exception if the listener is not subscribed.
+        /// </summary>
+        /// <param name="handler">Listener method subscribed to event.</param>
+        public static void TryUnsubscribe(Action handler)
+        {
+            try
+            {
+                Instance.RemoveListener(handler);
+            }
+            catch (InvalidOperationException)
+            {
+                Debug.LogWarning("Attempting to unsubscribe a method that is not subscribed.");
+            }
+        }
+
+        private void Publish(T arg)
+        {
+            eventHandler?.Invoke(arg);
+            
+            ClearOneTimeListeners();
+        }
+        
+        /// <summary>
+        /// Invoke event.
+        /// </summary>
+        /// <param name="arg">Event argument.</param>
+        public static void Invoke(T arg)
+        {
+            Instance.Publish(arg);
+        }
+        
+        /// <summary>
+        /// Invoke event.
+        /// </summary>
+        public static void Invoke()
+        {
+            Instance.Publish(default);
+        }
+
+        protected override void ClearOneTimeListeners()
+        {
+            base.ClearOneTimeListeners();
+            
+            foreach (Action listener in _oneTimeListeners.ToList())
+            {
+                RemoveListener(listener);
+            }
+            
+            _oneTimeListeners.Clear();
+        }
+    }
+    
+    public interface IEventParams
+    {
+    }
+}