(61d00a474) v0.9.7.1

2020-03-04 13:04:10 +01:00
parent 3c50efa5c9
commit 3c09ebe02f
5086 changed files with 786063 additions and 295871 deletions
@@ -0,0 +1,114 @@
+using System.Collections.Generic;
+using System;
+using System.Linq;
+
+namespace Barotrauma.Extensions
+{
+    public static class IEnumerableExtensions
+    {
+        /// <summary>
+        /// Randomizes the collection (using OrderBy) and returns it.
+        /// </summary>
+        public static IOrderedEnumerable<T> Randomize<T>(this IEnumerable<T> source, Rand.RandSync randSync = Rand.RandSync.Unsynced)
+        {
+            return source.OrderBy(i => Rand.Value(randSync));
+        }
+
+        /// <summary>
+        /// Randomizes the list in place without creating a new collection, using a Fisher-Yates-based algorithm.
+        /// </summary>
+        public static void Shuffle<T>(this IList<T> list, Rand.RandSync randSync = Rand.RandSync.Unsynced)
+        {
+            int n = list.Count;
+            while (n > 1)
+            {
+                n--;
+                int k = Rand.Int(n + 1, randSync);
+                T value = list[k];
+                list[k] = list[n];
+                list[n] = value;
+            }
+        }
+
+        public static T GetRandom<T>(this IEnumerable<T> source, Func<T, bool> predicate, Rand.RandSync randSync = Rand.RandSync.Unsynced)
+        {
+            return source.Where(predicate).GetRandom(randSync);
+        }
+
+        public static T GetRandom<T>(this IEnumerable<T> source, Rand.RandSync randSync = Rand.RandSync.Unsynced)
+        {
+            int count = source.Count();
+            return count == 0 ? default(T) : source.ElementAt(Rand.Range(0, count, randSync));
+        }
+
+        /// <summary>
+        /// Executes an action that modifies the collection on each element (such as removing items from the list).
+        /// Creates a temporary list.
+        /// </summary>
+        public static void ForEachMod<T>(this IEnumerable<T> source, Action<T> action)
+        {
+            var temp = new List<T>(source);
+            temp.ForEach(action);
+        }
+
+        /// <summary>
+        /// Generic version of List.ForEach.
+        /// Performs the specified action on each element of the collection (short hand for a foreach loop).
+        /// </summary>
+        public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
+        {
+            foreach (var item in source)
+            {
+                action(item);
+            }
+        }
+
+        /// <summary>
+        /// Shorthand for !source.Any(predicate) -> i.e. not any.
+        /// </summary>
+        public static bool None<T>(this IEnumerable<T> source, Func<T, bool> predicate = null)
+        {
+            if (predicate == null)
+            {
+                return !source.Any();
+            }
+            else
+            {
+                return !source.Any(predicate);
+            }
+        }
+
+        public static bool Multiple<T>(this IEnumerable<T> source, Func<T, bool> predicate = null)
+        {
+            if (predicate == null)
+            {
+                return source.Count() > 1;
+            }
+            else
+            {
+                return source.Count(predicate) > 1;
+            }
+        }
+        
+        public static IEnumerable<T> ToEnumerable<T>(this T item)
+        {
+            yield return item;
+        }
+
+        // source: https://stackoverflow.com/questions/19237868/get-all-children-to-one-list-recursive-c-sharp
+        public static IEnumerable<T> SelectManyRecursive<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector)
+        {
+            var result = source.SelectMany(selector);
+            if (!result.Any())
+            {
+                return result;
+            }
+            return result.Concat(result.SelectManyRecursive(selector));
+        }
+
+        public static void AddIfNotNull<T>(this IList<T> source, T value)
+        {
+            if (value != null) { source.Add(value); }
+        }
+    }
+}
@@ -0,0 +1,61 @@
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Extensions
+{
+    public static class PointExtensions
+    {
+        public static Point Multiply(this Point p, float f)
+        {
+            return new Point((int)(p.X * f), (int)(p.Y * f));
+        }
+
+        public static Point Multiply(this Point p, int i)
+        {
+            return new Point(p.X * i, p.Y * i);
+        }
+
+        public static Point Multiply(this Point p, Vector2 v)
+        {
+            return new Point((int)(p.X * v.X), (int)(p.Y * v.Y));
+        }
+
+        public static Point Divide(this Point p, int i)
+        {
+            if (i == 0) { return Point.Zero; }
+            return new Point(p.X / i, p.Y / i);
+        }
+
+        public static Point Divide(this Point p, float f)
+        {
+            if (f == 0) { return Point.Zero; }
+            return new Point((int)(p.X / f), (int)(p.Y / f));
+        }
+
+        public static Point Divide(this Point p, Vector2 v)
+        {
+            if (v.X == 0 || v.Y == 0) { return Point.Zero; }
+            return new Point((int)(p.X / v.X), (int)(p.Y / v.Y));
+        }
+
+        /// <summary>
+        /// Negates the X and Y components.
+        /// </summary>
+        public static Point Inverse(this Point p)
+        {
+            return new Point(-p.X, -p.Y);
+        }
+
+        /// <summary>
+        /// Flips the X and Y components.
+        /// </summary>
+        public static Point Flip(this Point p)
+        {
+            return new Point(p.Y, p.X);
+        }
+
+        public static Point Clamp(this Point p, Point min, Point max)
+        {
+            return new Point(MathHelper.Clamp(p.X, min.X, max.X), MathHelper.Clamp(p.Y, min.Y, max.Y));
+        }
+    }
+}
@@ -0,0 +1,61 @@
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Extensions
+{
+    public static class RectangleExtensions
+    {
+        public static Rectangle Multiply(this Rectangle rect, float f)
+        {
+            Vector2 location = new Vector2(rect.X, rect.Y) * f;
+            return new Rectangle(new Point((int)location.X, (int)location.Y), rect.MultiplySize(f));
+        }
+
+        public static Rectangle Divide(this Rectangle rect, float f)
+        {
+            Vector2 location = new Vector2(rect.X, rect.Y) / f;
+            return new Rectangle(new Point((int)location.X, (int)location.Y), rect.DivideSize(f));
+        }
+
+        public static Point DivideSize(this Rectangle rect, float f)
+        {
+            return new Point((int)(rect.Width / f), (int)(rect.Height / f));
+        }
+
+        public static Point DivideSize(this Rectangle rect, Vector2 f)
+        {
+            return new Point((int)(rect.Width / f.X), (int)(rect.Height / f.Y));
+        }
+
+        public static Point MultiplySize(this Rectangle rect, float f)
+        {
+            return new Point((int)(rect.Width * f), (int)(rect.Height * f));
+        }
+
+        public static Point MultiplySize(this Rectangle rect, Vector2 f)
+        {
+            return new Point((int)(rect.Width * f.X), (int)(rect.Height * f.Y));
+        }
+
+        public static Vector2 CalculateRelativeSize(this Rectangle rect, Rectangle relativeRect)
+        {
+            return new Vector2(rect.Width, rect.Height) / new Vector2(relativeRect.Width, relativeRect.Height);
+        }
+
+        public static Rectangle ScaleSize(this Rectangle rect, Rectangle relativeTo)
+        {
+            return rect.ScaleSize(rect.CalculateRelativeSize(relativeTo));
+        }
+
+        public static Rectangle ScaleSize(this Rectangle rect, Vector2 scale)
+        {
+            var size = rect.MultiplySize(scale);
+            return new Rectangle(rect.X, rect.Y, size.X, size.Y);
+        }
+
+        public static Rectangle ScaleSize(this Rectangle rect, float scale)
+        {
+            var size = rect.MultiplySize(scale);
+            return new Rectangle(rect.X, rect.Y, size.X, size.Y);
+        }
+    }
+}
@@ -0,0 +1,169 @@
+using System.Globalization;
+using Microsoft.Xna.Framework;
+using System.Linq;
+using System;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    public static class StringFormatter
+    {
+        public static string Replace(this string s, string replacement, Func<char, bool> predicate)
+        {
+            var newString = new string[s.Length];
+            for (int i = 0; i < s.Length; i++)
+            {
+                char letter = s[i];
+                string newLetter = letter.ToString();
+                if (predicate(letter))
+                {
+                    newLetter = replacement;
+                }
+                newString[i] = newLetter;
+            }
+            return new string(newString.SelectMany(str => str.ToCharArray()).ToArray());
+        }
+        
+        public static string Remove(this string s, string substring)
+        {
+            return s.Replace(substring, string.Empty);
+        }
+
+        public static string Remove(this string s, Func<char, bool> predicate)
+        {
+            return new string(s.ToCharArray().Where(c => !predicate(c)).ToArray());
+        }
+
+        public static string RemoveWhitespace(this string s)
+        {
+            return s.Remove(c => char.IsWhiteSpace(c));
+        }
+
+        public static string FormatSingleDecimal(this float value)
+        {
+            return value.ToString("F1", CultureInfo.InvariantCulture);
+        }
+
+        public static string FormatDoubleDecimal(this float value)
+        {
+            return value.ToString("F2", CultureInfo.InvariantCulture);
+        }
+
+        public static string FormatZeroDecimal(this float value)
+        {
+            return value.ToString("F0", CultureInfo.InvariantCulture);
+        }
+
+        public static string Format(this float value, int decimalCount)
+        {
+            return value.ToString($"F{decimalCount.ToString()}", CultureInfo.InvariantCulture);
+        }
+
+        public static string FormatSingleDecimal(this Vector2 value)
+        {
+            return $"({value.X.FormatSingleDecimal()}, {value.Y.FormatSingleDecimal()})";
+        }
+
+        public static string FormatDoubleDecimal(this Vector2 value)
+        {
+            return $"({value.X.FormatDoubleDecimal()}, {value.Y.FormatDoubleDecimal()})";
+        }
+
+        public static string FormatZeroDecimal(this Vector2 value)
+        {
+            return $"({value.X.FormatZeroDecimal()}, {value.Y.FormatZeroDecimal()})";
+        }
+
+        public static string Format(this Vector2 value, int decimalCount)
+        {
+            return $"({value.X.Format(decimalCount)}, {value.Y.Format(decimalCount)})";
+        }
+
+        /// <summary>
+        /// Capitalises the first letter (invariant) and forces the rest to lower case (invariant).
+        /// </summary>
+        public static string CapitaliseFirstInvariant(this string s)
+        {
+            if (string.IsNullOrEmpty(s)) { return string.Empty; }
+            return s.Substring(0, 1).ToUpperInvariant() + s.Substring(1, s.Length - 1).ToLowerInvariant();
+        }
+
+        /// <summary>
+        /// Adds spaces into a CamelCase string.
+        /// </summary>
+        public static string FormatCamelCaseWithSpaces(this string str)
+        {
+            return new string(InsertSpacesBeforeCaps(str).ToArray());
+            IEnumerable<char> InsertSpacesBeforeCaps(IEnumerable<char> input)
+            {
+                int i = 0;
+                int lastChar = input.Count() - 1;
+                foreach (char c in input)
+                {
+                    if (char.IsUpper(c) && i > 0)
+                    {
+                        yield return ' ';
+                    }
+
+                    yield return c;
+                    i++;
+                }
+            }
+        }
+
+        public static ICollection<string> ParseCommaSeparatedStringToCollection(string input, ICollection<string> texts = null, bool convertToLowerInvariant = true)
+        {
+            if (texts == null)
+            {
+                texts = new HashSet<string>();
+            }
+            else
+            {
+                texts.Clear();
+            }
+            if (!string.IsNullOrWhiteSpace(input))
+            {
+                foreach (string value in input.Split(','))
+                {
+                    if (string.IsNullOrWhiteSpace(value)) { continue; }
+                    if (convertToLowerInvariant)
+                    {
+                        texts.Add(value.ToLowerInvariant());
+                    }
+                    else
+                    {
+                        texts.Add(value);
+                    }
+                }
+            }
+            return texts;
+        }
+
+        public static ICollection<string> ParseSeparatedStringToCollection(string input, string[] separators, ICollection<string> texts = null, bool convertToLowerInvariant = true)
+        {
+            if (texts == null)
+            {
+                texts = new HashSet<string>();
+            }
+            else
+            {
+                texts.Clear();
+            }
+            if (!string.IsNullOrWhiteSpace(input))
+            {
+                foreach (string value in input.Split(separators, StringSplitOptions.RemoveEmptyEntries))
+                {
+                    if (convertToLowerInvariant)
+                    {
+                        texts.Add(value.ToLowerInvariant());
+                    }
+                    else
+                    {
+                        texts.Add(value);
+                    }
+                }
+            }
+            return texts;
+        }
+    }
+}
@@ -0,0 +1,96 @@
+using System;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Extensions
+{
+    public static class VectorExtensions
+    {
+        /// <summary>
+        /// Unity's Angle implementation without the conversion to degrees.
+        /// Returns the angle in radians between two vectors.
+        /// 0 - Pi.
+        /// </summary>
+        public static float Angle(this Vector2 from, Vector2 to)
+        {
+            return (float)Math.Acos(MathHelper.Clamp(Vector2.Dot(Vector2.Normalize(from), Vector2.Normalize(to)), -1f, 1f));
+        }
+
+        /// <summary>
+        /// Creates a forward pointing vector based on the rotation (in radians).
+        /// </summary>
+        public static Vector2 Forward(float radians, float length = 1)
+        {
+            return new Vector2((float)Math.Cos(radians), (float)Math.Sin(radians)) * length;
+        }
+
+        /// <summary>
+        /// Creates a backward pointing vector based on the rotation (in radians).
+        /// </summary>
+        public static Vector2 Backward(float radians, float length = 1)
+        {
+            return -Forward(radians, length);
+        }
+
+        /// <summary>
+        /// Creates a forward pointing vector based on the rotation (in radians). TODO: remove when the implications have been neutralized
+        /// </summary>
+        public static Vector2 ForwardFlipped(float radians, float length = 1)
+        {
+            return new Vector2((float)Math.Sin(radians), (float)Math.Cos(radians)) * length;
+        }
+
+        /// <summary>
+        /// Creates a backward pointing vector based on the rotation (in radians). TODO: remove when the implications have been neutralized
+        /// </summary>
+        public static Vector2 BackwardFlipped(float radians, float length = 1)
+        {
+            return -ForwardFlipped(radians, length);
+        }
+
+        /// <summary>
+        /// Creates a normalized perpendicular vector to the right from a forward vector.
+        /// </summary>
+        public static Vector2 Right(this Vector2 forward)
+        {
+            var normV = Vector2.Normalize(forward);
+            return new Vector2(normV.Y, -normV.X);
+        }
+
+        /// <summary>
+        /// Creates a normalized perpendicular vector to the left from a forward vector.
+        /// </summary>
+        public static Vector2 Left(this Vector2 forward)
+        {
+            return -forward.Right();
+        }
+
+        /// <summary>
+        /// Transforms a vector relative to the given up vector.
+        /// </summary>
+        public static Vector2 TransformVector(this Vector2 v, Vector2 up)
+        {
+            up = Vector2.Normalize(up);
+            return (up * v.Y) + (up.Right() * v.X);
+        }
+
+        /// <summary>
+        /// Flips the x and y components.
+        /// </summary>
+        public static Vector2 Flip(this Vector2 v) => new Vector2(v.Y, v.X);
+
+        /// <summary>
+        /// Returns the sum of the x and y components.
+        /// </summary>
+        public static float Combine(this Vector2 v) => v.X + v.Y;
+
+        public static Vector2 Clamp(this Vector2 v, Vector2 min, Vector2 max)
+        {
+            return Vector2.Clamp(v, min, max);
+        }
+
+        public static bool NearlyEquals(this Vector2 v, Vector2 other)
+        {
+            return MathUtils.NearlyEqual(v.X, other.X) && MathUtils.NearlyEqual(v.Y, other.Y);
+        }
+    }
+}