Add new EventReference class

Author: adamgraham

Documentation~/articles/events.md

@@ -13,3 +13,7 @@ An event can be created through the Asset menu, `Zigurous > Events > Game Event`
 ### Game Event Listener
 
 A [GameEventListener](/api/Zigurous.Architecture/GameEventListener) component can be added to any game object that needs to listen for an event. This is a class that derives from `MonoBehaviour` and will register and unregister itself as a listener for the specified event. The listener also declares a standard `UnityEvent` response property that is invoked when the event is raised.
+
+### Event Reference
+
+The [EventReference](/api/Zigurous.Architecture/EventReference) class allows a `UnityEvent` or `GameEvent` to be referenced. The option to switch between the two choices is available in the editor. Anywhere you might declare a variable as a `UnityEvent` or a `GameEvent` consider declaring it as an `EventReference` for more flexibility.

Documentation~/articles/scriptable-variables.md

@@ -12,7 +12,7 @@ For example, the player can declare their hitpoints as a `FloatVariable` instead
 
 The downside with this is it can be cumbersome to create assets for every variable declared in a behaviour. Instead of declaring `FloatVariable` we can declare a `FloatReference` for additional flexibility. This allows the value to either be a constant value or a reference to a variable asset; the choice is customizable in the editor. These reference types derive from [ValueReference\<TValue, TVariable\>](/api/Zigurous.Architecture/ValueReference-2).
 
-Supported Types:
+### Supported Types
 
 - Bool
 - Bounds

Editor/Events/EventReferencePropertyDrawer.cs

@@ -0,0 +1,70 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Zigurous.Architecture.Editor
+{
+    [CustomPropertyDrawer(typeof(EventReference), true)]
+    public sealed class EventReferencePropertyDrawer : PropertyDrawer
+    {
+        private readonly string[] popupOptions = { "Use Unity Event", "Use Game Event" };
+        private static GUIStyle popupStyle;
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            if (popupStyle == null)
+            {
+                popupStyle = new GUIStyle(GUI.skin.GetStyle("PaneOptions"));
+                popupStyle.imagePosition = ImagePosition.ImageOnly;
+            }
+
+            SerializedProperty useUnityEvent = property.FindPropertyRelative("useUnityEvent");
+            SerializedProperty unityEvent = property.FindPropertyRelative("unityEvent");
+            SerializedProperty gameEvent = property.FindPropertyRelative("gameEvent");
+
+            label = EditorGUI.BeginProperty(position, label, property);
+
+            if (!useUnityEvent.boolValue) {
+                position = EditorGUI.PrefixLabel(position, label);
+            }
+
+            Rect popupRect = new Rect(position);
+            popupRect.width = popupStyle.fixedWidth + popupStyle.margin.right;
+            popupRect.height = EditorGUIUtility.singleLineHeight;
+            popupRect.y += (popupRect.height - popupStyle.fixedHeight) / 2f;
+            position.width -= popupRect.width;
+            popupRect.x += position.width;
+
+            EditorGUI.BeginChangeCheck();
+
+            int indent = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+
+            int result = EditorGUI.Popup(popupRect, useUnityEvent.boolValue ? 0 : 1, popupOptions, popupStyle);
+            useUnityEvent.boolValue = result == 0;
+
+            if (useUnityEvent.boolValue) {
+                EditorGUI.PropertyField(position, unityEvent, label, true);
+            } else {
+                EditorGUI.PropertyField(position, gameEvent, GUIContent.none, true);
+            }
+
+            if (EditorGUI.EndChangeCheck()) {
+                property.serializedObject.ApplyModifiedProperties();
+            }
+
+            EditorGUI.indentLevel = indent;
+            EditorGUI.EndProperty();
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            SerializedProperty useUnityEvent = property.FindPropertyRelative("useUnityEvent");
+            SerializedProperty unityEvent = property.FindPropertyRelative("unityEvent");
+            SerializedProperty gameEvent = property.FindPropertyRelative("gameEvent");
+
+            return EditorGUI.GetPropertyHeight(useUnityEvent.boolValue ? unityEvent : gameEvent, true);
+        }
+
+    }
+
+}

Editor/Events/EventReferencePropertyDrawer.cs.meta

@@ -32,26 +32,26 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
                 popupStyle.imagePosition = ImagePosition.ImageOnly;
             }
 
-            label = EditorGUI.BeginProperty(position, label, property);
-            position = EditorGUI.PrefixLabel(position, label);
-
-            EditorGUI.BeginChangeCheck();
-
             SerializedProperty useConstant = property.FindPropertyRelative("useConstant");
             SerializedProperty constantValue = property.FindPropertyRelative("constantValue");
             SerializedProperty variable = property.FindPropertyRelative("variable");
 
-            Rect buttonRect = new Rect(position);
-            buttonRect.width = popupStyle.fixedWidth + popupStyle.margin.right;
-            buttonRect.height = EditorGUIUtility.singleLineHeight;
-            buttonRect.y += (buttonRect.height - popupStyle.fixedHeight) / 2f;
-            position.width -= buttonRect.width;
-            buttonRect.x += position.width;
+            label = EditorGUI.BeginProperty(position, label, property);
+            position = EditorGUI.PrefixLabel(position, label);
+
+            Rect popupRect = new Rect(position);
+            popupRect.width = popupStyle.fixedWidth + popupStyle.margin.right;
+            popupRect.height = EditorGUIUtility.singleLineHeight;
+            popupRect.y += (popupRect.height - popupStyle.fixedHeight) / 2f;
+            position.width -= popupRect.width;
+            popupRect.x += position.width;
+
+            EditorGUI.BeginChangeCheck();
 
             int indent = EditorGUI.indentLevel;
             EditorGUI.indentLevel = 0;
 
-            int result = EditorGUI.Popup(buttonRect, useConstant.boolValue ? 0 : 1, popupOptions, popupStyle);
+            int result = EditorGUI.Popup(popupRect, useConstant.boolValue ? 0 : 1, popupOptions, popupStyle);
             useConstant.boolValue = result == 0;
 
             EditorGUI.PropertyField(position, useConstant.boolValue ? constantValue : variable, GUIContent.none, true);
@@ -68,12 +68,9 @@ public override float GetPropertyHeight(SerializedProperty property, GUIContent
         {
             SerializedProperty useConstant = property.FindPropertyRelative("useConstant");
             SerializedProperty constantValue = property.FindPropertyRelative("constantValue");
+            SerializedProperty variable = property.FindPropertyRelative("variable");
 
-            if (useConstant.boolValue) {
-                return EditorGUI.GetPropertyHeight(constantValue, true);
-            } else {
-                return base.GetPropertyHeight(property, label);
-            }
+            return EditorGUI.GetPropertyHeight(useConstant.boolValue ? constantValue : variable, true);
         }
 
     }

Editor/Variables/ValueReferencePropertyDrawer.cs

@@ -1,5 +1,4 @@
 using UnityEngine;
-using UnityEngine.Events;
 
 namespace Zigurous.Architecture
 {
@@ -13,13 +12,13 @@ public sealed class TimerEvents
         /// An event invoked every timer interval.
         /// </summary>
         [Tooltip("An event invoked every timer interval.")]
-        public UnityEvent onTick;
+        public EventReference onTick;
 
         /// <summary>
         /// An event invoked every timer completion.
         /// </summary>
         [Tooltip("An event invoked every timer completion.")]
-        public UnityEvent onComplete;
+        public EventReference onComplete;
     }
 
 }

Runtime/Behaviours/TimerEvents.cs

@@ -0,0 +1,69 @@
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace Zigurous.Architecture
+{
+    /// <summary>
+    /// A reference to a UnityEvent or a GameEvent.
+    /// </summary>
+    [System.Serializable]
+    public sealed class EventReference
+    {
+        /// <summary>
+        /// Uses a UnityEvent instead of a GameEvent.
+        /// </summary>
+        [Tooltip("Uses a UnityEvent instead of a GameEvent.")]
+        public bool useUnityEvent = true;
+
+        /// <summary>
+        /// The UnityEvent to use.
+        /// </summary>
+        [Tooltip("The UnityEvent to use.")]
+        public UnityEvent unityEvent;
+
+        /// <summary>
+        /// The GameEvent to use.
+        /// </summary>
+        [Tooltip("The GameEvent to use.")]
+        public GameEvent gameEvent;
+
+        /// <summary>
+        /// Creates a new event reference.
+        /// </summary>
+        public EventReference() {}
+
+        /// <summary>
+        /// Creates a new event reference to the UnityEvent.
+        /// </summary>
+        /// <param name="unityEvent">The UnityEvent to use.</param>
+        public EventReference(UnityEvent unityEvent)
+        {
+            this.useUnityEvent = true;
+            this.unityEvent = unityEvent;
+        }
+
+        /// <summary>
+        /// Creates a new event reference to the GameEvent.
+        /// </summary>
+        /// <param name="gameEvent">The GameEvent to use.</param>
+        public EventReference(GameEvent gameEvent)
+        {
+            this.useUnityEvent = false;
+            this.gameEvent = gameEvent;
+        }
+
+        /// <summary>
+        /// Invokes or raises the event depending on the type.
+        /// </summary>
+        public void Invoke()
+        {
+            if (useUnityEvent) {
+                unityEvent?.Invoke();
+            } else {
+                gameEvent?.Raise();
+            }
+        }
+
+    }
+
+}