using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Web;
using HarmonyLib;
using Il2CppExitGames.Client.Photon;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppPhoton.Pun;
using Il2CppPhoton.Realtime;
using Il2CppRUMBLE.Economy;
using Il2CppRUMBLE.Environment.MatchFlow;
using Il2CppRUMBLE.Interactions.InteractionBase;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Slabs;
using Il2CppRUMBLE.Utilities;
using Il2CppSystem;
using Il2CppTMPro;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using NameBending;
using Newtonsoft.Json;
using RumbleModdingAPI.RMAPI;
using ThreeDISevenZeroR.UnityGifDecoder;
using ThreeDISevenZeroR.UnityGifDecoder.Decode;
using ThreeDISevenZeroR.UnityGifDecoder.Model;
using ThreeDISevenZeroR.UnityGifDecoder.Utils;
using UIFramework;
using UIFramework.Models;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "NameBending", "2.0.2", "TacoSlayer36", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 255, 248, 231)]
[assembly: MelonAuthorColor(255, 255, 248, 231)]
[assembly: MelonAdditionalDependencies(new string[] { "UIFramework" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("NameBending")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+c50a573436c558ae0beca3bdb5a3b049ab09300c")]
[assembly: AssemblyProduct("NameBending")]
[assembly: AssemblyTitle("NameBending")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
}
public static class HelperFunctions
{
	public static string ToHtmlStringRGB(this Color color)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		int value = Mathf.Clamp(Mathf.RoundToInt(color.r * 255f), 0, 255);
		int value2 = Mathf.Clamp(Mathf.RoundToInt(color.g * 255f), 0, 255);
		int value3 = Mathf.Clamp(Mathf.RoundToInt(color.b * 255f), 0, 255);
		return $"#{value:X2}{value2:X2}{value3:X2}";
	}

	public static bool IsGif(byte[] bytes)
	{
		if (bytes == null || bytes.Length < 6)
		{
			return false;
		}
		return bytes[0] == 71 && bytes[1] == 73 && bytes[2] == 70 && bytes[3] == 56 && (bytes[4] == 55 || bytes[4] == 57) && bytes[5] == 97;
	}

	public static List<FrameData> ConvertGifToList(byte[] bytes)
	{
		List<FrameData> list = new List<FrameData>();
		GifStream gifStream = new GifStream(bytes);
		int num = 0;
		while (gifStream.HasMoreData)
		{
			FrameData frameData = ReadNextGifFrame(gifStream);
			if (frameData != null && (Object)(object)frameData.Texture != (Object)null)
			{
				frameData.Index = num++;
				list.Add(frameData);
			}
		}
		return list;
	}

	private static FrameData ReadNextGifFrame(GifStream gifStream)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Expected O, but got Unknown
		GifStream.Token currentToken = gifStream.CurrentToken;
		GifStream.Token token = currentToken;
		if (token == GifStream.Token.Image)
		{
			GifImage gifImage = gifStream.ReadImage();
			Texture2D val = new Texture2D(gifStream.Header.width, gifStream.Header.height, (TextureFormat)5, false);
			((Texture)val).mipMapBias = Config.MipmapBias.Value;
			val.SetPixels32(Il2CppStructArray<Color32>.op_Implicit(gifImage.colors));
			val.Apply();
			float num = gifImage.SafeDelaySeconds;
			if (num < 0.001f)
			{
				num = 0.001f;
			}
			return new FrameData(val, num);
		}
		gifStream.SkipToken();
		return null;
	}

	public static string SanitizeString(string Input)
	{
		string pattern = "<[^>]*>";
		return Regex.Replace(Input, pattern, string.Empty);
	}

	public static string RemoveInPlaceCharArray(string input)
	{
		int length = input.Length;
		char[] array = input.ToCharArray();
		int length2 = 0;
		for (int i = 0; i < length; i++)
		{
			char c = array[i];
			switch (c)
			{
			case '\t':
			case '\n':
			case '\v':
			case '\f':
			case '\r':
			case ' ':
			case '\u0085':
			case '\u00a0':
			case '\u1680':
			case '\u2000':
			case '\u2001':
			case '\u2002':
			case '\u2003':
			case '\u2004':
			case '\u2005':
			case '\u2006':
			case '\u2007':
			case '\u2008':
			case '\u2009':
			case '\u200a':
			case '\u2028':
			case '\u2029':
			case '\u202f':
			case '\u205f':
			case '\u3000':
				continue;
			}
			array[length2++] = c;
		}
		return new string(array, 0, length2);
	}

	public static int LevenshteinDistance(string source, string target)
	{
		if (string.IsNullOrEmpty(source))
		{
			return (!string.IsNullOrEmpty(target)) ? target.Length : 0;
		}
		if (string.IsNullOrEmpty(target))
		{
			return source.Length;
		}
		int length = source.Length;
		int length2 = target.Length;
		int[,] array = new int[length + 1, length2 + 1];
		int num = 0;
		while (num <= length)
		{
			array[num, 0] = num++;
		}
		int num2 = 0;
		while (num2 <= length2)
		{
			array[0, num2] = num2++;
		}
		for (int i = 1; i <= length; i++)
		{
			for (int j = 1; j <= length2; j++)
			{
				int num3 = ((target[j - 1] != source[i - 1]) ? 1 : 0);
				array[i, j] = Math.Min(Math.Min(array[i - 1, j] + 1, array[i, j - 1] + 1), array[i - 1, j - 1] + num3);
			}
		}
		return array[length, length2];
	}

	public static Player FindPhotonPlayerFromRumblePlayer(Player player)
	{
		if (player == null)
		{
			return null;
		}
		foreach (Player item in (Il2CppArrayBase<Player>)(object)PhotonNetwork.PlayerList)
		{
			short? obj;
			if (player == null)
			{
				obj = null;
			}
			else
			{
				PlayerData data = player.Data;
				if (data == null)
				{
					obj = null;
				}
				else
				{
					GeneralData generalData = data.GeneralData;
					obj = ((generalData != null) ? new short?(generalData.actorNo) : ((short?)null));
				}
			}
			if (obj == item.ActorNumber)
			{
				return item;
			}
		}
		return null;
	}
}
namespace ThreeDISevenZeroR.UnityGifDecoder
{
	public class GifBitBlockReader
	{
		private Stream stream;

		private int currentByte;

		private int currentBitPosition;

		private int currentBufferPosition;

		private int currentBufferSize;

		private bool endReached;

		private readonly byte[] buffer;

		public GifBitBlockReader()
		{
			buffer = new byte[256];
		}

		public GifBitBlockReader(Stream stream)
			: this()
		{
			SetStream(stream);
		}

		public void SetStream(Stream stream)
		{
			this.stream = stream;
		}

		public void StartNewReading()
		{
			currentByte = 0;
			currentBitPosition = 8;
			ReadNextBlock();
		}

		public void FinishReading()
		{
			while (!endReached)
			{
				ReadNextBlock();
			}
		}

		public int ReadBits(int count)
		{
			int num = 0;
			int num2 = count;
			int num3 = 0;
			int num4 = 8 - currentBitPosition;
			while (num2 > 0)
			{
				if (currentBitPosition >= 8)
				{
					currentBitPosition = 0;
					num4 = 8;
					if (endReached)
					{
						currentByte = 0;
					}
					else
					{
						currentByte = buffer[currentBufferPosition++];
						if (currentBufferPosition == currentBufferSize)
						{
							ReadNextBlock();
						}
					}
				}
				byte b = (byte)((1 << num2) - 1 << currentBitPosition);
				int num5 = ((num4 < num2) ? num4 : num2);
				num += (b & currentByte) >> currentBitPosition << num3;
				currentBitPosition += num5;
				num2 -= num5;
				num3 += num5;
			}
			return num;
		}

		private void ReadNextBlock()
		{
			currentBufferSize = stream.ReadByte8();
			currentBufferPosition = 0;
			endReached = currentBufferSize == 0;
			if (!endReached)
			{
				stream.Read(buffer, 0, currentBufferSize);
			}
		}
	}
	public class GifCanvas
	{
		private Color32[] canvasColors;

		private Color32[] revertDisposalBuffer;

		private int canvasWidth;

		private int canvasHeight;

		private bool canvasIsEmpty;

		private Color32[] framePalette;

		private GifDisposalMethod frameDisposalMethod;

		private int frameCanvasPosition;

		private int frameCanvasRowEndPosition;

		private int frameTransparentColorIndex;

		private int frameRowCurrent;

		private int frameX;

		private int frameY;

		private int frameWidth;

		private int frameHeight;

		private int[] frameRowStart;

		private int[] frameRowEnd;

		public Color32[] Colors => canvasColors;

		public bool FlipVertically { get; set; } = true;

		public Color32 BackgroundColor { get; set; }

		public GifCanvas()
		{
			canvasIsEmpty = true;
		}

		public GifCanvas(int width, int height)
			: this()
		{
			SetSize(width, height);
		}

		public void SetSize(int width, int height)
		{
			if (width != canvasWidth || height != canvasHeight)
			{
				int num = width * height;
				canvasColors = (Color32[])(object)new Color32[num];
				frameRowStart = new int[height];
				frameRowEnd = new int[height];
				revertDisposalBuffer = null;
				canvasWidth = width;
				canvasHeight = height;
			}
			Reset();
		}

		public void Reset()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			frameDisposalMethod = GifDisposalMethod.Keep;
			frameX = 0;
			frameY = 0;
			frameWidth = canvasWidth;
			frameHeight = canvasHeight;
			if (!canvasIsEmpty)
			{
				FillWithColor(0, 0, canvasWidth, canvasHeight, new Color32(BackgroundColor.r, BackgroundColor.g, BackgroundColor.b, (byte)0));
				canvasIsEmpty = true;
			}
		}

		public void BeginNewFrame(int x, int y, int width, int height, Color32[] palette, int transparentColorIndex, bool isInterlaced, GifDisposalMethod disposalMethod)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			switch (frameDisposalMethod)
			{
			case GifDisposalMethod.ClearToBackgroundColor:
				FillWithColor(frameX, frameY, frameWidth, frameHeight, new Color32(BackgroundColor.r, BackgroundColor.g, BackgroundColor.b, (byte)0));
				break;
			case GifDisposalMethod.Revert:
				if (disposalMethod != GifDisposalMethod.Keep)
				{
					Array.Copy(revertDisposalBuffer, 0, canvasColors, 0, revertDisposalBuffer.Length);
				}
				break;
			}
			if (disposalMethod == GifDisposalMethod.Revert)
			{
				if (revertDisposalBuffer == null)
				{
					revertDisposalBuffer = (Color32[])(object)new Color32[canvasColors.Length];
				}
				Array.Copy(canvasColors, 0, revertDisposalBuffer, 0, revertDisposalBuffer.Length);
			}
			framePalette = palette;
			frameDisposalMethod = disposalMethod;
			canvasIsEmpty = false;
			frameWidth = width;
			frameHeight = height;
			frameX = x;
			frameY = y;
			frameCanvasPosition = 0;
			frameRowCurrent = -1;
			frameCanvasRowEndPosition = -1;
			frameTransparentColorIndex = transparentColorIndex;
			RouteFrameDrawing(x, y, width, height, isInterlaced);
		}

		public void OutputPixel(int color)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (frameCanvasPosition >= frameCanvasRowEndPosition)
			{
				frameRowCurrent++;
				frameCanvasPosition = frameRowStart[frameRowCurrent];
				frameCanvasRowEndPosition = frameRowEnd[frameRowCurrent];
			}
			if (color != frameTransparentColorIndex)
			{
				canvasColors[frameCanvasPosition] = framePalette[color];
			}
			frameCanvasPosition++;
		}

		public void FillWithColor(int x, int y, int width, int height, Color32 color)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (width == canvasWidth && height == canvasHeight)
			{
				for (int num = canvasColors.Length - 1; num >= 0; num--)
				{
					canvasColors[num] = color;
				}
				return;
			}
			int num2;
			int num3;
			if (FlipVertically)
			{
				num2 = (canvasHeight - y) * canvasWidth + x;
				num3 = num2 - canvasWidth * height;
			}
			else
			{
				num3 = y * canvasWidth + x;
				num2 = num3 + height * canvasWidth;
			}
			for (int i = num3; i < num2; i += canvasWidth)
			{
				int num4 = i + width;
				for (int j = i; j < num4; j++)
				{
					canvasColors[j] = color;
				}
			}
		}

		private void RouteFrameDrawing(int x, int y, int width, int height, bool deinterlace)
		{
			int currentRow = 0;
			if (deinterlace)
			{
				for (int i = 0; i < height; i += 8)
				{
					ScheduleRowIndex(i);
				}
				for (int j = 4; j < height; j += 8)
				{
					ScheduleRowIndex(j);
				}
				for (int k = 2; k < height; k += 4)
				{
					ScheduleRowIndex(k);
				}
				for (int l = 1; l < height; l += 2)
				{
					ScheduleRowIndex(l);
				}
			}
			else
			{
				for (int m = 0; m < height; m++)
				{
					ScheduleRowIndex(m);
				}
			}
			void ScheduleRowIndex(int row)
			{
				int num = (FlipVertically ? ((canvasHeight - 1 - (y + row)) * canvasWidth + x) : ((y + row) * canvasWidth + x));
				frameRowStart[currentRow] = num;
				frameRowEnd[currentRow] = num + width;
				currentRow++;
			}
		}
	}
	public class GifStream : IDisposable
	{
		public enum Token
		{
			Header,
			Palette,
			GraphicsControl,
			ImageDescriptor,
			Image,
			Comment,
			PlainText,
			NetscapeExtension,
			ApplicationExtension,
			EndOfFile
		}

		private Stream currentStream;

		private long headerStartPosition;

		private long firstFrameStartPosition;

		private GifHeader header;

		private GifGraphicControl graphicControl;

		private GifImageDescriptor imageDescriptor;

		private GifCanvas canvas;

		private GifLzwDictionary lzwDictionary;

		private GifBitBlockReader blockReader;

		private Color32[] globalColorTable;

		private Color32[] localColorTable;

		private readonly byte[] headerBuffer;

		private readonly byte[] colorTableBuffer;

		private readonly byte[] extensionApplicationBuffer;

		private bool nextPaletteIsGlobal;

		private const int ExtensionBlock = 33;

		private const int ImageDescriptorBlock = 44;

		private const int EndOfFile = 59;

		private const int PlainTextLabel = 1;

		private const int GraphicControlLabel = 249;

		private const int commentLabel = 254;

		private const int applicationExtensionLabel = 255;

		public bool FlipVertically
		{
			get
			{
				return canvas.FlipVertically;
			}
			set
			{
				canvas.FlipVertically = value;
			}
		}

		public bool DrawPlainTextBackground { get; set; }

		public GifHeader Header => header;

		public bool HasMoreData => CurrentToken != Token.EndOfFile;

		public Token CurrentToken { get; private set; }

		public Stream BaseStream
		{
			get
			{
				return currentStream;
			}
			set
			{
				SetStream(value);
			}
		}

		public GifStream()
		{
			lzwDictionary = new GifLzwDictionary();
			canvas = new GifCanvas();
			blockReader = new GifBitBlockReader();
			globalColorTable = (Color32[])(object)new Color32[256];
			localColorTable = (Color32[])(object)new Color32[256];
			headerBuffer = new byte[6];
			extensionApplicationBuffer = new byte[11];
			colorTableBuffer = new byte[768];
		}

		public GifStream(Stream stream)
			: this()
		{
			SetStream(stream);
		}

		public GifStream(byte[] gifBytes)
			: this(new MemoryStream(gifBytes))
		{
		}

		public GifStream(string path)
			: this(File.OpenRead(path))
		{
		}

		public void SetStream(Stream stream, bool disposePrevious = false)
		{
			if (disposePrevious)
			{
				currentStream?.Dispose();
			}
			header = default(GifHeader);
			imageDescriptor = default(GifImageDescriptor);
			graphicControl = default(GifGraphicControl);
			currentStream = stream;
			CurrentToken = Token.Header;
			blockReader.SetStream(stream);
		}

		public void Dispose()
		{
			currentStream?.Dispose();
		}

		public void SkipToken()
		{
			switch (CurrentToken)
			{
			case Token.Header:
				ReadHeader();
				break;
			case Token.Palette:
				ReadPalette();
				break;
			case Token.GraphicsControl:
				ReadGraphicsControl();
				break;
			case Token.ImageDescriptor:
				ReadImageDescriptor();
				break;
			case Token.Image:
				ReadImage();
				break;
			case Token.Comment:
				SkipComment();
				break;
			case Token.PlainText:
				SkipPlainText();
				break;
			case Token.NetscapeExtension:
				SkipNetscapeExtension();
				break;
			case Token.ApplicationExtension:
				SkipApplicationExtension();
				break;
			default:
				throw new InvalidOperationException($"Cannot skip token {CurrentToken}");
			}
		}

		public void Reset(bool skipHeader = true, bool resetCanvas = true)
		{
			long num = ((skipHeader && firstFrameStartPosition != -1) ? firstFrameStartPosition : headerStartPosition);
			if (currentStream.Position != num)
			{
				currentStream.Position = num;
			}
			SetCurrentToken(Token.Header);
			if (resetCanvas)
			{
				canvas.Reset();
			}
		}

		public GifHeader ReadHeader()
		{
			AssertToken(Token.Header);
			headerStartPosition = currentStream.Position;
			firstFrameStartPosition = -1L;
			currentStream.Read(headerBuffer, 0, headerBuffer.Length);
			if (BitUtils.CheckString(headerBuffer, "GIF87a"))
			{
				header.version = GifVersion.Gif87a;
			}
			else
			{
				if (!BitUtils.CheckString(headerBuffer, "GIF89a"))
				{
					throw new ArgumentException("Invalid or corrupted Gif file");
				}
				header.version = GifVersion.Gif89a;
			}
			header.width = currentStream.ReadInt16LittleEndian();
			header.height = currentStream.ReadInt16LittleEndian();
			byte b = currentStream.ReadByte8();
			header.globalColorTableSize = BitUtils.GetColorTableSize(b.GetBitsFromByte(0, 3));
			header.sortColors = b.GetBitFromByte(3);
			header.colorResolution = b.GetBitsFromByte(4, 3);
			header.hasGlobalColorTable = b.GetBitFromByte(7);
			header.transparentColorIndex = currentStream.ReadByte8();
			header.pixelAspectRatio = currentStream.ReadByte8();
			canvas.SetSize(header.width, header.height);
			if (header.hasGlobalColorTable)
			{
				SetCurrentToken(Token.Palette);
				nextPaletteIsGlobal = true;
			}
			else
			{
				DetermineNextToken();
			}
			return header;
		}

		public GifPalette ReadPalette()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			AssertToken(Token.Palette);
			int num = (nextPaletteIsGlobal ? header.globalColorTableSize : imageDescriptor.localColorTableSize);
			Color32[] array = (nextPaletteIsGlobal ? globalColorTable : localColorTable);
			currentStream.Read(colorTableBuffer, 0, num * 3);
			int num2 = 0;
			for (int i = 0; i < num; i++)
			{
				array[i] = new Color32(colorTableBuffer[num2++], colorTableBuffer[num2++], colorTableBuffer[num2++], byte.MaxValue);
			}
			if (nextPaletteIsGlobal)
			{
				firstFrameStartPosition = currentStream.Position;
				DetermineNextToken();
			}
			else
			{
				SetCurrentToken(Token.Image);
			}
			return new GifPalette
			{
				palette = array,
				size = num,
				isGlobal = nextPaletteIsGlobal
			};
		}

		public GifGraphicControl ReadGraphicsControl()
		{
			AssertToken(Token.GraphicsControl);
			currentStream.AssertByte(4);
			byte b = currentStream.ReadByte8();
			int bitsFromByte = b.GetBitsFromByte(2, 3);
			graphicControl.hasTransparency = b.GetBitFromByte(0);
			graphicControl.userInput = b.GetBitFromByte(1);
			graphicControl.delayTime = currentStream.ReadInt16LittleEndian();
			graphicControl.transparentColorIndex = currentStream.ReadByte8();
			if (!graphicControl.hasTransparency)
			{
				graphicControl.transparentColorIndex = -1;
			}
			switch (bitsFromByte)
			{
			case 0:
			case 1:
				graphicControl.disposalMethod = GifDisposalMethod.Keep;
				break;
			case 2:
				graphicControl.disposalMethod = GifDisposalMethod.ClearToBackgroundColor;
				break;
			case 3:
				graphicControl.disposalMethod = GifDisposalMethod.Revert;
				break;
			default:
				throw new ArgumentException($"Invalid disposal method type: {bitsFromByte}");
			}
			currentStream.AssertByte(0);
			DetermineNextToken();
			return graphicControl;
		}

		public GifImageDescriptor ReadImageDescriptor()
		{
			AssertToken(Token.ImageDescriptor);
			imageDescriptor.left = currentStream.ReadInt16LittleEndian();
			imageDescriptor.top = currentStream.ReadInt16LittleEndian();
			imageDescriptor.width = currentStream.ReadInt16LittleEndian();
			imageDescriptor.height = currentStream.ReadInt16LittleEndian();
			byte b = currentStream.ReadByte8();
			imageDescriptor.localColorTableSize = BitUtils.GetColorTableSize(b.GetBitsFromByte(0, 3));
			imageDescriptor.isInterlaced = b.GetBitFromByte(6);
			imageDescriptor.hasLocalColorTable = b.GetBitFromByte(7);
			if (imageDescriptor.hasLocalColorTable)
			{
				nextPaletteIsGlobal = false;
				SetCurrentToken(Token.Palette);
			}
			else
			{
				SetCurrentToken(Token.Image);
			}
			return imageDescriptor;
		}

		public GifImage ReadImage()
		{
			AssertToken(Token.Image);
			Color32[] colorTable = (imageDescriptor.hasLocalColorTable ? localColorTable : globalColorTable);
			byte b = currentStream.ReadByte8();
			if (b == 0 || b > 8)
			{
				throw new ArgumentException("Invalid lzw min code size");
			}
			DecodeLzwImageToCanvas(b, imageDescriptor.left, imageDescriptor.top, imageDescriptor.width, imageDescriptor.height, colorTable, graphicControl.transparentColorIndex, imageDescriptor.isInterlaced, graphicControl.disposalMethod);
			DetermineNextToken();
			return new GifImage
			{
				colors = canvas.Colors,
				userInput = graphicControl.userInput,
				delay = graphicControl.delayTime
			};
		}

		public string ReadComment()
		{
			AssertToken(Token.Comment);
			string result = Encoding.ASCII.GetString(BitUtils.ReadGifBlocks(currentStream));
			DetermineNextToken();
			return result;
		}

		public void SkipComment()
		{
			SkipBlock(Token.Comment);
		}

		public GifPlainText ReadPlainText()
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			AssertToken(Token.PlainText);
			currentStream.AssertByte(12);
			GifPlainText gifPlainText = new GifPlainText
			{
				left = currentStream.ReadInt16LittleEndian(),
				top = currentStream.ReadInt16LittleEndian(),
				width = currentStream.ReadInt16LittleEndian(),
				height = currentStream.ReadInt16LittleEndian(),
				charWidth = currentStream.ReadByte8(),
				charHeight = currentStream.ReadByte8(),
				foregroundColor = globalColorTable[currentStream.ReadByte8()],
				backgroundColor = globalColorTable[currentStream.ReadByte8()],
				text = Encoding.ASCII.GetString(BitUtils.ReadGifBlocks(currentStream)),
				colors = canvas.Colors
			};
			if (DrawPlainTextBackground)
			{
				FillPlainTextBackground(gifPlainText);
			}
			DetermineNextToken();
			return gifPlainText;
		}

		public void SkipPlainText()
		{
			if (DrawPlainTextBackground)
			{
				ReadPlainText();
			}
			else
			{
				SkipBlock(Token.PlainText);
			}
		}

		public GifNetscapeExtension ReadNetscapeExtension()
		{
			AssertToken(Token.NetscapeExtension);
			bool hasBufferSize = false;
			bool hasLoopCount = false;
			int loopCount = 0;
			int bufferSize = 0;
			while (true)
			{
				byte b = currentStream.ReadByte8();
				if (b == 0)
				{
					break;
				}
				switch (currentStream.ReadByte8())
				{
				case 1:
					hasLoopCount = true;
					loopCount = currentStream.ReadInt16LittleEndian();
					break;
				case 2:
					hasBufferSize = true;
					bufferSize = currentStream.ReadInt32LittleEndian();
					break;
				default:
					currentStream.Seek(b - 1, SeekOrigin.Current);
					break;
				}
			}
			DetermineNextToken();
			return new GifNetscapeExtension
			{
				hasLoopCount = hasLoopCount,
				hasBufferSize = hasBufferSize,
				loopCount = loopCount,
				bufferSize = bufferSize
			};
		}

		public void SkipNetscapeExtension()
		{
			SkipBlock(Token.NetscapeExtension);
		}

		public GifApplicationExtension ReadApplicationExtension()
		{
			AssertToken(Token.ApplicationExtension);
			List<byte[]> list = new List<byte[]>();
			string applicationIdentifier = Encoding.ASCII.GetString(extensionApplicationBuffer, 0, 8);
			string applicationAuthCode = Encoding.ASCII.GetString(extensionApplicationBuffer, 8, 3);
			while (true)
			{
				byte b = currentStream.ReadByte8();
				if (b == 0)
				{
					break;
				}
				byte[] array = new byte[b];
				currentStream.Read(array, 0, b);
				list.Add(array);
			}
			DetermineNextToken();
			return new GifApplicationExtension
			{
				applicationIdentifier = applicationIdentifier,
				applicationAuthCode = applicationAuthCode,
				applicationData = list.ToArray()
			};
		}

		public void SkipApplicationExtension()
		{
			SkipBlock(Token.ApplicationExtension);
		}

		private void DecodeLzwImageToCanvas(int lzwMinCodeSize, int x, int y, int width, int height, Color32[] colorTable, int transparentColorIndex, bool isInterlaced, GifDisposalMethod disposalMethod)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (header.hasGlobalColorTable)
			{
				canvas.BackgroundColor = globalColorTable[header.transparentColorIndex];
			}
			canvas.BeginNewFrame(x, y, width, height, colorTable, transparentColorIndex, isInterlaced, disposalMethod);
			lzwDictionary.InitWithWordSize(lzwMinCodeSize);
			blockReader.StartNewReading();
			lzwDictionary.DecodeStream(blockReader, canvas);
			blockReader.FinishReading();
		}

		private Token DetermineNextToken()
		{
			while (true)
			{
				byte b = currentStream.ReadByte8();
				switch (b)
				{
				case 33:
					switch (currentStream.ReadByte8())
					{
					case 254:
						return SetCurrentToken(Token.Comment);
					case 1:
						return SetCurrentToken(Token.PlainText);
					case 249:
						return SetCurrentToken(Token.GraphicsControl);
					case byte.MaxValue:
					{
						currentStream.AssertByte(11);
						currentStream.Read(extensionApplicationBuffer, 0, 11);
						Token currentToken = (BitUtils.CheckString(extensionApplicationBuffer, "NETSCAPE2.0") ? Token.NetscapeExtension : Token.ApplicationExtension);
						return SetCurrentToken(currentToken);
					}
					}
					break;
				case 44:
					return SetCurrentToken(Token.ImageDescriptor);
				case 59:
					return SetCurrentToken(Token.EndOfFile);
				default:
					throw new ArgumentException($"Unknown block type {b}");
				}
				BitUtils.SkipGifBlocks(currentStream);
			}
		}

		private Token SetCurrentToken(Token token)
		{
			CurrentToken = token;
			return token;
		}

		private void FillPlainTextBackground(GifPlainText text)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			canvas.BeginNewFrame(text.left, text.top, text.width, text.height, globalColorTable, graphicControl.transparentColorIndex, imageDescriptor.isInterlaced, graphicControl.disposalMethod);
			canvas.FillWithColor(text.left, text.top, text.width, text.height, text.backgroundColor);
		}

		private void AssertToken(Token token)
		{
			if (CurrentToken != token)
			{
				throw new InvalidOperationException($"Cannot invoke this method while current token is \"{CurrentToken}\", method should be called when token is {token}");
			}
		}

		private void SkipBlock(Token token)
		{
			AssertToken(token);
			BitUtils.SkipGifBlocks(currentStream);
			DetermineNextToken();
		}
	}
}
namespace ThreeDISevenZeroR.UnityGifDecoder.Utils
{
	public static class BitUtils
	{
		public static bool CheckString(byte[] array, string s)
		{
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] != s[i])
				{
					return false;
				}
			}
			return true;
		}

		public static int ReadInt16LittleEndian(this Stream reader)
		{
			byte b = reader.ReadByte8();
			byte b2 = reader.ReadByte8();
			return (b2 << 8) + b;
		}

		public static int ReadInt32LittleEndian(this Stream reader)
		{
			byte b = reader.ReadByte8();
			byte b2 = reader.ReadByte8();
			byte b3 = reader.ReadByte8();
			byte b4 = reader.ReadByte8();
			return (b4 << 24) + (b3 << 16) + (b2 << 8) + b;
		}

		public static byte ReadByte8(this Stream reader)
		{
			int num = reader.ReadByte();
			if (num == -1)
			{
				throw new EndOfStreamException();
			}
			return (byte)num;
		}

		public static void AssertByte(this Stream reader, int expectedValue)
		{
			byte b = reader.ReadByte8();
			if (b != expectedValue)
			{
				throw new ArgumentException($"Invalid byte, expected {expectedValue}, got {b}");
			}
		}

		public static int GetColorTableSize(int data)
		{
			return 1 << data + 1;
		}

		public static int GetBitsFromByte(this byte b, int offset, int count)
		{
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				num += (b.GetBitFromByte(offset + i) ? 1 : 0) << i;
			}
			return num;
		}

		public static bool GetBitFromByte(this byte b, int offset)
		{
			return (b & (1 << offset)) != 0;
		}

		public static byte[] ReadGifBlocks(Stream reader)
		{
			List<byte> list = new List<byte>();
			while (true)
			{
				byte b = reader.ReadByte8();
				if (b == 0)
				{
					break;
				}
				byte[] array = new byte[b];
				reader.Read(array, 0, array.Length);
				list.AddRange(array);
			}
			return list.ToArray();
		}

		public static void SkipGifBlocks(Stream reader)
		{
			while (true)
			{
				byte b = reader.ReadByte8();
				if (b == 0)
				{
					break;
				}
				reader.Seek(b, SeekOrigin.Current);
			}
		}
	}
}
namespace ThreeDISevenZeroR.UnityGifDecoder.Model
{
	public class GifApplicationExtension
	{
		public string applicationIdentifier;

		public string applicationAuthCode;

		public byte[][] applicationData;
	}
	public enum GifDisposalMethod
	{
		Keep,
		ClearToBackgroundColor,
		Revert
	}
	public struct GifGraphicControl
	{
		public bool userInput;

		public GifDisposalMethod disposalMethod;

		public int delayTime;

		public bool hasTransparency;

		public int transparentColorIndex;
	}
	public struct GifHeader
	{
		public GifVersion version;

		public int width;

		public int height;

		public bool hasGlobalColorTable;

		public int globalColorTableSize;

		public int transparentColorIndex;

		public bool sortColors;

		public int colorResolution;

		public int pixelAspectRatio;
	}
	public class GifImage
	{
		public bool userInput;

		public Color32[] colors;

		public int delay;

		public int DelayMs => delay * 10;

		public float SafeDelayMs => (delay > 1) ? DelayMs : 100;

		public float DelaySeconds => (float)delay / 100f;

		public float SafeDelaySeconds => SafeDelayMs / 1000f;
	}
	public struct GifImageDescriptor
	{
		public int left;

		public int top;

		public int width;

		public int height;

		public bool isInterlaced;

		public bool hasLocalColorTable;

		public int localColorTableSize;
	}
	public struct GifNetscapeExtension
	{
		public bool hasLoopCount;

		public bool hasBufferSize;

		public int loopCount;

		public int bufferSize;
	}
	public struct GifPalette
	{
		public Color32[] palette;

		public int size;

		public bool isGlobal;
	}
	public struct GifPlainText
	{
		public int left;

		public int top;

		public int width;

		public int height;

		public int charWidth;

		public int charHeight;

		public Color32 backgroundColor;

		public Color32 foregroundColor;

		public string text;

		public Color32[] colors;
	}
	public enum GifVersion
	{
		Gif89a,
		Gif87a
	}
}
namespace ThreeDISevenZeroR.UnityGifDecoder.Decode
{
	public class GifLzwDictionary
	{
		private readonly int[] dictionaryEntryOffsets;

		private readonly int[] dictionaryEntrySizes;

		private byte[] dictionaryHeap;

		private int dictionarySize;

		private int dictionaryHeapPosition;

		private int initialDictionarySize;

		private int initialLzwCodeSize;

		private int initialDictionaryHeapPosition;

		private int nextLzwCodeGrowth;

		private int currentMinLzwCodeSize;

		private int codeSize;

		private int clearCodeId;

		private int stopCodeId;

		private int lastCodeId;

		private bool isFull;

		public GifLzwDictionary()
		{
			dictionaryEntryOffsets = new int[4096];
			dictionaryEntrySizes = new int[4096];
			dictionaryHeap = new byte[32768];
		}

		public void InitWithWordSize(int minLzwCodeSize)
		{
			if (currentMinLzwCodeSize != minLzwCodeSize)
			{
				currentMinLzwCodeSize = minLzwCodeSize;
				dictionaryHeapPosition = 0;
				dictionarySize = 0;
				int num = 1 << minLzwCodeSize;
				for (int i = 0; i < num; i++)
				{
					dictionaryEntryOffsets[i] = dictionaryHeapPosition;
					dictionaryEntrySizes[i] = 1;
					dictionaryHeap[dictionaryHeapPosition++] = (byte)i;
				}
				initialDictionarySize = num + 2;
				initialLzwCodeSize = minLzwCodeSize + 1;
				initialDictionaryHeapPosition = dictionaryHeapPosition;
				clearCodeId = num;
				stopCodeId = num + 1;
			}
			Clear();
		}

		public void Clear()
		{
			codeSize = initialLzwCodeSize;
			dictionarySize = initialDictionarySize;
			dictionaryHeapPosition = initialDictionaryHeapPosition;
			nextLzwCodeGrowth = 1 << codeSize;
			isFull = false;
			lastCodeId = -1;
		}

		public void DecodeStream(GifBitBlockReader reader, GifCanvas c)
		{
			while (true)
			{
				int num = reader.ReadBits(codeSize);
				if (num == clearCodeId)
				{
					Clear();
					continue;
				}
				if (num == stopCodeId)
				{
					break;
				}
				if (num < dictionarySize)
				{
					if (lastCodeId >= 0)
					{
						CreateNewCode(lastCodeId, num);
					}
					lastCodeId = num;
				}
				else
				{
					lastCodeId = CreateNewCode(lastCodeId, lastCodeId);
				}
				int num2 = dictionaryEntryOffsets[lastCodeId];
				int num3 = dictionaryEntrySizes[lastCodeId];
				int num4 = num2 + num3;
				for (int i = num2; i < num4; i++)
				{
					c.OutputPixel(dictionaryHeap[i]);
				}
			}
		}

		public int CreateNewCode(int baseEntry, int deriveEntry)
		{
			if (isFull)
			{
				return -1;
			}
			int num = dictionaryEntryOffsets[baseEntry];
			int num2 = dictionaryEntrySizes[baseEntry];
			int num3 = dictionaryHeapPosition;
			int num4 = num2 + 1;
			int num5 = num3 + num4;
			if (dictionaryHeap.Length < num5)
			{
				Array.Resize(ref dictionaryHeap, Math.Max(dictionaryHeap.Length * 2, num5));
			}
			if (num2 < 12)
			{
				int num6 = num + num2;
				for (int i = num; i < num6; i++)
				{
					dictionaryHeap[dictionaryHeapPosition++] = dictionaryHeap[i];
				}
			}
			else
			{
				Buffer.BlockCopy(dictionaryHeap, num, dictionaryHeap, dictionaryHeapPosition, num2);
				dictionaryHeapPosition += num2;
			}
			dictionaryHeap[dictionaryHeapPosition++] = ((deriveEntry < initialDictionarySize) ? ((byte)deriveEntry) : dictionaryHeap[dictionaryEntryOffsets[deriveEntry]]);
			int num7 = dictionarySize++;
			dictionaryEntryOffsets[num7] = num3;
			dictionaryEntrySizes[num7] = num4;
			if (dictionarySize >= nextLzwCodeGrowth)
			{
				codeSize++;
				nextLzwCodeGrowth = ((codeSize == 12) ? int.MaxValue : (1 << codeSize));
			}
			if (dictionarySize >= 4096)
			{
				isFull = true;
			}
			return num7;
		}
	}
}
namespace NameBending
{
	[RegisterTypeInIl2Cpp]
	public class NameBend : MonoBehaviour
	{
		public Variation Variation;

		public List<BentImage> BentImages = new List<BentImage>();

		public Player Owner;

		public string PhotonEventString = null;

		public bool IsLocal = false;

		public bool IsPlayer = true;

		public bool IsScreenSpace = true;

		private PlayerNameTag _parentTag;

		public Core.DesignationType DesignationType = Core.DesignationType.Name;

		public string unbentText = "";

		private float _timer = 0f;

		public float AnimationProgress = 0f;

		private int steps = 0;

		private Player photonOwner => HelperFunctions.FindPhotonPlayerFromRumblePlayer(Owner);

		public PlayerNameTag ParentTag
		{
			get
			{
				if ((Object)(object)_parentTag != (Object)null)
				{
					return _parentTag;
				}
				_parentTag = ((Component)this).GetComponentInParent<PlayerNameTag>();
				return _parentTag;
			}
		}

		public bool IsRemote => !IsLocal && !IsScreenSpace;

		private string typeString => (DesignationType == Core.DesignationType.Name) ? "Name" : "Title";

		public float Timer
		{
			get
			{
				if (Config.Animations.Value)
				{
					return _timer;
				}
				return 0f;
			}
			set
			{
				_timer = value;
			}
		}

		private float frameDurationInSeconds => (float)Variation.FrameDuration / 1000f;

		public int FrameIndex
		{
			get
			{
				if (Config.Animations.Value)
				{
					return (int)Math.Truncate(AnimationProgress);
				}
				return 0;
			}
		}

		public float FrameProgress
		{
			get
			{
				if (Config.Animations.Value)
				{
					return AnimationProgress - (float)FrameIndex;
				}
				return 0f;
			}
		}

		public float LoopProgress
		{
			get
			{
				if (Config.Animations.Value)
				{
					return AnimationProgress / ((float)Variation.FindTotalFrameCount() * frameDurationInSeconds);
				}
				return 0f;
			}
		}

		public int LoopCount
		{
			get
			{
				if (Config.Animations.Value)
				{
					return (int)(Timer / ((float)Variation.FindTotalFrameCount() * frameDurationInSeconds));
				}
				return 0;
			}
		}

		private void Start()
		{
			if (!IsRemote)
			{
				Core.Instance.OnUpdateDesignations += OnUpdateDesignations;
			}
			OnUpdateDesignations();
			if (Variation != null)
			{
				TextMeshPro component = ((Component)this).GetComponent<TextMeshPro>();
				if ((Object)(object)component != (Object)null)
				{
					((TMP_Text)component).fontStyle = (FontStyles)0;
					((TMP_Text)component).characterSpacing = 0f;
				}
			}
		}

		private void OnDestroy()
		{
			Core.Instance.NameBends.Remove(this);
			Core.Instance.OnUpdateDesignations -= OnUpdateDesignations;
		}

		private void FixedUpdate()
		{
			CheckPlayerProps();
			Timer += Time.fixedDeltaTime;
			if (Variation != null)
			{
				Render();
			}
		}

		private void CheckPlayerProps()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			if (!PhotonNetwork.InRoom)
			{
				return;
			}
			Player owner = Owner;
			if (owner != null)
			{
				PlayerController controller = owner.Controller;
				if ((int)((controller != null) ? new ControllerType?(controller.controllerType) : ((ControllerType?)null)).GetValueOrDefault() == 1)
				{
					return;
				}
			}
			string hash;
			if (photonOwner != null)
			{
				Object obj = photonOwner.CustomProperties[Object.op_Implicit("NameBending.HashCode")];
				hash = ((obj != null) ? obj.ToString() : null) ?? "";
				string text = "-";
				if (Core.Instance.DesignationsHashes.ContainsKey(Owner.Controller))
				{
					text = Core.Instance.DesignationsHashes[Owner.Controller];
				}
				if (text != hash || !string.IsNullOrEmpty(PhotonEventString))
				{
					MelonCoroutines.Start(_());
					OnUpdateDesignations();
				}
			}
			IEnumerator _()
			{
				yield return (object)new WaitForFixedUpdate();
				Core.Instance.DesignationsHashes[Owner.Controller] = hash;
			}
		}

		public void OnUpdateDesignations()
		{
			if ((Object)(object)this == (Object)null)
			{
				return;
			}
			ResetAll();
			if (Config.DisableMod.Value)
			{
				return;
			}
			Variation = null;
			FetchVariation();
			if (!IsRemote && DesignationType == Core.DesignationType.Name && (!Config.MyBentName.Value || Config.DisableMod.Value))
			{
				Variation = null;
			}
			if (IsRemote && DesignationType == Core.DesignationType.Name && (!Config.OtherBentNames.Value || Config.DisableMod.Value))
			{
				Variation = null;
			}
			if (!IsRemote && DesignationType == Core.DesignationType.Title && (!Config.MyBentTitle.Value || Config.DisableMod.Value))
			{
				Variation = null;
			}
			if (IsRemote && DesignationType == Core.DesignationType.Title && (!Config.OtherBentTitles.Value || Config.DisableMod.Value))
			{
				Variation = null;
			}
			if (Variation != null)
			{
				ApplyImages();
				Timer = 0f;
				TextMeshPro component = ((Component)this).GetComponent<TextMeshPro>();
				if ((Object)(object)component != (Object)null && Variation != null)
				{
					((TMP_Text)component).enableAutoSizing = Variation.AutoScaling;
					((TMP_Text)component).fontStyle = (FontStyles)0;
					((TMP_Text)component).characterSpacing = 0f;
				}
			}
		}

		public void FetchVariation()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			if (Core.IsInMatch)
			{
				Player owner = Owner;
				if (owner != null)
				{
					PlayerController controller = owner.Controller;
					if ((int)((controller != null) ? new ControllerType?(controller.ControllerType) : ((ControllerType?)null)).GetValueOrDefault() == 1)
					{
						goto IL_00a1;
					}
				}
				if (DesignationType == Core.DesignationType.Name && Core.OpponentPhotonName != null)
				{
					PhotonEventString = Core.OpponentPhotonName;
					Core.OpponentPhotonName = null;
				}
				else if (DesignationType == Core.DesignationType.Title && Core.OpponentPhotonTitle != null)
				{
					PhotonEventString = Core.OpponentPhotonTitle;
					Core.OpponentPhotonTitle = null;
				}
			}
			goto IL_00a1;
			IL_00a1:
			if (!string.IsNullOrEmpty(PhotonEventString))
			{
				Variation = JsonConvert.DeserializeObject<Variation>(PhotonEventString);
				PhotonEventString = null;
			}
			else if (!IsRemote)
			{
				if (DesignationType == Core.DesignationType.Name)
				{
					Variation = Core.Instance.ActiveNameVariation;
				}
				if (DesignationType == Core.DesignationType.Title)
				{
					Variation = Core.Instance.ActiveTitleVariation;
				}
				if (Variation == null)
				{
					SetText(unbentText);
				}
			}
			else if (photonOwner != null)
			{
				Object val = photonOwner.CustomProperties[Object.op_Implicit("NameBending." + typeString)];
				string text = null;
				if (val != null)
				{
					text = val.ToString();
					if (text == null || text == "None")
					{
						SetText(unbentText);
						Variation = null;
						return;
					}
					Variation = JsonConvert.DeserializeObject<Variation>(text);
				}
			}
			if (Variation != null)
			{
				Variation.OwnerComponent = this;
				Variation.Owner = Owner;
				Variation.DesignationType = DesignationType.ToString();
				if (Variation.EnableFields && !Variation.FieldInstancesFound)
				{
					Variation.FindAllFieldInstances();
				}
				Variation.DownloadAllImages();
				if (Config.SaveNamesToFiles.Value && !Variation.ProhibitSaving)
				{
					saveVariation(Variation);
				}
			}
		}

		public void ReapplyImages()
		{
			ResetImages();
			ApplyImages();
		}

		public void ApplyImages()
		{
			if (Variation?.Images != null && Variation.Images.Count > 0)
			{
				foreach (ImageInfo image in Variation.Images)
				{
					CreateImageObject(image, Variation);
				}
			}
			foreach (BentImage bentImage in BentImages)
			{
				bentImage.RestartFrames();
			}
		}

		private void CreateImageObject(ImageInfo imageInfo, Variation containerVariation)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			if (!((Object)(object)this == (Object)null) && !((Object)(object)((Component)this).transform == (Object)null) && !Config.DisableMod.Value && Config.Images.Value)
			{
				GameObject val = GameObject.CreatePrimitive((PrimitiveType)4);
				((Object)val).name = "BentImagePlane";
				val.transform.SetParent(((Component)this).transform, false);
				float num = (float)(containerVariation.GetImageInfoIndex(imageInfo) + 1) * -0.0015f;
				if (imageInfo.ZDepth.HasValue)
				{
					num = imageInfo.ZDepth.Value * -0.0015f;
				}
				val.transform.localPosition = new Vector3(imageInfo.XOffset / 100f, imageInfo.YOffset / 100f, num);
				val.transform.localScale = new Vector3(imageInfo.Width / 1000f, 1f, imageInfo.Height / 1000f);
				Transform transform = val.transform;
				transform.localRotation *= Quaternion.Euler(90f, 180f, 0f);
				Material val2 = new Material(Core.Instance.CachedImageShader);
				val2.mainTexture = (Texture)(object)Core.Instance.CachedLoadingTexture;
				val.GetComponent<Renderer>().material = val2;
				if (IsScreenSpace)
				{
					val.layer = LayerMask.NameToLayer("UI");
				}
				BentImage bentImage = val.AddComponent<BentImage>();
				bentImage.ImageInfo = imageInfo;
				bentImage.ParentComponent = this;
				BentImages.Add(bentImage);
				Core.Instance.BentImages.Add(bentImage);
			}
		}

		private void saveVariation(Variation variation)
		{
			if (variation != null)
			{
				string serializedJsonIndented = variation.SerializedJsonIndented;
				string text = Path.Combine(Core.UserDataPath, "saved_names");
				string jsonPropertiesHashCode = variation.GetJsonPropertiesHashCode();
				string value = HelperFunctions.SanitizeString(variation.Owner.Data.GeneralData.PublicUsername);
				string playFabMasterId = variation.Owner.Data.GeneralData.PlayFabMasterId;
				string path = Path.Combine(text, $"{value}, {playFabMasterId} - {variation.DesignationType} {jsonPropertiesHashCode}.json");
				if (!Directory.Exists(text))
				{
					Directory.CreateDirectory(text);
				}
				File.WriteAllText(path, serializedJsonIndented);
			}
		}

		public void Render()
		{
			bool flag = !string.IsNullOrEmpty(Config.SimpleNameBend.Value);
			bool flag2 = !string.IsNullOrEmpty(Config.SimpleTitleBend.Value);
			if (Config.EnableSimpleConfig.Value)
			{
				if (DesignationType == Core.DesignationType.Name && flag)
				{
					SetText(truncateText(Config.SimpleNameBend.Value));
					return;
				}
				if (DesignationType == Core.DesignationType.Title && flag2)
				{
					SetText(truncateText(Config.SimpleTitleBend.Value));
					return;
				}
			}
			if (frameDurationInSeconds > 0f)
			{
				if (Variation.LoopFrames)
				{
					AnimationProgress = Timer / frameDurationInSeconds % (float)Variation.FindTotalFrameCount();
				}
				else
				{
					AnimationProgress = Math.Min(Timer / frameDurationInSeconds, Variation.FindLargestModifier());
				}
			}
			else
			{
				AnimationProgress = 0f;
			}
			try
			{
				int num = Variation.FindPrevModifierOfType("frame", FrameIndex);
				if (Variation.Frames.ContainsKey(num))
				{
					string text = Variation.Frames[num];
					if (Variation.EnableFields)
					{
						text = ProcessFields(num, Variation);
					}
					SetText(truncateText(text));
				}
			}
			catch
			{
			}
			try
			{
				int num2 = Variation.FindPrevModifierOfType("font", FrameIndex);
				if (num2 == -1)
				{
					SetFont(getFontFromName("GoodDogPlain"));
				}
				if (Variation.Fonts != null && Variation.Fonts.ContainsKey(num2))
				{
					SetFont(Variation.Fonts[num2]);
				}
			}
			catch
			{
			}
			try
			{
				int key = Variation.FindPrevModifierOfType("depth", FrameIndex);
				if (Variation.Depths != null && Variation.Depths.ContainsKey(key))
				{
					string s = Variation.Depths[key];
					float num3 = 0f;
					num3 = ((!Variation.Interpolation) ? float.Parse(s) : Mathf.Lerp(float.Parse(s), float.Parse(Variation.Depths[Variation.FindNextModifierOfType("depth", FrameIndex)]), FrameProgress));
					SetDepth(num3);
				}
			}
			catch
			{
			}
		}

		public void SetText(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			TextMeshProUGUI component = ((Component)this).gameObject.GetComponent<TextMeshProUGUI>();
			TextMeshPro component2 = ((Component)this).gameObject.GetComponent<TextMeshPro>();
			if ((Object)(object)component != (Object)null)
			{
				if (string.IsNullOrEmpty(unbentText))
				{
					unbentText = ((TMP_Text)component).text;
				}
				((TMP_Text)component).text = text;
			}
			else if ((Object)(object)component2 != (Object)null)
			{
				if (string.IsNullOrEmpty(unbentText))
				{
					unbentText = ((TMP_Text)component2).text;
				}
				((TMP_Text)component2).text = text;
			}
		}

		public void SetFont(TMP_FontAsset font)
		{
			if (!((Object)(object)this == (Object)null) && !((Object)(object)((Component)this).gameObject == (Object)null))
			{
				TextMeshProUGUI component = ((Component)this).gameObject.GetComponent<TextMeshProUGUI>();
				TextMeshPro component2 = ((Component)this).gameObject.GetComponent<TextMeshPro>();
				if ((Object)(object)component != (Object)null)
				{
					((TMP_Text)component).font = font;
				}
				else if ((Object)(object)component2 != (Object)null)
				{
					((TMP_Text)component2).font = font;
				}
			}
		}

		public void SetFont(string fontName)
		{
			TMP_FontAsset fontFromName = getFontFromName(fontName);
			if ((Object)(object)fontFromName != (Object)null)
			{
				SetFont(fontFromName);
			}
		}

		private string truncateText(string text)
		{
			if (Config.TruncationLength.Value <= 0)
			{
				return text;
			}
			return text.Substring(0, Config.TruncationLength.Value);
		}

		public void SetDepth(float depth)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localPosition = new Vector3(((Component)this).transform.localPosition.x, ((Component)this).transform.localPosition.y, depth / 10f);
		}

		public void ResetText()
		{
			SetText(unbentText);
		}

		public void ResetFont()
		{
			SetFont("GoodDogPlain");
		}

		public void ResetImages()
		{
			List<BentImage> list = new List<BentImage>();
			if ((Object)(object)this == (Object)null || (Object)(object)((Component)this).gameObject == (Object)null)
			{
				return;
			}
			BentImage[] array = Il2CppArrayBase<BentImage>.op_Implicit(((Component)this).GetComponentsInChildren<BentImage>());
			if (BentImages.Count == 0 && array.Length != 0)
			{
				BentImages.AddRange(array);
			}
			foreach (BentImage bentImage in BentImages)
			{
				bentImage.Reset();
				list.Add(bentImage);
			}
			foreach (BentImage item in list)
			{
				BentImages.Remove(item);
			}
		}

		public void ResetAll()
		{
			Variation = null;
			ResetText();
			ResetFont();
			ResetImages();
		}

		public static string ProcessFields(int frameIndex, Variation variation)
		{
			string text = variation.Frames[frameIndex];
			List<TypedField> typedFields = variation.TypedFields;
			string text2 = string.Empty;
			List<FieldInstance> list = new List<FieldInstance>();
			foreach (TypedField item in typedFields)
			{
				foreach (FieldInstance instance in item.Instances)
				{
					if (instance.FrameIndex == frameIndex)
					{
						list.Add(instance);
					}
				}
			}
			int num = 0;
			if (list.Count > 0)
			{
				for (int i = 0; i < list.Count; i++)
				{
					FieldInstance fieldInstance = list[i];
					TypedField ownerField = fieldInstance.OwnerField;
					string valueAsStringAt = ownerField.GetValueAsStringAt(fieldInstance, entry: true);
					if (num > text.Length)
					{
						break;
					}
					text2 += text.Substring(num, fieldInstance.StartPos - num);
					if (!ownerField.IsReferential && !ownerField.IsFactory)
					{
						if (!fieldInstance.IsSetter)
						{
							ownerField.SetValueUntyped(valueAsStringAt);
						}
						else
						{
							ownerField.SetValueUntyped(fieldInstance.SetTo);
						}
					}
					text2 += valueAsStringAt;
					num = fieldInstance.StartPos + fieldInstance.TotalLength;
				}
				if (num <= text.Length)
				{
					text2 += text.Substring(num);
				}
				return text2;
			}
			return text;
		}

		private TMP_FontAsset getFontFromName(string font)
		{
			foreach (TMP_FontAsset cachedFontAsset in Core.Instance.CachedFontAssets)
			{
				if (((Object)cachedFontAsset).name == font)
				{
					return cachedFontAsset;
				}
			}
			return null;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class BentImage : MonoBehaviour
	{
		public ImageInfo ImageInfo;

		public NameBend ParentComponent;

		public object SetTextureRoutine;

		public bool IsReset = false;

		private float timer = 0f;

		private int currentFrameIndex = 0;

		private Material material
		{
			get
			{
				if ((Object)(object)this != (Object)null && (Object)(object)((Component)this).gameObject != (Object)null)
				{
					Renderer componentInChildren = ((Component)this).GetComponentInChildren<Renderer>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						return componentInChildren.material;
					}
				}
				return null;
			}
		}

		private void OnDestroy()
		{
			Core.Instance.BentImages.Remove(this);
		}

		public void Update()
		{
			if (Config.DisableMod.Value || !Config.Images.Value)
			{
				return;
			}
			ImageInfo imageInfo = ImageInfo;
			if (!imageInfo.TextureDownloaded)
			{
				imageInfo = ImageInfo.GetLoadingGif();
			}
			if (!imageInfo.IsGIF)
			{
				return;
			}
			timer += Time.deltaTime;
			if (timer > imageInfo.GifDuration)
			{
				timer = 0f;
				currentFrameIndex = 0;
			}
			for (int i = currentFrameIndex; i < imageInfo.Frames.Count; i++)
			{
				FrameData frameData = imageInfo.Frames[i];
				if (frameData.GetTimestamp() < timer && frameData.Index > currentFrameIndex)
				{
					currentFrameIndex = frameData.Index;
					material.mainTexture = (Texture)(object)imageInfo.Frames[currentFrameIndex].Texture;
					break;
				}
			}
		}

		public void Reset()
		{
			if (SetTextureRoutine != null)
			{
				MelonCoroutines.Stop(SetTextureRoutine);
			}
			IsReset = true;
			try
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			catch
			{
			}
		}

		public void RestartFrames()
		{
			SetTextureRoutine = MelonCoroutines.Start(SetTextureWhenAvailable(0));
			timer = 0f;
		}

		public IEnumerator SetTextureWhenAvailable(int index)
		{
			int tries = 0;
			while (!ImageInfo.TextureDownloaded)
			{
				if (tries++ >= 500)
				{
					yield break;
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
			while ((Object)(object)material == (Object)null)
			{
				if (tries++ >= 500)
				{
					yield break;
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
			if (!ImageInfo.IsGIF)
			{
				material.mainTexture = (Texture)(object)ImageInfo.Texture;
			}
			else
			{
				material.mainTexture = (Texture)(object)ImageInfo.Frames[index].Texture;
			}
		}

		public void Censor()
		{
			ImageInfo.UndownloadImage();
			ImageInfo.Censored = true;
			ImageInfo.ForceUncensor = false;
			ImageInfo.Texture = Core.Instance.CachedCensoredTexture;
			ImageInfo.TextureDownloaded = true;
			RestartFrames();
		}

		public void CensorIfNeeded()
		{
			if (ImageInfo.Censored && !ImageInfo.ForceUncensor)
			{
				ImageInfo.UndownloadImage();
				ImageInfo.Texture = Core.Instance.CachedCensoredTexture;
				ImageInfo.TextureDownloaded = true;
				RestartFrames();
			}
		}

		public void Uncensor()
		{
			ImageInfo.UndownloadImage();
			ImageInfo.Censored = false;
			ImageInfo.ForceUncensor = true;
			if (ImageInfo.DownloadCoroutine != null)
			{
				MelonCoroutines.Stop(ImageInfo.DownloadCoroutine);
			}
			ImageInfo.DownloadCoroutine = MelonCoroutines.Start(ImageInfo.DownloadImage());
			RestartFrames();
		}

		public void UncensorIfNeeded()
		{
			if (!ImageInfo.Censored || ImageInfo.ForceUncensor)
			{
				ImageInfo.UndownloadImage();
				ImageInfo.Censored = false;
				if (ImageInfo.DownloadCoroutine != null)
				{
					MelonCoroutines.Stop(ImageInfo.DownloadCoroutine);
				}
				ImageInfo.DownloadCoroutine = MelonCoroutines.Start(ImageInfo.DownloadImage());
				RestartFrames();
			}
		}

		public void SetMipmapBias(float bias)
		{
			foreach (FrameData frame in ImageInfo.Frames)
			{
				((Texture)frame.Texture).mipMapBias = bias;
			}
		}

		public void SetOpacity(float opacity)
		{
			material.SetFloat("_Opacity", opacity);
		}
	}
	public static class Config
	{
		public static KeyCode _refreshHotkeyCode = (KeyCode)0;

		public static bool prevDisableMod = false;

		public static bool prevBentName = false;

		public static bool prevBentTitle = false;

		public static bool prevImages = false;

		public static int prevForceVariation = -1;

		public static bool prevTrustAll = false;

		public static MelonModel Me;

		public static MelonPreferences_Category Cat_NamePlate;

		public static MelonPreferences_Entry<bool> NameplatePreview;

		public static MelonPreferences_Entry<string> RefreshHotkey;

		public static MelonPreferences_Category Cat_SimpleConfig;

		public static MelonPreferences_Entry<bool> EnableSimpleConfig;

		public static MelonPreferences_Entry<string> SimpleNameBend;

		public static MelonPreferences_Entry<string> SimpleTitleBend;

		public static MelonPreferences_Entry<string> SimpleAltText;

		public static MelonPreferences_Category Cat_Toggles;

		public static MelonPreferences_Entry<bool> DisableMod;

		public static MelonPreferences_Entry<bool> MatchInfoPlates;

		public static MelonPreferences_Entry<bool> MyAltName;

		public static MelonPreferences_Entry<bool> MyBentName;

		public static MelonPreferences_Entry<bool> OtherBentNames;

		public static MelonPreferences_Entry<bool> MyBentTitle;

		public static MelonPreferences_Entry<bool> OtherBentTitles;

		public static MelonPreferences_Entry<bool> Animations;

		public static MelonPreferences_Entry<bool> Images;

		public static MelonPreferences_Category Cat_Advanced;

		public static MelonPreferences_Entry<int> TruncationLength;

		public static MelonPreferences_Entry<int> FieldDepthLimit;

		public static MelonPreferences_Entry<int> ForceVariationAt;

		public static MelonPreferences_Entry<float> MipmapBias;

		public static MelonPreferences_Entry<bool> SaveNamesToFiles;

		public static MelonPreferences_Entry<bool> TrustAllImages;

		public static MelonPreferences_Entry<bool> Disclaimer;

		public static string ConfigFilePath => Path.Combine(Core.UserDataPath, "UIConfig.cfg");

		public static KeyCode RefreshHotkeyCode
		{
			get
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Invalid comparison between Unknown and I4
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				if (!string.IsNullOrEmpty(RefreshHotkey.Value))
				{
					if ((int)_refreshHotkeyCode == 0)
					{
						_refreshHotkeyCode = parseKey(RefreshHotkey.Value);
					}
					return _refreshHotkeyCode;
				}
				return (KeyCode)0;
			}
		}

		public static void SetUpUI()
		{
			Cat_NamePlate = MelonPreferences.CreateCategory("NamePlate", "Name Plate");
			Cat_NamePlate.SetFilePath(ConfigFilePath);
			NameplatePreview = Cat_NamePlate.CreateEntry<bool>("NameplatePreview", false, "Nameplate Preview", "Show a preview of your nameplate on the screen", false, false, (ValueValidator)null, (string)null);
			UI.CreateButtonEntry(Cat_NamePlate, "Refresh", "Refresh Designations", "Update your name and title for everyone", (Action)Core.Instance.UpdateDesignations);
			RefreshHotkey = Cat_NamePlate.CreateEntry<string>("RefreshHotkey", "N", "Refresh Hotkey", "Keyboard button to refresh with\nLeave empty to disable", false, false, (ValueValidator)null, (string)null);
			Cat_SimpleConfig = MelonPreferences.CreateCategory("SimpleConfig", "Simple Config");
			Cat_SimpleConfig.SetFilePath(ConfigFilePath);
			EnableSimpleConfig = Cat_SimpleConfig.CreateEntry<bool>("EnableSimpleConfig", true, "Enable Simple Config", "Enable a simple way to set name, title, and alt text\nSupports Unity rich text tags, such as colors, e.g. <noparse><#F00></noparse>\nAdvanced features such as animations and images will require configuring the .json files in UserData/NameBending", false, false, (ValueValidator)null, (string)null);
			SimpleNameBend = Cat_SimpleConfig.CreateEntry<string>("SimpleNameBend", "", "Custom Bent Name", "When set, your name will appear like this to others who have the mod\nAdvanced features such as animations and images will require configuring the .json files in UserData/NameBending", false, false, (ValueValidator)null, (string)null);
			SimpleTitleBend = Cat_SimpleConfig.CreateEntry<string>("SimpleTitleBend", "", "Custom Bent Title", "When set, your title will appear like this to others who have the mod", false, false, (ValueValidator)null, (string)null);
			SimpleAltText = Cat_SimpleConfig.CreateEntry<string>("SimpleAltText", "", "Alt Text", $"When set, your name will appear like this to others who <b>do not</b> have the mod\nLimited to {71} characters", false, false, (ValueValidator)null, (string)null);
			Cat_Toggles = MelonPreferences.CreateCategory("Toggles", "Toggles");
			Cat_Toggles.SetFilePath(ConfigFilePath);
			DisableMod = Cat_Toggles.CreateEntry<bool>("DisableMod", false, "Disable Mod", "Turn off all name bending", false, false, (ValueValidator)null, (string)null);
			MatchInfoPlates = Cat_Toggles.CreateEntry<bool>("MatchInfoPlates", true, "MatchInfo Plates", "Show nameplates on the MatchInfo mod board", false, false, (ValueValidator)null, (string)null);
			MyAltName = Cat_Toggles.CreateEntry<bool>("MyAltName", true, "My Alt Name", "Enable the name that shows to people who don't have the mod", false, false, (ValueValidator)null, (string)null);
			MyBentName = Cat_Toggles.CreateEntry<bool>("MyBentName", true, "My Bent Name", "Show your custom name to other people", false, false, (ValueValidator)null, (string)null);
			OtherBentNames = Cat_Toggles.CreateEntry<bool>("OtherBentNames", true, "Other Bent Names", "Show other people's custom names", false, false, (ValueValidator)null, (string)null);
			MyBentTitle = Cat_Toggles.CreateEntry<bool>("MyBentTitle", true, "My Bent Title", "Show your custom title to other people", false, false, (ValueValidator)null, (string)null);
			OtherBentTitles = Cat_Toggles.CreateEntry<bool>("OtherBentTitles", true, "Other Bent Titles", "Show other people's custom titles", false, false, (ValueValidator)null, (string)null);
			Animations = Cat_Toggles.CreateEntry<bool>("Animations", true, "Animations", "Show animations in custom names and titles", false, false, (ValueValidator)null, (string)null);
			Images = Cat_Toggles.CreateEntry<bool>("Images", true, "Images", "Enable all nameplate images", false, false, (ValueValidator)null, (string)null);
			Cat_Advanced = MelonPreferences.CreateCategory("Advanced", "Advanced");
			Cat_Advanced.SetFilePath(ConfigFilePath);
			TruncationLength = Cat_Advanced.CreateEntry<int>("TruncationLength", -1, "Truncation Length", "The number of characters to truncate names to\nSet to -1 to disable", false, false, (ValueValidator)null, (string)null);
			FieldDepthLimit = Cat_Advanced.CreateEntry<int>("FieldDepthLimit", 10, "Field Depth Limit", "The amount of times fields are allowed to process other fields within themselves", false, false, (ValueValidator)null, (string)null);
			ForceVariationAt = Cat_Advanced.CreateEntry<int>("ForceVariationAt", -1, "ForceVariationAt", "Always pick the variation at this index\n-1 to disable", false, false, (ValueValidator)null, (string)null);
			MipmapBias = Cat_Advanced.CreateEntry<float>("MipmapBias", -0.5f, "Mipmap Bias", "The mipmap bias of images on nameplates\nLower numbers make clearer images\n(usually between -2.0 and 2.0)", false, false, (ValueValidator)null, (string)null);
			SaveNamesToFiles = Cat_Advanced.CreateEntry<bool>("SaveNamesToFiles", false, "Save Names to Files", "Save every name and title you come across to files in\nUserdata/NameBending/saved_names", false, false, (ValueValidator)null, (string)null);
			TrustAllImages = Cat_Advanced.CreateEntry<bool>("TrustAllImages", false, "<#F00><b>TRUST ALL IMAGES", "<b><#F00>Disable moderation features by automatically trusting images that have not been manually approved by moderators\nRequires accepting the disclaimer below", false, false, (ValueValidator)null, (string)null);
			Disclaimer = Cat_Advanced.CreateEntry<bool>("Disclaimer", false, "Accept Disclaimer", "I understand that by disabling moderation features, other users can subject me to any image on the internet. These images may be graphic, NSFW, offensive, triggering to photosensitivity, or otherwise unwanted.", false, false, (ValueValidator)null, (string)null);
			UI.CreateButtonEntry(Cat_Advanced, "Clear", "Clear Image Cache", "Remove any stored data about existing and previous nameplate images", (Action)Core.ClearImageCache);
			Me = UI.RegisterMelon((MelonBase)(object)Core.Instance, (MelonPreferences_Category[])(object)new MelonPreferences_Category[4] { Cat_NamePlate, Cat_SimpleConfig, Cat_Toggles, Cat_Advanced });
			((ModModelBase)Me).OnModSaved += OnPrefsSaved;
		}

		public static void OnPrefsSaved()
		{
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			MatchInfoBoard.SetMatchInfo(MatchInfoPlates.Value);
			Core.Instance.SetPlatePreview(NameplatePreview.Value);
			if (DisableMod.Value)
			{
				foreach (NameBend nameBend in Core.Instance.NameBends)
				{
					nameBend.ResetAll();
				}
			}
			if (!MyBentName.Value || DisableMod.Value)
			{
				foreach (NameBend nameBend2 in Core.Instance.NameBends)
				{
					if (!((Object)(object)nameBend2 == (Object)null) && nameBend2.DesignationType == Core.DesignationType.Name && nameBend2.IsLocal)
					{
						nameBend2.ResetAll();
					}
				}
			}
			if (!MyBentName.Value || DisableMod.Value)
			{
				foreach (NameBend nameBend3 in Core.Instance.NameBends)
				{
					if (!((Object)(object)nameBend3 == (Object)null) && nameBend3.DesignationType == Core.DesignationType.Name && !nameBend3.IsLocal)
					{
						nameBend3.ResetAll();
					}
				}
			}
			if (!MyBentName.Value || DisableMod.Value)
			{
				foreach (NameBend nameBend4 in Core.Instance.NameBends)
				{
					if (!((Object)(object)nameBend4 == (Object)null) && nameBend4.DesignationType == Core.DesignationType.Title && nameBend4.IsLocal)
					{
						nameBend4.ResetAll();
					}
				}
			}
			if (!MyBentName.Value || DisableMod.Value)
			{
				foreach (NameBend nameBend5 in Core.Instance.NameBends)
				{
					if (!((Object)(object)nameBend5 == (Object)null) && nameBend5.DesignationType == Core.DesignationType.Title && !nameBend5.IsLocal)
					{
						nameBend5.ResetAll();
					}
				}
			}
			if (EnableSimpleConfig.Value && SimpleAltText.Value.Length > 71)
			{
				Debug.Error($"Alt text cannot be more than {71} characters");
			}
			if (!Images.Value || DisableMod.Value)
			{
				foreach (BentImage bentImage in Core.Instance.BentImages)
				{
					if (!((Object)(object)bentImage == (Object)null))
					{
						bentImage.ImageInfo.UndownloadImage();
						bentImage.Reset();
					}
				}
			}
			_refreshHotkeyCode = (KeyCode)0;
			if (ForceVariationAt.Value != prevForceVariation)
			{
				Core.Instance.UpdateDesignations();
			}
			prevForceVariation = ForceVariationAt.Value;
			foreach (BentImage bentImage2 in Core.Instance.BentImages)
			{
				if (!((Object)(object)bentImage2 == (Object)null))
				{
					bentImage2.SetMipmapBias(MipmapBias.Value);
				}
			}
			if (prevTrustAll != (TrustAllImages.Value && Disclaimer.Value))
			{
				Core.ClearImageCache();
			}
			prevTrustAll = TrustAllImages.Value && Disclaimer.Value;
			if (TrustAllImages.Value && Disclaimer.Value)
			{
				foreach (BentImage bentImage3 in Core.Instance.BentImages)
				{
					if (!((Object)(object)bentImage3 == (Object)null))
					{
						bentImage3.Uncensor();
					}
				}
			}
			else
			{
				foreach (BentImage bentImage4 in Core.Instance.BentImages)
				{
					if (!((Object)(object)bentImage4 == (Object)null))
					{
						bentImage4.CensorIfNeeded();
					}
				}
			}
			if ((!prevDisableMod || DisableMod.Value) && (prevBentName || !MyBentName.Value) && (prevBentTitle || !MyBentTitle.Value) && (prevImages || !Images.Value))
			{
				return;
			}
			foreach (NameBend nameBend6 in Core.Instance.NameBends)
			{
				nameBend6.OnUpdateDesignations();
			}
		}

		private static KeyCode parseKey(string key)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<KeyCode>(key, ignoreCase: true, out KeyCode result))
			{
				return result;
			}
			return (KeyCode)0;
		}
	}
	public static class BuildInfo
	{
		public const string Name = "NameBending";

		public const string Author = "TacoSlayer36";

		public const string Version = "2.0.2";

		public const string Description = "Change your name and title to anything you like";
	}
	public class Core : MelonMod
	{
		public enum DesignationType
		{
			Name,
			Title
		}

		[HarmonyPatch(typeof(PlayerController), "Initialize", new Type[] { typeof(Player) })]
		public static class playerspawn
		{
			private static void Postfix(ref PlayerController __instance, ref Player player)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Invalid comparison between Unknown and I4
				bool isLocal = (int)player.Controller.controllerType == 1;
				Instance.ApplyComponentsToPlate(player, isPlayer: true, isLocal, isUI: false);
			}
		}

		[HarmonyPatch(typeof(PlayerNameTag), "ChangeOpacity", new Type[] { typeof(float) })]
		public static class nametagopacity
		{
			private static void Postfix(ref PlayerNameTag __instance, ref float alpha)
			{
				foreach (NameBend componentsInChild in ((Component)__instance).GetComponentsInChildren<NameBend>())
				{
					if (!((Object)(object)componentsInChild != (Object)null) || componentsInChild.IsScreenSpace)
					{
						continue;
					}
					foreach (BentImage bentImage in componentsInChild.BentImages)
					{
						bentImage.SetOpacity(alpha);
					}
				}
			}
		}

		public static Core Instance;

		private bool globalInit = false;

		public static string CurrentScene = "Loader";

		public const byte EventNumber = 31;

		public bool EventRaised = false;

		public static string OpponentPhotonName = null;

		public static string OpponentPhotonTitle = null;

		public GameObject ModParent;

		public GameObject localNameplateImageObject;

		public GameObject LocalNameplateClone;

		public RawImage LocalRawNameplateImage;

		public GameObject CanvasObject;

		public static readonly HttpClient _http = new HttpClient();

		public const int AltTextCharLimit = 71;

		private string nameConfigFileName = "CustomBentName";

		private string titleConfigFileName = "CustomBentTitle";

		public bool HasNameConfigFile = false;

		public bool HasTitleConfigFile = false;

		public const int FloatingPointPrecision = 5;

		public const string FieldPattern = "{([\\da-zA-Z_\\-|.#]+)(=[^}]+)?}";

		public Root NameRoot = null;

		public Root TitleRoot = null;

		public Variation ActiveNameVariation = null;

		public Variation ActiveTitleVariation = null;

		private int nameVariationIndex = 0;

		private int titleVariationIndex = 0;

		public Dictionary<PlayerController, string> DesignationsHashes = new Dictionary<PlayerController, string>();

		public List<NameBend> NameBends = new List<NameBend>();

		public List<BentImage> BentImages = new List<BentImage>();

		private bool shownNoNameFileWarning = false;

		private bool shownNoTitleFileWarning = false;

		private bool shownNameTemplateWarning = false;

		private bool shownTitleTemplateWarning = false;

		private bool shownLowFrameDurationWarning = false;

		private long lastDesignationUpdate = 0L;

		public List<TMP_FontAsset> CachedFontAssets = new List<TMP_FontAsset>();

		public Shader CachedImageShader;

		public List<FrameData> CachedLoadingFrames;

		public Texture2D CachedCensoredTexture;

		public Texture2D CachedLoadingTexture;

		public Texture2D CachedFailedTexture;

		public Dictionary<string, List<FrameData>> CachedImages = new Dictionary<string, List<FrameData>>();

		public GameObject PlatePreviewCanvas;

		public static bool IsInMatch => CurrentScene.StartsWith("Map") && ((Il2CppArrayBase<Player>)(object)PhotonNetwork.PlayerList).Count == 2;

		public static string UserDataPath => Path.Combine("UserData", "NameBending");

		public string MyDesignationsHash
		{
			get
			{
				string s = ActiveNameVariation?.GetJsonPropertiesHashCode() + ActiveTitleVariation?.GetJsonPropertiesHashCode();
				byte[] bytes = Encoding.UTF8.GetBytes(s);
				byte[] inArray = SHA256.HashData(bytes);
				return Convert.ToHexString(inArray).Substring(0, 9);
			}
		}

		public event Action OnUpdateDesignations;

		public IEnumerator ApplyComponentsToPlate(GameObject plate, Player player, bool isPlayer, bool isLocal, bool isUI)
		{
			PlayerNameTag nameTag = plate.GetComponent<PlayerNameTag>();
			nameTag.RefreshNameTag();
			foreach (TextMeshPro tmp in plate.GetComponentsInChildren<TextMeshPro>())
			{
				((TMP_Text)tmp).fontStyle = (FontStyles)0;
				((TMP_Text)tmp).characterSpacing = 0f;
			}
			MelonCoroutines.Start(applyWhenAble(DesignationType.Name));
			MelonCoroutines.Start(applyWhenAble(DesignationType.Title));
			IEnumerator applyWhenAble(DesignationType type)
			{
				if (!isLocal)
				{
					Player photonOwner = null;
					int tries = 0;
					while (tries++ < 20)
					{
						Player obj = photonOwner;
						if (((obj != null) ? obj.CustomProperties : null) != null || (type == DesignationType.Name && !string.IsNullOrEmpty(OpponentPhotonName)) || (type == DesignationType.Title && !string.IsNullOrEmpty(OpponentPhotonTitle)))
						{
							break;
						}
						foreach (Player photonPlayer in (Il2CppArrayBase<Player>)(object)PhotonNetwork.PlayerList)
						{
							Player obj2 = player;
							short? obj3;
							if (obj2 == null)
							{
								obj3 = null;
							}
							else
							{
								PlayerData data = obj2.Data;
								if (data == null)
								{
									obj3 = null;
								}
								else
								{
									GeneralData generalData = data.GeneralData;
									obj3 = ((generalData != null) ? new short?(generalData.actorNo) : ((short?)null));
								}
							}
							if (obj3 == photonPlayer.ActorNumber)
							{
								photonOwner = photonPlayer;
								break;
							}
						}
						yield return (object)new WaitForSeconds(0.25f);
					}
				}
				int childIndex = ((type != DesignationType.Name) ? 2 : 0);
				NameBend component = ((Component)plate.transform.GetChild(childIndex)).gameObject.AddComponent<NameBend>();
				component.IsLocal = isLocal;
				component.IsPlayer = isPlayer;
				component.IsScreenSpace = isUI;
				component.DesignationType = type;
				component.Owner = player;
				component.ApplyImages();
				Instance.NameBends.Add(component);
			}
		}

		public void ApplyComponentsToPlate(Player player, bool isPlayer, bool isLocal, bool isUI)
		{
			GameObject gameObject = ((Component)player.Controller.PlayerNameTag).gameObject;
			MelonCoroutines.Start(ApplyComponentsToPlate(gameObject, player, isPlayer, isLocal, isUI));
		}

		public Variation PickVariation(Root root, DesignationType designationType)
		{
			if (root == null)
			{
				return null;
			}
			Variation variation = null;
			if (root.DoRandomVariations)
			{
				Random random = new Random();
				double num = root.Variations.Sum((Variation v) => v.GetWeightFromString());
				double num2 = random.NextDouble() * num;
				double num3 = 0.0;
				Variation variation2 = null;
				foreach (Variation variation3 in root.Variations)
				{
					num3 += variation3.GetWeightFromString();
					if (num2 <= num3)
					{
						variation2 = variation3;
						break;
					}
				}
				variation = variation2;
			}
			else
			{
				if (designationType == DesignationType.Name)
				{
					variation = root.Variations[nameVariationIndex = (nameVariationIndex + 1) % root.Variations.Count];
				}
				if (designationType == DesignationType.Title)
				{
					variation = root.Variations[titleVariationIndex = (titleVariationIndex + 1) % root.Variations.Count];
				}
			}
			if (Config.ForceVariationAt.Value >= 0 && Config.ForceVariationAt.Value < root.Variations.Count)
			{
				variation = root.Variations[Config.ForceVariationAt.Value];
			}
			if (variation == null)
			{
				return null;
			}
			variation.DesignationType = ((designationType == DesignationType.Name) ? "Name" : "Title");
			variation.Owner = Singleton<PlayerManager>.Instance.LocalPlayer;
			return variation;
		}

		public override void OnLateInitializeMelon()
		{
			Instance = this;
			Config.SetUpUI();
			loadFonts();
			loadShader();
			readDesignationFiles();
		}

		public override void OnSceneWasUnloaded(int buildIndex, string sceneName)
		{
			EventRaised = false;
			OpponentPhotonName = null;
			OpponentPhotonTitle = null;
			Object.Destroy((Object)(object)MatchInfoBoard.PlateClone1);
			Object.Destroy((Object)(object)MatchInfoBoard.PlateClone2);
			MelonCoroutines.Start(listenForLandButton("FlatLand"));
			MelonCoroutines.Start(listenForLandButton("VoidLand"));
			IEnumerator listenForLandButton(string landType)
			{
				yield return (object)new WaitForSeconds(3f);
				GameObject obj = GameObject.Find(landType);
				if (obj != null)
				{
					obj.GetComponentInChildren<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
					{
						MelonCoroutines.Start(OnLandEntered());
					}));
				}
			}
		}

		private IEnumerator OnLandEntered()
		{
			yield return (object)new WaitForSeconds(1.5f);
			GameObject modParent = ModParent;
			if (modParent != null)
			{
				modParent.SetActive(true);
			}
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			CurrentScene = sceneName;
			if (sceneName == "Gym")
			{
				if (!globalInit)
				{
					globalInit = true;
					Config.OnPrefsSaved();
				}
				GameObject gameObject = NameTag.GetGameObject();
				MelonCoroutines.Start(ApplyComponentsToPlate(gameObject, Singleton<PlayerManager>.Instance.LocalPlayer, isPlayer: false, isLocal: true, isUI: false));
			}
			if (buildIndex >= 3)
			{
				if ((Object)(object)MatchInfoBoard.Board == (Object)null)
				{
					MelonCoroutines.Start(MatchInfoBoard.FindMatchInfoBoard(callback));
				}
				else
				{
					callback();
				}
			}
			if (globalInit)
			{
				MelonCoroutines.Start(_());
			}
			IEnumerator _()
			{
				yield return (object)new WaitForSeconds(0.5f);
				readDesignationFiles();
				UpdateDesignations();
			}
			static void callback()
			{
				MelonCoroutines.Start(MatchInfoBoard.SetUpMatchInfo());
			}
		}

		public override void OnUpdate()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (globalInit && Input.GetKeyDown(Config.RefreshHotkeyCode))
			{
				readDesignationFiles();
				UpdateDesignations();
			}
		}

		public void UpdateDesignations()
		{
			long num = 3000 - (DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() - lastDesignationUpdate);
			if (num > 0 && PhotonNetwork.InRoom)
			{
				Debug.Error("Please wait " + Mathf.Round((float)(num / 1000)).ToString("0") + " seconds before updating your name again");
				return;
			}
			if (globalInit)
			{
				string message = "Updating your name and title...";
				if (Instance.HasNameConfigFile && !Instance.HasTitleConfigFile)
				{
					message = "Updating your name...";
				}
				if (!Instance.HasNameConfigFile && Instance.HasTitleConfigFile)
				{
					message = "Updating your title...";
				}
				if (!Instance.HasNameConfigFile && !Instance.HasTitleConfigFile)
				{
					message = "Nothing to update";
				}
				Debug.Log(message);
			}
			if (NameRoot != null && Config.MyBentName.Value && !Config.DisableMod.Value)
			{
				ActiveNameVariation = PickVariation(NameRoot, DesignationType.Name);
			}
			else
			{
				ActiveNameVariation = null;
			}
			if (TitleRoot != null && Config.MyBentTitle.Value && !Config.DisableMod.Value)
			{
				ActiveTitleVariation = PickVariation(TitleRoot, DesignationType.Title);
			}
			else
			{
				ActiveTitleVariation = null;
			}
			if (ActiveTitleVariation != null)
			{
				ActiveTitleVariation.MarkTitleCounterfeit();
			}
			string text = Singleton<PlayerManager>.Instance.LocalPlayer.Data.GeneralData.PublicUsername;
			if (Config.EnableSimpleConfig.Value && !string.IsNullOrEmpty(Config.SimpleAltText.Value))
			{
				text = Config.SimpleAltText.Value;
			}
			else if (ActiveNameVariation != null)
			{
				text = ActiveNameVariation.AltText;
			}
			if (Config.MyAltName.Value && !string.IsNullOrWhiteSpace(text) && text.Length <= 71)
			{
				Singleton<PlayerManager>.Instance.LocalPlayer.Data.GeneralData.PublicUsername = text;
			}
			if (text.Length > 71)
			{
				Debug.Error($"Alt text cannot be more than {71} characters");
			}
			if (PhotonNetwork.InRoom)
			{
				MelonCoroutines.Start(AddLocalProp("Name", GetVariationString(ActiveNameVariation)));
				MelonCoroutines.Start(AddLocalProp("Title", GetVariationString(ActiveTitleVariation)));
				MelonCoroutines.Start(AddLocalProp("HashCode", MyDesignationsHash));
			}
			lastDesignationUpdate = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
			this.OnUpdateDesignations?.Invoke();
		}

		public string GetVariationString(Variation variation)
		{
			if (variation == null)
			{
				return "None";
			}
			if (variation.DesignationType == "Name" && Config.EnableSimpleConfig.Value && !string.IsNullOrEmpty(Config.SimpleNameBend.Value))
			{
				return "{\"frames\":{\"0\":\"" + Config.SimpleNameBend.Value + "\"}}";
			}
			if (variation.DesignationType == "Title" && Config.EnableSimpleConfig.Value && !string.IsNullOrEmpty(Config.SimpleTitleBend.Value))
			{
				return "{\"frames\":{\"0\":\"" + Config.SimpleTitleBend.Value + "\"}}";
			}
			return variation.SerializedJson;
		}

		public string GetVariationHash(Variation variation)
		{
			if (variation == null)
			{
				return "";
			}
			if (variation.DesignationType == "Name" && Config.EnableSimpleConfig.Value && !string.IsNullOrEmpty(Config.SimpleNameBend.Value))
			{
				byte[] bytes = Encoding.UTF8.GetBytes(Config.SimpleNameBend.Value);
				byte[] inArray = SHA256.HashData(bytes);
				return Convert.ToHexString(inArray).Substring(0, 9);
			}
			if (variation.DesignationType == "Title" && Config.EnableSimpleConfig.Value && !string.IsNullOrEmpty(Config.SimpleTitleBend.Value))
			{
				byte[] bytes2 = Encoding.UTF8.GetBytes(Config.SimpleTitleBend.Value);
				byte[] inArray2 = SHA256.HashData(bytes2);
				return Convert.ToHexString(inArray2).Substring(0, 9);
			}
			return variation.GetJsonPropertiesHashCode();
		}

		public static void ClearImageCache()
		{
			Instance.CachedImages.Clear();
			Debug.Log("Cleared image cache");
		}

		private void readDesignationFiles()
		{
			readDesignationFile(DesignationType.Name);
			readDesignationFile(DesignationType.Title);
		}

		private void readDesignationFile(DesignationType type)
		{
			//IL_00a3: Expected O, but got Unknown
			//IL_0113: Expected O, but got Unknown
			string empty = string.Empty;
			switch (type)
			{
			case DesignationType.Name:
				empty = nameConfigFileName;
				break;
			case DesignationType.Title:
				empty = titleConfigFileName;
				break;
			}
			string text = Path.Combine(UserDataPath, empty);
			string path = text + ".json";
			string path2 = text + "TEMPLATE.json";
			if (File.Exists(path))
			{
				switch (type)
				{
				case DesignationType.Name:
					HasNameConfigFile = true;
					try
					{
						NameRoot = deserializeFile(DesignationType.Name);
						if (NameRoot != null)
						{
							NameRoot.Type = DesignationType.Name;
						}
					}
					catch (JsonException ex4)
					{
						JsonException ex5 = ex4;
						((MelonBase)this).LoggerInstance.Error(((Exception)(object)ex5).Message);
						((MelonBase)this).LoggerInstance.Error("Make sure your JSON is formatted correctly");
					}
					break;
				case DesignationType.Title:
					HasTitleConfigFile = true;
					try
					{
						TitleRoot = deserializeFile(DesignationType.Title);
						if (TitleRoot != null)
						{
							TitleRoot.Type = DesignationType.Title;
						}
					}
					catch (JsonException ex)
					{
						JsonException ex2 = ex;
						((MelonBase)this).LoggerInstance.Error(((Exception)(object)ex2).Message);
						((MelonBase)this).LoggerInstance.Error("Make sure your JSON is formatted correctly");
					}
					catch (FileNotFoundException)
					{
						((MelonBase)this).LoggerInstance.Error("Bent title config file not found");
					}
					break;
				}
			}
			else
			{
				switch (type)
				{
				case DesignationType.Name:
					HasNameConfigFile = false;
					if (!shownNoNameFileWarning)
					{
						Debug.Log("No bent name file found; name will not be bent");
						NameRoot = null;
					}
					break;
				case DesignationType.Title:
					HasTitleConfigFile = false;
					if (!shownNoTitleFileWarning)
					{
						Debug.Log("No bent title file found; title will not be bent");
						TitleRoot = null;
					}
					break;
				}
			}
			if (File.Exists(path2))
			{
				if (type == DesignationType.Name && !shownNameTemplateWarning && NameRoot == null)
				{
					shownNameTemplateWarning = true;
					((MelonBase)this).LoggerInstance.Warning("TEMPLATE file detected for bent name");
				}
				else if (type == DesignationType.Title && !shownTitleTemplateWarning && TitleRoot == null)
				{
					shownTitleTemplateWarning = true;
					((MelonBase)this).LoggerInstance.Warning("TEMPLATE file detected for bent title");
				}
				if (shownNameTemplateWarning || shownTitleTemplateWarning)
				{
					((MelonBase)this).LoggerInstance.Warning("Don't forget to remove TEMPLATE from your config files");
				}
			}
		}

		private Root deserializeFile(DesignationType type)
		{
			//IL_00c0: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			string text = ((type == DesignationType.Name) ? "Name" : "Title");
			if (type == DesignationType.Name && !HasNameConfigFile)
			{
				return null;
			}
			if (type == DesignationType.Title && !HasTitleConfigFile)
			{
				return null;
			}
			Root root = new Root();
			string text2 = string.Empty;
			switch (type)
			{
			case DesignationType.Name:
				text2 = File.ReadAllText(Path.Combine(UserDataPath, nameConfigFileName + ".json"));
				break;
			case DesignationType.Title:
				text2 = File.ReadAllText(Path.Combine(UserDataPath, titleConfigFileName + ".json"));
				break;
			}
			try
			{
				root = JsonConvert.DeserializeObject<Root>(text2);
			}
			catch (JsonException ex)
			{
				JsonException ex2 = ex;
				throw new JsonException("Error deserializing bent " + text + " config file: " + ((Exception)(object)ex2).Message);
			}
			if (!shownLowFrameDurationWarning)
			{
				foreach (Variation variation in root.Variations)
				{
					if (variation.FrameDuration > 0 && variation.FrameDuration < 20)
					{
						((MelonBase)this).LoggerInstance.Warning($"Frame duration ({variation.FrameDuration} in {text} config) is lower than 20ms; some frames may be skipped");
						shownLowFrameDurationWarning = true;
					}
				}
			}
			return root;
		}

		private void loadFonts()
		{
			if (CachedFontAssets.Count > 0)
			{
				return;
			}
			List<TMP_FontAsset> list = new List<TMP_FontAsset>();
			try
			{
				foreach (string item in new List<string>
				{
					"Arial", "ChineseRocks", "ComicSans", "Crumble", "GoodDogPlain", "Impact", "Minecraft", "Roboto", "SGA", "TimesNewRoman",
					"Tumble", "TokiPona", "Avasinistral", "Wingdings", "Papyrus", "Cascadia", "Hollywood", "HighwayGothic"
				})
				{
					Font val = AssetBundles.LoadAssetFromStream<Font>((MelonMod)(object)this, "NameBending.assets.namebending", item);
					TMP_FontAsset val2 = TMP_FontAsset.CreateFontAsset(val);
					((Object)val2).hideFlags = (HideFlags)61;
					((Object)val2).name = item;
					list.Add(val2);
				}
				CachedFontAssets = list;
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Error("Error loading fonts: " + ex.Message);
			}
			try
			{
				CachedLoadingTexture = AssetBundles.LoadAssetFromStream<Texture2D>((MelonMod)(object)this, "NameBending.assets.namebending", "LoadingTexture");
				CachedCensoredTexture = AssetBundles.LoadAssetFromStream<Texture2D>((MelonMod)(object)this, "NameBending.assets.namebending", "CensoredTexture");
				CachedFailedTexture = AssetBundles.LoadAssetFromStream<Texture2D>((MelonMod)(object)this, "NameBending.assets.namebending", "FailedTexture");
				CachedLoadingFrames = HelperFunctions.ConvertGifToList(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)AssetBundles.LoadAssetFromStream<TextAsset>((MelonMod)(object)this, "NameBending.assets.namebending", "LoadingGif").bytes));
				((Object)CachedLoadingTexture).hideFlags = (HideFlags)61;
				((Object)CachedCensoredTexture).hideFlags = (HideFlags)61;
				((Object)CachedFailedTexture).hideFlags = (HideFlags)61;
				foreach (FrameData cachedLoadingFrame in CachedLoadingFrames)
				{
					((Object)cachedLoadingFrame.Texture).hideFlags = (HideFlags)61;
					cachedLoadingFrame.HolderList = CachedLoadingFrames;
				}
			}
			catch (Exception ex2)
			{
				((MelonBase)this).LoggerInstance.Error("Error loading built-in textures: " + ex2.Message);
			}
			CachedFontAssets = list;
		}

		private void loadShader()
		{
			Shader val = AssetBundles.LoadAssetFromStream<Shader>((MelonMod)(object)this, "NameBending.assets.namebending", "SimpleRGBA");
			((Object)val).hideFlags = (HideFlags)61;
			CachedImageShader = val;
		}

		public IEnumerator AddLocalProp(string type, string text)
		{
			if (!PhotonNetwork.InRoom)
			{
				yield break;
			}
			if (!Instance.EventRaised && IsInMatch)
			{
				_ = "NameBending." + type.Substring(0, 1) + "|" + text;
				Instance.EventRaised = true;
			}
			Player local = null;
			int tries = 0;
			while (local == null)
			{
				if (tries > 300)
				{
					((MelonBase)this).LoggerInstance.Error("Failed to get local Photon player");
					yield break;
				}
				PlayerManager instance = Singleton<PlayerManager>.Instance;
				local = HelperFunctions.FindPhotonPlayerFromRumblePlayer((instance != null) ? instance.LocalPlayer : null);
				if (local == null)
				{
					yield return (object)new WaitForSeconds(0.2f);
					tries++;
				}
			}
			Hashtable prop = new Hashtable();
			prop[Object.op_Implicit("NameBending." + type)] = Object.op_Implicit(text);
			local.SetCustomProperties(prop, (Hashtable)null, (WebFlags)null);
		}

		public IEnumerator AddLocalProp(string type, Variation variation)
		{
			MelonCoroutines.Start(AddLocalProp(type, variation?.SerializedJson ?? "None"));
			yield break;
		}

		public void EventReceived(EventData photonEvent)
		{
			if (photonEvent.Code == 31 && photonEvent.CustomData.ToString().StartsWith("NameBending."))
			{
				string text = photonEvent.CustomData.ToString().Substring(12, 1);
				string text2 = photonEvent.CustomData.ToString().Substring(14);
				if (text == "N")
				{
					OpponentPhotonName = text2;
				}
				else if (text == "T")
				{
					OpponentPhotonTitle = text2;
				}
			}
		}

		public void CreatePlatePreview()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Expected O, but got Unknown
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ModParent == (Object)null)
			{
				ModParent = new GameObject("NameBending");
			}
			CanvasObject = new GameObject("NameplateCanvas");
			CanvasObject.transform.SetParent(ModParent.transform);
			Canvas val = CanvasObject.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			CanvasScaler val2 = CanvasObject.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.screenMatchMode = (ScreenMatchMode)0;
			val2.matchWidthOrHeight = 0.5f;
			CanvasObject.AddComponent<GraphicRaycaster>();
			localNameplateImageObject = new GameObject("LocalNameplateImage");
			localNameplateImageObject.transform.SetParent(CanvasObject.transform, false);
			RawImage val3 = localNameplateImageObject.AddComponent<RawImage>();
			float num = (float)Mathf.Min(Screen.width, Screen.height) / 1.5f;
			RectTransform component = localNameplateImageObject.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(1f, 1f);
			component.anchoredPosition = new Vector2(-10f, 200f);
			component.sizeDelta = new Vector2(num, num);
			GameObject val4 = new GameObject("LocalNameplateCamera");
			val4.transform.SetParent(ModParent.transform);
			Camera val5 = val4.AddComponent<Camera>();
			val5.clearFlags = (CameraClearFlags)2;
			val5.backgroundColor = new Color(0f, 0f, 0f, 0f);
			val5.cullingMask = LayerMask.GetMask(new string[1] { "UI" });
			RenderTexture val6 = new RenderTexture(900, 900, 16);
			val6.Create();
			val5.targetTexture = val6;
			val5.orthographic = false;
			((Component)val5).transform.position = new Vector3(0f, -1000f, 1f);
			((Component)val5).transform.rotation = Quaternion.Euler(0f, 180f, 0f);
			LocalRawNameplateImage = localNameplateImageObject.GetComponent<RawImage>();
			LocalRawNameplateImage.texture = (Texture)(object)val6;
			if ((Object)(object)LocalNameplateClone == (Object)null)
			{
				GameObject gameObject = ((Component)((Component)Singleton<PlayerManager>.Instance.LocalPlayer.Controller).transform.Find("NameTag")).gameObject;
				LocalNameplateClone = CloneNameplate(gameObject, isUI: true);
				LocalNameplateClone.transform.SetParent(ModParent.transform);
				LocalNameplateClone.active = true;
				LocalNameplateClone.transform.position = new Vector3(0f, -1000f, 0f);
			}
		}

		public GameObject CloneNameplate(GameObject nameplate, bool isUI = false)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Invalid comparison between Unknown and I4
			GameObject val = Object.Instantiate<GameObject>(nameplate);
			val.SetActive(true);
			PlayerNameTag component = val.GetComponent<PlayerNameTag>();
			if ((Object)(object)((PlayerControllerSubsystem)component).parentController == (Object)null)
			{
				((PlayerControllerSubsystem)component).parentController = nameplate.GetComponentInParent<PlayerController>();
			}
			if ((Object)(object)((PlayerControllerSubsystem)component).parentController == (Object)null)
			{
				((PlayerControllerSubsystem)component).parentController = ((Component)component.followTarget).GetComponentInParent<PlayerController>();
			}
			if ((Object)(object)((PlayerControllerSubsystem)component).parentController == (Object)null)
			{
				((PlayerControllerSubsystem)component).parentController = Singleton<PlayerManager>.Instance.LocalPlayer.Controller;
			}
			PlayerController parentController = ((PlayerControllerSubsystem)component).parentController;
			bool isLocal = (int)parentController.controllerType == 1;
			component.followTarget = null;
			component.ChangeOpacity(1f);
			component.RefreshNameTag();
			foreach (NameBend componentsInChild in val.GetComponentsInChildren<NameBend>())
			{
				componentsInChild.ResetAll();
				Object.DestroyImmediate((Object)(object)componentsInChild);
			}
			MelonCoroutines.Start(Instance.ApplyComponentsToPlate(val, parentController.assignedPlayer, isPlayer: false, isLocal, isUI));
			if (isUI)
			{
				foreach (Transform componentsInChild2 in val.GetComponentsInChildren<Transform>())
				{
					((Component)componentsInChild2).gameObject.layer = LayerMask.NameToLayer("UI");
				}
			}
			return val;
		}

		public void SetPlatePreview(bool enabled)
		{
			if (globalInit)
			{
				if (Config.DisableMod.Value)
				{
					enabled = false;
				}
				MelonCoroutines.Start(_());
			}
			IEnumerator _()
			{
				while (true)
				{
					PlayerManager instance = Singleton<PlayerManager>.Instance;
					object obj;
					if (instance == null)
					{
						obj = null;
					}
					else
					{
						Player localPlayer = instance.LocalPlayer;
						obj = ((localPlayer != null) ? localPlayer.Controller : null);
					}
					if (!((Object)obj == (Object)null))
					{
						break;
					}
					yield return (object)new WaitForSeconds(0.25f);
				}
				if ((Object)(object)CanvasObject == (Object)null && enabled)
				{
					CreatePlatePreview();
				}
				if ((Object)(object)CanvasObject != (Object)null)
				{
					CanvasObject.SetActive(enabled);
					foreach (NameBend component in LocalNameplateClone.GetComponentsInChildren<NameBend>())
					{
						component.OnUpdateDesignations();
					}
				}
			}
		}
	}
	internal static class Debug
	{
		public static bool debugMode = false;

		private static string lastDiffLogMessage = string.Empty;

		internal static void DiffLog(string message, bool debugOnly = true, int logLevel = 0)
		{
			if (message != lastDiffLogMessage)
			{
				lastDiffLogMessage = message;
				Log("DIFFLOG: " + message, debugOnly, logLevel);
			}
		}

		internal static void Log(string message, bool debugOnly = false, int logLevel = 0)
		{
			if (!(!debugMode && debugOnly))
			{
				switch (logLevel)
				{
				case 1:
					Melon<Core>.Logger.Warning(message);
					break;
				case 2:
					Melon<Core>.Logger.Error(message);
					break;
				default:
					Melon<Core>.Logger.Msg(message);
					break;
				}
			}
		}

		internal static void Deb(string message)
		{
			Log(message, debugOnly: true);
		}

		internal static void Msg(string message)
		{
			Log(message);
		}

		internal static void Warning(string message)
		{
			Log(message, debugOnly: false, 1);
		}

		internal static void Error(string message)
		{
			Log(message, debugOnly: false, 2);
		}
	}
	public class TypedField
	{
		public enum FieldType
		{
			Boolean,
			Number,
			String,
			Color,
			Referential
		}

		public enum FormatType
		{
			None,
			SigFigs,
			Round,
			Hex
		}

		public NameBend OwnerComponent;

		public static ReadOnlyCollection<string> FactoryFields = new List<string> { "RANDOM", "INSTANCE_RANDOM", "FRAME_PROGRESS", "LOOP_PROGRESS", "FRAME", "TIMER" }.AsReadOnly();

		public string Identifier;

		public int DefinitionIndex = 0;

		public int InstanceIndexTracker = 0;

		public FieldType CurrentFieldType;

		public FormatType CurrentFormatType;

		public