com.wallstop-studios.unity-helpers 2.0.0-rc50 → 2.0.0-rc51

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -3,6 +3,7 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Threading.Tasks;
     using DataStructure;
     using DataStructure.Adapters;
     using Helper;
@@ -1577,6 +1578,13 @@
             return false;
         }
 
+        public static Task AsTask(this AsyncOperation asyncOp)
+        {
+            TaskCompletionSource<bool> taskCompletionSource = new();
+            asyncOp.completed += _ => taskCompletionSource.SetResult(true);
+            return taskCompletionSource.Task;
+        }
+
 #if UNITY_EDITOR
         public static IEnumerable<Sprite> GetSpritesFromClip(this AnimationClip clip)
         {

package/Runtime/Core/Helper/SceneHelper.cs

@@ -0,0 +1,216 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using Extension;
+    using UnityEngine;
+    using UnityEngine.Events;
+    using UnityEngine.SceneManagement;
+    using Utils;
+    using Object = UnityEngine.Object;
+#if UNITY_EDITOR
+    using UnityEditor;
+    using UnityEditor.SceneManagement;
+#endif
+
+    public static class SceneHelper
+    {
+        public static string[] GetAllScenePaths(string[] searchFolders = null)
+        {
+#if UNITY_EDITOR
+            searchFolders ??= Array.Empty<string>();
+            return AssetDatabase
+                .FindAssets("t:Scene", searchFolders)
+                .Select(AssetDatabase.GUIDToAssetPath)
+                .ToArray();
+#else
+            return Array.Empty<string>();
+#endif
+        }
+
+        public static string[] GetScenesInBuild()
+        {
+#if UNITY_EDITOR
+            return EditorBuildSettings
+                .scenes.Where(scene => scene.enabled)
+                .Select(scene => scene.path)
+                .ToArray();
+#else
+            return Array.Empty<string>();
+#endif
+        }
+
+        public static async Task<DeferredDisposalResult<T>> GetObjectOfTypeInScene<T>(
+            string scenePath
+        )
+            where T : Object
+        {
+            DeferredDisposalResult<T[]> result = await GetAllObjectsOfTypeInScene<T>(scenePath);
+            return new DeferredDisposalResult<T>(
+                result.Result.FirstOrDefault(),
+                result.DisposeAsync
+            );
+        }
+
+        public static async Task<DeferredDisposalResult<T[]>> GetAllObjectsOfTypeInScene<T>(
+            string scenePath
+        )
+            where T : Object
+        {
+            // Ensure singleton is created
+            _ = UnityMainThreadDispatcher.Instance;
+            TaskCompletionSource<T[]> taskCompletionSource = new();
+
+            SceneLoadScope sceneScope = new(scenePath, OnSceneLoaded);
+            return await taskCompletionSource.Task.ContinueWith(result =>
+            {
+                return new DeferredDisposalResult<T[]>(
+                    result.Result,
+                    async () =>
+                    {
+                        TaskCompletionSource<bool> disposalComplete = new();
+                        UnityMainThreadDispatcher.Instance.RunOnMainThread(
+                            () =>
+                                sceneScope
+                                    .DisposeAsync()
+                                    .ContinueWith(_ => disposalComplete.SetResult(true))
+                        );
+
+                        await disposalComplete.Task;
+                    }
+                );
+            });
+
+            void OnSceneLoaded(Scene scene, LoadSceneMode mode)
+            {
+                if (!string.Equals(scene.path, scenePath, StringComparison.Ordinal))
+                {
+                    return;
+                }
+
+                T[] foundObjects = Object
+                    .FindObjectsByType<T>(FindObjectsInactive.Include, FindObjectsSortMode.None)
+                    .Where(obj =>
+                    {
+                        GameObject go = obj.GetGameObject();
+                        if (go == null)
+                        {
+                            return false;
+                        }
+
+                        return go.scene == scene;
+                    })
+                    .ToArray();
+                taskCompletionSource.TrySetResult(foundObjects);
+            }
+        }
+
+        public sealed class SceneLoadScope
+        {
+            private Scene? _openedScene;
+            private readonly UnityAction<Scene, LoadSceneMode> _onSceneLoaded;
+            private readonly bool _eventAdded;
+
+            public SceneLoadScope(string scenePath, UnityAction<Scene, LoadSceneMode> onSceneLoaded)
+            {
+                _onSceneLoaded = onSceneLoaded;
+                _eventAdded = false;
+                Scene activeScene = SceneManager.GetActiveScene();
+                if (
+                    !activeScene.IsValid()
+                    || !activeScene.isLoaded
+                    || !string.Equals(activeScene.path, scenePath, StringComparison.Ordinal)
+                )
+                {
+#if UNITY_EDITOR
+                    if (Application.isPlaying)
+                    {
+                        SceneManager.sceneLoaded += onSceneLoaded;
+                        _eventAdded = true;
+                        _openedScene = EditorSceneManager.LoadSceneInPlayMode(
+                            scenePath,
+                            new LoadSceneParameters(LoadSceneMode.Additive, LocalPhysicsMode.None)
+                        );
+                    }
+                    else
+                    {
+                        _openedScene = EditorSceneManager.OpenScene(
+                            scenePath,
+                            OpenSceneMode.Additive
+                        );
+                        onSceneLoaded?.Invoke(_openedScene.Value, LoadSceneMode.Additive);
+                    }
+#else
+                    SceneManager.sceneLoaded += onSceneLoaded;
+                    _eventAdded = true;
+                    SceneManager.sceneLoaded += LocalSceneLoaded;
+                    SceneManager.LoadScene(scenePath, LoadSceneMode.Additive);
+                    _openedScene = SceneManager.GetSceneByPath(scenePath);
+
+                    void LocalSceneLoaded(Scene scene, LoadSceneMode mode)
+                    {
+                        if (!string.Equals(scene.path, scenePath, StringComparison.Ordinal))
+                        {
+                            return;
+                        }
+
+                        _openedScene = scene;
+                        SceneManager.sceneLoaded -= LocalSceneLoaded;
+                    }
+#endif
+                }
+                else
+                {
+                    onSceneLoaded?.Invoke(activeScene, LoadSceneMode.Single);
+                    _openedScene = null;
+                }
+            }
+
+            public async Task DisposeAsync()
+            {
+                if (_eventAdded)
+                {
+                    SceneManager.sceneLoaded -= _onSceneLoaded;
+                }
+
+                if (_openedScene == null)
+                {
+                    return;
+                }
+
+                Scene openedScene = _openedScene.Value;
+                if (!openedScene.IsValid())
+                {
+                    return;
+                }
+
+                if (!openedScene.isLoaded)
+                {
+                    return;
+                }
+
+#if UNITY_EDITOR
+                if (Application.isPlaying)
+                {
+                    AsyncOperation asyncOperation = SceneManager.UnloadSceneAsync(
+                        openedScene,
+                        UnloadSceneOptions.None
+                    );
+                    await asyncOperation.AsTask();
+                }
+                else
+                {
+                    EditorSceneManager.CloseScene(openedScene, true);
+                }
+#else
+                AsyncOperation asyncOperation = SceneManager.UnloadSceneAsync(
+                    openedScene,
+                    UnloadSceneOptions.None
+                );
+                await asyncOperation.AsTask();
+#endif
+            }
+        }
+    }
+}

package/Runtime/Core/Helper/SceneHelper.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 366d25a4bde54caa9dbb17d039c63e6f
+timeCreated: 1743955669

package/Runtime/Core/Helper/UnityMainThreadDispatcher.cs

@@ -0,0 +1,32 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Collections.Concurrent;
+    using UnityEngine;
+    using Utils;
+
+    public sealed class UnityMainThreadDispatcher : RuntimeSingleton<UnityMainThreadDispatcher>
+    {
+        private readonly ConcurrentQueue<Action> _actions = new();
+
+        public void RunOnMainThread(Action action)
+        {
+            _actions.Enqueue(action);
+        }
+
+        private void Update()
+        {
+            while (_actions.TryDequeue(out Action action))
+            {
+                try
+                {
+                    action();
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+    }
+}

package/Runtime/Core/Helper/UnityMainThreadDispatcher.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6d44672eb7364a0995fa1055d4187970
+timeCreated: 1743968724

package/Runtime/Core/Random/AbstractRandom.cs

@@ -67,7 +67,13 @@
                 throw new ArgumentException("Max cannot be zero");
             }
 
-            return (uint)(NextDouble() * max);
+            uint result = (uint)(NextDouble() * max);
+            if (result == max)
+            {
+                return result - 1;
+            }
+
+            return result;
         }
 
         public uint NextUint(uint min, uint max)
@@ -129,7 +135,13 @@
                 throw new ArgumentException($"Max {max} cannot be less-than or equal-to 0");
             }
 
-            return (long)(NextDouble() * max);
+            long result = (long)(NextDouble() * max);
+            if (result == max)
+            {
+                return result - 1;
+            }
+
+            return result;
         }
 
         public long NextLong(long min, long max)
@@ -147,7 +159,13 @@
                 return unchecked((long)NextUlong());
             }
 
-            return unchecked((long)(NextDouble() * range + min));
+            long result = unchecked((long)(NextDouble() * range + min));
+            if (result == max)
+            {
+                return result - 1;
+            }
+
+            return result;
         }
 
         public ulong NextUlong()
@@ -159,7 +177,12 @@
 
         public ulong NextUlong(ulong max)
         {
-            return (ulong)(NextDouble() * max);
+            ulong result = (ulong)(NextDouble() * max);
+            if (result == max)
+            {
+                return result - 1;
+            }
+            return result;
         }
 
         public ulong NextUlong(ulong min, ulong max)

package/Runtime/Utils/DeferredDisposalResult.cs

@@ -0,0 +1,19 @@
+namespace UnityHelpers.Utils
+{
+    using System;
+    using System.Threading.Tasks;
+
+    public sealed class DeferredDisposalResult<T>
+    {
+        public T Result { get; }
+        private readonly Func<Task> _disposeAsync;
+
+        public DeferredDisposalResult(T result, Func<Task> disposeAsync)
+        {
+            Result = result;
+            _disposeAsync = disposeAsync;
+        }
+
+        public Task DisposeAsync() => _disposeAsync();
+    }
+}

package/Runtime/Utils/DeferredDisposalResult.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 00dfb26d7b8d468fb709192ddf56e4bf
+timeCreated: 1743970028

package/Tests/Runtime/Helper/SceneHelperTests.cs

@@ -0,0 +1,92 @@
+namespace UnityHelpers.Tests.Helper
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using Core.Helper;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+    using UnityHelpers.Utils;
+
+    public sealed class SceneHelperTests
+    {
+        private readonly List<Func<Task>> _disposalTasks = new();
+
+        [UnityTearDown]
+        public IEnumerator TearDown()
+        {
+            foreach (Task disposal in _disposalTasks.Select(disposalProducer => disposalProducer()))
+            {
+                while (!disposal.IsCompleted)
+                {
+                    yield return null;
+                }
+            }
+
+            _disposalTasks.Clear();
+        }
+
+        [Test]
+        public void GetScenesInBuild()
+        {
+            // This will only pass if you have scenes in your build path
+            string[] scenes = SceneHelper.GetScenesInBuild();
+            Assert.That(scenes, Is.Not.Empty);
+        }
+
+        [Test]
+        public void GetAllScenePaths()
+        {
+            string[] scenePaths = SceneHelper.GetAllScenePaths();
+            Assert.That(scenePaths, Is.Not.Empty);
+            Assert.IsTrue(
+                scenePaths.Any(path => path.Contains("Test1")),
+                string.Join(",", scenePaths)
+            );
+            Assert.IsTrue(
+                scenePaths.Any(path => path.Contains("Test2")),
+                string.Join(",", scenePaths)
+            );
+        }
+
+        [UnityTest]
+        public IEnumerator GetObjectOfTypeInScene()
+        {
+            Task<DeferredDisposalResult<SpriteRenderer>> task =
+                SceneHelper.GetObjectOfTypeInScene<SpriteRenderer>(
+                    @"Packages\com.wallstop-studios.unity-helpers\Tests\Runtime\Scenes\Test1.unity"
+                );
+            while (!task.IsCompleted)
+            {
+                yield return null;
+            }
+            Assert.IsTrue(task.IsCompletedSuccessfully, task.Exception?.ToString() ?? string.Empty);
+
+            _disposalTasks.Add(task.Result.DisposeAsync);
+            SpriteRenderer found = task.Result.Result;
+            Assert.IsTrue(found != null);
+        }
+
+        [UnityTest]
+        public IEnumerator GetAllObjectOfTypeInScene()
+        {
+            Task<DeferredDisposalResult<SpriteRenderer[]>> task =
+                SceneHelper.GetAllObjectsOfTypeInScene<SpriteRenderer>(
+                    @"Packages\com.wallstop-studios.unity-helpers\Tests\Runtime\Scenes\Test1.unity"
+                );
+
+            while (!task.IsCompleted)
+            {
+                yield return null;
+            }
+
+            Assert.IsTrue(task.IsCompletedSuccessfully, task.Exception?.ToString() ?? string.Empty);
+            _disposalTasks.Add(task.Result.DisposeAsync);
+            SpriteRenderer[] found = task.Result.Result;
+            Assert.That(found, Has.Length.EqualTo(7));
+        }
+    }
+}

package/Tests/Runtime/Helper/SceneHelperTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 342b5f1eb6ff4986934cf2fa225f34a3
+timeCreated: 1743957199