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

package/Runtime/Core/DataStructure/StringWrapper.cs

@@ -0,0 +1,90 @@
+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
+     */
+    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() ?? 0;
+        }
+
+        public static StringWrapper Get(string value)
+        {
+            return Cache.GetOrAdd(value, key => new StringWrapper(key));
+        }
+
+        public static void Remove(string value)
+        {
+            _ = 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);
+        }
+
+        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/StringWrapper.cs.meta

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

package/Runtime/Core/DataStructure/TimedCache.cs

@@ -0,0 +1,50 @@
+namespace UnityHelpers.Core.DataStructure
+{
+    using System;
+    using Helper;
+    using Random;
+    using UnityEngine;
+
+    public sealed class TimedCache<T>
+    {
+        public T Value
+        {
+            get
+            {
+                if (!_lastRead.HasValue || Helpers.HasEnoughTimePassed(_lastRead.Value, _cacheTtl))
+                {
+                    Reset();
+                }
+
+                return _value;
+            }
+        }
+
+        private readonly Func<T> _valueProducer;
+        private readonly float _cacheTtl;
+
+        private float? _lastRead;
+        private T _value;
+
+        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;
+            if (useJitter && 0 <_cacheTtl)
+            {
+                _cacheTtl += PcgRandom.Instance.NextFloat(_cacheTtl);
+            }
+        }
+
+        public void Reset()
+        {
+            _value = _valueProducer();
+            _lastRead = Time.time;
+        }
+    }
+}

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

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

package/Runtime/Core/DataStructure.meta

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

package/Runtime/Core/Extension/AnimatorExtensions.cs

@@ -0,0 +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);
+            }
+        }
+    }
+}

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

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

package/Runtime/Core/Extension/CircleExtensions.cs

@@ -0,0 +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);
+                    }
+                }
+            }
+        }
+    }
+}

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

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

package/Runtime/Core/Extension/ColorExtensions.cs

@@ -0,0 +1,72 @@
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using Random;
+    using UnityEngine;
+
+    // https://sharpsnippets.wordpress.com/2014/03/11/c-extension-complementary-color/
+    public static class ColorExtensions
+    {
+        public static Color GetComplement(this Color source, IRandom random = null, float variance = 0f)
+        {
+            Color inputColor = source;
+            //if RGB values are close to each other by a diff less than 10%, then if RGB values are lighter side, decrease the blue by 50% (eventually it will increase in conversion below), if RBB values are on darker side, decrease yellow by about 50% (it will increase in conversion)
+            float avgColorValue = (source.r + source.g + source.b) / 3;
+            float rDiff = Math.Abs(source.r - avgColorValue);
+            float gDiff = Math.Abs(source.g - avgColorValue);
+            float bDiff = Math.Abs(source.b - avgColorValue);
+            const float greyDelta = 20 / 255f;
+            if (rDiff < greyDelta && gDiff < greyDelta && bDiff < greyDelta) //The color is a shade of gray
+            {
+                if (avgColorValue < 123 / 255f) //color is dark
+                {
+                    inputColor.b = 220 / 255f;
+                    inputColor.g = 230 / 255f;
+                    inputColor.r = 50 / 255f;
+                }
+                else
+                {
+                    inputColor.r = 255 / 255f;
+                    inputColor.g = 255 / 255f;
+                    inputColor.b = 50 / 255f;
+                }
+            }
+
+            if (random != null)
+            {
+                if (variance != 0)
+                {
+                    variance = Math.Abs(variance);
+
+                    float minR = Clamp(inputColor.r - variance);
+                    float maxR = Clamp(inputColor.r + variance);
+                    inputColor.r = random.NextFloat(minR, maxR);
+
+                    float minG = Clamp(inputColor.g - variance);
+                    float maxG = Clamp(inputColor.g + variance);
+                    inputColor.g = random.NextFloat(minG, maxG);
+
+                    float minB = Clamp(inputColor.b - variance);
+                    float maxB = Clamp(inputColor.b + variance);
+                    inputColor.b = random.NextFloat(minB, maxB);
+                }
+                else
+                {
+                    inputColor.r *= random.NextFloat(1 / inputColor.r);
+                    inputColor.g *= random.NextFloat(1 / inputColor.g);
+                    inputColor.b *= random.NextFloat(1 / inputColor.b);
+                }
+            }
+
+            Color.RGBToHSV(inputColor, out float h, out float s, out float v);
+            h = h < 0.5f ? h + 0.5f : h - 0.5f;
+            Color result = Color.HSVToRGB(h, s, v);
+            return result;
+        }
+
+        private static float Clamp(float value)
+        {
+            return Math.Clamp(value, 0, 1);
+        }
+    }
+}

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

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

package/Runtime/Core/Extension/DictionaryExtensions.cs

@@ -0,0 +1,173 @@
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    public static class DictionaryExtensions
+    {
+        public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> valueProducer)
+        {
+            if (dictionary.TryGetValue(key, out V result))
+            {
+                return result;
+            }
+
+            return dictionary[key] = valueProducer();
+        }
+        public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
+        {
+            if (dictionary.TryGetValue(key, out V result))
+            {
+                return result;
+            }
+
+            return dictionary[key] = valueProducer(key);
+        }
+
+        public static V GetOrElse<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> valueProducer)
+        {
+            if (dictionary.TryGetValue(key, out V value))
+            {
+                return value;
+            }
+            return valueProducer.Invoke();
+        }
+
+        public static V GetOrElse<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
+        {
+            if (dictionary.TryGetValue(key, out V value))
+            {
+                return value;
+            }
+
+            return valueProducer.Invoke(key);
+        }
+
+        public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key) where V : new()
+        {
+            if (dictionary.TryGetValue(key, out V result))
+            {
+                return result;
+            }
+
+            return dictionary[key] = new V();
+        }
+
+        public static V GetOrElse<K, V>(this IDictionary<K, V> dictionary, K key, V value)
+        {
+            return GetOrElse(dictionary, key, () => value);
+        }
+
+        public static bool Remove<K, V>(this IDictionary<K, V> dictionary, K key, out V value)
+        {
+            if (dictionary.TryGetValue(key, out value))
+            {
+                return dictionary.Remove(key);
+            }
+            return false;
+        }
+
+        public static V AddOrUpdate<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> creator, Func<K, V, V> updater)
+        {
+            V latest = dictionary.TryGetValue(key, out V value) ? updater(key, value) : creator(key);
+            dictionary[key] = latest;
+            return latest;
+        }
+
+        public static Dictionary<K, V> Merge<K, V>(this IDictionary<K, V> lhs, IDictionary<K, V> rhs)
+        {
+            Dictionary<K, V> result = new Dictionary<K, V>(lhs.Count);
+            foreach (KeyValuePair<K, V> kvp in lhs)
+            {
+                if (rhs.ContainsKey(kvp.Key))
+                {
+                    continue;
+                }
+
+                result[kvp.Key] = kvp.Value;
+            }
+
+            foreach (KeyValuePair<K, V> kvp in rhs)
+            {
+                result[kvp.Key] = kvp.Value;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        ///  </summary>
+        /// <typeparam name="K">Key type.</typeparam>
+        /// <typeparam name="V">Value type.</typeparam>
+        /// <param name="lhs">Basis dictionary.</param>
+        /// <param name="rhs">Changed dictionary.</param>
+        /// <returns>All elements of rhs that either don't exist in or are different from lhs</returns>
+        public static Dictionary<K, V> Difference<K, V>(this IDictionary<K, V> lhs, IDictionary<K, V> rhs)
+        {
+            Dictionary<K, V> result = new Dictionary<K, V>(rhs.Count);
+            foreach (KeyValuePair<K, V> kvp in rhs)
+            {
+                K key = kvp.Key;
+                V existing;
+                if (lhs.TryGetValue(key, out existing))
+                {
+                    if (Equals(existing, kvp.Value))
+                    {
+                        continue;
+                    }
+
+                    result[key] = kvp.Value;
+                }
+            }
+
+            return result;
+        }
+
+        public static Dictionary<V, K> Reverse<K, V>(this IDictionary<K, V> dictionary)
+        {
+            Dictionary<V, K> output = new Dictionary<V, K>(dictionary.Count);
+            foreach (KeyValuePair<K, V> entry in dictionary)
+            {
+                output[entry.Value] = entry.Key;
+            }
+            return output;
+        }
+
+        public static Dictionary<K, V> ToDictionary<K, V>(this IDictionary<K, V> dictionary)
+        {
+            return new Dictionary<K, V>(dictionary);
+        }
+
+        public static Dictionary<K, V> ToDictionary<K, V>(this IEnumerable<KeyValuePair<K, V>> prettyMuchADictionary)
+        {
+            return prettyMuchADictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+        }
+
+        public static bool ContentEquals<K, V>(this IDictionary<K, V> dictionary, IDictionary<K, V> other)
+        {
+            if (ReferenceEquals(dictionary, other))
+            {
+                return true;
+            }
+
+            if (ReferenceEquals(dictionary, null) || ReferenceEquals(other, null))
+            {
+                return false;
+            }
+
+            if (dictionary.Count != other.Count)
+            {
+                return false;
+            }
+
+            return !dictionary.Except(other).Any();
+        }
+
+        public static void Deconstruct<K, V>(this KeyValuePair<K, V> kvp, out K key, out V value)
+        {
+            key = kvp.Key;
+            value = kvp.Value;
+        }
+    }
+}

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

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