// Decompiled with JetBrains decompiler
// Type: Terraria.Utils
// Assembly: Terraria, Version=1.4.0.5, Culture=neutral, PublicKeyToken=null
// MVID: 67F9E73E-0A81-4937-A22C-5515CD405A83
// Assembly location: C:\Users\mikeyisbaeyt\Downloads\depotdownloader-2.4.5\depots\105601\6707058\Terraria.exe

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Graphics.PackedVector;
using Microsoft.Xna.Framework.Input;
using ReLogic.Content;
using ReLogic.Graphics;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using Terraria.DataStructures;
using Terraria.GameContent;
using Terraria.UI;
using Terraria.UI.Chat;
using Terraria.Utilities;
using Terraria.Utilities.Terraria.Utilities;

namespace Terraria
{
  public static class Utils
  {
    public const long MaxCoins = 999999999;
    public static Dictionary<DynamicSpriteFont, float[]> charLengths = new Dictionary<DynamicSpriteFont, float[]>();
    private static Regex _substitutionRegex = new Regex("{(\\?(?:!)?)?([a-zA-Z][\\w\\.]*)}", RegexOptions.Compiled);
    private const ulong RANDOM_MULTIPLIER = 25214903917;
    private const ulong RANDOM_ADD = 11;
    private const ulong RANDOM_MASK = 281474976710655;

    public static Color ColorLerp_BlackToWhite(float percent) => Color.Lerp(Color.Black, Color.White, percent);

    public static Vector2 Round(Vector2 input) => new Vector2((float) Math.Round((double) input.X), (float) Math.Round((double) input.Y));

    public static bool IsPowerOfTwo(int x) => x != 0 && (x & x - 1) == 0;

    public static float SmoothStep(float min, float max, float x) => MathHelper.Clamp((float) (((double) x - (double) min) / ((double) max - (double) min)), 0.0f, 1f);

    public static float UnclampedSmoothStep(float min, float max, float x) => (float) (((double) x - (double) min) / ((double) max - (double) min));

    public static Dictionary<string, string> ParseArguements(string[] args)
    {
      string str1 = (string) null;
      string str2 = "";
      Dictionary<string, string> dictionary = new Dictionary<string, string>();
      string str3;
      for (int index = 0; index < args.Length; ++index)
      {
        if (args[index].Length != 0)
        {
          if (args[index][0] == '-' || args[index][0] == '+')
          {
            if (str1 != null)
            {
              dictionary.Add(str1.ToLower(), str2);
              str3 = "";
            }
            str1 = args[index];
            str2 = "";
          }
          else
          {
            if (str2 != "")
              str2 += " ";
            str2 += args[index];
          }
        }
      }
      if (str1 != null)
      {
        dictionary.Add(str1.ToLower(), str2);
        str3 = "";
      }
      return dictionary;
    }

    public static void Swap<T>(ref T t1, ref T t2)
    {
      T obj = t1;
      t1 = t2;
      t2 = obj;
    }

    public static T Clamp<T>(T value, T min, T max) where T : IComparable<T>
    {
      if (value.CompareTo(max) > 0)
        return max;
      return value.CompareTo(min) < 0 ? min : value;
    }

    public static float Turn01ToCyclic010(float value) => (float) (1.0 - (Math.Cos((double) value * 6.28318548202515) * 0.5 + 0.5));

    public static float PingPongFrom01To010(float value)
    {
      value %= 1f;
      if ((double) value < 0.0)
        ++value;
      return (double) value >= 0.5 ? (float) (2.0 - (double) value * 2.0) : value * 2f;
    }

    public static float MultiLerp(float percent, params float[] floats)
    {
      float num1 = (float) (1.0 / ((double) floats.Length - 1.0));
      float num2 = num1;
      int index;
      for (index = 0; (double) percent / (double) num2 > 1.0 && index < floats.Length - 2; ++index)
        num2 += num1;
      return MathHelper.Lerp(floats[index], floats[index + 1], (percent - num1 * (float) index) / num1);
    }

    public static float WrappedLerp(float value1, float value2, float percent)
    {
      float amount = percent * 2f;
      if ((double) amount > 1.0)
        amount = 2f - amount;
      return MathHelper.Lerp(value1, value2, amount);
    }

    public static float GetLerpValue(float from, float to, float t, bool clamped = false)
    {
      if (clamped)
      {
        if ((double) from < (double) to)
        {
          if ((double) t < (double) from)
            return 0.0f;
          if ((double) t > (double) to)
            return 1f;
        }
        else
        {
          if ((double) t < (double) to)
            return 1f;
          if ((double) t > (double) from)
            return 0.0f;
        }
      }
      return (float) (((double) t - (double) from) / ((double) to - (double) from));
    }

    public static float Remap(
      float fromValue,
      float fromMin,
      float fromMax,
      float toMin,
      float toMax,
      bool clamped = true)
    {
      return MathHelper.Lerp(toMin, toMax, Utils.GetLerpValue(fromMin, fromMax, fromValue, clamped));
    }

    public static void ClampWithinWorld(
      ref int minX,
      ref int minY,
      ref int maxX,
      ref int maxY,
      bool lastValuesInclusiveToIteration = false,
      int fluffX = 0,
      int fluffY = 0)
    {
      int num = lastValuesInclusiveToIteration ? 1 : 0;
      minX = Utils.Clamp<int>(minX, fluffX, Main.maxTilesX - num - fluffX);
      maxX = Utils.Clamp<int>(maxX, fluffX, Main.maxTilesX - num - fluffX);
      minY = Utils.Clamp<int>(minY, fluffY, Main.maxTilesY - num - fluffY);
      maxY = Utils.Clamp<int>(maxY, fluffY, Main.maxTilesY - num - fluffY);
    }

    public static double GetLerpValue(double from, double to, double t, bool clamped = false)
    {
      if (clamped)
      {
        if (from < to)
        {
          if (t < from)
            return 0.0;
          if (t > to)
            return 1.0;
        }
        else
        {
          if (t < to)
            return 1.0;
          if (t > from)
            return 0.0;
        }
      }
      return (t - from) / (to - from);
    }

    public static string[] ConvertMonoArgsToDotNet(string[] brokenArgs)
    {
      ArrayList arrayList = new ArrayList();
      string str = "";
      for (int index = 0; index < brokenArgs.Length; ++index)
      {
        if (brokenArgs[index].StartsWith("-"))
        {
          if (str != "")
          {
            arrayList.Add((object) str);
            str = "";
          }
          else
            arrayList.Add((object) "");
          arrayList.Add((object) brokenArgs[index]);
        }
        else
        {
          if (str != "")
            str += " ";
          str += brokenArgs[index];
        }
      }
      arrayList.Add((object) str);
      string[] strArray = new string[arrayList.Count];
      arrayList.CopyTo((Array) strArray);
      return strArray;
    }

    public static T Max<T>(params T[] args) where T : IComparable
    {
      T obj = args[0];
      for (int index = 1; index < args.Length; ++index)
      {
        if (obj.CompareTo((object) args[index]) < 0)
          obj = args[index];
      }
      return obj;
    }

    public static List<List<TextSnippet>> WordwrapStringSmart(
      string text,
      Color c,
      DynamicSpriteFont font,
      int maxWidth,
      int maxLines)
    {
      TextSnippet[] array = ChatManager.ParseMessage(text, c).ToArray();
      List<List<TextSnippet>> textSnippetListList = new List<List<TextSnippet>>();
      List<TextSnippet> textSnippetList1 = new List<TextSnippet>();
      for (int index1 = 0; index1 < array.Length; ++index1)
      {
        TextSnippet textSnippet = array[index1];
        string[] strArray = textSnippet.Text.Split('\n');
        for (int index2 = 0; index2 < strArray.Length - 1; ++index2)
        {
          textSnippetList1.Add(textSnippet.CopyMorph(strArray[index2]));
          textSnippetListList.Add(textSnippetList1);
          textSnippetList1 = new List<TextSnippet>();
        }
        textSnippetList1.Add(textSnippet.CopyMorph(strArray[strArray.Length - 1]));
      }
      textSnippetListList.Add(textSnippetList1);
      if (maxWidth != -1)
      {
        for (int index3 = 0; index3 < textSnippetListList.Count; ++index3)
        {
          List<TextSnippet> textSnippetList2 = textSnippetListList[index3];
          float num1 = 0.0f;
          for (int index4 = 0; index4 < textSnippetList2.Count; ++index4)
          {
            float stringLength = textSnippetList2[index4].GetStringLength(font);
            if ((double) stringLength + (double) num1 > (double) maxWidth)
            {
              int num2 = maxWidth - (int) num1;
              if ((double) num1 > 0.0)
                num2 -= 16;
              int num3 = Math.Min(textSnippetList2[index4].Text.Length, num2 / 8);
              if (num3 < 0)
                num3 = 0;
              string[] strArray = textSnippetList2[index4].Text.Split(' ');
              int num4 = num3;
              if (strArray.Length > 1)
              {
                num4 = 0;
                for (int index5 = 0; index5 < strArray.Length && num4 + strArray[index5].Length <= num3; ++index5)
                  num4 += strArray[index5].Length + 1;
                if (num4 > num3)
                  num4 = num3;
              }
              string newText1 = textSnippetList2[index4].Text.Substring(0, num4);
              string newText2 = textSnippetList2[index4].Text.Substring(num4);
              List<TextSnippet> textSnippetList3 = new List<TextSnippet>()
              {
                textSnippetList2[index4].CopyMorph(newText2)
              };
              for (int index6 = index4 + 1; index6 < textSnippetList2.Count; ++index6)
                textSnippetList3.Add(textSnippetList2[index6]);
              textSnippetList2[index4] = textSnippetList2[index4].CopyMorph(newText1);
              textSnippetListList[index3] = textSnippetListList[index3].Take<TextSnippet>(index4 + 1).ToList<TextSnippet>();
              textSnippetListList.Insert(index3 + 1, textSnippetList3);
              break;
            }
            num1 += stringLength;
          }
        }
      }
      if (maxLines != -1)
      {
        while (textSnippetListList.Count > 10)
          textSnippetListList.RemoveAt(10);
      }
      return textSnippetListList;
    }

    public static string[] WordwrapString(
      string text,
      DynamicSpriteFont font,
      int maxWidth,
      int maxLines,
      out int lineAmount)
    {
      string[] strArray = new string[maxLines];
      int index1 = 0;
      List<string> stringList1 = new List<string>((IEnumerable<string>) text.Split('\n'));
      List<string> stringList2 = new List<string>((IEnumerable<string>) stringList1[0].Split(' '));
      for (int index2 = 1; index2 < stringList1.Count && index2 < maxLines; ++index2)
      {
        stringList2.Add("\n");
        stringList2.AddRange((IEnumerable<string>) stringList1[index2].Split(' '));
      }
      bool flag = true;
      while (stringList2.Count > 0)
      {
        string str1 = stringList2[0];
        string str2 = " ";
        if (stringList2.Count == 1)
          str2 = "";
        if (str1 == "\n")
        {
          // ISSUE: explicit reference operation
          ^ref strArray[index1++] += str1;
          flag = true;
          if (index1 < maxLines)
            stringList2.RemoveAt(0);
          else
            break;
        }
        else if (flag)
        {
          if ((double) font.MeasureString(str1).X > (double) maxWidth)
          {
            char ch = str1[0];
            string str3 = ch.ToString() ?? "";
            int num = 1;
            while (true)
            {
              DynamicSpriteFont dynamicSpriteFont = font;
              string str4 = str3;
              ch = str1[num];
              string str5 = ch.ToString();
              string str6 = str4 + str5 + "-";
              if ((double) dynamicSpriteFont.MeasureString(str6).X <= (double) maxWidth)
              {
                string str7 = str3;
                ch = str1[num++];
                string str8 = ch.ToString();
                str3 = str7 + str8;
              }
              else
                break;
            }
            string str9 = str3 + "-";
            strArray[index1++] = str9 + " ";
            if (index1 < maxLines)
            {
              stringList2.RemoveAt(0);
              stringList2.Insert(0, str1.Substring(num));
            }
            else
              break;
          }
          else
          {
            ref string local = ref strArray[index1];
            local = local + str1 + str2;
            flag = false;
            stringList2.RemoveAt(0);
          }
        }
        else if ((double) font.MeasureString(strArray[index1] + str1).X > (double) maxWidth)
        {
          ++index1;
          if (index1 < maxLines)
            flag = true;
          else
            break;
        }
        else
        {
          ref string local = ref strArray[index1];
          local = local + str1 + str2;
          flag = false;
          stringList2.RemoveAt(0);
        }
      }
      lineAmount = index1;
      if (lineAmount == maxLines)
        --lineAmount;
      return strArray;
    }

    public static Rectangle CenteredRectangle(Vector2 center, Vector2 size) => new Rectangle((int) ((double) center.X - (double) size.X / 2.0), (int) ((double) center.Y - (double) size.Y / 2.0), (int) size.X, (int) size.Y);

    public static Vector2 Vector2FromElipse(Vector2 angleVector, Vector2 elipseSizes)
    {
      if (elipseSizes == Vector2.Zero || angleVector == Vector2.Zero)
        return Vector2.Zero;
      angleVector.Normalize();
      Vector2 vector2 = Vector2.One / Vector2.Normalize(elipseSizes);
      angleVector *= vector2;
      angleVector.Normalize();
      return angleVector * elipseSizes / 2f;
    }

    public static bool FloatIntersect(
      float r1StartX,
      float r1StartY,
      float r1Width,
      float r1Height,
      float r2StartX,
      float r2StartY,
      float r2Width,
      float r2Height)
    {
      return (double) r1StartX <= (double) r2StartX + (double) r2Width && (double) r1StartY <= (double) r2StartY + (double) r2Height && (double) r1StartX + (double) r1Width >= (double) r2StartX && (double) r1StartY + (double) r1Height >= (double) r2StartY;
    }

    public static long CoinsCount(out bool overFlowing, Item[] inv, params int[] ignoreSlots)
    {
      List<int> intList = new List<int>((IEnumerable<int>) ignoreSlots);
      long num = 0;
      for (int index = 0; index < inv.Length; ++index)
      {
        if (!intList.Contains(index))
        {
          switch (inv[index].type)
          {
            case 71:
              num += (long) inv[index].stack;
              break;
            case 72:
              num += (long) (inv[index].stack * 100);
              break;
            case 73:
              num += (long) (inv[index].stack * 10000);
              break;
            case 74:
              num += (long) (inv[index].stack * 1000000);
              break;
          }
          if (num >= 999999999L)
          {
            overFlowing = true;
            return 999999999;
          }
        }
      }
      overFlowing = false;
      return num;
    }

    public static int[] CoinsSplit(long count)
    {
      int[] numArray = new int[4];
      long num1 = 0;
      long num2 = 1000000;
      for (int index = 3; index >= 0; --index)
      {
        numArray[index] = (int) ((count - num1) / num2);
        num1 += (long) numArray[index] * num2;
        num2 /= 100L;
      }
      return numArray;
    }

    public static long CoinsCombineStacks(out bool overFlowing, params long[] coinCounts)
    {
      long num = 0;
      foreach (long coinCount in coinCounts)
      {
        num += coinCount;
        if (num >= 999999999L)
        {
          overFlowing = true;
          return 999999999;
        }
      }
      overFlowing = false;
      return num;
    }

    public static void PoofOfSmoke(Vector2 position)
    {
      int num = Main.rand.Next(3, 7);
      for (int index1 = 0; index1 < num; ++index1)
      {
        int index2 = Gore.NewGore(position, (Main.rand.NextFloat() * 6.283185f).ToRotationVector2() * new Vector2(2f, 0.7f) * 0.7f, Main.rand.Next(11, 14));
        Main.gore[index2].scale = 0.7f;
        Main.gore[index2].velocity *= 0.5f;
      }
      for (int index = 0; index < 10; ++index)
      {
        Dust dust = Main.dust[Dust.NewDust(position, 14, 14, 16, Alpha: 100, Scale: 1.5f)];
        dust.position += new Vector2(5f);
        dust.velocity = (Main.rand.NextFloat() * 6.283185f).ToRotationVector2() * new Vector2(2f, 0.7f) * 0.7f * (float) (0.5 + 0.5 * (double) Main.rand.NextFloat());
      }
    }

    public static Vector2 ToScreenPosition(this Vector2 worldPosition) => Vector2.Transform(worldPosition - Main.screenPosition, Main.GameViewMatrix.ZoomMatrix) / Main.UIScale;

    public static string PrettifyPercentDisplay(float percent, string originalFormat) => string.Format("{0:" + originalFormat + "}", (object) percent).TrimEnd('0', '%', ' ').TrimEnd('.', ' ').TrimStart('0', ' ') + "%";

    public static void TrimTextIfNeeded(
      ref string text,
      DynamicSpriteFont font,
      float scale,
      float maxWidth)
    {
      int num = 0;
      for (Vector2 vector2 = font.MeasureString(text) * scale; (double) vector2.X > (double) maxWidth; vector2 = font.MeasureString(text) * scale)
      {
        text = text.Substring(0, text.Length - 1);
        ++num;
      }
      if (num <= 0)
        return;
      text = text.Substring(0, text.Length - 1) + "…";
    }

    public static string FormatWith(string original, object obj)
    {
      string input = original;
      PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(obj);
      return Utils._substitutionRegex.Replace(input, (MatchEvaluator) (match =>
      {
        if (match.Groups[1].Length != 0)
          return "";
        PropertyDescriptor propertyDescriptor = properties.Find(match.Groups[2].ToString(), false);
        return propertyDescriptor == null ? "" : (propertyDescriptor.GetValue(obj) ?? (object) "").ToString();
      }));
    }

    public static bool TryCreatingDirectory(string folderPath)
    {
      if (Directory.Exists(folderPath))
        return true;
      try
      {
        Directory.CreateDirectory(folderPath);
        return true;
      }
      catch (Exception ex)
      {
        string folderPath1 = folderPath;
        FancyErrorPrinter.ShowDirectoryCreationFailError(ex, folderPath1);
        return false;
      }
    }

    public static void OpenFolder(string folderPath)
    {
      if (!Utils.TryCreatingDirectory(folderPath))
        return;
      Process.Start(folderPath);
    }

    public static byte[] ToByteArray(this string str)
    {
      byte[] numArray = new byte[str.Length * 2];
      Buffer.BlockCopy((Array) str.ToCharArray(), 0, (Array) numArray, 0, numArray.Length);
      return numArray;
    }

    public static float NextFloat(this UnifiedRandom r) => (float) r.NextDouble();

    public static float NextFloatDirection(this UnifiedRandom r) => (float) (r.NextDouble() * 2.0 - 1.0);

    public static float NextFloat(this UnifiedRandom random, FloatRange range) => random.NextFloat() * (range.Maximum - range.Minimum) + range.Minimum;

    public static T NextFromList<T>(this UnifiedRandom random, params T[] objs) => objs[random.Next(objs.Length)];

    public static int Next(this UnifiedRandom random, IntRange range) => random.Next(range.Minimum, range.Maximum + 1);

    public static Vector2 NextVector2Square(this UnifiedRandom r, float min, float max) => new Vector2((max - min) * (float) r.NextDouble() + min, (max - min) * (float) r.NextDouble() + min);

    public static Vector2 NextVector2FromRectangle(this UnifiedRandom r, Rectangle rect) => new Vector2((float) rect.X + r.NextFloat() * (float) rect.Width, (float) rect.Y + r.NextFloat() * (float) rect.Height);

    public static Vector2 NextVector2Unit(
      this UnifiedRandom r,
      float startRotation = 0.0f,
      float rotationRange = 6.283185f)
    {
      return (startRotation + rotationRange * r.NextFloat()).ToRotationVector2();
    }

    public static Vector2 NextVector2Circular(
      this UnifiedRandom r,
      float circleHalfWidth,
      float circleHalfHeight)
    {
      return r.NextVector2Unit() * new Vector2(circleHalfWidth, circleHalfHeight) * r.NextFloat();
    }

    public static Vector2 NextVector2CircularEdge(
      this UnifiedRandom r,
      float circleHalfWidth,
      float circleHalfHeight)
    {
      return r.NextVector2Unit() * new Vector2(circleHalfWidth, circleHalfHeight);
    }

    public static int Width(this Asset<Texture2D> asset) => !asset.IsLoaded ? 0 : asset.Value.Width;

    public static int Height(this Asset<Texture2D> asset) => !asset.IsLoaded ? 0 : asset.Value.Height;

    public static Rectangle Frame(
      this Asset<Texture2D> tex,
      int horizontalFrames = 1,
      int verticalFrames = 1,
      int frameX = 0,
      int frameY = 0,
      int sizeOffsetX = 0,
      int sizeOffsetY = 0)
    {
      return !tex.IsLoaded ? Rectangle.Empty : tex.Value.Frame(horizontalFrames, verticalFrames, frameX, frameY, sizeOffsetX, sizeOffsetY);
    }

    public static Rectangle OffsetSize(this Rectangle rect, int xSize, int ySize)
    {
      rect.Width += xSize;
      rect.Height += ySize;
      return rect;
    }

    public static Vector2 Size(this Asset<Texture2D> tex) => !tex.IsLoaded ? Vector2.Zero : tex.Value.Size();

    public static Rectangle Frame(
      this Texture2D tex,
      int horizontalFrames = 1,
      int verticalFrames = 1,
      int frameX = 0,
      int frameY = 0,
      int sizeOffsetX = 0,
      int sizeOffsetY = 0)
    {
      int num1 = tex.Width / horizontalFrames;
      int num2 = tex.Height / verticalFrames;
      return new Rectangle(num1 * frameX, num2 * frameY, num1 + sizeOffsetX, num2 + sizeOffsetY);
    }

    public static Vector2 OriginFlip(
      this Rectangle rect,
      Vector2 origin,
      SpriteEffects effects)
    {
      if (effects.HasFlag((Enum) SpriteEffects.FlipHorizontally))
        origin.X = (float) rect.Width - origin.X;
      if (effects.HasFlag((Enum) SpriteEffects.FlipVertically))
        origin.Y = (float) rect.Height - origin.Y;
      return origin;
    }

    public static Vector2 Size(this Texture2D tex) => new Vector2((float) tex.Width, (float) tex.Height);

    public static void WriteRGB(this BinaryWriter bb, Color c)
    {
      bb.Write(c.R);
      bb.Write(c.G);
      bb.Write(c.B);
    }

    public static void WriteVector2(this BinaryWriter bb, Vector2 v)
    {
      bb.Write(v.X);
      bb.Write(v.Y);
    }

    public static void WritePackedVector2(this BinaryWriter bb, Vector2 v)
    {
      HalfVector2 halfVector2 = new HalfVector2(v.X, v.Y);
      bb.Write(halfVector2.PackedValue);
    }

    public static Color ReadRGB(this BinaryReader bb) => new Color((int) bb.ReadByte(), (int) bb.ReadByte(), (int) bb.ReadByte());

    public static Vector2 ReadVector2(this BinaryReader bb) => new Vector2(bb.ReadSingle(), bb.ReadSingle());

    public static Vector2 ReadPackedVector2(this BinaryReader bb) => new HalfVector2()
    {
      PackedValue = bb.ReadUInt32()
    }.ToVector2();

    public static Vector2 Left(this Rectangle r) => new Vector2((float) r.X, (float) (r.Y + r.Height / 2));

    public static Vector2 Right(this Rectangle r) => new Vector2((float) (r.X + r.Width), (float) (r.Y + r.Height / 2));

    public static Vector2 Top(this Rectangle r) => new Vector2((float) (r.X + r.Width / 2), (float) r.Y);

    public static Vector2 Bottom(this Rectangle r) => new Vector2((float) (r.X + r.Width / 2), (float) (r.Y + r.Height));

    public static Vector2 TopLeft(this Rectangle r) => new Vector2((float) r.X, (float) r.Y);

    public static Vector2 TopRight(this Rectangle r) => new Vector2((float) (r.X + r.Width), (float) r.Y);

    public static Vector2 BottomLeft(this Rectangle r) => new Vector2((float) r.X, (float) (r.Y + r.Height));

    public static Vector2 BottomRight(this Rectangle r) => new Vector2((float) (r.X + r.Width), (float) (r.Y + r.Height));

    public static Vector2 Center(this Rectangle r) => new Vector2((float) (r.X + r.Width / 2), (float) (r.Y + r.Height / 2));

    public static Vector2 Size(this Rectangle r) => new Vector2((float) r.Width, (float) r.Height);

    public static float Distance(this Rectangle r, Vector2 point)
    {
      if (Utils.FloatIntersect((float) r.Left, (float) r.Top, (float) r.Width, (float) r.Height, point.X, point.Y, 0.0f, 0.0f))
        return 0.0f;
      return (double) point.X >= (double) r.Left && (double) point.X <= (double) r.Right ? ((double) point.Y < (double) r.Top ? (float) r.Top - point.Y : point.Y - (float) r.Bottom) : ((double) point.Y >= (double) r.Top && (double) point.Y <= (double) r.Bottom ? ((double) point.X < (double) r.Left ? (float) r.Left - point.X : point.X - (float) r.Right) : ((double) point.X < (double) r.Left ? ((double) point.Y < (double) r.Top ? Vector2.Distance(point, r.TopLeft()) : Vector2.Distance(point, r.BottomLeft())) : ((double) point.Y < (double) r.Top ? Vector2.Distance(point, r.TopRight()) : Vector2.Distance(point, r.BottomRight()))));
    }

    public static Vector2 ClosestPointInRect(this Rectangle r, Vector2 point)
    {
      Vector2 vector2 = point;
      if ((double) vector2.X < (double) r.Left)
        vector2.X = (float) r.Left;
      if ((double) vector2.X > (double) r.Right)
        vector2.X = (float) r.Right;
      if ((double) vector2.Y < (double) r.Top)
        vector2.Y = (float) r.Top;
      if ((double) vector2.Y > (double) r.Bottom)
        vector2.Y = (float) r.Bottom;
      return vector2;
    }

    public static Rectangle Modified(this Rectangle r, int x, int y, int w, int h) => new Rectangle(r.X + x, r.Y + y, r.Width + w, r.Height + h);

    public static float ToRotation(this Vector2 v) => (float) Math.Atan2((double) v.Y, (double) v.X);

    public static Vector2 ToRotationVector2(this float f) => new Vector2((float) Math.Cos((double) f), (float) Math.Sin((double) f));

    public static Vector2 RotatedBy(
      this Vector2 spinningpoint,
      double radians,
      Vector2 center = default (Vector2))
    {
      float num1 = (float) Math.Cos(radians);
      float num2 = (float) Math.Sin(radians);
      Vector2 vector2_1 = spinningpoint - center;
      Vector2 vector2_2 = center;
      vector2_2.X += (float) ((double) vector2_1.X * (double) num1 - (double) vector2_1.Y * (double) num2);
      vector2_2.Y += (float) ((double) vector2_1.X * (double) num2 + (double) vector2_1.Y * (double) num1);
      return vector2_2;
    }

    public static Vector2 RotatedByRandom(this Vector2 spinninpoint, double maxRadians) => spinninpoint.RotatedBy(Main.rand.NextDouble() * maxRadians - Main.rand.NextDouble() * maxRadians);

    public static Vector2 Floor(this Vector2 vec)
    {
      vec.X = (float) (int) vec.X;
      vec.Y = (float) (int) vec.Y;
      return vec;
    }

    public static bool HasNaNs(this Vector2 vec) => float.IsNaN(vec.X) || float.IsNaN(vec.Y);

    public static bool Between(this Vector2 vec, Vector2 minimum, Vector2 maximum) => (double) vec.X >= (double) minimum.X && (double) vec.X <= (double) maximum.X && (double) vec.Y >= (double) minimum.Y && (double) vec.Y <= (double) maximum.Y;

    public static Vector2 ToVector2(this Point p) => new Vector2((float) p.X, (float) p.Y);

    public static Vector2 ToVector2(this Point16 p) => new Vector2((float) p.X, (float) p.Y);

    public static Vector2 ToWorldCoordinates(this Point p, float autoAddX = 8f, float autoAddY = 8f) => p.ToVector2() * 16f + new Vector2(autoAddX, autoAddY);

    public static Vector2 ToWorldCoordinates(this Point16 p, float autoAddX = 8f, float autoAddY = 8f) => p.ToVector2() * 16f + new Vector2(autoAddX, autoAddY);

    public static Vector2 MoveTowards(
      this Vector2 currentPosition,
      Vector2 targetPosition,
      float maxAmountAllowedToMove)
    {
      Vector2 v = targetPosition - currentPosition;
      return (double) v.Length() < (double) maxAmountAllowedToMove ? targetPosition : currentPosition + v.SafeNormalize(Vector2.Zero) * maxAmountAllowedToMove;
    }

    public static Point16 ToTileCoordinates16(this Vector2 vec) => new Point16((int) vec.X >> 4, (int) vec.Y >> 4);

    public static Point ToTileCoordinates(this Vector2 vec) => new Point((int) vec.X >> 4, (int) vec.Y >> 4);

    public static Point ToPoint(this Vector2 v) => new Point((int) v.X, (int) v.Y);

    public static Vector2 SafeNormalize(this Vector2 v, Vector2 defaultValue) => v == Vector2.Zero || v.HasNaNs() ? defaultValue : Vector2.Normalize(v);

    public static Vector2 ClosestPointOnLine(this Vector2 P, Vector2 A, Vector2 B)
    {
      Vector2 vector2_1 = P - A;
      Vector2 vector2_2 = B - A;
      float num1 = vector2_2.LengthSquared();
      Vector2 vector2_3 = vector2_2;
      float num2 = Vector2.Dot(vector2_1, vector2_3) / num1;
      if ((double) num2 < 0.0)
        return A;
      return (double) num2 > 1.0 ? B : A + vector2_2 * num2;
    }

    public static bool RectangleLineCollision(
      Vector2 rectTopLeft,
      Vector2 rectBottomRight,
      Vector2 lineStart,
      Vector2 lineEnd)
    {
      if (lineStart.Between(rectTopLeft, rectBottomRight) || lineEnd.Between(rectTopLeft, rectBottomRight))
        return true;
      Vector2 P = new Vector2(rectBottomRight.X, rectTopLeft.Y);
      Vector2 vector2 = new Vector2(rectTopLeft.X, rectBottomRight.Y);
      Vector2[] vector2Array = new Vector2[4]
      {
        rectTopLeft.ClosestPointOnLine(lineStart, lineEnd),
        P.ClosestPointOnLine(lineStart, lineEnd),
        vector2.ClosestPointOnLine(lineStart, lineEnd),
        rectBottomRight.ClosestPointOnLine(lineStart, lineEnd)
      };
      for (int index = 0; index < vector2Array.Length; ++index)
      {
        if (vector2Array[0].Between(rectTopLeft, vector2))
          return true;
      }
      return false;
    }

    public static Vector2 RotateRandom(this Vector2 spinninpoint, double maxRadians) => spinninpoint.RotatedBy(Main.rand.NextDouble() * maxRadians - Main.rand.NextDouble() * maxRadians);

    public static float AngleTo(this Vector2 Origin, Vector2 Target) => (float) Math.Atan2((double) Target.Y - (double) Origin.Y, (double) Target.X - (double) Origin.X);

    public static float AngleFrom(this Vector2 Origin, Vector2 Target) => (float) Math.Atan2((double) Origin.Y - (double) Target.Y, (double) Origin.X - (double) Target.X);

    public static Vector2 rotateTowards(
      Vector2 currentPosition,
      Vector2 currentVelocity,
      Vector2 targetPosition,
      float maxChange)
    {
      float num = currentVelocity.Length();
      float targetAngle = currentPosition.AngleTo(targetPosition);
      return currentVelocity.ToRotation().AngleTowards(targetAngle, (float) Math.PI / 180f).ToRotationVector2() * num;
    }

    public static float Distance(this Vector2 Origin, Vector2 Target) => Vector2.Distance(Origin, Target);

    public static float DistanceSQ(this Vector2 Origin, Vector2 Target) => Vector2.DistanceSquared(Origin, Target);

    public static Vector2 DirectionTo(this Vector2 Origin, Vector2 Target) => Vector2.Normalize(Target - Origin);

    public static Vector2 DirectionFrom(this Vector2 Origin, Vector2 Target) => Vector2.Normalize(Origin - Target);

    public static bool WithinRange(this Vector2 Origin, Vector2 Target, float MaxRange) => (double) Vector2.DistanceSquared(Origin, Target) <= (double) MaxRange * (double) MaxRange;

    public static Vector2 XY(this Vector4 vec) => new Vector2(vec.X, vec.Y);

    public static Vector2 ZW(this Vector4 vec) => new Vector2(vec.Z, vec.W);

    public static Vector3 XZW(this Vector4 vec) => new Vector3(vec.X, vec.Z, vec.W);

    public static Vector3 YZW(this Vector4 vec) => new Vector3(vec.Y, vec.Z, vec.W);

    public static Color MultiplyRGB(this Color firstColor, Color secondColor) => new Color((int) (byte) ((double) ((int) firstColor.R * (int) secondColor.R) / (double) byte.MaxValue), (int) (byte) ((double) ((int) firstColor.G * (int) secondColor.G) / (double) byte.MaxValue), (int) (byte) ((double) ((int) firstColor.B * (int) secondColor.B) / (double) byte.MaxValue));

    public static Color MultiplyRGBA(this Color firstColor, Color secondColor) => new Color((int) (byte) ((double) ((int) firstColor.R * (int) secondColor.R) / (double) byte.MaxValue), (int) (byte) ((double) ((int) firstColor.G * (int) secondColor.G) / (double) byte.MaxValue), (int) (byte) ((double) ((int) firstColor.B * (int) secondColor.B) / (double) byte.MaxValue), (int) (byte) ((double) ((int) firstColor.A * (int) secondColor.A) / (double) byte.MaxValue));

    public static string Hex3(this Color color)
    {
      byte num = color.R;
      string str1 = num.ToString("X2");
      num = color.G;
      string str2 = num.ToString("X2");
      num = color.B;
      string str3 = num.ToString("X2");
      return (str1 + str2 + str3).ToLower();
    }

    public static string Hex4(this Color color)
    {
      byte num = color.R;
      string str1 = num.ToString("X2");
      num = color.G;
      string str2 = num.ToString("X2");
      num = color.B;
      string str3 = num.ToString("X2");
      num = color.A;
      string str4 = num.ToString("X2");
      return (str1 + str2 + str3 + str4).ToLower();
    }

    public static int ToDirectionInt(this bool value) => !value ? -1 : 1;

    public static int ToInt(this bool value) => !value ? 0 : 1;

    public static int ModulusPositive(this int myInteger, int modulusNumber) => (myInteger % modulusNumber + modulusNumber) % modulusNumber;

    public static float AngleLerp(this float curAngle, float targetAngle, float amount)
    {
      float angle;
      if ((double) targetAngle < (double) curAngle)
      {
        float num = targetAngle + 6.283185f;
        angle = (double) num - (double) curAngle > (double) curAngle - (double) targetAngle ? MathHelper.Lerp(curAngle, targetAngle, amount) : MathHelper.Lerp(curAngle, num, amount);
      }
      else
      {
        if ((double) targetAngle <= (double) curAngle)
          return curAngle;
        float num = targetAngle - 6.283185f;
        angle = (double) targetAngle - (double) curAngle > (double) curAngle - (double) num ? MathHelper.Lerp(curAngle, num, amount) : MathHelper.Lerp(curAngle, targetAngle, amount);
      }
      return MathHelper.WrapAngle(angle);
    }

    public static float AngleTowards(this float curAngle, float targetAngle, float maxChange)
    {
      curAngle = MathHelper.WrapAngle(curAngle);
      targetAngle = MathHelper.WrapAngle(targetAngle);
      if ((double) curAngle < (double) targetAngle)
      {
        if ((double) targetAngle - (double) curAngle > 3.14159274101257)
          curAngle += 6.283185f;
      }
      else if ((double) curAngle - (double) targetAngle > 3.14159274101257)
        curAngle -= 6.283185f;
      curAngle += MathHelper.Clamp(targetAngle - curAngle, -maxChange, maxChange);
      return MathHelper.WrapAngle(curAngle);
    }

    public static bool deepCompare(this int[] firstArray, int[] secondArray)
    {
      if (firstArray == null && secondArray == null)
        return true;
      if (firstArray == null || secondArray == null || firstArray.Length != secondArray.Length)
        return false;
      for (int index = 0; index < firstArray.Length; ++index)
      {
        if (firstArray[index] != secondArray[index])
          return false;
      }
      return true;
    }

    public static List<int> GetTrueIndexes(this bool[] array)
    {
      List<int> intList = new List<int>();
      for (int index = 0; index < array.Length; ++index)
      {
        if (array[index])
          intList.Add(index);
      }
      return intList;
    }

    public static List<int> GetTrueIndexes(params bool[][] arrays)
    {
      List<int> source = new List<int>();
      foreach (bool[] array in arrays)
        source.AddRange((IEnumerable<int>) array.GetTrueIndexes());
      return source.Distinct<int>().ToList<int>();
    }

    public static bool PressingShift(this KeyboardState kb) => kb.IsKeyDown(Keys.LeftShift) || kb.IsKeyDown(Keys.RightShift);

    public static bool PressingControl(this KeyboardState kb) => kb.IsKeyDown(Keys.LeftControl) || kb.IsKeyDown(Keys.RightControl);

    public static bool PlotLine(Point16 p0, Point16 p1, Utils.TileActionAttempt plot, bool jump = true) => Utils.PlotLine((int) p0.X, (int) p0.Y, (int) p1.X, (int) p1.Y, plot, jump);

    public static bool PlotLine(Point p0, Point p1, Utils.TileActionAttempt plot, bool jump = true) => Utils.PlotLine(p0.X, p0.Y, p1.X, p1.Y, plot, jump);

    private static bool PlotLine(
      int x0,
      int y0,
      int x1,
      int y1,
      Utils.TileActionAttempt plot,
      bool jump = true)
    {
      if (x0 == x1 && y0 == y1)
        return plot(x0, y0);
      bool flag = Math.Abs(y1 - y0) > Math.Abs(x1 - x0);
      if (flag)
      {
        Utils.Swap<int>(ref x0, ref y0);
        Utils.Swap<int>(ref x1, ref y1);
      }
      int num1 = Math.Abs(x1 - x0);
      int num2 = Math.Abs(y1 - y0);
      int num3 = num1 / 2;
      int num4 = y0;
      int num5 = x0 < x1 ? 1 : -1;
      int num6 = y0 < y1 ? 1 : -1;
      for (int index = x0; index != x1; index += num5)
      {
        if (flag)
        {
          if (!plot(num4, index))
            return false;
        }
        else if (!plot(index, num4))
          return false;
        num3 -= num2;
        if (num3 < 0)
        {
          num4 += num6;
          if (!jump)
          {
            if (flag)
            {
              if (!plot(num4, index))
                return false;
            }
            else if (!plot(index, num4))
              return false;
          }
          num3 += num1;
        }
      }
      return true;
    }

    public static int RandomNext(ref ulong seed, int bits)
    {
      seed = Utils.RandomNextSeed(seed);
      return (int) (seed >> 48 - bits);
    }

    public static ulong RandomNextSeed(ulong seed) => (ulong) ((long) seed * 25214903917L + 11L & 281474976710655L);

    public static float RandomFloat(ref ulong seed) => (float) Utils.RandomNext(ref seed, 24) / 1.677722E+07f;

    public static int RandomInt(ref ulong seed, int max)
    {
      if ((max & -max) == max)
        return (int) ((long) max * (long) Utils.RandomNext(ref seed, 31) >> 31);
      int num1;
      int num2;
      do
      {
        num1 = Utils.RandomNext(ref seed, 31);
        num2 = num1 % max;
      }
      while (num1 - num2 + (max - 1) < 0);
      return num2;
    }

    public static int RandomInt(ref ulong seed, int min, int max) => Utils.RandomInt(ref seed, max - min) + min;

    public static bool PlotTileLine(
      Vector2 start,
      Vector2 end,
      float width,
      Utils.TileActionAttempt plot)
    {
      float num = width / 2f;
      Vector2 vector2_1 = end - start;
      Vector2 vector2_2 = vector2_1 / vector2_1.Length();
      Vector2 vector2_3 = new Vector2(-vector2_2.Y, vector2_2.X) * num;
      Point tileCoordinates1 = (start - vector2_3).ToTileCoordinates();
      Point tileCoordinates2 = (start + vector2_3).ToTileCoordinates();
      Point tileCoordinates3 = start.ToTileCoordinates();
      Point tileCoordinates4 = end.ToTileCoordinates();
      Point lineMinOffset = new Point(tileCoordinates1.X - tileCoordinates3.X, tileCoordinates1.Y - tileCoordinates3.Y);
      Point lineMaxOffset = new Point(tileCoordinates2.X - tileCoordinates3.X, tileCoordinates2.Y - tileCoordinates3.Y);
      return Utils.PlotLine(tileCoordinates3.X, tileCoordinates3.Y, tileCoordinates4.X, tileCoordinates4.Y, (Utils.TileActionAttempt) ((x, y) => Utils.PlotLine(x + lineMinOffset.X, y + lineMinOffset.Y, x + lineMaxOffset.X, y + lineMaxOffset.Y, plot, false)));
    }

    public static bool PlotTileTale(
      Vector2 start,
      Vector2 end,
      float width,
      Utils.TileActionAttempt plot)
    {
      float halfWidth = width / 2f;
      Vector2 vector2_1 = end - start;
      Vector2 vector2_2 = vector2_1 / vector2_1.Length();
      Vector2 perpOffset = new Vector2(-vector2_2.Y, vector2_2.X);
      Point pointStart = start.ToTileCoordinates();
      Point tileCoordinates1 = end.ToTileCoordinates();
      int length = 0;
      Utils.PlotLine(pointStart.X, pointStart.Y, tileCoordinates1.X, tileCoordinates1.Y, (Utils.TileActionAttempt) ((_param1, _param2) =>
      {
        ++length;
        return true;
      }));
      length--;
      int curLength = 0;
      return Utils.PlotLine(pointStart.X, pointStart.Y, tileCoordinates1.X, tileCoordinates1.Y, (Utils.TileActionAttempt) ((x, y) =>
      {
        float num = (float) (1.0 - (double) curLength / (double) length);
        ++curLength;
        Point tileCoordinates2 = (start - perpOffset * halfWidth * num).ToTileCoordinates();
        Point tileCoordinates3 = (start + perpOffset * halfWidth * num).ToTileCoordinates();
        Point point1 = new Point(tileCoordinates2.X - pointStart.X, tileCoordinates2.Y - pointStart.Y);
        Point point2 = new Point(tileCoordinates3.X - pointStart.X, tileCoordinates3.Y - pointStart.Y);
        return Utils.PlotLine(x + point1.X, y + point1.Y, x + point2.X, y + point2.Y, plot, false);
      }));
    }

    public static bool PlotTileArea(int x, int y, Utils.TileActionAttempt plot)
    {
      if (!WorldGen.InWorld(x, y))
        return false;
      List<Point> pointList1 = new List<Point>();
      List<Point> pointList2 = new List<Point>();
      HashSet<Point> pointSet = new HashSet<Point>();
      pointList2.Add(new Point(x, y));
      while (pointList2.Count > 0)
      {
        pointList1.Clear();
        pointList1.AddRange((IEnumerable<Point>) pointList2);
        pointList2.Clear();
        while (pointList1.Count > 0)
        {
          Point point1 = pointList1[0];
          if (!WorldGen.InWorld(point1.X, point1.Y, 1))
          {
            pointList1.Remove(point1);
          }
          else
          {
            pointSet.Add(point1);
            pointList1.Remove(point1);
            if (plot(point1.X, point1.Y))
            {
              Point point2 = new Point(point1.X - 1, point1.Y);
              if (!pointSet.Contains(point2))
                pointList2.Add(point2);
              point2 = new Point(point1.X + 1, point1.Y);
              if (!pointSet.Contains(point2))
                pointList2.Add(point2);
              point2 = new Point(point1.X, point1.Y - 1);
              if (!pointSet.Contains(point2))
                pointList2.Add(point2);
              point2 = new Point(point1.X, point1.Y + 1);
              if (!pointSet.Contains(point2))
                pointList2.Add(point2);
            }
          }
        }
      }
      return true;
    }

    public static int RandomConsecutive(double random, int odds) => (int) Math.Log(1.0 - random, 1.0 / (double) odds);

    public static Vector2 RandomVector2(UnifiedRandom random, float min, float max) => new Vector2((max - min) * (float) random.NextDouble() + min, (max - min) * (float) random.NextDouble() + min);

    public static bool IndexInRange<T>(this T[] t, int index) => index >= 0 && index < t.Length;

    public static bool IndexInRange<T>(this List<T> t, int index) => index >= 0 && index < t.Count;

    public static T SelectRandom<T>(UnifiedRandom random, params T[] choices) => choices[random.Next(choices.Length)];

    public static void DrawBorderStringFourWay(
      SpriteBatch sb,
      DynamicSpriteFont font,
      string text,
      float x,
      float y,
      Color textColor,
      Color borderColor,
      Vector2 origin,
      float scale = 1f)
    {
      Color color = borderColor;
      Vector2 zero = Vector2.Zero;
      for (int index = 0; index < 5; ++index)
      {
        switch (index)
        {
          case 0:
            zero.X = x - 2f;
            zero.Y = y;
            break;
          case 1:
            zero.X = x + 2f;
            zero.Y = y;
            break;
          case 2:
            zero.X = x;
            zero.Y = y - 2f;
            break;
          case 3:
            zero.X = x;
            zero.Y = y + 2f;
            break;
          default:
            zero.X = x;
            zero.Y = y;
            color = textColor;
            break;
        }
        DynamicSpriteFontExtensionMethods.DrawString(sb, font, text, zero, color, 0.0f, origin, scale, SpriteEffects.None, 0.0f);
      }
    }

    public static Vector2 DrawBorderString(
      SpriteBatch sb,
      string text,
      Vector2 pos,
      Color color,
      float scale = 1f,
      float anchorx = 0.0f,
      float anchory = 0.0f,
      int maxCharactersDisplayed = -1)
    {
      if (maxCharactersDisplayed != -1 && text.Length > maxCharactersDisplayed)
        text.Substring(0, maxCharactersDisplayed);
      DynamicSpriteFont font = FontAssets.MouseText.Value;
      Vector2 vector2 = font.MeasureString(text);
      ChatManager.DrawColorCodedStringWithShadow(sb, font, text, pos, color, 0.0f, new Vector2(anchorx, anchory) * vector2, new Vector2(scale), spread: 1.5f);
      return vector2 * scale;
    }

    public static Vector2 DrawBorderStringBig(
      SpriteBatch spriteBatch,
      string text,
      Vector2 pos,
      Color color,
      float scale = 1f,
      float anchorx = 0.0f,
      float anchory = 0.0f,
      int maxCharactersDisplayed = -1)
    {
      if (maxCharactersDisplayed != -1 && text.Length > maxCharactersDisplayed)
        text.Substring(0, maxCharactersDisplayed);
      DynamicSpriteFont dynamicSpriteFont = FontAssets.DeathText.Value;
      for (int index1 = -1; index1 < 2; ++index1)
      {
        for (int index2 = -1; index2 < 2; ++index2)
          DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, dynamicSpriteFont, text, pos + new Vector2((float) index1, (float) index2), Color.Black, 0.0f, new Vector2(anchorx, anchory) * dynamicSpriteFont.MeasureString(text), scale, SpriteEffects.None, 0.0f);
      }
      DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, dynamicSpriteFont, text, pos, color, 0.0f, new Vector2(anchorx, anchory) * dynamicSpriteFont.MeasureString(text), scale, SpriteEffects.None, 0.0f);
      return dynamicSpriteFont.MeasureString(text) * scale;
    }

    public static void DrawInvBG(SpriteBatch sb, Rectangle R, Color c = default (Color)) => Utils.DrawInvBG(sb, R.X, R.Y, R.Width, R.Height, c);

    public static void DrawInvBG(SpriteBatch sb, float x, float y, float w, float h, Color c = default (Color)) => Utils.DrawInvBG(sb, (int) x, (int) y, (int) w, (int) h, c);

    public static void DrawInvBG(SpriteBatch sb, int x, int y, int w, int h, Color c = default (Color))
    {
      if (c == new Color())
        c = new Color(63, 65, 151, (int) byte.MaxValue) * 0.785f;
      Texture2D texture = TextureAssets.InventoryBack13.Value;
      if (w < 20)
        w = 20;
      if (h < 20)
        h = 20;
      sb.Draw(texture, new Rectangle(x, y, 10, 10), new Rectangle?(new Rectangle(0, 0, 10, 10)), c);
      sb.Draw(texture, new Rectangle(x + 10, y, w - 20, 10), new Rectangle?(new Rectangle(10, 0, 10, 10)), c);
      sb.Draw(texture, new Rectangle(x + w - 10, y, 10, 10), new Rectangle?(new Rectangle(texture.Width - 10, 0, 10, 10)), c);
      sb.Draw(texture, new Rectangle(x, y + 10, 10, h - 20), new Rectangle?(new Rectangle(0, 10, 10, 10)), c);
      sb.Draw(texture, new Rectangle(x + 10, y + 10, w - 20, h - 20), new Rectangle?(new Rectangle(10, 10, 10, 10)), c);
      sb.Draw(texture, new Rectangle(x + w - 10, y + 10, 10, h - 20), new Rectangle?(new Rectangle(texture.Width - 10, 10, 10, 10)), c);
      sb.Draw(texture, new Rectangle(x, y + h - 10, 10, 10), new Rectangle?(new Rectangle(0, texture.Height - 10, 10, 10)), c);
      sb.Draw(texture, new Rectangle(x + 10, y + h - 10, w - 20, 10), new Rectangle?(new Rectangle(10, texture.Height - 10, 10, 10)), c);
      sb.Draw(texture, new Rectangle(x + w - 10, y + h - 10, 10, 10), new Rectangle?(new Rectangle(texture.Width - 10, texture.Height - 10, 10, 10)), c);
    }

    public static string ReadEmbeddedResource(string path)
    {
      using (Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(path))
      {
        using (StreamReader streamReader = new StreamReader(manifestResourceStream))
          return streamReader.ReadToEnd();
      }
    }

    public static void DrawSplicedPanel(
      SpriteBatch sb,
      Texture2D texture,
      int x,
      int y,
      int w,
      int h,
      int leftEnd,
      int rightEnd,
      int topEnd,
      int bottomEnd,
      Color c)
    {
      if (w < leftEnd + rightEnd)
        w = leftEnd + rightEnd;
      if (h < topEnd + bottomEnd)
        h = topEnd + bottomEnd;
      sb.Draw(texture, new Rectangle(x, y, leftEnd, topEnd), new Rectangle?(new Rectangle(0, 0, leftEnd, topEnd)), c);
      sb.Draw(texture, new Rectangle(x + leftEnd, y, w - leftEnd - rightEnd, topEnd), new Rectangle?(new Rectangle(leftEnd, 0, texture.Width - leftEnd - rightEnd, topEnd)), c);
      sb.Draw(texture, new Rectangle(x + w - rightEnd, y, topEnd, rightEnd), new Rectangle?(new Rectangle(texture.Width - rightEnd, 0, rightEnd, topEnd)), c);
      sb.Draw(texture, new Rectangle(x, y + topEnd, leftEnd, h - topEnd - bottomEnd), new Rectangle?(new Rectangle(0, topEnd, leftEnd, texture.Height - topEnd - bottomEnd)), c);
      sb.Draw(texture, new Rectangle(x + leftEnd, y + topEnd, w - leftEnd - rightEnd, h - topEnd - bottomEnd), new Rectangle?(new Rectangle(leftEnd, topEnd, texture.Width - leftEnd - rightEnd, texture.Height - topEnd - bottomEnd)), c);
      sb.Draw(texture, new Rectangle(x + w - rightEnd, y + topEnd, rightEnd, h - topEnd - bottomEnd), new Rectangle?(new Rectangle(texture.Width - rightEnd, topEnd, rightEnd, texture.Height - topEnd - bottomEnd)), c);
      sb.Draw(texture, new Rectangle(x, y + h - bottomEnd, leftEnd, bottomEnd), new Rectangle?(new Rectangle(0, texture.Height - bottomEnd, leftEnd, bottomEnd)), c);
      sb.Draw(texture, new Rectangle(x + leftEnd, y + h - bottomEnd, w - leftEnd - rightEnd, bottomEnd), new Rectangle?(new Rectangle(leftEnd, texture.Height - bottomEnd, texture.Width - leftEnd - rightEnd, bottomEnd)), c);
      sb.Draw(texture, new Rectangle(x + w - rightEnd, y + h - bottomEnd, rightEnd, bottomEnd), new Rectangle?(new Rectangle(texture.Width - rightEnd, texture.Height - bottomEnd, rightEnd, bottomEnd)), c);
    }

    public static void DrawSettingsPanel(
      SpriteBatch spriteBatch,
      Vector2 position,
      float width,
      Color color)
    {
      Utils.DrawPanel(TextureAssets.SettingsPanel.Value, 2, 0, spriteBatch, position, width, color);
    }

    public static void DrawSettings2Panel(
      SpriteBatch spriteBatch,
      Vector2 position,
      float width,
      Color color)
    {
      Utils.DrawPanel(TextureAssets.SettingsPanel.Value, 2, 0, spriteBatch, position, width, color);
    }

    public static void DrawPanel(
      Texture2D texture,
      int edgeWidth,
      int edgeShove,
      SpriteBatch spriteBatch,
      Vector2 position,
      float width,
      Color color)
    {
      spriteBatch.Draw(texture, position, new Rectangle?(new Rectangle(0, 0, edgeWidth, texture.Height)), color);
      spriteBatch.Draw(texture, new Vector2(position.X + (float) edgeWidth, position.Y), new Rectangle?(new Rectangle(edgeWidth + edgeShove, 0, texture.Width - (edgeWidth + edgeShove) * 2, texture.Height)), color, 0.0f, Vector2.Zero, new Vector2((width - (float) (edgeWidth * 2)) / (float) (texture.Width - (edgeWidth + edgeShove) * 2), 1f), SpriteEffects.None, 0.0f);
      spriteBatch.Draw(texture, new Vector2(position.X + width - (float) edgeWidth, position.Y), new Rectangle?(new Rectangle(texture.Width - edgeWidth, 0, edgeWidth, texture.Height)), color);
    }

    public static void DrawRectangle(
      SpriteBatch sb,
      Vector2 start,
      Vector2 end,
      Color colorStart,
      Color colorEnd,
      float width)
    {
      Utils.DrawLine(sb, start, new Vector2(start.X, end.Y), colorStart, colorEnd, width);
      Utils.DrawLine(sb, start, new Vector2(end.X, start.Y), colorStart, colorEnd, width);
      Utils.DrawLine(sb, end, new Vector2(start.X, end.Y), colorStart, colorEnd, width);
      Utils.DrawLine(sb, end, new Vector2(end.X, start.Y), colorStart, colorEnd, width);
    }

    public static void DrawLaser(
      SpriteBatch sb,
      Texture2D tex,
      Vector2 start,
      Vector2 end,
      Vector2 scale,
      Utils.LaserLineFraming framing)
    {
      Vector2 vector2_1 = start;
      Vector2 vector2_2 = Vector2.Normalize(end - start);
      float distanceLeft1 = (end - start).Length();
      float rotation = vector2_2.ToRotation() - 1.570796f;
      if (vector2_2.HasNaNs())
        return;
      float distanceCovered;
      Rectangle frame;
      Vector2 origin;
      Color color;
      framing(0, vector2_1, distanceLeft1, new Rectangle(), out distanceCovered, out frame, out origin, out color);
      sb.Draw(tex, vector2_1, new Rectangle?(frame), color, rotation, frame.Size() / 2f, scale, SpriteEffects.None, 0.0f);
      float distanceLeft2 = distanceLeft1 - distanceCovered * scale.Y;
      Vector2 vector2_3 = vector2_1 + vector2_2 * ((float) frame.Height - origin.Y) * scale.Y;
      if ((double) distanceLeft2 > 0.0)
      {
        float num = 0.0f;
        while ((double) num + 1.0 < (double) distanceLeft2)
        {
          framing(1, vector2_3, distanceLeft2 - num, frame, out distanceCovered, out frame, out origin, out color);
          if ((double) distanceLeft2 - (double) num < (double) frame.Height)
          {
            distanceCovered *= (distanceLeft2 - num) / (float) frame.Height;
            frame.Height = (int) ((double) distanceLeft2 - (double) num);
          }
          sb.Draw(tex, vector2_3, new Rectangle?(frame), color, rotation, origin, scale, SpriteEffects.None, 0.0f);
          num += distanceCovered * scale.Y;
          vector2_3 += vector2_2 * distanceCovered * scale.Y;
        }
      }
      framing(2, vector2_3, distanceLeft2, new Rectangle(), out distanceCovered, out frame, out origin, out color);
      sb.Draw(tex, vector2_3, new Rectangle?(frame), color, rotation, origin, scale, SpriteEffects.None, 0.0f);
    }

    public static void DrawLine(SpriteBatch spriteBatch, Point start, Point end, Color color) => Utils.DrawLine(spriteBatch, new Vector2((float) (start.X << 4), (float) (start.Y << 4)), new Vector2((float) (end.X << 4), (float) (end.Y << 4)), color);

    public static void DrawLine(SpriteBatch spriteBatch, Vector2 start, Vector2 end, Color color)
    {
      float num1 = Vector2.Distance(start, end);
      Vector2 v = (end - start) / num1;
      Vector2 vector2 = start;
      Vector2 screenPosition = Main.screenPosition;
      float rotation = v.ToRotation();
      for (float num2 = 0.0f; (double) num2 <= (double) num1; num2 += 4f)
      {
        float num3 = num2 / num1;
        spriteBatch.Draw(TextureAssets.BlackTile.Value, vector2 - screenPosition, new Rectangle?(), new Color(new Vector4(num3, num3, num3, 1f) * color.ToVector4()), rotation, Vector2.Zero, 0.25f, SpriteEffects.None, 0.0f);
        vector2 = start + num2 * v;
      }
    }

    public static void DrawLine(
      SpriteBatch spriteBatch,
      Vector2 start,
      Vector2 end,
      Color colorStart,
      Color colorEnd,
      float width)
    {
      float num1 = Vector2.Distance(start, end);
      Vector2 v = (end - start) / num1;
      Vector2 vector2 = start;
      Vector2 screenPosition = Main.screenPosition;
      float rotation = v.ToRotation();
      float scale = width / 16f;
      for (float num2 = 0.0f; (double) num2 <= (double) num1; num2 += width)
      {
        float amount = num2 / num1;
        spriteBatch.Draw(TextureAssets.BlackTile.Value, vector2 - screenPosition, new Rectangle?(), Color.Lerp(colorStart, colorEnd, amount), rotation, Vector2.Zero, scale, SpriteEffects.None, 0.0f);
        vector2 = start + num2 * v;
      }
    }

    public static void DrawRectForTilesInWorld(
      SpriteBatch spriteBatch,
      Rectangle rect,
      Color color)
    {
      Utils.DrawRectForTilesInWorld(spriteBatch, new Point(rect.X, rect.Y), new Point(rect.X + rect.Width, rect.Y + rect.Height), color);
    }

    public static void DrawRectForTilesInWorld(
      SpriteBatch spriteBatch,
      Point start,
      Point end,
      Color color)
    {
      Utils.DrawRect(spriteBatch, new Vector2((float) (start.X << 4), (float) (start.Y << 4)), new Vector2((float) ((end.X << 4) - 4), (float) ((end.Y << 4) - 4)), color);
    }

    public static void DrawRect(SpriteBatch spriteBatch, Rectangle rect, Color color) => Utils.DrawRect(spriteBatch, new Vector2((float) rect.X, (float) rect.Y), new Vector2((float) (rect.X + rect.Width), (float) (rect.Y + rect.Height)), color);

    public static void DrawRect(SpriteBatch spriteBatch, Vector2 start, Vector2 end, Color color)
    {
      Utils.DrawLine(spriteBatch, start, new Vector2(start.X, end.Y), color);
      Utils.DrawLine(spriteBatch, start, new Vector2(end.X, start.Y), color);
      Utils.DrawLine(spriteBatch, end, new Vector2(start.X, end.Y), color);
      Utils.DrawLine(spriteBatch, end, new Vector2(end.X, start.Y), color);
    }

    public static void DrawRect(
      SpriteBatch spriteBatch,
      Vector2 topLeft,
      Vector2 topRight,
      Vector2 bottomRight,
      Vector2 bottomLeft,
      Color color)
    {
      Utils.DrawLine(spriteBatch, topLeft, topRight, color);
      Utils.DrawLine(spriteBatch, topRight, bottomRight, color);
      Utils.DrawLine(spriteBatch, bottomRight, bottomLeft, color);
      Utils.DrawLine(spriteBatch, bottomLeft, topLeft, color);
    }

    public static void DrawCursorSingle(
      SpriteBatch sb,
      Color color,
      float rot = float.NaN,
      float scale = 1f,
      Vector2 manualPosition = default (Vector2),
      int cursorSlot = 0,
      int specialMode = 0)
    {
      bool flag1 = false;
      bool flag2 = true;
      bool flag3 = true;
      Vector2 origin = Vector2.Zero;
      Vector2 vector2_1 = new Vector2((float) Main.mouseX, (float) Main.mouseY);
      if (manualPosition != Vector2.Zero)
        vector2_1 = manualPosition;
      if (float.IsNaN(rot))
      {
        rot = 0.0f;
      }
      else
      {
        flag1 = true;
        rot -= 2.356194f;
      }
      if (cursorSlot == 4 || cursorSlot == 5)
      {
        flag2 = false;
        origin = new Vector2(8f);
        if (flag1 && specialMode == 0)
        {
          float num1 = rot;
          if ((double) num1 < 0.0)
            num1 += 6.283185f;
          for (float num2 = 0.0f; (double) num2 < 4.0; ++num2)
          {
            if ((double) Math.Abs(num1 - 1.570796f * num2) <= 0.785398185253143)
            {
              rot = 1.570796f * num2;
              break;
            }
          }
        }
      }
      Vector2 vector2_2 = Vector2.One;
      if (Main.ThickMouse && cursorSlot == 0 || cursorSlot == 1)
        vector2_2 = Main.DrawThickCursor(cursorSlot == 1);
      if (flag2)
        sb.Draw(TextureAssets.Cursors[cursorSlot].Value, vector2_1 + vector2_2 + Vector2.One, new Rectangle?(), color.MultiplyRGB(new Color(0.2f, 0.2f, 0.2f, 0.5f)), rot, origin, scale * 1.1f, SpriteEffects.None, 0.0f);
      if (!flag3)
        return;
      sb.Draw(TextureAssets.Cursors[cursorSlot].Value, vector2_1 + vector2_2, new Rectangle?(), color, rot, origin, scale, SpriteEffects.None, 0.0f);
    }

    public delegate bool TileActionAttempt(int x, int y);

    public delegate void LaserLineFraming(
      int stage,
      Vector2 currentPosition,
      float distanceLeft,
      Rectangle lastFrame,
      out float distanceCovered,
      out Rectangle frame,
      out Vector2 origin,
      out Color color);

    public delegate Color ColorLerpMethod(float percent);
  }
}