(f0d812055) v0.9.9.0

Barotrauma/BarotraumaShared/SharedSource/Extensions/IEnumerableExtensions.cs

@@ -7,24 +7,23 @@ namespace Barotrauma.Extensions
     public static class IEnumerableExtensions
     {
         /// <summary>
-        /// Randomizes the collection and returns it.
+        /// Randomizes the collection (using OrderBy) and returns it.
         /// </summary>
-        public static IOrderedEnumerable<T> Randomize<T>(this IEnumerable<T> source)
+        public static IOrderedEnumerable<T> Randomize<T>(this IEnumerable<T> source, Rand.RandSync randSync = Rand.RandSync.Unsynced)
         {
-            return source.OrderBy(i => Rand.Value());
+            return source.OrderBy(i => Rand.Value(randSync));
         }
 
         /// <summary>
-        /// Randomizes the list in place.
+        /// Randomizes the list in place without creating a new collection, using a Fisher-Yates-based algorithm.
         /// </summary>
-        public static void RandomizeList<T>(this List<T> list)
+        public static void Shuffle<T>(this IList<T> list, Rand.RandSync randSync = Rand.RandSync.Unsynced)
         {
-            //Fisher-Yates shuffle
             int n = list.Count;
             while (n > 1)
             {
                 n--;
-                int k = Rand.Int(n + 1);
+                int k = Rand.Int(n + 1, randSync);
                 T value = list[k];
                 list[k] = list[n];
                 list[n] = value;

Barotrauma/BarotraumaShared/SharedSource/Extensions/RectangleExtensions.cs

@@ -57,5 +57,43 @@ namespace Barotrauma.Extensions
             var size = rect.MultiplySize(scale);
             return new Rectangle(rect.X, rect.Y, size.X, size.Y);
         }
+
+        public static bool IntersectsWorld(this Rectangle rect, Rectangle value)
+        {
+            int bottom = rect.Y - rect.Height;
+            int otherBottom = value.Y - value.Height;
+            return value.Left < rect.Right && rect.Left < value.Right &&
+                   value.Top > bottom && rect.Top > otherBottom;
+        }
+
+        /// <summary>
+        /// Like the XNA method, but treats the y-coordinate so that up is greater and down is lower.
+        /// </summary>
+        public static bool ContainsWorld(this Rectangle rect, Rectangle other)
+        {
+            return 
+                (rect.X <= other.X) && ((other.X + other.Width) <= (rect.X + rect.Width)) && 
+                (rect.Y >= other.Y) && ((other.Y - other.Height) >= (rect.Y - rect.Height));
+        }
+
+        /// <summary>
+        /// Like the XNA method, but treats the y-coordinate so that up is greater and down is lower.
+        /// </summary>
+        public static bool ContainsWorld(this Rectangle rect, Vector2 point)
+        {
+            return 
+                (rect.X <= point.X) && (point.X < (rect.X + rect.Width)) &&
+                (rect.Y >= point.Y) && (point.Y > (rect.Y - rect.Height));
+        }
+
+        /// <summary>
+        /// Like the XNA method, but treats the y-coordinate so that up is greater and down is lower.
+        /// </summary>
+        public static bool ContainsWorld(this Rectangle rect, Point point)
+        {
+            return
+                (rect.X <= point.X) && (point.X < (rect.X + rect.Width)) &&
+                (rect.Y >= point.Y) && (point.Y > (rect.Y - rect.Height));
+        }
     }
 }