Update game event editors (#21)

* Update game event editors

* Use None as default reset type

* Update changelog

* Update usage readme

Author: Edvinas01

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.0] - 2020-10-13
+
+### Changed
+- Made game event editors more user-friendly.
+- Naming in asset menus for game events.
+- Listeners are now exposed as an unmodifiable `ICollection`.
+
 ## [1.0.0-rc.1] - 2020-10-11
 
 ## [0.7.0] - 2020-10-11

Documentation~/README.md

@@ -17,7 +17,7 @@ Game events are scriptable objects (_Right Click -> Create -> Game Events -> ...
 Available game events:
 - `GameEvent` - simple event which doesn't accept any arguments.
 - `BoolGameEvent` - event with a `bool` argument.
-- `IntGameEvent` - event with a `int` argument.
+- `IntGameEvent` - event with an `int` argument.
 - `FloatGameEvent` - event with a `float` argument.
 - `StringGameEvent` - event with a `string` argument.
 - `Vector2GameEvent` - event with a `Vector2` argument.
@@ -35,20 +35,20 @@ Mutable objects are used for storing and editing data on `ScriptableObject` asse
 
 Available mutable objects:
 - `MutableBool` - encapsulates a `bool` value.
-- `MutableInt` - encapsulates a `int` value.
+- `MutableInt` - encapsulates an `int` value.
 - `MutableFloat` - encapsulates a `float` value.
 - `MutableString` - encapsulates a `string` value.
 - `MutableVector2` - encapsulates a `Vector2` value.
 - `MutableVector3` - encapsulates a `Vector3` value.
 
 Each mutable object has a `ResetType` property. This allows specifying when data in the mutable object should be reset. The following modes are available:
-- `None` - do not reset.
+- `None` - do not reset (default).
 - `ActiveSceneChange` - when the active (focused) scene changes.
 - `SceneUnloaded` - when the current scene gets unloaded.
 - `SceneLoaded` - when the scene is loaded.
 
 ### Custom game events
-In some situations, built-in game events might not suffice. For example if a custom type needs to be passed as an argument to the event. In this case, custom game event can be created which would carry all the necessary data.
+In some situations, built-in game events might not suffice. For example if a custom type needs to be passed as an argument to the event. In this case, a custom game event can be created which would carry all the necessary data.
 
 To create a custom game event, first create a regular `UnityEvent`:
 ```cs
@@ -74,7 +74,7 @@ public class CustomGameEventListener : ArgumentGameEventListener<CustomGameEvent
 }
 ```
 
-Optionally add a custom editor so that the event could be raised, and the listeners which reference the event get displayed in the inspector.
+, add a custom editor so that the event could be raised, and the listeners which reference the event get displayed in the inspector.
 ```cs
 [CustomEditor(typeof(CustomGameEvent))]
 public class GameObjectGameEventEditor : ArgumentGameEventEditor<CustomGameEvent, Custom>

Editor/GameEvents/Game/GameEventEditor.cs

@@ -8,8 +8,6 @@ namespace GameEvents.Game
     [CustomEditor(typeof(GameEvent))]
     public class GameEventEditor : Editor
     {
-        private const int GroupSpacingPixels = 8;
-
         public override void OnInspectorGUI()
         {
             base.OnInspectorGUI();
@@ -21,7 +19,7 @@ public override void OnInspectorGUI()
             }
 
             GUI.enabled = Application.isPlaying;
-            GUILayout.Space(GroupSpacingPixels);
+            EditorGUILayout.Space();
 
             DrawRaise(gameEvent);
 
@@ -30,29 +28,17 @@ public override void OnInspectorGUI()
                 return;
             }
 
-            GUILayout.Space(GroupSpacingPixels);
-            DrawListeners(gameEvent);
+            EditorGUILayout.Space();
+            GameEventEditors.DrawReferences(gameEvent);
         }
 
         private static void DrawRaise(IGameEvent gameEvent)
         {
-            GUILayout.Label("Raise event (play mode only)");
+            GameEventEditors.DrawPlaymodeLabel("Raise event");
             if (GUILayout.Button("Raise"))
             {
                 gameEvent.RaiseGameEvent();
             }
         }
-
-        private static void DrawListeners(IGameEvent gameEvent)
-        {
-            GUILayout.Label("Listeners");
-            foreach (var listener in gameEvent.Listeners)
-            {
-                if (listener is MonoBehaviour behaviour)
-                {
-                    EditorGUILayout.ObjectField(behaviour, typeof(Object), true);
-                }
-            }
-        }
     }
 }

Editor/GameEvents/GameEventEditors.cs

@@ -0,0 +1,69 @@
+using System.Collections.Generic;
+using GameEvents.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace GameEvents
+{
+    public static class GameEventEditors
+    {
+        /// <summary>
+        ///     Draw a list of argument game event listener references.
+        /// </summary>
+        public static void DrawReferences<TArgument>(
+            IArgumentGameEvent<TArgument> gameEvent
+        )
+        {
+            DrawListeners(gameEvent.Listeners);
+        }
+
+        /// <summary>
+        ///     Draw a list of game event listener references.
+        /// </summary>
+        public static void DrawReferences(IGameEvent gameEvent)
+        {
+            DrawListeners(gameEvent.Listeners);
+        }
+
+        /// <summary>
+        ///     Draw a label which changes its suffix based on play mode state.
+        /// </summary>
+        public static void DrawPlaymodeLabel(string text)
+        {
+            var labelSuffix = Application.isPlaying ? "" : "(play mode only)";
+            GUILayout.Label($"{text} {labelSuffix}");
+        }
+
+        private static void DrawListeners<T>(ICollection<T> listeners)
+        {
+            DrawPlaymodeLabel("Listeners");
+            if (Application.isPlaying)
+            {
+                if (listeners.Count == 0)
+                {
+                    EditorGUILayout.HelpBox(
+                        "There are no listeners on this event",
+                        MessageType.Warning
+                    );
+
+                    return;
+                }
+
+                foreach (var listener in listeners)
+                {
+                    if (listener is MonoBehaviour behaviour)
+                    {
+                        EditorGUILayout.ObjectField(behaviour, typeof(Object), true);
+                    }
+                }
+            }
+            else
+            {
+                EditorGUILayout.HelpBox(
+                    "Registered listeners will be displayed here",
+                    MessageType.Info
+                );
+            }
+        }
+    }
+}

Editor/GameEvents/GameEventEditors.cs.meta

@@ -7,8 +7,6 @@ namespace GameEvents.Generic
     public abstract class ArgumentGameEventEditor<TGameEvent, TArgument> : Editor
         where TGameEvent : class, IArgumentGameEvent<TArgument>
     {
-        private const int GroupSpacingPixels = 8;
-
         private TArgument argumentValue = default;
 
         public override void OnInspectorGUI()
@@ -21,22 +19,17 @@ public override void OnInspectorGUI()
             }
 
             GUI.enabled = Application.isPlaying;
-            GUILayout.Space(GroupSpacingPixels);
+            EditorGUILayout.Space();
 
             DrawRaise(gameEvent);
 
-            if (!Application.isPlaying)
-            {
-                return;
-            }
-
-            GUILayout.Space(GroupSpacingPixels);
-            DrawListeners(gameEvent);
+            EditorGUILayout.Space();
+            GameEventEditors.DrawReferences(gameEvent);
         }
 
         private void DrawRaise(TGameEvent gameEvent)
         {
-            GUILayout.Label("Raise event (play mode only)");
+            GameEventEditors.DrawPlaymodeLabel("Raise event");
             GUILayout.BeginHorizontal();
 
             argumentValue = DrawArgumentField(argumentValue);
@@ -48,18 +41,6 @@ private void DrawRaise(TGameEvent gameEvent)
             GUILayout.EndHorizontal();
         }
 
-        private static void DrawListeners(TGameEvent gameEvent)
-        {
-            GUILayout.Label("Listeners");
-            foreach (var listener in gameEvent.Listeners)
-            {
-                if (listener is MonoBehaviour behaviour)
-                {
-                    EditorGUILayout.ObjectField(behaviour, typeof(Object), true);
-                }
-            }
-        }
-
         /// <returns>
         ///     Value that is entered in the argument field.
         /// </returns>

Editor/GameEvents/Generic/ArgumentGameEventEditor.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using GameEvents.Generic;
 using UnityEngine;
 
@@ -11,10 +12,17 @@ public class GameEvent : ScriptableObject, IGameEvent
         [Tooltip("Should debug messages be logged for this event")]
         private bool debug = false;
 
+        private readonly ReadOnlyCollection<IGameEventListener> readListeners;
+
         private readonly List<IGameEventListener> listeners =
             new List<IGameEventListener>();
 
-        public IEnumerable<IGameEventListener> Listeners => listeners;
+        public ICollection<IGameEventListener> Listeners => readListeners;
+
+        public GameEvent()
+        {
+            readListeners = listeners.AsReadOnly();
+        }
 
         public void RaiseGameEvent()
         {

Runtime/GameEvents/Game/GameEvent.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using UnityEngine;
 
 namespace GameEvents.Generic
@@ -10,10 +11,17 @@ public abstract class ArgumentGameEvent<TArgument>
         [Tooltip("Should debug messages be logged for this event")]
         private bool debug = false;
 
+        private readonly ReadOnlyCollection<IArgumentGameEventListener<TArgument>> readListeners;
+
         private readonly List<IArgumentGameEventListener<TArgument>> listeners =
             new List<IArgumentGameEventListener<TArgument>>();
 
-        public IEnumerable<IArgumentGameEventListener<TArgument>> Listeners => listeners;
+        public ICollection<IArgumentGameEventListener<TArgument>> Listeners => readListeners;
+
+        public ArgumentGameEvent()
+        {
+            readListeners = listeners.AsReadOnly();
+        }
 
         public void RaiseGameEvent(TArgument argument)
         {

Runtime/GameEvents/Generic/ArgumentGameEvent.cs

@@ -7,7 +7,7 @@ public interface IArgumentGameEvent<TArgument>
         /// <summary>
         ///     Currently registered listeners.
         /// </summary>
-        IEnumerable<IArgumentGameEventListener<TArgument>> Listeners { get; }
+        ICollection<IArgumentGameEventListener<TArgument>> Listeners { get; }
 
         /// <summary>
         ///     Raise this event with an argument.

Runtime/GameEvents/Generic/IArgumentGameEvent.cs

@@ -7,7 +7,7 @@ public interface IGameEvent
         /// <summary>
         ///     Currently registered listeners.
         /// </summary>
-        IEnumerable<IGameEventListener> Listeners { get; }
+        ICollection<IGameEventListener> Listeners { get; }
 
         /// <summary>
         ///     Raise this event.