Implemented support for events without arg

Author: danigfedev

Editor/EditorUI.meta

@@ -0,0 +1,44 @@
+using UnityEditor;
+using System;
+using UnityEngine;
+
+namespace Editor.EditorUI
+{
+    public class BaseEventListenerCustomInspector : UnityEditor.Editor
+    {
+        protected const string EventSOVariableName = "_baseEvent";
+        
+        protected SerializedProperty _baseEventProp;
+        
+        protected virtual void OnEnable()
+        {
+            _baseEventProp = serializedObject.FindProperty(EventSOVariableName);
+        }
+        
+        protected void DrawEventInspector(string label, string tooltip, Func<UnityEngine.Object, bool> validationLogic)
+        {
+            serializedObject.Update();
+            // EditorGUILayout.Space();
+            // EditorGUILayout.LabelField("Event Configuration", EditorStyles.boldLabel);
+
+            EditorGUI.BeginChangeCheck();
+            var newObj = EditorGUILayout.ObjectField(new GUIContent(label, tooltip), _baseEventProp.objectReferenceValue, typeof(ScriptableObject), false);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (newObj == null || validationLogic(newObj))
+                {
+                    _baseEventProp.objectReferenceValue = newObj;
+                }
+                else
+                {
+                    EditorUtility.DisplayDialog("Compatibility Error",
+                        "The selected Asset does not implement the required interface.", "Ok");
+                }
+            }
+
+            DrawPropertiesExcluding(serializedObject, "m_Script", EventSOVariableName);
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Editor/EditorUI/BaseEventListenerCustomInspector.cs

@@ -0,0 +1,23 @@
+using System;
+using SOBaseEvents.Refactor;
+using UnityEditor;
+
+namespace Editor.EditorUI
+{
+    [CustomEditor(typeof(EventListener<>), true)]
+    [CanEditMultipleObjects]
+    public class EventListenerCustomInspector : BaseEventListenerCustomInspector
+    {
+        public override void OnInspectorGUI()
+        {
+            DrawEventInspector("Event Asset (Void)",
+                "Must implement ISOEventRegistry",
+                obj => ValidationLogic(obj));
+        }
+
+        private bool ValidationLogic(Object obj)
+        {
+            return obj is ISOEventBase && obj is ISOEventRegistry;
+        }
+    }
+}

Editor/EditorUI/BaseEventListenerCustomInspector.cs.meta

@@ -0,0 +1,43 @@
+using System;
+using SOBaseEvents.Refactor;
+using UnityEditor;
+using Object = UnityEngine.Object;
+
+namespace Editor.EditorUI
+{
+    [CustomEditor(typeof(EventListener<,>), true)]
+    [CanEditMultipleObjects]
+    public class EventListenerWithArgCustomInspector : BaseEventListenerCustomInspector
+    {
+        Type _tArg;
+        
+        private void OnEnable()
+        {
+            base.OnEnable();
+            var type = target.GetType();
+
+            while (type != null && (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(EventListener<,>)))
+            {
+                type = type.BaseType;
+            }
+
+            if (type != null)
+            {
+                _tArg = type.GetGenericArguments()[1];
+            }
+        }
+        
+        public override void OnInspectorGUI()
+        {
+            DrawEventInspector("Event Asset",
+                $"Must implement ISOEventRegistry<{(_tArg != null ? _tArg.Name : "T")}>",
+                obj => ValidationLogic(obj));
+        }
+
+        private bool ValidationLogic(Object obj)
+        {
+            var registryInterface = typeof(ISOEventRegistry<>).MakeGenericType(_tArg);
+            return obj is ISOEventBase && registryInterface.IsAssignableFrom(obj.GetType());
+        }
+    }
+}

Editor/EditorUI/EventListenerCustomInspector.cs

@@ -3,6 +3,31 @@
 
 namespace SOBaseEvents.Refactor
 {
+    public abstract class EventListener<TEvent> : MonoBehaviour where TEvent : class, ISOEventRegistry
+    {
+        public event Action OnEventRaised;
+        
+        [SerializeField] protected ScriptableObject _baseEvent;  
+        
+        protected TEvent _typedEvent => _baseEvent as TEvent;
+
+        private void OnEnable()
+        {
+            if (_typedEvent != null)
+            {
+                _typedEvent.AddListener(OnEventRaised);
+            }
+        }
+
+        private void OnDisable()
+        {
+            if (_typedEvent != null)
+            {
+                _typedEvent.RemoveListener(OnEventRaised);
+            }
+        }
+    }
+    
     public abstract class EventListener<TEvent, TArg> : MonoBehaviour where TEvent : class, ISOEventRegistry<TArg>
     {
         public event Action<TArg> OnEventRaised;

Editor/EditorUI/EventListenerCustomInspector.cs.meta

@@ -4,6 +4,60 @@
 
 namespace SOBaseEvents.Refactor
 {
+    public abstract class EventSOBase : ScriptableObject, ISOEventBase, ISOEventRegistry, ISOEventRaiser
+    {
+        private readonly List<Action> _listeners = new();
+        
+        public void AddListener(Action listener)
+        {
+            if (_listeners.Contains(listener))
+            {
+                var (objectName, methodName) = GetListenerInfo(listener);
+                Debug.LogError($"[ScriptableObjectEvents] Listener {methodName} of GameObject {objectName} already registered. Aborting registration.");
+                return;
+            }
+            
+            _listeners.Add(listener);
+        }
+
+        public void RemoveListener(Action listener)
+        {
+            if (!_listeners.Contains(listener))
+            {
+                var (objectName, methodName) = GetListenerInfo(listener);
+                Debug.LogError($"[ScriptableObjectEvents] Listener {methodName} of GameObject {objectName} is not registered. Aborting removal.");
+                return;
+            }
+
+            _listeners.Remove(listener);
+        }
+
+        public void RaiseEvent()
+        {
+            for (int i = _listeners.Count - 1; i >= 0; i--)
+            {
+                _listeners[i]?.Invoke();
+            }
+        }
+        
+        private (string objectName, string methodName) GetListenerInfo(Action listener)
+        {
+            var objectName = string.Empty;
+            var methodName = listener.Method.Name;
+                
+            if (listener.Target is MonoBehaviour mb)
+            {
+                objectName = mb.gameObject.name;
+            }
+            else if (listener.Target != null)
+            {
+                objectName = listener.Target.ToString();
+            }
+
+            return (objectName, methodName);
+        }
+    }
+    
     public abstract class EventSOBase<TArg> : ScriptableObject, ISOEventBase, ISOEventRegistry<TArg>, ISOEventRaiser<TArg>
     {
         private readonly List<Action<TArg>> _listeners = new();