com.valectric.mooserunner 2.1.4

package/Samples~/Demos/MooseRunner.Demo.Support/MessageDisplayManager.cs

@@ -0,0 +1,291 @@
+using UnityEngine;
+using UnityEngine.UI;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using static UnityEngine.EventSystems.EventTrigger;
+using Debug = System.Diagnostics.Debug;
+
+namespace MooseRunner.Internal.Tests
+{
+    /// <summary>
+    /// Manages the display of messages in a persistent UI canvas.
+    /// Messages are displayed in a vertical list and are automatically removed after their lifetime expires.
+    /// </summary>
+    public class MessageDisplayManager : MonoBehaviour
+    {
+        /// <summary>
+        /// The singleton instance of the <see cref="MessageDisplayManager"/>.
+        /// </summary>
+        private static MessageDisplayManager _instance;
+
+        /// <summary>
+        /// Provides global access to the <see cref="MessageDisplayManager"/> instance. 
+        /// Ensures that the manager is created and persists across scenes.
+        /// </summary>
+        public static MessageDisplayManager Instance
+        {
+            get
+            {
+                // If instance exists, return it
+                if (_instance != null) return _instance;
+
+                // 1. Find any existing instance in the scene
+                MessageDisplayManager[] instances = FindObjectsByType<MessageDisplayManager>(FindObjectsSortMode.None);
+                if (instances.Length > 0)
+                {
+                    _instance = instances[0];
+
+                    if (instances.Length > 1)
+                    {
+                        UnityEngine.Debug.LogWarning("Multiple TestRunnerHelper instances found! Using the first one.");
+                        // Optionally, destroy duplicates here
+                        for (int i = 1; i < instances.Length; i++)
+                        {
+                            Destroy(instances[i].gameObject);
+                        }
+                    }
+                    return _instance;
+                }
+
+                // 2. No instance found, instantiate the prefab
+                if (_instance == null)
+                {
+                    GameObject obj = new GameObject("MessageDisplayManager");
+                    _instance = obj.AddComponent<MessageDisplayManager>();
+                    DontDestroyOnLoad(obj); // Ensure it persists across scenes
+                }
+                return _instance;
+            }
+        }
+
+        /// <summary>
+        /// The canvas used to display the message UI.
+        /// </summary>
+        private Canvas _canvas;
+
+        /// <summary>
+        /// The content area within the canvas that holds all displayed messages.
+        /// </summary>
+        private RectTransform _contentArea;
+
+        /// <summary>
+        /// A dictionary that stores active messages, indexed by a unique key derived from the caller's context.
+        /// </summary>
+        private readonly Dictionary<string, MessageEntry> _messages = new Dictionary<string, MessageEntry>();
+
+        /// <summary>
+        /// The default duration (in seconds) for which a message remains visible.
+        /// </summary>
+        private const float MessageLifetime = 10f;
+
+        ///<summary>
+        ///Keeps track of last method
+        /// </summary>
+        private string _lastMethod;
+
+
+        /// <summary>
+        /// Represents a single message entry in the display manager.
+        /// </summary>
+        private class MessageEntry
+        {
+            /// <summary>
+            /// The text content of the message.
+            /// </summary>
+            public string DisplayText;
+
+            /// <summary>
+            /// The remaining lifetime of the message, in seconds.
+            /// </summary>
+            public float RemainingTime;
+
+            /// <summary>
+            /// The UI element used to display the message.
+            /// </summary>
+            public Text UIElement;
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="MessageEntry"/> class.
+            /// </summary>
+            /// <param name="text">The message text to display.</param>
+            /// <param name="duration">The duration the message should remain visible.</param>
+            /// <param name="uiElement">The UI text element associated with the message.</param>
+            public MessageEntry(string text, float duration, Text uiElement)
+            {
+                DisplayText = text;
+                RemainingTime = duration;
+                UIElement = uiElement;
+            }
+        }
+
+        /// <summary>
+        /// Ensures that the UI elements for displaying messages are created and properly configured.
+        /// </summary>
+        private void EnsureUIExists()
+        {
+            if (_canvas == null)
+            {
+                
+                // Create Canvas
+                _canvas = gameObject.AddComponent<Canvas>();
+                _canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+                DontDestroyOnLoad(gameObject);
+                
+                // Add a Canvas Scaler
+                CanvasScaler scaler = gameObject.AddComponent<CanvasScaler>();
+                scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
+
+                // Add a Scroll View for Messages
+                GameObject scrollViewObj = new GameObject("ScrollView");
+                scrollViewObj.transform.SetParent(gameObject.transform);
+                RectTransform scrollRectTransform = scrollViewObj.AddComponent<RectTransform>();
+                scrollRectTransform.anchorMin = new Vector2(0, 0);
+                scrollRectTransform.anchorMax = new Vector2(1, 1);
+                scrollRectTransform.sizeDelta = Vector2.zero;
+                scrollRectTransform.offsetMin = new Vector2(10, 10);
+                scrollRectTransform.offsetMax = new Vector2(-10, -10);
+
+                ScrollRect scrollRect = scrollViewObj.AddComponent<ScrollRect>();
+                scrollRect.horizontal = false;
+
+                // Create Content Area
+                GameObject contentObj = new GameObject("Content");
+                contentObj.transform.SetParent(scrollViewObj.transform);
+                _contentArea = contentObj.AddComponent<RectTransform>();
+
+                _contentArea.anchorMin = new Vector2(0, 1);
+                _contentArea.anchorMax = new Vector2(1, 1);
+                _contentArea.pivot = new Vector2(0.5f, 1);
+                _contentArea.sizeDelta = new Vector2(0, 0);
+                _contentArea.offsetMin = new Vector2(0, 0);
+                _contentArea.offsetMax = new Vector2(0, 0);
+
+                scrollRect.content = _contentArea;
+
+                VerticalLayoutGroup layoutGroup = contentObj.AddComponent<VerticalLayoutGroup>();
+                layoutGroup.childAlignment = TextAnchor.UpperCenter;
+                layoutGroup.childScaleWidth = true;
+                layoutGroup.childScaleHeight = true;
+                layoutGroup.childControlWidth = false;
+                layoutGroup.childControlHeight = false;
+                layoutGroup.childForceExpandWidth = false;
+                layoutGroup.childForceExpandHeight = false;
+
+                Mask mask = scrollViewObj.AddComponent<Mask>();
+                mask.showMaskGraphic = false;
+                scrollViewObj.AddComponent<Image>();
+            
+            }
+        }
+
+        /// <summary>
+        /// Displays a message in the UI with an optional duration.
+        /// </summary>
+        /// <param name="message">The message text to display.</param>
+        /// <param name="duration">The duration the message remains visible (in seconds).</param>
+        public void ShowMessage(string message, float duration = MessageLifetime)
+        {
+            EnsureUIExists();
+
+            // Get caller details using reflection
+            StackFrame frame = new StackFrame(1);
+            MethodBase method = frame.GetMethod();
+            string assemblyName = method.Module.Assembly.GetName().Name;
+            string methodKey = $"{assemblyName}.{method.ReflectedType.FullName}.{method.Name}";
+            if(_lastMethod != methodKey)
+            {
+                //Removes any method key which comes back so that they are in right order.
+                if (_messages.ContainsKey(methodKey)){
+                    MessageEntry curr = _messages[methodKey];
+                    Destroy(curr.UIElement.gameObject);
+                    _messages.Remove(methodKey);
+                }
+            }
+            _lastMethod = methodKey;
+
+            if (_messages.ContainsKey(methodKey))
+            {
+                _messages[methodKey].DisplayText = message;
+                _messages[methodKey].RemainingTime = duration;
+            }
+            else
+            {
+                GameObject messageObj = new GameObject("Message");
+                messageObj.transform.SetParent(_contentArea.transform);
+
+                Text messageText = messageObj.AddComponent<Text>();
+                messageText.fontStyle = FontStyle.Normal;
+                messageText.font = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf");
+                messageText.fontSize = 70;
+                messageText.color = Color.black;
+
+                _messages[methodKey] = new MessageEntry(message, duration, messageText);
+
+                RectTransform rectTransform = messageText.GetComponent<RectTransform>();
+                rectTransform.anchorMin = new Vector2(0, 1);
+                rectTransform.anchorMax = new Vector2(1, 1);
+                rectTransform.pivot = new Vector2(0.5f, 1);
+                rectTransform.sizeDelta = new Vector2(3000, 100);
+                rectTransform.localScale = new Vector3(0.2f, 0.2f, 1);
+            }
+
+            UpdateDisplayedMessages();
+        }
+
+        /// <summary>
+        /// Unity's Update method. Manages message lifetime and removes expired messages.
+        /// </summary>
+        private void Update()
+        {
+            if (_instance == null)
+            {
+                Transform content = gameObject.transform.GetChild(0).GetChild(0);
+                for (int i = content.childCount - 1; i >= 0; i--)
+                {
+                    Destroy(content.GetChild(i).gameObject);
+                }
+
+            }
+            List<string> keysToRemove = new List<string>();
+            bool displayDirty = false;
+
+            foreach (var entry in _messages)
+            {
+                entry.Value.RemainingTime -= Time.unscaledDeltaTime;
+                if (entry.Value.RemainingTime <= 0)
+                {
+                    Destroy(entry.Value.UIElement.gameObject);
+                    keysToRemove.Add(entry.Key);
+                    displayDirty = true;
+                }
+            }
+
+            foreach (var key in keysToRemove)
+            {
+                _messages.Remove(key);
+                displayDirty = true;
+            }
+
+            if (displayDirty)
+            {
+                UpdateDisplayedMessages();
+            }
+        }
+
+        /// <summary>
+        /// Updates the layout and content size of the displayed messages.
+        /// </summary>
+        private void UpdateDisplayedMessages()
+        {
+            float contentHeight = 0;
+            foreach (var entry in _messages.Values)
+            {
+                entry.UIElement.text = entry.DisplayText;
+                contentHeight += entry.UIElement.preferredHeight;
+            }
+
+            _contentArea.sizeDelta = new Vector2(_contentArea.sizeDelta.x, contentHeight);
+        }
+    }
+}

package/Samples~/Demos/MooseRunner.Demo.Support/MessageDisplayManager.cs.meta

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

package/Samples~/Demos/MooseRunner.Demo.Support/MooseRunner.Demo.Support.asmdef

@@ -0,0 +1,19 @@
+{
+  "name": "MooseRunner.Demo.Support",
+  "rootNamespace": "",
+  "references": [
+    "UnityEngine.TestRunner"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "precompiledReferences": [
+    "nunit.framework.dll"
+  ],
+  "autoReferenced": false,
+  "defineConstraints": [
+    "UNITY_INCLUDE_TESTS"
+  ],
+  "versionDefines": [],
+  "noEngineReferences": false
+}

package/Samples~/Demos/MooseRunner.Demo.Support/MooseRunner.Demo.Support.asmdef.meta

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

package/Samples~/Demos/MooseRunner.Demo.Tests/DummyTestBase1.cs

@@ -0,0 +1,71 @@
+using System.Collections;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using UnityEngine.TestTools;
+using MooseRunner.Multiplaytest;
+
+namespace MooseRunner.Internal.Tests
+{
+    public class DummyTestBase1
+    {
+        /// <summary>
+        /// Sets up the test environment before any test is executed.
+        /// Ensures that the "OneCameraScene" is created with a camera. 
+        /// If the scene does not exist, it creates a new scene with a camera, 
+        /// unloads all other scenes, and makes the new scene active.
+        /// </summary>
+        /// <returns>An enumerator for the asynchronous setup process.</returns>
+
+        [OneTimeSetUp]
+        public async Task SetUpOnce()
+        {
+            await MooseRunnerFacade.Instance.LoadSceneFromNameAsync("OneCameraScene");
+        }
+
+        // Regular setup, called before each individual test
+        [SetUp]
+        public void SetUpBase()
+        {
+            Debug.Log("DummyTestBase1 SetUp: Called before each test.");
+        }
+
+        // Dummy test that runs synchronously
+        [Test]
+        public void SyncTest()
+        {
+            Debug.Log("DummyTestBase1 SyncTest: This is a synchronous test.");
+            MessageDisplayManager.Instance.ShowMessage("DummyTestBase1 SyncTest");
+            Assert.IsTrue(true); // Dummy assertion
+        }
+
+        // Dummy test that runs asynchronously (PlayMode)
+        [UnityTest]
+        public IEnumerator CoroutineTestBaseClass()
+        {
+            Debug.Log("DummyTestBase1 CoroutineTestBaseClass: This is an coroutine test.");
+            for (int i = 0; i < 20; i++)
+            {
+                MessageDisplayManager.Instance.ShowMessage("DummyTestBase1 CoroutineTestBaseClass wait for " + (20 - i).ToString());
+                yield return new WaitForSeconds(1); // Simulate some asynchronous behavior
+            }
+            MessageDisplayManager.Instance.ShowMessage("DummyTestBase1 CoroutineTestBaseClass wait for 0");
+            Assert.IsTrue(true); // Dummy assertion
+        }
+
+        // Regular teardown, called after each individual test
+        [TearDown]
+        public void TearDownSetUpBase()
+        {
+            Debug.Log("DummyTestBase1 TearDown: Called after each test.");
+        }
+
+        // One-time teardown, called once after all tests in this class
+        [OneTimeTearDown]
+        public void OneTimeTearDownSetUpBase()
+        {
+            Debug.Log("DummyTestBase1 OneTimeTearDown: Called once after all tests.");
+        }
+    }
+}

package/Samples~/Demos/MooseRunner.Demo.Tests/DummyTestBase1.cs.meta

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