com.wallstop-studios.dxmessaging 1.0.0-rc10

package/Runtime/Core/MessageRegistrationToken.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d5dce65290c6c424b870b19b6353e6b1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Messages/IBroadcastMessage.cs

@@ -0,0 +1,27 @@
+namespace DxMessaging.Core.Messages
+{
+    using System;
+
+    /// <summary>
+    /// Message from a specific entity but for any listener.
+    /// </summary>
+    /// <note>
+    /// BroadcastMessages should be thought of as reactionary. Things like "EntityX has died", "EntityX has picked up ItemZ",
+    /// or "EntityX has lost 1 health".
+    /// Inheritance should be completely flat. Ie, IBroadcastMessage should be the direct parent of every implementer.
+    /// </note>
+    public interface IBroadcastMessage : IMessage { }
+
+    /// <summary>
+    /// No-alloc BroadcastMessages. Derive from this type to not have your messages boxed (if they are structs).
+    /// <code>
+    /// public readonly MyCoolStruct : IBroadCastMessage{MyCoolStruct}
+    /// </code>
+    /// </summary>
+    /// <typeparam name="T">Concrete type of the derived. Should be the derived type and nothing else.</typeparam>
+    public interface IBroadcastMessage<T> : IBroadcastMessage where T: IBroadcastMessage
+    {
+        Type IMessage.MessageType => typeof(T);
+    }
+
+}

package/Runtime/Core/Messages/IBroadcastMessage.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ef4b123d67e3bcd4a8ebe2f18b3acbf9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Messages/ITargetedMessage.cs

@@ -0,0 +1,26 @@
+namespace DxMessaging.Core.Messages
+{
+    using System;
+
+    /// <summary>
+    /// Used to specify general-purposes messages that are meant to be sent to a specific entity.
+    /// </summary>
+    /// <note>
+    /// TargetedMessages should be thought of as commands. Things like "EntityX, pick up this rock" or
+    /// "EntityX, you successfully completed an active reload".
+    /// Inheritance should be completely flat. Ie, TargetedMessages should be the direct parent of every implementer.
+    /// </note>
+    public interface ITargetedMessage : IMessage { }
+
+    /// <summary>
+    /// No-alloc TargetedMessages. Derive from this type to not have your messages boxed (if they are structs).
+    /// <code>
+    /// public readonly MyCoolStruct : ITargetedMessage{MyCoolStruct}
+    /// </code>
+    /// </summary>
+    /// <typeparam name="T">Concrete type of the derived. Should be the derived type and nothing else.</typeparam>
+    public interface ITargetedMessage<T> : ITargetedMessage where T: ITargetedMessage
+    {
+        Type IMessage.MessageType => typeof(T);
+    }
+}

package/Runtime/Core/Messages/ITargetedMessage.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5b82bbdd13cb3654aafba14e0c21ca52
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Messages/IUntargetedMessage.cs

@@ -0,0 +1,26 @@
+namespace DxMessaging.Core.Messages
+{
+    using System;
+
+    /// <summary>
+    /// Used to specify general-purposes messages that aren't meant to be sent to specific entity.
+    /// </summary>
+    /// <note>
+    /// UntargetedMessages should be thought of as game-wide, global information. Things like
+    /// "The world has been regenerated." or "The video settings have been updated to this resolution".
+    /// Inheritance should be completely flat. Ie, UntargetedMessages should be the direct parent of every implementer.
+    /// </note>
+    public interface IUntargetedMessage : IMessage { }
+
+    /// <summary>
+    /// No-alloc UntargetedMessages. Derive from this type to not have your messages boxed (if they are structs).
+    /// <code>
+    /// public readonly MyCoolStruct : IUntargetedMessage{MyCoolStruct}
+    /// </code>
+    /// </summary>
+    /// <typeparam name="T">Concrete type of the derived. Should be the derived type and nothing else.</typeparam>
+    public interface IUntargetedMessage<T> : IUntargetedMessage where T : IUntargetedMessage
+    {
+        Type IMessage.MessageType => typeof(T);
+    }
+}

package/Runtime/Core/Messages/IUntargetedMessage.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0a0789976ef004e4c926d5f25bd92e50
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Messages.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: eb7aa358315732945a9f45ad92904b2f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/MessagingDebug.cs

@@ -0,0 +1,71 @@
+namespace DxMessaging.Core
+{
+    using System;
+
+    /// <summary>
+    /// Severity of the log message
+    /// </summary>
+    public enum LogLevel
+    {
+        Debug = 0,
+        Info = 1,
+        Warn = 2,
+        Error = 3,
+    }
+
+    /// <summary>
+    /// Debug functionality for all of the Messaging Components.
+    /// </summary>
+    public static class MessagingDebug
+    {
+
+        /// <summary>
+        /// Custom log function to use.
+        /// </summary>
+        /// <note>
+        /// For Unity, you could do LogFunction = Debug.Log;
+        /// </note>
+        public static Action<LogLevel, string> LogFunction = null;
+
+        /// <summary>
+        /// Logs a message to the debug log function, if it's not null.
+        /// </summary>
+        /// <param name="logLevel">Severity of the message.</param>
+        /// <param name="message">Message to log.</param>
+        public static void Log(LogLevel logLevel, string message)
+        {
+            LogFunction?.Invoke(logLevel, message);
+        }
+
+        /// <summary>
+        /// Logs a format string + args to the debug log function, if it's not null.
+        /// </summary>
+        /// <note>
+        /// Will call string.Format(message, args)
+        /// </note>
+        /// <param name="logLevel">Severity of the message.</param>
+        /// <param name="message">Format string.</param>
+        /// <param name="args">Args to populate format string with.</param>
+        public static void Log(LogLevel logLevel, string message, params object[] args)
+        {
+            Action<LogLevel, string> logFunction = LogFunction;
+            /*
+                We can potentially avoid an unnecessary string.Format call if the LogFunction is null,
+                which is why the null check is outside the InternalLog function.
+            */
+            if (logFunction == null)
+            {
+                return;
+            }
+
+            if (args.Length <= 0)
+            {
+                logFunction.Invoke(logLevel, message);
+            }
+            else
+            {
+                logFunction.Invoke(logLevel, string.Format(message, args));
+            }
+        }
+    }
+}

package/Runtime/Core/MessagingDebug.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 95f160b63321b69489108cdf413b55d2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b58cce05d4f7d9447a63e82e2169f927
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Unity/MessageAwareComponent.cs

@@ -0,0 +1,77 @@
+namespace DxMessaging.Unity
+{
+    using Core;
+    using UnityEngine;
+    
+    [RequireComponent(typeof(MessagingComponent))]
+    public abstract class MessageAwareComponent : MonoBehaviour
+    {
+        protected MessageRegistrationToken _messageRegistrationToken;
+
+        /// <summary>
+        ///     If true, will register/un-register handles when the component is enabled or disabled.
+        /// </summary>
+        protected virtual bool MessageRegistrationTiedToEnableStatus => true;
+
+        protected bool _isQuitting;
+
+        protected virtual void Awake()
+        {
+            SetupMessageHandlers();
+        }
+
+        protected void SetupMessageHandlers()
+        {
+            if (_messageRegistrationToken == null)
+            {
+                MessagingComponent messenger = GetComponent<MessagingComponent>();
+                _messageRegistrationToken = messenger.Create(this);
+            }
+
+            RegisterMessageHandlers();
+            _messageRegistrationToken.Enable();
+        }
+
+        protected virtual void RegisterMessageHandlers()
+        {
+            // No-op, expectation is that implementations implement their own logic here
+        }
+
+        protected virtual void OnEnable()
+        {
+            if (MessageRegistrationTiedToEnableStatus)
+            {
+                _messageRegistrationToken?.Enable();
+            }
+        }
+
+        protected virtual void OnDisable()
+        {
+            if (_isQuitting)
+            {
+                return;
+            }
+
+            if (MessageRegistrationTiedToEnableStatus)
+            {
+                _messageRegistrationToken?.Disable();
+            }
+        }
+
+        protected virtual void OnDestroy()
+        {
+            if (_isQuitting)
+            {
+                return;
+            }
+
+            _messageRegistrationToken?.Disable();
+            _messageRegistrationToken = null;
+        }
+
+        protected virtual void OnApplicationQuit()
+        {
+            _isQuitting = true;
+        }
+    }
+}

package/Runtime/Unity/MessageAwareComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f0743aa54f7a37f4c985cf9b55f68279
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Unity/MessagingComponent.cs

@@ -0,0 +1,73 @@
+namespace DxMessaging.Unity
+{
+    using Core;
+    using System;
+    using System.Collections.Generic;
+    using UnityEngine;
+    
+    [DisallowMultipleComponent]
+    public sealed class MessagingComponent : MonoBehaviour
+    {
+        private MessageHandler _messageHandler;
+        private readonly Dictionary<MonoBehaviour, MessageRegistrationToken> _registeredListeners = new Dictionary<MonoBehaviour, MessageRegistrationToken>();
+
+        public MessageRegistrationToken Create(MonoBehaviour listener)
+        {
+            if (listener == null)
+            {
+                throw new ArgumentNullException(nameof(listener));
+            }
+
+            if (gameObject.GetInstanceID() != listener.gameObject.GetInstanceID())
+            {
+                throw new ArgumentException(string.Format(
+                    "Cannot create a RegistrationToken without an valid owner. {0}.",
+                    listener.gameObject.GetInstanceID()));
+            }
+
+            if (_registeredListeners.TryGetValue(listener, out MessageRegistrationToken createdToken))
+            {
+                MessagingDebug.Log(LogLevel.Warn, "Ignoring double RegistrationToken request for {0}.", listener);
+                return createdToken;
+            }
+
+            if (_messageHandler == null)
+            {
+                _messageHandler = new MessageHandler(gameObject)
+                {
+                    active = true
+                };
+                MessagingDebug.Log(LogLevel.Debug, "Creating MessageHandler for componentType {0}, GameObject name: {1}, InstanceId: {2}.",
+                    listener.GetType(), listener.gameObject.name, (InstanceId) gameObject);
+            }
+            else
+            {
+                MessagingDebug.Log(LogLevel.Debug,
+                    "Using existing MessageHandler for componentType {0}, GameObject name: {1}, InstanceId: {2}.",
+                    listener.GetType(), listener.gameObject.name, (InstanceId) gameObject);
+            }
+
+            createdToken = MessageRegistrationToken.Create(_messageHandler);
+            _registeredListeners[listener] = createdToken;
+            return createdToken;
+        }
+
+        private void OnEnable()
+        {
+            ToggleMessageHandler(true);
+        }
+
+        private void OnDisable()
+        {
+            ToggleMessageHandler(false);
+        }
+
+        private void ToggleMessageHandler(bool newActive)
+        {
+            if (_messageHandler != null && _messageHandler.active != newActive)
+            {
+                _messageHandler.active = newActive;
+            }
+        }
+    }
+}

package/Runtime/Unity/MessagingComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 98ea04ea326660845ba49942dacbf907
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Unity.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 702cd276d59d0b1458d22d6d33e91c6e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/WallstopStudios.DxMessaging.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "WallstopStudios.DxMessaging",
+    "rootNamespace": "DxMessaging",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "System.Runtime.CompilerServices.Unsafe.dll"
+    ],
+    "autoReferenced": true,
+    "defineConstraints": [
+        "UNITY_2017_1_OR_NEWER"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Runtime/WallstopStudios.DxMessaging.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 184635fd03dde55408891bd932619c81
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6f74abcfd99785a4c857762e91493ea3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Editor/WallstopStudios.DxMessaging.Tests.Editor.asmdef

@@ -0,0 +1,23 @@
+{
+    "name": "WallstopStudios.DxMessaging.Tests.Editor",
+    "rootNamespace": "DxMessaging.Tests.Editor",
+    "references": [
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Tests/Editor/WallstopStudios.DxMessaging.Tests.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: c646054334573af4a95dfd389817700c
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2f8663039d4ca4f43a9acdf5f22e30ed
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: