using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Utilities;
using Il2CppTMPro;
using MatchInfo;
using MelonLoader;
using RumbleModUI;
using RumbleModdingAPI;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Main), "MatchInfo", "2.4.0", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 195, 0, 255)]
[assembly: MelonAuthorColor(255, 195, 0, 255)]
[assembly: VerifyLoaderVersion(0, 6, 6, true)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("MatchInfo")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MatchInfo")]
[assembly: AssemblyTitle("MatchInfo")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MatchInfo;

public static class BuildInfo
{
	public const string ModName = "MatchInfo";

	public const string ModVersion = "2.4.0";

	public const string Author = "UlvakSkillz";
}
public class Main : MelonMod
{
	[CompilerGenerated]
	private sealed class <MatchStarted>d__51 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Main <>4__this;

		private bool <won>5__1;

		private string <winOrLose>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <MatchStarted>d__51(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<winOrLose>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			case 2:
				<>1__state = -1;
				break;
			}
			if (<>4__this.matchActive)
			{
				if (!<>4__this.ranWinLoss && Singleton<PlayerManager>.instance.AllPlayers.Count == 2 && <>4__this.MatchSlabOne.activeSelf)
				{
					<won>5__1 = false;
					<winOrLose>5__2 = "Unlocalized Entry!";
					if (Players.IsHost())
					{
						Log("Host");
						<winOrLose>5__2 = ((TMP_Text)<>4__this.Slab1Text).text;
					}
					else
					{
						Log("Client");
						<winOrLose>5__2 = ((TMP_Text)<>4__this.Slab2Text).text;
					}
					if (<winOrLose>5__2 == "Unlocalized Entry!")
					{
						<>2__current = (object)new WaitForFixedUpdate();
						<>1__state = 1;
						return true;
					}
					if (<winOrLose>5__2 == "Victory!")
					{
						Log("Win");
						<won>5__1 = true;
					}
					else
					{
						Log("Lose");
						<won>5__1 = false;
					}
					if (<won>5__1)
					{
						<>4__this.fileText[<>4__this.playerFileSpot + 1] = (int.Parse(<>4__this.fileText[<>4__this.playerFileSpot + 1]) + 1).ToString();
						((TMP_Text)player2MatchWinsComponent).text = <>4__this.fileText[<>4__this.playerFileSpot + 1] + " Wins";
					}
					else
					{
						<>4__this.fileText[<>4__this.playerFileSpot + 2] = (int.Parse(<>4__this.fileText[<>4__this.playerFileSpot + 2]) + 1).ToString();
						((TMP_Text)player1MatchWinsComponent).text = <>4__this.fileText[<>4__this.playerFileSpot + 2] + " Wins";
					}
					((TMP_Text)player2BPComponent).text = Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.BattlePoints + " BP";
					((TMP_Text)player1BPComponent).text = Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.BattlePoints + " BP";
					<>4__this.ranWinLoss = true;
					File.WriteAllLines(<>4__this.FILEPATH + "\\" + <>4__this.FILENAME, <>4__this.fileText);
					<winOrLose>5__2 = null;
				}
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 2;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <MoveSign>d__52 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Main <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <MoveSign>d__52(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(7f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (<>4__this.currentScene == "Map0")
				{
					matchInfoGameObject.transform.position = new Vector3(-1f, -0.5f, 20.5f);
					matchInfoGameObject.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
				}
				else if (<>4__this.currentScene == "Map1")
				{
					matchInfoGameObject.transform.position = new Vector3(0f, 5.25f, 11f);
					matchInfoGameObject.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
				}
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <OnePlayerFound>d__53 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Main <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <OnePlayerFound>d__53(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(4f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				matchInfoGameObject.SetActive(false);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private string currentScene = "Loader";

	public Mod MatchInfo = new Mod();

	public bool enabled = true;

	private bool init = false;

	private bool backedUp = false;

	private string FILEPATH = "UserData\\MatchInfo";

	private string FILENAME = "MatchInfo.txt";

	private string BACKUPFILENAME = "MatchInfo_Backup";

	private List<string> fileText = new List<string>();

	public static GameObject matchInfoGameObject;

	public static GameObject player1GameObject;

	public static GameObject player2GameObject;

	public static GameObject vsGameObject;

	public static GameObject player1BPGameObject;

	public static GameObject player2BPGameObject;

	public static GameObject player1MatchWinsGameObject;

	public static GameObject player2MatchWinsGameObject;

	public static TextMeshPro player1Component;

	public static TextMeshPro player2Component;

	public static TextMeshPro vsComponent;

	public static TextMeshPro player1BPComponent;

	public static TextMeshPro player2BPComponent;

	public static TextMeshPro player1MatchWinsComponent;

	public static TextMeshPro player2MatchWinsComponent;

	public static GameObject gymMatchInfoGameObject;

	public static GameObject gymMatchInfoTotalGameObject;

	public static GameObject gymMatchInfoWinsGameObject;

	public static GameObject gymMatchInfoLossesGameObject;

	public static GameObject gymMatchInfoWinPercentGameObject;

	public static TextMeshPro gymMatchInfoTitleComponent;

	public static TextMeshPro gymMatchInfoTotalComponent;

	public static TextMeshPro gymMatchInfoWinsComponent;

	public static TextMeshPro gymMatchInfoLossesComponent;

	public static TextMeshPro gymMatchInfoWinPercentComponent;

	private bool matchActive = false;

	private bool showGymInfo = true;

	private bool showMatchInfo = true;

	private GameObject MatchSlabOne;

	private TextMeshPro Slab1Text;

	private TextMeshPro Slab2Text;

	private int playerFileSpot = 0;

	private bool ranWinLoss = true;

	public static void Log(string msg)
	{
		MelonLogger.Msg(msg);
	}

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
		currentScene = sceneName;
	}

	public override void OnLateInitializeMelon()
	{
		Calls.onMapInitialized += mapLoaded;
		UI.instance.UI_Initialized += UIInit;
		CheckFiles();
	}

	private void CheckFiles()
	{
		if (!Directory.Exists(FILEPATH))
		{
			Log("Folder Not Found, Creating Folder: " + FILEPATH);
			Directory.CreateDirectory(FILEPATH);
		}
		if (!File.Exists(FILEPATH + "\\" + FILENAME))
		{
			Log("Creating File " + FILENAME);
			File.Create(FILEPATH + "\\" + FILENAME);
		}
		if (!Directory.Exists(FILEPATH + "\\Backups"))
		{
			Log("Folder Not Found, Creating Folder: " + FILEPATH + "\\Backups");
			Directory.CreateDirectory(FILEPATH + "\\Backups");
		}
		if (!File.Exists(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "1.txt"))
		{
			Log("Creating File " + BACKUPFILENAME + "1.txt");
			saveFile("", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "1.txt");
		}
		if (!File.Exists(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "2.txt"))
		{
			Log("Creating File " + BACKUPFILENAME + "2.txt");
			saveFile("", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "2.txt");
		}
		if (!File.Exists(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "3.txt"))
		{
			Log("Creating File " + BACKUPFILENAME + "3.txt");
			saveFile("", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "3.txt");
		}
		string[] array = ReadFileText(FILEPATH, FILENAME);
		string[] array2 = array;
		foreach (string item in array2)
		{
			fileText.Add(item);
		}
	}

	public static string[] ReadFileText(string filePath, string fileName)
	{
		try
		{
			return File.ReadAllLines(filePath + "\\" + fileName);
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
		}
		return null;
	}

	private void saveFile(string textToSave, string file)
	{
		FileStream fileStream = File.Create(file);
		byte[] bytes = Encoding.UTF8.GetBytes(textToSave);
		fileStream.Write(bytes);
		fileStream.Close();
		fileStream.Dispose();
	}

	private void UIInit()
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Expected O, but got Unknown
		MatchInfo.ModName = "MatchInfo";
		MatchInfo.ModVersion = "2.4.0";
		MatchInfo.SetFolder("MatchInfo");
		MatchInfo.AddToList("Show Gym Info", true, 0, "Toggles Mod Info in Gym On/Off", new Tags());
		MatchInfo.AddToList("Show Win/Loss in Match", true, 0, "Toggles Mod Info in Matches", new Tags());
		MatchInfo.GetFromFile();
		MatchInfo.ModSaved += Save;
		UI.instance.AddMod(MatchInfo);
		Save();
	}

	public void Save()
	{
		showGymInfo = (bool)MatchInfo.Settings[0].SavedValue;
		showMatchInfo = (bool)MatchInfo.Settings[1].SavedValue;
		if (currentScene == "Gym")
		{
			gymMatchInfoGameObject.SetActive(showGymInfo);
		}
		else if (currentScene == "Map0" || currentScene == "Map1")
		{
			player1MatchWinsGameObject.SetActive(showMatchInfo);
			player2MatchWinsGameObject.SetActive(showMatchInfo);
		}
	}

	public void mapLoaded()
	{
		//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		if (currentScene == "Gym")
		{
			if (!init)
			{
				RunInit();
			}
			matchInfoGameObject.SetActive(false);
			gymMatchInfoGameObject.SetActive(true);
			CountWinLoss();
			if (!showGymInfo)
			{
				gymMatchInfoGameObject.SetActive(false);
			}
			matchActive = false;
		}
		else
		{
			gymMatchInfoGameObject.SetActive(false);
		}
		if (!(currentScene == "Map0") && !(currentScene == "Map1"))
		{
			return;
		}
		matchInfoGameObject.SetActive(true);
		try
		{
			if (currentScene == "Map0")
			{
				MatchSlabOne = MatchFormCanvas.GetGameObject();
				Slab1Text = MatchText.GetGameObject().GetComponent<TextMeshPro>();
				Slab2Text = MatchText.GetGameObject().GetComponent<TextMeshPro>();
			}
			else if (currentScene == "Map1")
			{
				MatchSlabOne = MatchFormCanvas.GetGameObject();
				Slab1Text = MatchText.GetGameObject().GetComponent<TextMeshPro>();
				Slab2Text = MatchText.GetGameObject().GetComponent<TextMeshPro>();
			}
		}
		catch
		{
			return;
		}
		if (Players.IsHost())
		{
			matchInfoGameObject.transform.position = new Vector3(-3f, 3f, 0f);
			matchInfoGameObject.transform.rotation = Quaternion.Euler(0f, -90f, 0f);
		}
		else
		{
			matchInfoGameObject.transform.position = new Vector3(3f, 3f, 0f);
			matchInfoGameObject.transform.rotation = Quaternion.Euler(0f, 90f, 0f);
		}
		((TMP_Text)player2Component).text = Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.PublicUsername;
		if (Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.PlayFabMasterId == "5832566FD2375E31")
		{
			((TMP_Text)player2Component).text = "<#990099>U<#ff00ff>l<#ff66ff>v<#cc66ff>a<#9966ff>k<#6666ff>S<#3366ff>k<#6699ff>i<#809fff>l<#b3c6ff>l<#e6ecff>z";
		}
		((TMP_Text)player2BPComponent).text = Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.BattlePoints + " BP";
		if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1)
		{
			((TMP_Text)player1Component).text = Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername;
			if (Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId == "5832566FD2375E31")
			{
				((TMP_Text)player1Component).text = "<#990099>U<#ff00ff>l<#ff66ff>v<#cc66ff>a<#9966ff>k<#6666ff>S<#3366ff>k<#6699ff>i<#809fff>l<#b3c6ff>l<#e6ecff>z";
			}
			((TMP_Text)player1BPComponent).text = Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.BattlePoints + " BP";
			bool flag = false;
			for (int i = 0; i < fileText.Count; i += 3)
			{
				if (fileText[i].Contains(Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId))
				{
					if (fileText[i] == Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId)
					{
						List<string> list = fileText;
						int index = i;
						list[index] = list[index] + " - " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername;
					}
					else if (!fileText[i].Contains(Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername))
					{
						fileText[i] = Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId + " - " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername;
					}
					playerFileSpot = i;
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				fileText.Add(Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId + " - " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername);
				fileText.Add("0");
				fileText.Add("0");
				playerFileSpot = fileText.Count - 3;
			}
			player1MatchWinsGameObject.SetActive(true);
			player2MatchWinsGameObject.SetActive(true);
			((TMP_Text)player1MatchWinsComponent).text = fileText[playerFileSpot + 2] + " Wins";
			((TMP_Text)player2MatchWinsComponent).text = fileText[playerFileSpot + 1] + " Wins";
			if (!showMatchInfo)
			{
				player1MatchWinsGameObject.SetActive(false);
				player2MatchWinsGameObject.SetActive(false);
			}
			matchActive = true;
			ranWinLoss = false;
			MelonCoroutines.Start(MoveSign());
			MelonCoroutines.Start(MatchStarted());
		}
		else
		{
			MelonCoroutines.Start(OnePlayerFound());
		}
	}

	[IteratorStateMachine(typeof(<MatchStarted>d__51))]
	private IEnumerator MatchStarted()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <MatchStarted>d__51(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<MoveSign>d__52))]
	private IEnumerator MoveSign()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <MoveSign>d__52(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<OnePlayerFound>d__53))]
	public IEnumerator OnePlayerFound()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <OnePlayerFound>d__53(0)
		{
			<>4__this = this
		};
	}

	public void CountWinLoss()
	{
		int num = 0;
		int num2 = 0;
		for (int i = 0; i < fileText.Count; i += 3)
		{
			num += int.Parse(fileText[i + 1]);
			num2 += int.Parse(fileText[i + 2]);
		}
		((TMP_Text)gymMatchInfoTotalComponent).text = "Total: " + (num + num2);
		((TMP_Text)gymMatchInfoWinsComponent).text = "Wins: " + num;
		((TMP_Text)gymMatchInfoLossesComponent).text = "Losses: " + num2;
		((TMP_Text)gymMatchInfoWinPercentComponent).text = "Win Rate: " + (float)(int)((float)num / (float)(num + num2) * 10000f) / 100f + "%";
		if (num + num2 == 0)
		{
			((TMP_Text)gymMatchInfoWinPercentComponent).text = "Win Rate: N/A";
		}
	}

	private void RunInit()
	{
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Expected O, but got Unknown
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0459: Unknown result type (might be due to invalid IL or missing references)
		//IL_06a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_06c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_06eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_070f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0733: Unknown result type (might be due to invalid IL or missing references)
		//IL_0757: Unknown result type (might be due to invalid IL or missing references)
		//IL_077b: Unknown result type (might be due to invalid IL or missing references)
		//IL_079f: Unknown result type (might be due to invalid IL or missing references)
		//IL_07c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_07e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_080b: Unknown result type (might be due to invalid IL or missing references)
		//IL_082f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0853: Unknown result type (might be due to invalid IL or missing references)
		if (!backedUp)
		{
			Log("Backing up File 2 -> 3");
			File.Copy(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "2.txt", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "3.txt", overwrite: true);
			Log("Backing up File 1 -> 2");
			File.Copy(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "1.txt", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "2.txt", overwrite: true);
			Log("Backing up File MatchInfo.txt -> 1");
			File.Copy(FILEPATH + "\\" + FILENAME, FILEPATH + "\\Backups\\" + BACKUPFILENAME + "1.txt", overwrite: true);
			backedUp = true;
		}
		matchInfoGameObject = new GameObject();
		((Object)matchInfoGameObject).name = "MatchInfoMod";
		matchInfoGameObject.SetActive(false);
		player1GameObject = Object.Instantiate<GameObject>(Nr.GetGameObject());
		player1GameObject.transform.parent = matchInfoGameObject.transform;
		((Object)player1GameObject).name = "Player1Name";
		player1Component = player1GameObject.GetComponent<TextMeshPro>();
		((TMP_Text)player1Component).text = "name";
		((TMP_Text)player1Component).fontSize = 5f;
		((TMP_Text)player1Component).color = new Color(1f, 1f, 1f, 1f);
		((TMP_Text)player1Component).outlineColor = Color32.op_Implicit(new Color(0f, 0f, 0f, 0.5f));
		((TMP_Text)player1Component).alignment = (TextAlignmentOptions)516;
		((TMP_Text)player1Component).enableWordWrapping = false;
		((TMP_Text)player1Component).outlineWidth = 0.1f;
		player2GameObject = Object.Instantiate<GameObject>(player1GameObject);
		player2GameObject.transform.parent = matchInfoGameObject.transform;
		((Object)player2GameObject).name = "Player2Name";
		player2Component = player2GameObject.GetComponent<TextMeshPro>();
		((TMP_Text)player2Component).alignment = (TextAlignmentOptions)513;
		vsGameObject = Object.Instantiate<GameObject>(player2GameObject);
		vsGameObject.transform.parent = matchInfoGameObject.transform;
		((Object)vsGameObject).name = "VSText";
		vsComponent = vsGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)vsComponent).alignment = (TextAlignmentOptions)514;
		((TMP_Text)vsComponent).color = new Color(0f, 0f, 0f, 1f);
		((TMP_Text)vsComponent).text = "vs";
		((TMP_Text)vsComponent).fontSize = 3.5f;
		player1BPGameObject = Object.Instantiate<GameObject>(player2GameObject);
		player1BPGameObject.transform.parent = matchInfoGameObject.transform;
		((Object)player1BPGameObject).name = "Player1BP";
		player1BPComponent = player1BPGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)player1BPComponent).alignment = (TextAlignmentOptions)514;
		((TMP_Text)player1BPComponent).text = "P1BP";
		((TMP_Text)player1BPComponent).fontSize = 4f;
		player2BPGameObject = Object.Instantiate<GameObject>(player2GameObject);
		player2BPGameObject.transform.parent = matchInfoGameObject.transform;
		((Object)player2BPGameObject).name = "Player2BP";
		player2BPComponent = player2BPGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)player2BPComponent).alignment = (TextAlignmentOptions)514;
		((TMP_Text)player2BPComponent).text = "P2BP";
		((TMP_Text)player2BPComponent).fontSize = 4f;
		player1MatchWinsGameObject = Object.Instantiate<GameObject>(player1BPGameObject);
		player1MatchWinsGameObject.transform.parent = matchInfoGameObject.transform;
		((Object)player1MatchWinsGameObject).name = "P1Wins";
		player1MatchWinsComponent = player1MatchWinsGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)player1MatchWinsComponent).alignment = (TextAlignmentOptions)514;
		((TMP_Text)player1MatchWinsComponent).text = "0 Wins";
		((TMP_Text)player1MatchWinsComponent).color = new Color(1f, 1f, 1f, 1f);
		player2MatchWinsGameObject = Object.Instantiate<GameObject>(player1MatchWinsGameObject);
		player2MatchWinsGameObject.transform.parent = matchInfoGameObject.transform;
		((Object)player2MatchWinsGameObject).name = "P2Wins";
		player2MatchWinsComponent = player2MatchWinsGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)player2MatchWinsComponent).alignment = (TextAlignmentOptions)514;
		((TMP_Text)player2MatchWinsComponent).text = "0 Wins";
		gymMatchInfoGameObject = Object.Instantiate<GameObject>(player1GameObject);
		((Object)gymMatchInfoGameObject).name = "GymMatchInfo";
		gymMatchInfoTitleComponent = gymMatchInfoGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)gymMatchInfoTitleComponent).alignment = (TextAlignmentOptions)513;
		((TMP_Text)gymMatchInfoTitleComponent).text = "Match History";
		((TMP_Text)gymMatchInfoTitleComponent).fontSize = 3.5f;
		gymMatchInfoTotalGameObject = Object.Instantiate<GameObject>(gymMatchInfoGameObject);
		gymMatchInfoTotalGameObject.transform.parent = gymMatchInfoGameObject.transform;
		((Object)gymMatchInfoTotalGameObject).name = "Total";
		gymMatchInfoTotalComponent = gymMatchInfoTotalGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)gymMatchInfoTotalComponent).text = "Total: ";
		gymMatchInfoWinsGameObject = Object.Instantiate<GameObject>(gymMatchInfoTotalGameObject);
		gymMatchInfoWinsGameObject.transform.parent = gymMatchInfoGameObject.transform;
		((Object)gymMatchInfoWinsGameObject).name = "Wins";
		gymMatchInfoWinsComponent = gymMatchInfoWinsGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)gymMatchInfoWinsComponent).text = "Wins: ";
		gymMatchInfoLossesGameObject = Object.Instantiate<GameObject>(gymMatchInfoTotalGameObject);
		gymMatchInfoLossesGameObject.transform.parent = gymMatchInfoGameObject.transform;
		((Object)gymMatchInfoLossesGameObject).name = "Losses";
		gymMatchInfoLossesComponent = gymMatchInfoLossesGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)gymMatchInfoLossesComponent).text = "Losses: ";
		gymMatchInfoWinPercentGameObject = Object.Instantiate<GameObject>(gymMatchInfoTotalGameObject);
		gymMatchInfoWinPercentGameObject.transform.parent = gymMatchInfoGameObject.transform;
		((Object)gymMatchInfoWinPercentGameObject).name = "WinPercent";
		gymMatchInfoWinPercentComponent = gymMatchInfoWinPercentGameObject.GetComponent<TextMeshPro>();
		((TMP_Text)gymMatchInfoWinPercentComponent).text = "Win Rate: ";
		player1GameObject.transform.position = new Vector3(-0.75f, 1f, 0f);
		player1BPGameObject.transform.position = new Vector3(-1.25f, 0.5f, 0f);
		vsGameObject.transform.position = new Vector3(0f, 0.75f, 0f);
		player2GameObject.transform.position = new Vector3(0.75f, 1f, 0f);
		player2BPGameObject.transform.position = new Vector3(1.25f, 0.5f, 0f);
		player1MatchWinsGameObject.transform.position = new Vector3(-1.25f, 0f, 0f);
		player2MatchWinsGameObject.transform.position = new Vector3(1.25f, 0f, 0f);
		gymMatchInfoGameObject.transform.position = new Vector3(5.5236f, 2.75f, 11.3364f);
		gymMatchInfoGameObject.transform.rotation = Quaternion.Euler(0f, 30.5f, 0f);
		gymMatchInfoTotalGameObject.transform.localPosition = new Vector3(0.0334f, -0.3f, -0.0012f);
		gymMatchInfoWinsGameObject.transform.localPosition = new Vector3(0.0334f, -0.6f, -0.0012f);
		gymMatchInfoLossesGameObject.transform.localPosition = new Vector3(0.0334f, -0.9f, -0.0012f);
		gymMatchInfoWinPercentGameObject.transform.localPosition = new Vector3(0.0334f, -1.2f, -0.0012f);
		gymMatchInfoGameObject.SetActive(false);
		Object.DontDestroyOnLoad((Object)(object)matchInfoGameObject);
		Object.DontDestroyOnLoad((Object)(object)gymMatchInfoGameObject);
		init = true;
		Log("Initialized");
	}
}