com.wallstop-studios.unity-helpers 2.0.0-rc58 → 2.0.0-rc59

package/Runtime/Core/DataStructure/RTree.cs.meta

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

package/Runtime/Core/DataStructure/StringWrapper.cs

@@ -1,91 +1,91 @@
-namespace UnityHelpers.Core.DataStructure
-{
-    using System;
-    using System.Collections.Concurrent;
-
-    /*
-        Used to cache strings, meant to be used in place of strings as keys for when a Dictionary
-        has a known set of values
-     */
-    [Serializable]
-    public sealed class StringWrapper : IEquatable<StringWrapper>, IComparable<StringWrapper>
-    {
-        private static readonly ConcurrentDictionary<string, StringWrapper> Cache = new();
-
-        public readonly string value;
-
-        private readonly int _hashCode;
-
-        private StringWrapper(string value)
-        {
-            this.value = value;
-            _hashCode = value.GetHashCode();
-        }
-
-        public static StringWrapper Get(string value)
-        {
-            return Cache.GetOrAdd(value, key => new StringWrapper(key));
-        }
-
-        public static bool Remove(string value)
-        {
-            return Cache.TryRemove(value, out _);
-        }
-
-        public bool Equals(StringWrapper other)
-        {
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            if (ReferenceEquals(other, null))
-            {
-                return false;
-            }
-
-            if (_hashCode != other._hashCode)
-            {
-                return false;
-            }
-
-            return string.Equals(value, other.value, StringComparison.Ordinal);
-        }
-
-        public int CompareTo(StringWrapper other)
-        {
-            if (ReferenceEquals(this, other))
-            {
-                return 0;
-            }
-
-            if (ReferenceEquals(other, null))
-            {
-                return -1;
-            }
-
-            int comparison = _hashCode.CompareTo(other._hashCode);
-            if (comparison != 0)
-            {
-                return comparison;
-            }
-
-            return string.Compare(value, other.value, StringComparison.Ordinal);
-        }
-
-        public override int GetHashCode()
-        {
-            return _hashCode;
-        }
-
-        public override bool Equals(object other)
-        {
-            return Equals(other as StringWrapper);
-        }
-
-        public override string ToString()
-        {
-            return value;
-        }
-    }
-}
+namespace UnityHelpers.Core.DataStructure
+{
+    using System;
+    using System.Collections.Concurrent;
+
+    /*
+        Used to cache strings, meant to be used in place of strings as keys for when a Dictionary
+        has a known set of values
+     */
+    [Serializable]
+    public sealed class StringWrapper : IEquatable<StringWrapper>, IComparable<StringWrapper>
+    {
+        private static readonly ConcurrentDictionary<string, StringWrapper> Cache = new();
+
+        public readonly string value;
+
+        private readonly int _hashCode;
+
+        private StringWrapper(string value)
+        {
+            this.value = value;
+            _hashCode = value.GetHashCode();
+        }
+
+        public static StringWrapper Get(string value)
+        {
+            return Cache.GetOrAdd(value, key => new StringWrapper(key));
+        }
+
+        public static bool Remove(string value)
+        {
+            return Cache.TryRemove(value, out _);
+        }
+
+        public bool Equals(StringWrapper other)
+        {
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            if (ReferenceEquals(other, null))
+            {
+                return false;
+            }
+
+            if (_hashCode != other._hashCode)
+            {
+                return false;
+            }
+
+            return string.Equals(value, other.value, StringComparison.Ordinal);
+        }
+
+        public int CompareTo(StringWrapper other)
+        {
+            if (ReferenceEquals(this, other))
+            {
+                return 0;
+            }
+
+            if (ReferenceEquals(other, null))
+            {
+                return -1;
+            }
+
+            int comparison = _hashCode.CompareTo(other._hashCode);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            return string.Compare(value, other.value, StringComparison.Ordinal);
+        }
+
+        public override int GetHashCode()
+        {
+            return _hashCode;
+        }
+
+        public override bool Equals(object other)
+        {
+            return Equals(other as StringWrapper);
+        }
+
+        public override string ToString()
+        {
+            return value;
+        }
+    }
+}

package/Runtime/Core/DataStructure/TimedCache.cs

@@ -1,66 +1,66 @@
-namespace UnityHelpers.Core.DataStructure
-{
-    using System;
-    using Helper;
-    using Random;
-    using UnityEngine;
-
-    public sealed class TimedCache<T>
-    {
-        public T Value
-        {
-            get
-            {
-                if (!_lastRead.HasValue)
-                {
-                    Reset();
-                }
-                else if (
-                    Helpers.HasEnoughTimePassed(
-                        _lastRead.Value,
-                        _cacheTtl + (_shouldUseJitter && !_usedJitter ? _jitterAmount : 0f)
-                    )
-                )
-                {
-                    if (_shouldUseJitter)
-                    {
-                        _usedJitter = true;
-                    }
-                    Reset();
-                }
-
-                return _value;
-            }
-        }
-
-        private readonly Func<T> _valueProducer;
-        private readonly float _cacheTtl;
-
-        private float? _lastRead;
-        private T _value;
-
-        private bool _usedJitter;
-        private readonly bool _shouldUseJitter;
-        private readonly float _jitterAmount;
-
-        public TimedCache(Func<T> valueProducer, float cacheTtl, bool useJitter = false)
-        {
-            _valueProducer =
-                valueProducer ?? throw new ArgumentNullException(nameof(valueProducer));
-            if (cacheTtl < 0)
-            {
-                throw new ArgumentException(nameof(cacheTtl));
-            }
-
-            _cacheTtl = cacheTtl;
-            _shouldUseJitter = useJitter;
-            _jitterAmount = useJitter ? PRNG.Instance.NextFloat(0f, cacheTtl) : 0f;
-        }
-
-        public void Reset()
-        {
-            _value = _valueProducer();
-            _lastRead = Time.time;
-        }
-    }
-}
+namespace UnityHelpers.Core.DataStructure
+{
+    using System;
+    using Helper;
+    using Random;
+    using UnityEngine;
+
+    public sealed class TimedCache<T>
+    {
+        public T Value
+        {
+            get
+            {
+                if (!_lastRead.HasValue)
+                {
+                    Reset();
+                }
+                else if (
+                    Helpers.HasEnoughTimePassed(
+                        _lastRead.Value,
+                        _cacheTtl + (_shouldUseJitter && !_usedJitter ? _jitterAmount : 0f)
+                    )
+                )
+                {
+                    if (_shouldUseJitter)
+                    {
+                        _usedJitter = true;
+                    }
+                    Reset();
+                }
+
+                return _value;
+            }
+        }
+
+        private readonly Func<T> _valueProducer;
+        private readonly float _cacheTtl;
+
+        private float? _lastRead;
+        private T _value;
+
+        private bool _usedJitter;
+        private readonly bool _shouldUseJitter;
+        private readonly float _jitterAmount;
+
+        public TimedCache(Func<T> valueProducer, float cacheTtl, bool useJitter = false)
+        {
+            _valueProducer =
+                valueProducer ?? throw new ArgumentNullException(nameof(valueProducer));
+            if (cacheTtl < 0)
+            {
+                throw new ArgumentException(nameof(cacheTtl));
+            }
+
+            _cacheTtl = cacheTtl;
+            _shouldUseJitter = useJitter;
+            _jitterAmount = useJitter ? PRNG.Instance.NextFloat(0f, cacheTtl) : 0f;
+        }
+
+        public void Reset()
+        {
+            _value = _valueProducer();
+            _lastRead = Time.time;
+        }
+    }
+}

package/Runtime/Core/Extension/AnimatorExtensions.cs

@@ -1,25 +1,25 @@
-namespace UnityHelpers.Core.Extension
-{
-    using UnityEngine;
-
-    public static class AnimatorExtensions
-    {
-        public static void ResetTriggers(this Animator animator)
-        {
-            if (!animator || !animator.isActiveAndEnabled)
-            {
-                return;
-            }
-
-            foreach (AnimatorControllerParameter animatorParameter in animator.parameters)
-            {
-                if (animatorParameter.type != AnimatorControllerParameterType.Trigger)
-                {
-                    continue;
-                }
-
-                animator.ResetTrigger(animatorParameter.name);
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using UnityEngine;
+
+    public static class AnimatorExtensions
+    {
+        public static void ResetTriggers(this Animator animator)
+        {
+            if (!animator || !animator.isActiveAndEnabled)
+            {
+                return;
+            }
+
+            foreach (AnimatorControllerParameter animatorParameter in animator.parameters)
+            {
+                if (animatorParameter.type != AnimatorControllerParameterType.Trigger)
+                {
+                    continue;
+                }
+
+                animator.ResetTrigger(animatorParameter.name);
+            }
+        }
+    }
+}

package/Runtime/Core/Extension/AsyncOperationExtensions.cs

@@ -1,110 +1,110 @@
-namespace UnityHelpers.Core.Extension
-{
-    using System;
-    using System.Collections.Concurrent;
-    using System.Collections.Generic;
-    using System.Runtime.CompilerServices;
-    using System.Threading.Tasks;
-    using UnityEngine;
-
-    public static class AsyncOperationExtensions
-    {
-        private static readonly ConcurrentDictionary<
-            AsyncOperation,
-            Action<AsyncOperation>
-        > Handlers = new();
-        private static readonly ConcurrentDictionary<AsyncOperation, Action> Continuations = new();
-
-        public readonly struct AsyncOperationAwaiter : INotifyCompletion
-        {
-            private readonly AsyncOperation _operation;
-
-            public AsyncOperationAwaiter(AsyncOperation operation)
-            {
-                _operation = operation ?? throw new ArgumentNullException(nameof(operation));
-            }
-
-            public bool IsCompleted => _operation.isDone;
-
-            public void OnCompleted(Action continuation)
-            {
-                Continuations[_operation] = continuation;
-
-                Action<AsyncOperation> handler = CachedHandler;
-                if (!Handlers.TryAdd(_operation, handler))
-                {
-                    return;
-                }
-
-                Handlers[_operation] = handler;
-                _operation.completed += handler;
-            }
-
-            public void GetResult() { }
-        }
-
-        private static readonly Action<AsyncOperation> CachedHandler = OnOperationCompleted;
-
-        private static void OnOperationCompleted(AsyncOperation operation)
-        {
-            Handlers.Remove(operation, out Action<AsyncOperation> _);
-            if (!Continuations.Remove(operation, out Action completionCondition))
-            {
-                return;
-            }
-
-            completionCondition?.Invoke();
-        }
-
-        public static async Task AsTask(this AsyncOperation asyncOp)
-        {
-            if (asyncOp.isDone)
-            {
-                return;
-            }
-
-            await asyncOp;
-        }
-
-        public static async ValueTask AsValueTask(this AsyncOperation asyncOp)
-        {
-            if (asyncOp.isDone)
-            {
-                return;
-            }
-
-            await asyncOp;
-        }
-
-#if !UNITY_2023_1_OR_NEWER
-        public static AsyncOperationAwaiter GetAwaiter(this AsyncOperation op)
-        {
-            return new AsyncOperationAwaiter(op);
-        }
-#endif
-
-        public static async ValueTask WithContinuation(this ValueTask task, Action continuation)
-        {
-            await task;
-            continuation?.Invoke();
-        }
-
-        public static async ValueTask<TResult> WithContinuation<TResult>(
-            this ValueTask<TResult> task,
-            Func<TResult, TResult> continuation
-        )
-        {
-            TResult result = await task;
-            return continuation(result);
-        }
-
-        public static async ValueTask WithContinuation<TResult>(
-            this ValueTask<TResult> task,
-            Action<TResult> continuation
-        )
-        {
-            TResult result = await task;
-            continuation(result);
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Runtime.CompilerServices;
+    using System.Threading.Tasks;
+    using UnityEngine;
+
+    public static class AsyncOperationExtensions
+    {
+        private static readonly ConcurrentDictionary<
+            AsyncOperation,
+            Action<AsyncOperation>
+        > Handlers = new();
+        private static readonly ConcurrentDictionary<AsyncOperation, Action> Continuations = new();
+
+        public readonly struct AsyncOperationAwaiter : INotifyCompletion
+        {
+            private readonly AsyncOperation _operation;
+
+            public AsyncOperationAwaiter(AsyncOperation operation)
+            {
+                _operation = operation ?? throw new ArgumentNullException(nameof(operation));
+            }
+
+            public bool IsCompleted => _operation.isDone;
+
+            public void OnCompleted(Action continuation)
+            {
+                Continuations[_operation] = continuation;
+
+                Action<AsyncOperation> handler = CachedHandler;
+                if (!Handlers.TryAdd(_operation, handler))
+                {
+                    return;
+                }
+
+                Handlers[_operation] = handler;
+                _operation.completed += handler;
+            }
+
+            public void GetResult() { }
+        }
+
+        private static readonly Action<AsyncOperation> CachedHandler = OnOperationCompleted;
+
+        private static void OnOperationCompleted(AsyncOperation operation)
+        {
+            Handlers.Remove(operation, out Action<AsyncOperation> _);
+            if (!Continuations.Remove(operation, out Action completionCondition))
+            {
+                return;
+            }
+
+            completionCondition?.Invoke();
+        }
+
+        public static async Task AsTask(this AsyncOperation asyncOp)
+        {
+            if (asyncOp.isDone)
+            {
+                return;
+            }
+
+            await asyncOp;
+        }
+
+        public static async ValueTask AsValueTask(this AsyncOperation asyncOp)
+        {
+            if (asyncOp.isDone)
+            {
+                return;
+            }
+
+            await asyncOp;
+        }
+
+#if !UNITY_2023_1_OR_NEWER
+        public static AsyncOperationAwaiter GetAwaiter(this AsyncOperation op)
+        {
+            return new AsyncOperationAwaiter(op);
+        }
+#endif
+
+        public static async ValueTask WithContinuation(this ValueTask task, Action continuation)
+        {
+            await task;
+            continuation?.Invoke();
+        }
+
+        public static async ValueTask<TResult> WithContinuation<TResult>(
+            this ValueTask<TResult> task,
+            Func<TResult, TResult> continuation
+        )
+        {
+            TResult result = await task;
+            return continuation(result);
+        }
+
+        public static async ValueTask WithContinuation<TResult>(
+            this ValueTask<TResult> task,
+            Action<TResult> continuation
+        )
+        {
+            TResult result = await task;
+            continuation(result);
+        }
+    }
+}

package/Runtime/Core/Extension/CircleExtensions.cs

@@ -1,25 +1,25 @@
-namespace UnityHelpers.Core.Extension
-{
-    using System.Collections.Generic;
-    using DataStructure;
-    using DataStructure.Adapters;
-    using UnityEngine;
-
-    public static class CircleExtensions
-    {
-        public static IEnumerable<FastVector3Int> EnumerateArea(this Circle circle, int z = 0)
-        {
-            for (int x = (int)-circle.radius; x < circle.radius; ++x)
-            {
-                for (int y = (int)-circle.radius; y < circle.radius; ++y)
-                {
-                    Vector2 point = new(x, y);
-                    if (circle.Contains(point))
-                    {
-                        yield return new FastVector3Int(x, y, z);
-                    }
-                }
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using System.Collections.Generic;
+    using DataStructure;
+    using DataStructure.Adapters;
+    using UnityEngine;
+
+    public static class CircleExtensions
+    {
+        public static IEnumerable<FastVector3Int> EnumerateArea(this Circle circle, int z = 0)
+        {
+            for (int x = (int)-circle.radius; x < circle.radius; ++x)
+            {
+                for (int y = (int)-circle.radius; y < circle.radius; ++y)
+                {
+                    Vector2 point = new(x, y);
+                    if (circle.Contains(point))
+                    {
+                        yield return new FastVector3Int(x, y, z);
+                    }
+                }
+            }
+        }
+    }
+}