com.wallstop-studios.unity-helpers 1.0.0-rc4

package/Runtime/Core/Extension/DirectionExtensions.cs

@@ -0,0 +1,210 @@
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Helper;
+    using Model;
+    using UnityEngine;
+
+    public static class DirectionExtensions
+    {
+        private static readonly List<Direction> Directions = Enum.GetValues(typeof(Direction)).OfType<Direction>().Except(Enumerables.Of(Direction.None)).ToList();
+
+        public static Direction Opposite(this Direction direction)
+        {
+            switch (direction)
+            {
+                case Direction.North:
+                    return Direction.South;
+                case Direction.NorthEast:
+                    return Direction.SouthWest;
+                case Direction.East:
+                    return Direction.West;
+                case Direction.SouthEast:
+                    return Direction.NorthWest;
+                case Direction.South:
+                    return Direction.North;
+                case Direction.SouthWest:
+                    return Direction.NorthEast;
+                case Direction.West:
+                    return Direction.East;
+                case Direction.NorthWest:
+                    return Direction.SouthEast;
+                case Direction.None:
+                    return Direction.None;
+                default:
+                    throw new ArgumentException($"Unknown direction {direction}.");
+            }
+        }
+
+        public static Vector2Int AsVector2Int(this Direction direction)
+        {
+            switch (direction)
+            {
+                case Direction.None:
+                    return Vector2Int.zero;
+                case Direction.North:
+                    return Vector2Int.up;
+                case Direction.NorthEast:
+                    return new Vector2Int(1, 1);
+                case Direction.East:
+                    return Vector2Int.right;
+                case Direction.SouthEast:
+                    return new Vector2Int(1, -1);
+                case Direction.South:
+                    return Vector2Int.down;
+                case Direction.SouthWest:
+                    return new Vector2Int(-1, -1);
+                case Direction.West:
+                    return Vector2Int.left;
+                case Direction.NorthWest:
+                    return new Vector2Int(-1, 1);
+                default:
+                    throw new ArgumentException($"Unknown direction {direction}.");
+            }
+        }
+
+        public static Vector2 AsVector2(this Direction direction)
+        {
+            return direction.AsVector2Int();
+        }
+
+        public static Direction AsDirection(this Vector3 vector3)
+        {
+            return AsDirection((Vector2)vector3);
+        }
+
+        public static IEnumerable<Direction> Split(this Direction direction)
+        {
+            bool foundAny = false;
+            foreach (Direction singleDirection in Directions)
+            {
+                if (direction.HasFlag(singleDirection))
+                {
+                    foundAny = true;
+                    yield return singleDirection;
+                }
+            }
+
+            if (!foundAny)
+            {
+                yield return Direction.None;
+            }
+        }
+
+        public static Direction Combine(this IEnumerable<Direction> directions)
+        {
+            Direction combined = Direction.None;
+            foreach (Direction direction in directions)
+            {
+                combined |= direction;
+            }
+
+            return combined;
+        }
+
+        public static Direction AsDirection(this Vector2 vector, bool preferAngles = false)
+        {
+            if (vector.x == 0 && vector.y == 0)
+            {
+                return Direction.None;
+            }
+
+            float angle;
+            if (vector.x < 0)
+            {
+                angle = 360 - Mathf.Atan2(vector.x, vector.y) * Mathf.Rad2Deg * -1;
+            }
+            else
+            {
+                angle = Mathf.Atan2(vector.x, vector.y) * Mathf.Rad2Deg;
+            }
+
+            if (preferAngles)
+            {
+                if (345 <= angle || angle < 15)
+                {
+                    return Direction.North;
+                }
+
+                if (15 <= angle && angle < 75)
+                {
+                    return Direction.NorthEast;
+                }
+
+                if (75 <= angle && angle < 105)
+                {
+                    return Direction.East;
+                }
+
+                if (105 <= angle && angle < 165)
+                {
+                    return Direction.SouthEast;
+                }
+
+                if (165 <= angle && angle < 195)
+                {
+                    return Direction.South;
+                }
+
+                if (195 <= angle && angle < 255)
+                {
+                    return Direction.SouthWest;
+                }
+
+                if (255 <= angle && angle < 285)
+                {
+                    return Direction.West;
+                }
+
+                if (285 <= angle && angle < 345)
+                {
+                    return Direction.NorthWest;
+                }
+            }
+
+            if (337.5 <= angle || angle < 22.5)
+            {
+                return Direction.North;
+            }
+
+            if (22.5 <= angle && angle < 67.5)
+            {
+                return Direction.NorthEast;
+            }
+
+            if (67.5 <= angle && angle < 112.5)
+            {
+                return Direction.East;
+            }
+
+            if (112.5 <= angle && angle < 157.5)
+            {
+                return Direction.SouthEast;
+            }
+
+            if (157.5 <= angle && angle < 202.5)
+            {
+                return Direction.South;
+            }
+
+            if (202.5 <= angle && angle < 247.5)
+            {
+                return Direction.SouthWest;
+            }
+
+            if (247.5 <= angle && angle < 292.5)
+            {
+                return Direction.West;
+            }
+
+            if (292.5 <= angle && angle < 337.5)
+            {
+                return Direction.NorthWest;
+            }
+
+            return Direction.None;
+        }
+    }
+}

package/Runtime/Core/Extension/DirectionExtensions.cs.meta

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

package/Runtime/Core/Extension/HashSetExtensions.cs

@@ -0,0 +1,12 @@
+namespace UnityHelpers.Core.Extension
+{
+    using System.Collections.Generic;
+
+    public static class HashSetExtensions
+    {
+        public static void AddRange<T>(this HashSet<T> set, IEnumerable<T> elements)
+        {
+            set.UnionWith(elements);
+        }
+    }
+}

package/Runtime/Core/Extension/HashSetExtensions.cs.meta

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

package/Runtime/Core/Extension/IEnumerableExtensions.cs

@@ -0,0 +1,109 @@
+namespace UnityHelpers.Core.Extension
+{
+    using Random;
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    public static class IEnumerableExtensions
+    {
+        private static readonly ConcurrentDictionary<object, object> ComparerCache = new();
+
+        public static IList<T> AsList<T>(this IEnumerable<T> enumeration)
+        {
+            if (enumeration is IList<T> list)
+            {
+                return list;
+            }
+
+            return enumeration.ToList();
+        }
+
+        public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> enumeration, Func<T, T, int> comparer)
+        {
+            FuncBasedComparer<T> comparerObject = (FuncBasedComparer<T>) ComparerCache.GetOrAdd(comparer, () => new FuncBasedComparer<T>(comparer));
+            return enumeration.OrderBy(_ => _, comparerObject);
+        }
+
+        public static IEnumerable<T> Ordered<T>(this IEnumerable<T> enumerable) where T : IComparable
+        {
+            return enumerable.OrderBy(_ => _);
+        }
+
+        public static IEnumerable<T> Shuffled<T>(this IEnumerable<T> enumerable, IRandom random = null)
+        {
+            random = random ?? ThreadLocalRandom<PcgRandom>.Instance;
+            return enumerable.OrderBy(_ => random.Next());
+        }
+
+        public static IEnumerable<T> Infinite<T>(this IEnumerable<T> enumerable)
+        {
+            ICollection<T> collection = enumerable as ICollection<T> ?? enumerable.ToList();
+            if (collection.Count == 0)
+            {
+                yield break;
+            }
+
+            while (true)
+            {
+                foreach (T element in collection)
+                {
+                    yield return element;
+                }
+            }
+        }
+
+        public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
+        {
+            foreach (T item in enumerable)
+            {
+                action(item);
+            }
+        }
+
+        public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> items, int size)
+        {
+            using var enumerator = items.GetEnumerator();
+            bool hasNext = enumerator.MoveNext();
+
+            IEnumerable<T> NextPartitionOf()
+            {
+                int remainingCountForPartition = size;
+                while (remainingCountForPartition-- > 0 && hasNext)
+                {
+                    yield return enumerator.Current;
+                    hasNext = enumerator.MoveNext();
+                }
+            }
+
+            while (hasNext)
+            {
+                yield return NextPartitionOf().ToList();
+            }
+        }
+
+        public static List<T> ToList<T>(this IEnumerable<T> enumerable, int count)
+        {
+            List<T> list = new(count);
+            list.AddRange(enumerable);
+            return list;
+        }
+
+
+        private class FuncBasedComparer<T> : IComparer<T>
+        {
+            private readonly Func<T, T, int> _comparer;
+
+            public FuncBasedComparer(Func<T, T, int> comparer)
+            {
+                _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
+            }
+
+            public int Compare(T lhs, T rhs)
+            {
+                return _comparer(lhs, rhs);
+            }
+        }
+    }
+}

package/Runtime/Core/Extension/IEnumerableExtensions.cs.meta

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

package/Runtime/Core/Extension/IListExtensions.cs

@@ -0,0 +1,49 @@
+namespace UnityHelpers.Core.Extension
+{
+    using Random;
+    using System.Collections.Generic;
+
+    public static class IListExtensions
+    {
+        public static void Shuffle<T>(this IList<T> list, IRandom random = null)
+        {
+            if (list is not { Count: > 1 })
+            {
+                return;
+            }
+
+            random ??= PcgRandom.Instance;
+
+            int length = list.Count;
+            for (int i = 0; i < length - 1; ++i)
+            {
+                int nextIndex = random.Next(i, length);
+                if (nextIndex == i)
+                {
+                    continue;
+                }
+                (list[i], list[nextIndex]) = (list[nextIndex], list[i]);
+            }
+        }
+
+        public static void RemoveAtSwapBack<T>(this IList<T> list, int index)
+        {
+            if (list.Count <= 1)
+            {
+                list.Clear();
+                return;
+            }
+
+            int lastIndex = list.Count - 1;
+            if (index == lastIndex)
+            {
+                list.RemoveAt(index);
+                return;
+            }
+
+            T last = list[lastIndex];
+            list[index] = last;
+            list.RemoveAt(lastIndex);
+        }
+    }
+}

package/Runtime/Core/Extension/IListExtensions.cs.meta

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

package/Runtime/Core/Extension/LoggingExtensions.cs

@@ -0,0 +1,196 @@
+#if !ENABLE_UBERLOGGING && (DEVELOPMENT_BUILD || DEBUG || UNITY_EDITOR)
+#define ENABLE_UBERLOGGING
+#endif
+
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Diagnostics;
+    using System.Threading;
+    using Helper;
+    using JetBrains.Annotations;
+    using UnityEngine;
+    using Debug = UnityEngine.Debug;
+
+    public static class LoggingExtensions
+    {
+        private static readonly Thread UnityMainThread;
+
+        private static bool LoggingEnabled = true;
+
+        static LoggingExtensions()
+        {
+#if ENABLE_UBERLOGGING
+            /*
+                Unity throws exceptions if you try to log on something that isn't the main thread.
+                Sometimes, it's nice to log in async Tasks. Assume that the first initialization of
+                this class will be done by the Unity main thread, and then check every time we log.
+                If the logging thread is not the unity main thread, then do nothing
+                (instead of throwing...)
+             */
+            UnityMainThread = Thread.CurrentThread;
+#endif
+        }
+
+        public static void EnableLogging(this UnityEngine.Object component)
+        {
+            LoggingEnabled = true;
+        }
+
+        public static void DisableLogging(this UnityEngine.Object component)
+        {
+            LoggingEnabled = false;
+        }
+
+        
+        [StringFormatMethod("message")]
+        public static void Log(this UnityEngine.Object component, string message, params object[] args)
+        {
+#if ENABLE_UBERLOGGING
+            if (!LoggingEnabled)
+            {
+                return;
+            }
+            LogDebug(component, message, args);
+#endif
+        }
+
+        
+        [StringFormatMethod("message")]
+        public static void LogMethod(this UnityEngine.Object component)
+        {
+#if ENABLE_UBERLOGGING
+            StackTrace stackTrace = new StackTrace();
+            string methodName = stackTrace.GetFrame(1).GetMethod().Name;
+            LogDebug(component, methodName);
+#endif
+        }
+
+        
+        [StringFormatMethod("message")]
+        public static void LogDebug(this UnityEngine.Object component, string message, params object[] args)
+        {
+#if ENABLE_UBERLOGGING
+            if (!LoggingEnabled)
+            {
+                return;
+            }
+            LogDebug(component, message, null, args);
+#endif
+        }
+
+        
+        [StringFormatMethod("message")]
+        public static void LogWarn(this UnityEngine.Object component, string message, params object[] args)
+        {
+#if ENABLE_UBERLOGGING
+            if (!LoggingEnabled)
+            {
+                return;
+            }
+            LogWarn(component, message, null, args);
+#endif
+        }
+
+        
+        [StringFormatMethod("message")]
+        public static void LogError(this UnityEngine.Object component, string message, params object[] args)
+        {
+#if ENABLE_UBERLOGGING
+            if (!LoggingEnabled)
+            {
+                return;
+            }
+            LogError(component, message, null, args);
+#endif
+        }
+
+        
+        [StringFormatMethod("message")]
+        public static void Log(this UnityEngine.Object component, string message, Exception e, params object[] args)
+        {
+#if ENABLE_UBERLOGGING
+            if (!LoggingEnabled)
+            {
+                return;
+            }
+            LogDebug(component, message, e, args);
+#endif
+        }
+
+        
+        [StringFormatMethod("message")]
+        public static void LogDebug(this UnityEngine.Object component, string message, Exception e, params object[] args)
+        {
+#if ENABLE_UBERLOGGING
+            if (!LoggingEnabled)
+            {
+                return;
+            }
+            if (Equals(Thread.CurrentThread, UnityMainThread))
+            {
+                Debug.Log(Wrap(component, string.Format(message, args), e));
+            }
+#endif
+        }
+
+        
+        [StringFormatMethod("message")]
+        public static void LogWarn(this UnityEngine.Object component, string message, Exception e, params object[] args)
+        {
+#if ENABLE_UBERLOGGING
+            if (!LoggingEnabled)
+            {
+                return;
+            }
+            if (Equals(Thread.CurrentThread, UnityMainThread))
+            {
+                Debug.LogWarning(Wrap(component, string.Format(message, args), e));
+            }
+#endif
+        }
+
+        
+        [StringFormatMethod("message")]
+        public static void LogError(this UnityEngine.Object component, string message, Exception e, params object[] args)
+        {
+#if ENABLE_UBERLOGGING
+            if (!LoggingEnabled)
+            {
+                return;
+            }
+            if (Equals(Thread.CurrentThread, UnityMainThread))
+            {
+                Debug.LogError(Wrap(component, string.Format(message, args), e));
+            }
+#endif
+        }
+
+        private static string Wrap(UnityEngine.Object component, string message, Exception e)
+        {
+#if ENABLE_UBERLOGGING
+            float now = Time.time;
+            string componentType = component == null ? "NO_TYPE" : component.GetType().Name;
+            string gameObjectName = "NO_NAME";
+            if (component != null)
+            {
+                GameObject owner = component.GetGameObject();
+                if (owner != null)
+                {
+                    gameObjectName = owner.name;
+                }
+            }
+
+            string prepend = string.Format("{0}|{2}[{1}]|", now, componentType, gameObjectName);
+            if (e != null)
+            {
+                return prepend + message + "\n    " + e;
+            }
+
+            return prepend + message;
+#else
+            return string.Empty;
+#endif
+        }
+    }
+}

package/Runtime/Core/Extension/LoggingExtensions.cs.meta

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