using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using MenuLib;
using MenuLib.MonoBehaviors;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Photon.Pun;
using RepoSeeded;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;
using WebSocketSharp;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Larsielol")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RepoVersus")]
[assembly: AssemblyTitle("RepoVersus")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RepoVersus
{
	[HarmonyPatch(typeof(MenuButton))]
	internal class ChangeMenuButtons
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__1_0;

			public static UnityAction <>9__1_1;

			internal void <setup>b__1_0()
			{
				DataDirector.instance.networkRegion = "";
				SemiFunc.MenuActionHostGame((string)null, (List<string>)null);
			}

			internal void <setup>b__1_1()
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				MenuManager.instance.PagePopUp("Could not open lobby menu", Color.white, "Sorry! For now only the host can join a lobby.", "Alrighty!", false);
			}
		}

		private static MenuButton startButton;

		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		public static void setup(MenuButton __instance)
		{
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Expected O, but got Unknown
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			if (((TMP_Text)__instance.buttonText).text != "start game" && (Object)(object)__instance != (Object)(object)startButton)
			{
				if (((TMP_Text)__instance.buttonText).text == "Leave")
				{
					__instance.menuButtonPopUp.option1Event.AddListener(new UnityAction(RepoVersus.Instance.leaveLobby));
				}
				else if (((TMP_Text)__instance.buttonText).text.ToLower() == "join friend")
				{
					((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setTextDelayed(__instance, "Join Teammate"));
					((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setPositionDelayed(__instance, new Vector3(0f, 202f, 0f)));
					((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setSizeDelayed(__instance, new Vector2(124f, 36f)));
				}
				else if (((TMP_Text)__instance.buttonText).text == "Private Game")
				{
					__instance.menuButtonPopUp = null;
					((UnityEventBase)__instance.button.onClick).RemoveAllListeners();
					ButtonClickedEvent onClick = __instance.button.onClick;
					object obj = <>c.<>9__1_0;
					if (obj == null)
					{
						UnityAction val = delegate
						{
							DataDirector.instance.networkRegion = "";
							SemiFunc.MenuActionHostGame((string)null, (List<string>)null);
						};
						<>c.<>9__1_0 = val;
						obj = (object)val;
					}
					((UnityEvent)onClick).AddListener((UnityAction)obj);
					((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setTextDelayed(__instance, "Create team"));
				}
				else
				{
					if (!(((TMP_Text)__instance.buttonText).text.ToLower() == "Versus Lobby"))
					{
						return;
					}
					if (SemiFunc.IsMasterClientOrSingleplayer())
					{
						((UnityEventBase)__instance.button.onClick).RemoveAllListeners();
						((UnityEvent)__instance.button.onClick).AddListener(new UnityAction(RepoVersus.Instance.openLobbyPage));
						return;
					}
					((UnityEventBase)__instance.button.onClick).RemoveAllListeners();
					ButtonClickedEvent onClick2 = __instance.button.onClick;
					object obj2 = <>c.<>9__1_1;
					if (obj2 == null)
					{
						UnityAction val2 = delegate
						{
							//IL_000b: Unknown result type (might be due to invalid IL or missing references)
							MenuManager.instance.PagePopUp("Could not open lobby menu", Color.white, "Sorry! For now only the host can join a lobby.", "Alrighty!", false);
						};
						<>c.<>9__1_1 = val2;
						obj2 = (object)val2;
					}
					((UnityEvent)onClick2).AddListener((UnityAction)obj2);
				}
				return;
			}
			startButton = __instance;
			__instance.menuButtonPopUp = null;
			((UnityEventBase)__instance.button.onClick).RemoveAllListeners();
			if (RepoVersus.currentLobby.host == SteamClient.Name)
			{
				((UnityEvent)__instance.button.onClick).AddListener((UnityAction)delegate
				{
					((Behaviour)__instance).enabled = false;
					RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new ServerManager.UpdateOutboundPacket
					{
						type = "start",
						action = ""
					}));
				});
			}
			else
			{
				((UnityEvent)__instance.button.onClick).AddListener((UnityAction)delegate
				{
					RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new ServerManager.UpdateOutboundPacket
					{
						type = "ready",
						action = ""
					}));
					if (!RepoVersus.currentLobby.playerData[SteamClient.Name].ready)
					{
						((TMP_Text)__instance.buttonText).SetText("Unready", true);
						RepoVersus.currentLobby.playerData[SteamClient.Name].ready = true;
					}
					else
					{
						((TMP_Text)__instance.buttonText).SetText("Ready up", true);
						RepoVersus.currentLobby.playerData[SteamClient.Name].ready = false;
					}
				});
			}
			if (!RepoVersus.currentLobby.playerData.ContainsKey(SteamClient.Name) || RepoVersus.currentLobby.started)
			{
				((Graphic)__instance.buttonText).color = new Color(0.25f, 0.25f, 0.25f);
				((Behaviour)__instance).enabled = false;
			}
			else
			{
				((Graphic)__instance.buttonText).color = new Color(0.5f, 0.5f, 0.5f);
				((Behaviour)__instance).enabled = true;
			}
			updateStartButton(setupAgain: false);
			if (RepoVersus.currentLobby.host == SteamClient.Name)
			{
				((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setTextDelayed(__instance, "Start match"));
			}
			else if (!RepoVersus.currentLobby.playerData.ContainsKey(SteamClient.Name) || !RepoVersus.currentLobby.playerData[SteamClient.Name].ready)
			{
				((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setTextDelayed(__instance, "Ready up"));
			}
			else
			{
				((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setTextDelayed(__instance, "Unready"));
			}
		}

		private static IEnumerator setTextDelayed(MenuButton button, string text)
		{
			yield return null;
			((TMP_Text)button.buttonText).SetText(text, true);
		}

		private static IEnumerator setPositionDelayed(MenuButton button, Vector3 pos)
		{
			//IL_000e: 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)
			yield return null;
			((Component)button).transform.localPosition = pos;
		}

		private static IEnumerator setSizeDelayed(MenuButton button, Vector2 sizeDelta)
		{
			//IL_000e: 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)
			yield return null;
			button.rectTransform.sizeDelta = sizeDelta;
		}

		public static void updateStartButton(bool setupAgain = true)
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			if (setupAgain && (Object)(object)startButton != (Object)null)
			{
				setup(startButton);
			}
			if (!((Object)(object)startButton != (Object)null) || !(RepoVersus.currentLobby.host == SteamClient.Name))
			{
				return;
			}
			bool flag = true;
			foreach (KeyValuePair<string, ServerManager.PlayerData> playerDatum in RepoVersus.currentLobby.playerData)
			{
				if (playerDatum.Key == SteamClient.Name || playerDatum.Value.ready)
				{
					continue;
				}
				flag = false;
				break;
			}
			if (flag)
			{
				((Behaviour)startButton).enabled = true;
				((Graphic)startButton.buttonText).color = Color.gray;
				((TMP_Text)startButton.buttonText).SetText("Start match", true);
			}
			else
			{
				((Graphic)startButton.buttonText).color = new Color(0.25f, 0.25f, 0.25f);
				((Behaviour)startButton).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(RunManager))]
	internal class DeathManager
	{
		[HarmonyPatch("ChangeLevel")]
		[HarmonyPrefix]
		private static bool detectLevelFail(bool _levelFailed, ref ChangeLevelType _changeLevelType)
		{
			if (_levelFailed && !SemiFunc.RunIsShop() && !SemiFunc.RunIsLobby())
			{
				if (RepoVersus.currentLobby.settings.forfeitOnDeath)
				{
					RepoVersus.Instance.playerForfeit();
					return false;
				}
				if (RunManager.instance.levelsCompleted != 0)
				{
					SemiFunc.SaveFileLoad("RepoVersus", (List<string>)null);
					RunManager.instance.ChangeLevel(true, false, (ChangeLevelType)1);
					ExtractTracking.extract = 1;
					return false;
				}
				RepoSeeded.setSeed(RepoVersus.currentLobby.seed);
				RunManager.instance.ResetProgress();
				MenuPageLobby.instance.ButtonStart();
				ExtractTracking.extract = 1;
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetRunLevel")]
		private static void StartOfRun(int ___levelsCompleted)
		{
			if (___levelsCompleted == 0)
			{
				StatsManager.instance.saveFileCurrent = "RepoVersus";
			}
		}
	}
	[HarmonyPatch(typeof(RoundDirector))]
	internal static class ExtractTracking
	{
		public static int extract = 1;

		[HarmonyPrefix]
		[HarmonyPatch("ExtractionCompleted")]
		private static void SendExtractionMessage()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				if (extract == RepoVersus.currentLobby.playerData[SteamClient.Name].extract)
				{
					ServerManager.finishedExtract();
				}
				extract++;
			}
		}
	}
	[HarmonyPatch(typeof(MenuPageEsc))]
	internal class LeaveLobbyOnLeaveREPOLobby
	{
		[HarmonyPatch("ButtonEventQuitToMenu")]
		[HarmonyPrefix]
		private static void leaveVersusLobby()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				RepoVersus.Instance.leaveLobby();
			}
		}
	}
	[HarmonyPatch(typeof(NetworkManager))]
	internal class leaveLobbyWhenHostDcs
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnMasterClientSwitched")]
		private static void resetLobbyOnHostDc()
		{
			RepoVersus.Instance.leaveLobby();
		}
	}
	[HarmonyPatch(typeof(RunManager))]
	internal class LevelFilter
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetRunLevel")]
		private static void filterLevel()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer() || !(RepoVersus.currentLobby.settings.levelFilter != "All"))
			{
				return;
			}
			for (int i = 0; i < RunManager.instance.levels.Count; i++)
			{
				Level val = RunManager.instance.levels[i];
				if (val.NarrativeName == RepoVersus.currentLobby.settings.levelFilter)
				{
					RunManager.instance.levelCurrent = val;
					break;
				}
			}
		}
	}
	[HarmonyPatch(typeof(SemiFunc))]
	internal static class LevelTracking
	{
		[HarmonyPrefix]
		[HarmonyPatch("StatSetRunLevel")]
		private static void SendLevelMessage(int value)
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				while (value > RepoVersus.currentLobby.playerData[SteamClient.Name].level)
				{
					ServerManager.finishedLevel();
					RepoVersus.currentLobby.playerData[SteamClient.Name].level++;
					RepoVersus.currentLobby.playerData[SteamClient.Name].extract = 1;
				}
				if (value == RepoVersus.currentLobby.playerData[SteamClient.Name].level)
				{
					ServerManager.finishedLevel();
				}
				ExtractTracking.extract = 1;
			}
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal class pleaseHelpOhgodFuckUI
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static bool patch()
		{
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between Unknown and I4
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Invalid comparison between Unknown and I4
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Invalid comparison between Unknown and I4
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Invalid comparison between Unknown and I4
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			MenuManager instance = MenuManager.instance;
			instance.currentMenuID = "";
			instance.currentMenuIDTransform = null;
			List<MenuButton> list = instance.allMenuButtons.ToList();
			foreach (MenuButton item in list)
			{
				if (item.hovering || !Object.op_Implicit((Object)(object)item.parentPage) || item.parentPage.addedPageOnTop || ((int)item.parentPage.currentPageState != 3 && (int)item.parentPage.currentPageState != 2))
				{
					try
					{
						item.RegisterHover();
					}
					catch (NullReferenceException)
					{
					}
				}
			}
			foreach (MenuButton item2 in list)
			{
				if (item2.hovering || !Object.op_Implicit((Object)(object)item2.parentPage) || item2.parentPage.addedPageOnTop || ((int)item2.parentPage.currentPageState != 3 && (int)item2.parentPage.currentPageState != 2))
				{
					try
					{
						item2.ProcessHover();
					}
					catch (NullReferenceException)
					{
					}
				}
			}
			if (Object.op_Implicit((Object)(object)PlayerController.instance))
			{
				instance.soundPosition = ((Component)PlayerController.instance).transform.position;
			}
			else
			{
				instance.soundPosition = ((Component)instance).transform.position;
			}
			switch (instance.currentMenuState)
			{
			case 0:
				instance.StateOpen();
				instance.stateStart = false;
				break;
			case 1:
				instance.StateClosed();
				instance.stateStart = false;
				break;
			}
			if (Input.GetMouseButton(0))
			{
				if (instance.mouseHoldPosition == Vector2.zero)
				{
					instance.mouseHoldPosition = SemiFunc.UIMousePosToUIPos();
				}
			}
			else
			{
				instance.mouseHoldPosition = Vector2.zero;
			}
			if (instance.textInputActive)
			{
				if (instance.textInputActiveTimer <= 0f)
				{
					instance.textInputActive = false;
				}
				instance.textInputActiveTimer -= Time.deltaTime;
			}
			if (instance.cutsceneSoundOverride)
			{
				if (instance.cutsceneSoundOverrideTimer <= 0f)
				{
					instance.cutsceneSoundOverride = false;
					instance.soundAction.Type = instance.defaultSoundType;
					instance.soundConfirm.Type = instance.defaultSoundType;
					instance.soundDeny.Type = instance.defaultSoundType;
					instance.soundDud.Type = instance.defaultSoundType;
					instance.soundTick.Type = instance.defaultSoundType;
					instance.soundHover.Type = instance.defaultSoundType;
					instance.soundPageIntro.Type = instance.defaultSoundType;
					instance.soundPageOutro.Type = instance.defaultSoundType;
					instance.soundWindowPopUp.Type = instance.defaultSoundType;
					instance.soundWindowPopUpClose.Type = instance.defaultSoundType;
					instance.soundMove.Type = instance.defaultSoundType;
				}
				instance.cutsceneSoundOverrideTimer -= Time.deltaTime;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	internal class PunManagerPatcher
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void startPost()
		{
			((Component)PunManager.instance).gameObject.AddComponent<TeamHandler>();
		}
	}
	[HarmonyPatch(typeof(MenuPageLobby))]
	internal class lobbyJoinPatcher
	{
		[HarmonyPostfix]
		[HarmonyPatch("PlayerAdd")]
		public static void playerJoined()
		{
			RepoVersus.setNewLbobyForTeam();
		}
	}
	[BepInPlugin("Larsielol.RepoVersus", "RepoVersus", "1.0.5")]
	public class RepoVersus : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static BuilderDelegate <>9__26_2;

			public static ShouldCloseMenuDelegate <>9__30_0;

			public static ScrollViewBuilderDelegate <>9__30_1;

			public static ScrollViewBuilderDelegate <>9__30_2;

			public static Action<string> <>9__30_6;

			public static ScrollViewBuilderDelegate <>9__30_3;

			public static Action<bool> <>9__30_8;

			public static Action<bool> <>9__30_10;

			public static Action <>9__30_13;

			public static BuilderDelegate <>9__30_11;

			public static ScrollViewBuilderDelegate <>9__30_12;

			public static EventHandler <>9__38_0;

			internal void <Awake>b__26_2(Transform parent)
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				Transform val = parent.Find("Buttons");
				Transform val2 = val.Find("Menu Button - Public Game");
				((Component)val2).gameObject.SetActive(false);
				Transform val3 = val.Find("Menu Button - singleplayer");
				((Component)val3).gameObject.SetActive(false);
				Transform val4 = val.Find("Menu Button - Tutorial");
				((Component)val4).gameObject.SetActive(false);
				Transform val5 = val.Find("Menu Button - Quit game");
				val5.localPosition = val4.localPosition;
				Transform val6 = val.Find("Menu Button - Settings");
				val6.localPosition = val3.localPosition;
			}

			internal bool <openLobbyPage>b__30_0()
			{
				lobbyPage = null;
				return true;
			}

			internal RectTransform <openLobbyPage>b__30_1(Transform scrollView)
			{
				//IL_0009: 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_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				REPOLabel val = MenuAPI.CreateREPOLabel("The lobby leader has not", scrollView, default(Vector2));
				((Transform)((REPOElement)val).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
				((Graphic)val.labelTMP).color = Color.gray;
				return ((REPOElement)val).rectTransform;
			}

			internal RectTransform <openLobbyPage>b__30_2(Transform scrollView)
			{
				//IL_0009: 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_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				REPOLabel val = MenuAPI.CreateREPOLabel("joined a RepoVersus lobby yet.", scrollView, default(Vector2));
				((Transform)((REPOElement)val).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
				((Graphic)val.labelTMP).color = Color.gray;
				return ((REPOElement)val).rectTransform;
			}

			internal RectTransform <openLobbyPage>b__30_3(Transform scrollView)
			{
				//IL_002e: 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)
				Action<string> obj = delegate(string code)
				{
					RepoVersus.currentCode = code.Replace(" ", "").ToUpper();
				};
				string currentCode = RepoVersus.currentCode;
				REPOInputField val = MenuAPI.CreateREPOInputField("Lobby name", obj, scrollView, default(Vector2), false, "", currentCode);
				return ((REPOElement)val).rectTransform;
			}

			internal void <openLobbyPage>b__30_6(string code)
			{
				currentCode = code.Replace(" ", "").ToUpper();
			}

			internal void <openLobbyPage>b__30_8(bool created)
			{
				if (created && (Object)(object)lobbyPage != (Object)null)
				{
					ChangeMenuButtons.updateStartButton();
					refreshLobbyPage();
				}
			}

			internal void <openLobbyPage>b__30_10(bool joined)
			{
				if (joined && (Object)(object)lobbyPage != (Object)null)
				{
					ChangeMenuButtons.updateStartButton();
					refreshLobbyPage();
				}
			}

			internal void <openLobbyPage>b__30_11(Transform parent)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				REPOButton val = MenuAPI.CreateREPOButton("Leave Lobby", (Action)delegate
				{
					ws.Close();
					lobbyPage.ClosePage(true);
					ChangeMenuButtons.updateStartButton();
				}, parent, new Vector2(50f, 35f));
			}

			internal void <openLobbyPage>b__30_13()
			{
				ws.Close();
				lobbyPage.ClosePage(true);
				ChangeMenuButtons.updateStartButton();
			}

			internal RectTransform <openLobbyPage>b__30_12(Transform scrollView)
			{
				//IL_0009: 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_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				REPOLabel val = MenuAPI.CreateREPOLabel("Players", scrollView, default(Vector2));
				((Transform)((REPOElement)val).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.8f, 0.85f));
				return ((REPOElement)val).rectTransform;
			}

			internal void <ConnectToLobbyWs>b__38_0(object sender, EventArgs e)
			{
				Console.WriteLine("Connected to the websocket");
				if (wsOn)
				{
					ws.Close();
				}
				else
				{
					wsOn = true;
				}
				setNewLbobyForTeam();
			}
		}

		private static bool returningToLobby = false;

		internal static ServerManager.Lobby currentLobby = new ServerManager.Lobby();

		internal static string key;

		private ConfigEntry<bool> hideLobbyName;

		private static bool wsOn = false;

		private static WebSocket ws;

		public static bool inMatch = false;

		private static string currentCode = "";

		private static ServerManager.PlayerData highestLevel = new ServerManager.PlayerData();

		private static REPOPopupPage lobbyPage;

		internal static string newestToast = "";

		internal static RepoVersus Instance { get; private set; } = null;

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		public static void trySetSeed(string seed)
		{
			if (!inMatch)
			{
				setSeed(seed);
			}
		}

		public static void setSeed(string seed)
		{
			RepoSeeded.setSeed(seed);
			currentLobby.seed = seed;
		}

		internal void leaveLobby()
		{
			UIManager.SetToast("");
			ExtractTracking.extract = 1;
			if (ws == null || !wsOn)
			{
				if (currentLobby.settings != null)
				{
					currentLobby.settings.clearSeedFields();
				}
				currentLobby = new ServerManager.Lobby();
			}
			else
			{
				ws.Close();
			}
		}

		private void Awake()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			hideLobbyName = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Hide lobby name", false, (ConfigDescription)null);
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			RepoSeeded.isLibrary = true;
			RepoSeeded.shouldSave = true;
			RepoSeeded.randomizeSeed = false;
			MenuAPI.AddElementToLobbyMenu((BuilderDelegate)delegate(Transform parent)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				REPOButton val2 = MenuAPI.CreateREPOButton("Versus Lobby", (Action)openLobbyPage, parent, Vector2.op_Implicit(new Vector3(128f, 64f, 0f)));
			});
			MenuAPI.AddElementToEscapeMenu((BuilderDelegate)delegate(Transform parent)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if (SemiFunc.IsMasterClientOrSingleplayer())
				{
					REPOButton val2 = MenuAPI.CreateREPOButton("Forfeit", (Action)delegate
					{
						playerForfeit();
					}, parent, new Vector2(126f, 70f));
				}
			});
			object obj = <>c.<>9__26_2;
			if (obj == null)
			{
				BuilderDelegate val = delegate(Transform parent)
				{
					//IL_0068: Unknown result type (might be due to invalid IL or missing references)
					//IL_0083: Unknown result type (might be due to invalid IL or missing references)
					Transform val2 = parent.Find("Buttons");
					Transform val3 = val2.Find("Menu Button - Public Game");
					((Component)val3).gameObject.SetActive(false);
					Transform val4 = val2.Find("Menu Button - singleplayer");
					((Component)val4).gameObject.SetActive(false);
					Transform val5 = val2.Find("Menu Button - Tutorial");
					((Component)val5).gameObject.SetActive(false);
					Transform val6 = val2.Find("Menu Button - Quit game");
					val6.localPosition = val5.localPosition;
					Transform val7 = val2.Find("Menu Button - Settings");
					val7.localPosition = val4.localPosition;
				};
				<>c.<>9__26_2 = val;
				obj = (object)val;
			}
			MenuAPI.AddElementToMainMenu((BuilderDelegate)obj);
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal static void setNewLbobyForTeam()
		{
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("setLobby", (RpcTarget)1, new object[1] { JsonConvert.SerializeObject((object)currentLobby) });
			}
		}

		private static void refreshLobbyPage()
		{
			if (!((Object)(object)lobbyPage == (Object)null))
			{
				Console.WriteLine("Reopening the lobby menu.");
				lobbyPage.ClosePage(true);
				Instance.openLobbyPage();
			}
		}

		internal static void closeLobbyPage()
		{
			if (!((Object)(object)lobbyPage == (Object)null))
			{
				lobbyPage.ClosePage(true);
			}
		}

		public void openLobbyPage()
		{
			//IL_0068: 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)
			//IL_0073: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Expected O, but got Unknown
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Expected O, but got Unknown
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			string text = "Lobby";
			if (currentLobby != null && currentLobby.name != null && !hideLobbyName.Value)
			{
				text = currentLobby.name;
			}
			lobbyPage = MenuAPI.CreateREPOPopupPage(text, (PresetSide)0, false, true, 1.5f);
			REPOPopupPage obj = lobbyPage;
			object obj2 = <>c.<>9__30_0;
			if (obj2 == null)
			{
				ShouldCloseMenuDelegate val = delegate
				{
					lobbyPage = null;
					return true;
				};
				<>c.<>9__30_0 = val;
				obj2 = (object)val;
			}
			obj.onEscapePressed = (ShouldCloseMenuDelegate)obj2;
			if (currentLobby == null || currentLobby.name == null)
			{
				if (!SemiFunc.IsMasterClientOrSingleplayer())
				{
					REPOPopupPage obj3 = lobbyPage;
					object obj4 = <>c.<>9__30_1;
					if (obj4 == null)
					{
						ScrollViewBuilderDelegate val2 = delegate(Transform scrollView)
						{
							//IL_0009: 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_0026: Unknown result type (might be due to invalid IL or missing references)
							//IL_002b: Unknown result type (might be due to invalid IL or missing references)
							//IL_003c: Unknown result type (might be due to invalid IL or missing references)
							REPOLabel val8 = MenuAPI.CreateREPOLabel("The lobby leader has not", scrollView, default(Vector2));
							((Transform)((REPOElement)val8).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
							((Graphic)val8.labelTMP).color = Color.gray;
							return ((REPOElement)val8).rectTransform;
						};
						<>c.<>9__30_1 = val2;
						obj4 = (object)val2;
					}
					obj3.AddElementToScrollView((ScrollViewBuilderDelegate)obj4, 0f, 0f);
					REPOPopupPage obj5 = lobbyPage;
					object obj6 = <>c.<>9__30_2;
					if (obj6 == null)
					{
						ScrollViewBuilderDelegate val3 = delegate(Transform scrollView)
						{
							//IL_0009: 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_0026: Unknown result type (might be due to invalid IL or missing references)
							//IL_002b: Unknown result type (might be due to invalid IL or missing references)
							//IL_003c: Unknown result type (might be due to invalid IL or missing references)
							REPOLabel val8 = MenuAPI.CreateREPOLabel("joined a RepoVersus lobby yet.", scrollView, default(Vector2));
							((Transform)((REPOElement)val8).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
							((Graphic)val8.labelTMP).color = Color.gray;
							return ((REPOElement)val8).rectTransform;
						};
						<>c.<>9__30_2 = val3;
						obj6 = (object)val3;
					}
					obj5.AddElementToScrollView((ScrollViewBuilderDelegate)obj6, 0f, 0f);
					lobbyPage.OpenPage(false);
					return;
				}
				REPOPopupPage obj7 = lobbyPage;
				object obj8 = <>c.<>9__30_3;
				if (obj8 == null)
				{
					ScrollViewBuilderDelegate val4 = delegate(Transform scrollView)
					{
						//IL_002e: 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)
						Action<string> obj13 = delegate(string code)
						{
							currentCode = code.Replace(" ", "").ToUpper();
						};
						string text2 = currentCode;
						REPOInputField val8 = MenuAPI.CreateREPOInputField("Lobby name", obj13, scrollView, default(Vector2), false, "", text2);
						return ((REPOElement)val8).rectTransform;
					};
					<>c.<>9__30_3 = val4;
					obj8 = (object)val4;
				}
				obj7.AddElementToScrollView((ScrollViewBuilderDelegate)obj8, 0f, 0f);
				lobbyPage.AddElement((BuilderDelegate)delegate(Transform page)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					REPOButton val8 = MenuAPI.CreateREPOButton("Create Lobby", (Action)delegate
					{
						((MonoBehaviour)this).StartCoroutine(MakeLobby(currentCode, delegate(bool created)
						{
							if (created && (Object)(object)lobbyPage != (Object)null)
							{
								ChangeMenuButtons.updateStartButton();
								refreshLobbyPage();
							}
						}));
						currentCode = "";
					}, page, new Vector2(70f, 240f));
				});
				lobbyPage.AddElement((BuilderDelegate)delegate(Transform page)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					REPOButton val8 = MenuAPI.CreateREPOButton("Join Lobby", (Action)delegate
					{
						((MonoBehaviour)this).StartCoroutine(JoinLobby(currentCode, delegate(bool joined)
						{
							if (joined && (Object)(object)lobbyPage != (Object)null)
							{
								ChangeMenuButtons.updateStartButton();
								refreshLobbyPage();
							}
						}));
						currentCode = "";
					}, page, new Vector2(190f, 240f));
				});
				lobbyPage.OpenPage(false);
				return;
			}
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				REPOPopupPage obj9 = lobbyPage;
				object obj10 = <>c.<>9__30_11;
				if (obj10 == null)
				{
					BuilderDelegate val5 = delegate(Transform parent)
					{
						//IL_0030: Unknown result type (might be due to invalid IL or missing references)
						REPOButton val8 = MenuAPI.CreateREPOButton("Leave Lobby", (Action)delegate
						{
							ws.Close();
							lobbyPage.ClosePage(true);
							ChangeMenuButtons.updateStartButton();
						}, parent, new Vector2(50f, 35f));
					};
					<>c.<>9__30_11 = val5;
					obj10 = (object)val5;
				}
				obj9.AddElement((BuilderDelegate)obj10);
			}
			REPOPopupPage obj11 = lobbyPage;
			object obj12 = <>c.<>9__30_12;
			if (obj12 == null)
			{
				ScrollViewBuilderDelegate val6 = delegate(Transform scrollView)
				{
					//IL_0009: 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_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					REPOLabel val8 = MenuAPI.CreateREPOLabel("Players", scrollView, default(Vector2));
					((Transform)((REPOElement)val8).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.8f, 0.85f));
					return ((REPOElement)val8).rectTransform;
				};
				<>c.<>9__30_12 = val6;
				obj12 = (object)val6;
			}
			obj11.AddElementToScrollView((ScrollViewBuilderDelegate)obj12, 0f, -10f);
			foreach (string p in currentLobby.playerData.Keys)
			{
				lobbyPage.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
				{
					//IL_0013: 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_0030: Unknown result type (might be due to invalid IL or missing references)
					//IL_0035: 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)
					REPOLabel val8 = MenuAPI.CreateREPOLabel(p ?? "", scrollView, default(Vector2));
					((Transform)((REPOElement)val8).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
					((Graphic)val8.labelTMP).color = Color.gray;
					return ((REPOElement)val8).rectTransform;
				}, 0f, -10f);
			}
			lobbyPage.OpenPage(false);
			REPOPopupPage val7 = MenuAPI.CreateREPOPopupPage("Settings", (PresetSide)1, false, false, 0f);
			currentLobby.settings.putInScrollView(val7, currentLobby.host == SteamClient.Name);
			val7.OpenPage(true);
		}

		internal IEnumerator MakeLobby(string name, Action<bool> onCreate)
		{
			yield return ((MonoBehaviour)this).StartCoroutine(ServerManager.postJsonRequest("/api/createlobby", new ServerManager.GenericUnsafeRequest
			{
				name = name,
				player = SteamClient.Name
			}, delegate(string response)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				bool flag = !response.Contains("error");
				if (flag)
				{
					createdLobby(response);
				}
				else
				{
					string error = JsonUtility.FromJson<ServerManager.GenericResponse>(response).error;
					MenuManager.instance.PagePopUp("Something went wrong while creating the lobby!", Color.gray, error, "Close", false);
				}
				onCreate(flag);
			}));
		}

		internal IEnumerator JoinLobby(string name, Action<bool> onJoin)
		{
			Logger.LogMessage((object)("Joining lobby " + name + ".\n"));
			yield return ((MonoBehaviour)this).StartCoroutine(ServerManager.postJsonRequest("/api/join", new ServerManager.GenericUnsafeRequest
			{
				name = name,
				player = SteamClient.Name
			}, delegate(string response)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				bool flag = !response.Contains("error");
				if (flag)
				{
					joinedLobby(response);
				}
				else
				{
					string error = JsonUtility.FromJson<ServerManager.GenericResponse>(response).error;
					MenuManager.instance.PagePopUp("Something went wrong while joining the lobby!", Color.gray, error, "Close", false);
				}
				onJoin(flag);
			}));
		}

		private void showWinScreen()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MenuManager.instance.PagePopUp("Match results", Color.green, "You won!", "Close", false);
		}

		private void showLossScreen()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MenuManager.instance.PagePopUp("Match results", Color.red, "You lost :(", "Close", false);
		}

		private void showMatchEndedScreen()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!returningToLobby)
			{
				MenuManager.instance.PagePopUp("Match ended", Color.red, "The ongoing match has ended, you can now ready up and play another round!", "Close", false);
				UIManager.SetToast("");
			}
		}

		internal IEnumerator TryReturnToLobby(bool playerWon, bool lostConnection = false)
		{
			if (returningToLobby)
			{
				yield break;
			}
			returningToLobby = true;
			bool startedInLobbyMenu = false;
			RunManager rm = RunManager.instance;
			if (SemiFunc.MenuLevel())
			{
				startedInLobbyMenu = true;
				showMatchEndedScreen();
			}
			UIManager.SetToast("");
			while (!SemiFunc.MenuLevel())
			{
				rm.ChangeLevel(true, SemiFunc.RunIsArena(), (ChangeLevelType)3);
				yield return (object)new WaitForSeconds(3f);
			}
			rm.ResetProgress();
			currentLobby.reset();
			ChangeMenuButtons.updateStartButton();
			returningToLobby = false;
			yield return (object)new WaitForSeconds(5f);
			if (lostConnection)
			{
				MenuManager.instance.PagePopUp("Disconnected", Color.red, "You got disconnected from the server. Check the logs for more info.", "Close", false);
			}
			else if (!startedInLobbyMenu && SemiFunc.MenuLevel())
			{
				if (playerWon)
				{
					showWinScreen();
				}
				else
				{
					showLossScreen();
				}
			}
		}

		private IEnumerator tryAndReconnect()
		{
			UIManager.SetToast("Disconnected from the server, reconnecting...", 15);
			for (int i = 0; i < 10; i++)
			{
				if (ws.IsAlive)
				{
					break;
				}
				if (wsOn)
				{
					break;
				}
				ConnectToLobbyWs();
				yield return (object)new WaitForSeconds(1f);
			}
			if (ws == null || !ws.IsAlive)
			{
				wsOn = false;
				currentLobby.settings.clearSeedFields();
				currentLobby = new ServerManager.Lobby();
				((MonoBehaviour)this).StartCoroutine(TryReturnToLobby(playerWon: false, lostConnection: true));
			}
			else
			{
				UIManager.SetToast("Reconnected to the server!", 5);
			}
			setNewLbobyForTeam();
		}

		internal void ConnectToLobbyWs()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			if (ws != null && ws.IsAlive)
			{
				return;
			}
			ws = new WebSocket("wss://repoversus.com/ws/" + currentLobby.name + "/" + SteamClient.Name + "/" + key, Array.Empty<string>());
			ws.OnOpen += delegate
			{
				Console.WriteLine("Connected to the websocket");
				if (wsOn)
				{
					ws.Close();
				}
				else
				{
					wsOn = true;
				}
				setNewLbobyForTeam();
			};
			ws.OnMessage += delegate(object sender, MessageEventArgs e)
			{
				ServerManager.UpdateInboundPacket updateInboundPacket = JsonUtility.FromJson<ServerManager.UpdateInboundPacket>(e.Data);
				Console.WriteLine("Message received: " + e.Data);
				if (updateInboundPacket.type == "update")
				{
					if (updateInboundPacket.action == "level")
					{
						currentLobby.playerData[updateInboundPacket.player].extract = 1;
						if (currentLobby.playerData[updateInboundPacket.player].level >= highestLevel.level)
						{
							UIManager.SetToast($"{updateInboundPacket.player} has completed level {currentLobby.playerData[updateInboundPacket.player].level}.");
						}
						currentLobby.playerData[updateInboundPacket.player].level++;
					}
					else if (updateInboundPacket.action == "extract")
					{
						if (currentLobby.playerData[updateInboundPacket.player].level >= highestLevel.level && currentLobby.playerData[updateInboundPacket.player].extract >= highestLevel.extract)
						{
							UIManager.SetToast($"{updateInboundPacket.player} has completed extract {currentLobby.playerData[updateInboundPacket.player].extract} in level {currentLobby.playerData[updateInboundPacket.player].level}.");
						}
						currentLobby.playerData[updateInboundPacket.player].extract++;
					}
					else if (updateInboundPacket.action == "forfeit")
					{
						UIManager.SetToast(updateInboundPacket.player + " has forfeit the match.", 10);
					}
				}
				else if (updateInboundPacket.type == "join")
				{
					currentLobby.playerData[updateInboundPacket.player] = new ServerManager.PlayerData();
					ChangeMenuButtons.updateStartButton();
				}
				else if (updateInboundPacket.type == "leave")
				{
					int num = 0;
					currentLobby.playerData.Remove(updateInboundPacket.player);
					foreach (KeyValuePair<string, ServerManager.PlayerData> playerDatum in currentLobby.playerData)
					{
						if ((playerDatum.Value.ready && playerDatum.Key != SteamClient.Name) || !currentLobby.playerData[SteamClient.Name].ready)
						{
							num++;
							break;
						}
					}
					if (num == 0)
					{
						playerWon();
					}
					if (updateInboundPacket.player == currentLobby.host)
					{
						ws.Close();
					}
					ChangeMenuButtons.updateStartButton();
				}
				else if (updateInboundPacket.type == "setting")
				{
					ServerManager.SettingsPacket settingsPacket = JsonUtility.FromJson<ServerManager.SettingsPacket>(e.Data);
					if (settingsPacket.setting == "levels")
					{
						currentLobby.settings.levels = int.Parse(settingsPacket.newValue);
					}
					else if (settingsPacket.setting == "seed")
					{
						setSeed(settingsPacket.newValue);
					}
					else if (settingsPacket.setting == "setSeed")
					{
						currentLobby.settings.setSeed = settingsPacket.newValue == "True";
					}
					else if (settingsPacket.setting == "forfeitOnDeath")
					{
						currentLobby.settings.forfeitOnDeath = settingsPacket.newValue == "True";
					}
					else if (settingsPacket.setting == "levelFilter")
					{
						currentLobby.settings.levelFilter = settingsPacket.newValue;
					}
					currentLobby.settings.updateFields();
				}
				else if (updateInboundPacket.type == "ready")
				{
					currentLobby.playerData[updateInboundPacket.player].ready = !currentLobby.playerData[updateInboundPacket.player].ready;
					ChangeMenuButtons.updateStartButton();
				}
				else if (updateInboundPacket.type == "start")
				{
					ExtractTracking.extract = 1;
					foreach (ServerManager.PlayerData value in currentLobby.playerData.Values)
					{
						value.ready = true;
					}
					currentLobby.started = true;
					MenuPageLobby.instance.ButtonStart();
				}
				if (updateInboundPacket.type == "finish")
				{
					ServerManager.FinishInboundPacket finishInboundPacket = JsonUtility.FromJson<ServerManager.FinishInboundPacket>(e.Data);
					UIManager.SetToast("");
					setSeed(finishInboundPacket.newSeed);
					foreach (string item in currentLobby.playerData.Keys.ToList())
					{
						currentLobby.playerData[item] = new ServerManager.PlayerData();
					}
					ExtractTracking.extract = 1;
					((MonoBehaviour)this).StartCoroutine(TryReturnToLobby(finishInboundPacket.winner == SteamClient.Name));
					currentLobby.started = false;
				}
			};
			ws.OnClose += delegate(object sender, CloseEventArgs e)
			{
				if (!e.WasClean)
				{
					Console.ForegroundColor = ConsoleColor.Red;
					Console.WriteLine("The websocket to the lobby was closed for unclean reason:\n" + e.Reason);
					Console.ResetColor();
					ws = null;
					tryAndReconnect();
				}
				else
				{
					wsOn = false;
					currentLobby.settings.clearSeedFields();
					currentLobby = new ServerManager.Lobby();
					if (!SemiFunc.RunIsLobbyMenu() && !SemiFunc.IsMainMenu())
					{
						((MonoBehaviour)this).StartCoroutine(TryReturnToLobby(playerWon: false, lostConnection: true));
					}
					setNewLbobyForTeam();
				}
			};
			ws.ConnectAsync();
		}

		internal static void sendWsMessage(string message)
		{
			if (wsOn)
			{
				ws.SendAsync(message, (Action<bool>)null);
			}
		}

		internal void createdLobby(string response)
		{
			currentLobby = JsonConvert.DeserializeObject<ServerManager.Lobby>(response);
			currentLobby.playerData[SteamClient.Name] = new ServerManager.PlayerData();
			currentLobby.host = SteamClient.Name;
			int num = response.IndexOf("\"key\":\"");
			int num2 = num + "\"key\":\"".Length;
			int num3 = response.IndexOf("\"", num2);
			key = response.Substring(num2, num3 - num2);
			setSeed(currentLobby.seed);
			ConnectToLobbyWs();
		}

		internal void joinedLobby(string response)
		{
			currentLobby = JsonConvert.DeserializeObject<ServerManager.Lobby>(response);
			key = JsonUtility.FromJson<ServerManager.GenericResponse>(response).key;
			ServerManager.PlayerList playerList = JsonConvert.DeserializeObject<ServerManager.PlayerList>(response);
			foreach (string player in playerList.players)
			{
				currentLobby.playerData[player] = new ServerManager.PlayerData();
			}
			setSeed(currentLobby.seed);
			ConnectToLobbyWs();
		}

		internal IEnumerator StartLobby()
		{
			yield return ((MonoBehaviour)this).StartCoroutine(ServerManager.postJsonRequest("/api/startlobby", new ServerManager.GenericSafeRequest
			{
				name = currentLobby.name,
				player = SteamClient.Name,
				key = key
			}));
		}

		internal void playerWon()
		{
			((MonoBehaviour)this).StartCoroutine(TryReturnToLobby(playerWon: true));
			if (currentLobby.playerData[SteamClient.Name].ready)
			{
				ServerManager.UpdateOutboundPacket updateOutboundPacket = new ServerManager.UpdateOutboundPacket();
				updateOutboundPacket.type = "ready";
				updateOutboundPacket.action = "";
				sendWsMessage(JsonUtility.ToJson((object)updateOutboundPacket));
				ChangeMenuButtons.updateStartButton();
			}
			UIManager.SetToast("");
		}

		internal void playerLost()
		{
			currentLobby.playerData[SteamClient.Name] = new ServerManager.PlayerData();
			((MonoBehaviour)this).StartCoroutine(TryReturnToLobby(playerWon: false));
		}

		internal void playerForfeit()
		{
			ServerManager.UpdateOutboundPacket updateOutboundPacket = new ServerManager.UpdateOutboundPacket();
			updateOutboundPacket.type = "update";
			updateOutboundPacket.action = "forfeit";
			sendWsMessage(JsonUtility.ToJson((object)updateOutboundPacket));
			playerLost();
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	internal static class ServerManager
	{
		internal static class ClientFields
		{
			public static REPOLabel levelsField;

			public static REPOLabel seedField;

			public static REPOLabel ffOnDeathField;

			public static REPOLabel levelFilterField;

			public static void update()
			{
				if ((Object)(object)seedFieldHost != (Object)null)
				{
					seedFieldHost.inputStringSystem.SetValue(RepoVersus.currentLobby.seed, false);
				}
				if ((Object)(object)seedField != (Object)null && (Object)(object)((REPOElement)seedField).repoScrollViewElement != (Object)null)
				{
					((TMP_Text)seedField.labelTMP).text = "Seed: " + RepoVersus.currentLobby.seed;
					((REPOElement)seedField).repoScrollViewElement.visibility = RepoVersus.currentLobby.settings.setSeed;
				}
				if ((Object)(object)levelsField != (Object)null)
				{
					((TMP_Text)levelsField.labelTMP).text = "Levels: " + RepoVersus.currentLobby.settings.levels;
				}
				if ((Object)(object)ffOnDeathField != (Object)null)
				{
					((TMP_Text)ffOnDeathField.labelTMP).text = "Forfeit on death: " + (RepoVersus.currentLobby.settings.forfeitOnDeath ? "On" : "Off");
				}
				if ((Object)(object)levelFilterField != (Object)null)
				{
					string levelFilter = RepoVersus.currentLobby.settings.levelFilter;
					((TMP_Text)levelFilterField.labelTMP).text = ((levelFilter == "All") ? levelFilter : ("Only " + levelFilter));
					((REPOElement)levelFilterField).repoScrollViewElement.visibility = levelFilter != "All";
				}
			}
		}

		[Serializable]
		public class GenericUnsafeRequest
		{
			public string name;

			public string player;
		}

		[Serializable]
		public class GenericSafeRequest
		{
			public string name;

			public string player;

			public string key = RepoVersus.key;
		}

		[Serializable]
		public class GameSettings
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static ScrollViewBuilderDelegate <>9__4_7;

				public static Action<string> <>9__4_10;

				public static ScrollViewBuilderDelegate <>9__4_1;

				internal RectTransform <putInScrollView>b__4_7(Transform scrollView)
				{
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					//IL_0048: Unknown result type (might be due to invalid IL or missing references)
					//IL_004d: Unknown result type (might be due to invalid IL or missing references)
					//IL_005e: Unknown result type (might be due to invalid IL or missing references)
					REPOLabel val = MenuAPI.CreateREPOLabel("Forfeit on death: " + (RepoVersus.currentLobby.settings.forfeitOnDeath ? "On" : "Off"), scrollView, default(Vector2));
					((Transform)((REPOElement)val).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
					((Graphic)val.labelTMP).color = Color.gray;
					ClientFields.ffOnDeathField = val;
					return ((REPOElement)val).rectTransform;
				}

				internal RectTransform <putInScrollView>b__4_1(Transform scrollView)
				{
					//IL_0033: Unknown result type (might be due to invalid IL or missing references)
					//IL_0039: Unknown result type (might be due to invalid IL or missing references)
					Action<string> obj = delegate(string newSeed)
					{
						RepoVersus.setSeed(newSeed);
						RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new SettingsPacket
						{
							setting = "seed",
							newValue = newSeed
						}));
						RepoVersus.setNewLbobyForTeam();
					};
					string seed = RepoVersus.currentLobby.seed;
					seedFieldHost = MenuAPI.CreateREPOInputField("Seed", obj, scrollView, default(Vector2), false, "", seed);
					return ((REPOElement)seedFieldHost).rectTransform;
				}

				internal void <putInScrollView>b__4_10(string newSeed)
				{
					RepoVersus.setSeed(newSeed);
					RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new SettingsPacket
					{
						setting = "seed",
						newValue = newSeed
					}));
					RepoVersus.setNewLbobyForTeam();
				}
			}

			public bool setSeed = false;

			public int levels;

			public bool forfeitOnDeath = false;

			public string levelFilter = "All";

			public void putInScrollView(REPOPopupPage page, bool hosting)
			{
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Expected O, but got Unknown
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Expected O, but got Unknown
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Expected O, but got Unknown
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Expected O, but got Unknown
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Expected O, but got Unknown
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a0: Expected O, but got Unknown
				//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_0124: Expected O, but got Unknown
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Expected O, but got Unknown
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Expected O, but got Unknown
				if (!hosting)
				{
					REPOLabel label = null;
					page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
					{
						//IL_0019: Unknown result type (might be due to invalid IL or missing references)
						//IL_001f: 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_0044: Unknown result type (might be due to invalid IL or missing references)
						//IL_005a: Unknown result type (might be due to invalid IL or missing references)
						label = MenuAPI.CreateREPOLabel("Seed: " + RepoVersus.currentLobby.seed, scrollView, default(Vector2));
						((Transform)((REPOElement)label).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
						((Graphic)label.labelTMP).color = Color.gray;
						ClientFields.seedField = label;
						return ((REPOElement)label).rectTransform;
					}, 0f, 0f);
					((REPOElement)label).repoScrollViewElement.visibility = setSeed;
					page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
					{
						//IL_0019: Unknown result type (might be due to invalid IL or missing references)
						//IL_001f: 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_003b: Unknown result type (might be due to invalid IL or missing references)
						//IL_004c: Unknown result type (might be due to invalid IL or missing references)
						REPOLabel val3 = MenuAPI.CreateREPOLabel($"Levels: {levels}", scrollView, default(Vector2));
						((Transform)((REPOElement)val3).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
						((Graphic)val3.labelTMP).color = Color.gray;
						ClientFields.levelsField = val3;
						return ((REPOElement)val3).rectTransform;
					}, 0f, -10f);
					object obj = <>c.<>9__4_7;
					if (obj == null)
					{
						ScrollViewBuilderDelegate val = delegate(Transform scrollView)
						{
							//IL_002b: Unknown result type (might be due to invalid IL or missing references)
							//IL_0031: Unknown result type (might be due to invalid IL or missing references)
							//IL_0048: Unknown result type (might be due to invalid IL or missing references)
							//IL_004d: Unknown result type (might be due to invalid IL or missing references)
							//IL_005e: Unknown result type (might be due to invalid IL or missing references)
							REPOLabel val3 = MenuAPI.CreateREPOLabel("Forfeit on death: " + (RepoVersus.currentLobby.settings.forfeitOnDeath ? "On" : "Off"), scrollView, default(Vector2));
							((Transform)((REPOElement)val3).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
							((Graphic)val3.labelTMP).color = Color.gray;
							ClientFields.ffOnDeathField = val3;
							return ((REPOElement)val3).rectTransform;
						};
						<>c.<>9__4_7 = val;
						obj = (object)val;
					}
					page.AddElementToScrollView((ScrollViewBuilderDelegate)obj, 0f, -10f);
					page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
					{
						//IL_003e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0044: Unknown result type (might be due to invalid IL or missing references)
						//IL_0064: Unknown result type (might be due to invalid IL or missing references)
						//IL_0069: Unknown result type (might be due to invalid IL or missing references)
						//IL_007f: Unknown result type (might be due to invalid IL or missing references)
						label = MenuAPI.CreateREPOLabel((levelFilter == "All") ? levelFilter : ("Only " + levelFilter), scrollView, default(Vector2));
						((Transform)((REPOElement)label).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
						((Graphic)label.labelTMP).color = Color.gray;
						ClientFields.levelFilterField = label;
						return ((REPOElement)label).rectTransform;
					}, 0f, -10f);
					((REPOElement)label).repoScrollViewElement.visibility = levelFilter != "All";
					return;
				}
				page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
				{
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Unknown result type (might be due to invalid IL or missing references)
					Action<bool> obj3 = delegate(bool randomize)
					{
						setSeed = !randomize;
						((REPOElement)seedFieldHost).repoScrollViewElement.visibility = setSeed;
						seedFieldHost.inputStringSystem.SetValue(RepoVersus.currentLobby.seed, false);
						RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new SettingsPacket
						{
							setting = "setSeed",
							newValue = setSeed.ToString()
						}));
						RepoVersus.setNewLbobyForTeam();
					};
					bool flag = !setSeed;
					REPOToggle val3 = MenuAPI.CreateREPOToggle("Randomize seed", obj3, scrollView, default(Vector2), "ON", "OFF", flag);
					return ((REPOElement)val3).rectTransform;
				}, 0f, 0f);
				object obj2 = <>c.<>9__4_1;
				if (obj2 == null)
				{
					ScrollViewBuilderDelegate val2 = delegate(Transform scrollView)
					{
						//IL_0033: Unknown result type (might be due to invalid IL or missing references)
						//IL_0039: Unknown result type (might be due to invalid IL or missing references)
						Action<string> obj3 = delegate(string newSeed)
						{
							RepoVersus.setSeed(newSeed);
							RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new SettingsPacket
							{
								setting = "seed",
								newValue = newSeed
							}));
							RepoVersus.setNewLbobyForTeam();
						};
						string seed = RepoVersus.currentLobby.seed;
						seedFieldHost = MenuAPI.CreateREPOInputField("Seed", obj3, scrollView, default(Vector2), false, "", seed);
						return ((REPOElement)seedFieldHost).rectTransform;
					};
					<>c.<>9__4_1 = val2;
					obj2 = (object)val2;
				}
				page.AddElementToScrollView((ScrollViewBuilderDelegate)obj2, 0f, 0f);
				((REPOElement)seedFieldHost).repoScrollViewElement.visibility = setSeed;
				page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
				{
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0022: Unknown result type (might be due to invalid IL or missing references)
					Action<bool> obj3 = delegate(bool ffOnDeath)
					{
						forfeitOnDeath = ffOnDeath;
						RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new SettingsPacket
						{
							setting = "forfeitOnDeath",
							newValue = forfeitOnDeath.ToString()
						}));
						RepoVersus.setNewLbobyForTeam();
					};
					bool flag = forfeitOnDeath;
					REPOToggle val3 = MenuAPI.CreateREPOToggle("Forfeit on death", obj3, scrollView, default(Vector2), "ON", "OFF", flag);
					return ((REPOElement)val3).rectTransform;
				}, 0f, 0f);
				page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
				{
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					//IL_0027: Unknown result type (might be due to invalid IL or missing references)
					Action<int> obj3 = delegate(int lvls)
					{
						levels = lvls;
						string message = JsonUtility.ToJson((object)new SettingsPacket
						{
							setting = "levels",
							newValue = levels.ToString()
						});
						RepoVersus.sendWsMessage(message);
						RepoVersus.setNewLbobyForTeam();
					};
					int num = levels;
					REPOSlider val3 = MenuAPI.CreateREPOSlider("Levels", "", obj3, scrollView, default(Vector2), 1, 20, num, "", "", (BarBehavior)0);
					UIManager.removeSliderBackground(val3);
					return ((REPOElement)val3).rectTransform;
				}, 0f, 0f);
				page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
				{
					//IL_007c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0082: Unknown result type (might be due to invalid IL or missing references)
					List<string> list = new List<string> { "All" };
					foreach (Level level in RunManager.instance.levels)
					{
						list.Add(level.NarrativeName);
					}
					REPOSlider val3 = MenuAPI.CreateREPOSlider("Level filter", "", (Action<string>)delegate(string s)
					{
						levelFilter = s;
						string message = JsonUtility.ToJson((object)new SettingsPacket
						{
							setting = "levelFilter",
							newValue = s
						});
						RepoVersus.sendWsMessage(message);
						RepoVersus.setNewLbobyForTeam();
					}, scrollView, list.ToArray(), levelFilter, default(Vector2), "", "", (BarBehavior)0);
					UIManager.removeSliderBackground(val3);
					return ((REPOElement)val3).rectTransform;
				}, 0f, 0f);
			}

			public void updateFields()
			{
				if ((Object)(object)seedFieldHost != (Object)null)
				{
					seedFieldHost.inputStringSystem.SetValue(RepoVersus.currentLobby.seed, false);
				}
				ClientFields.update();
			}

			public void clearSeedFields()
			{
				ClientFields.seedField = null;
				seedFieldHost = null;
			}
		}

		[Serializable]
		public class GenericResponse
		{
			public string success;

			public string error;

			public string seed;

			public string key;
		}

		[Serializable]
		public class Lobby
		{
			public string name;

			public string host;

			public Dictionary<string, PlayerData> playerData = new Dictionary<string, PlayerData>();

			public string seed;

			public bool started = false;

			public GameSettings settings;

			public void reset()
			{
				foreach (PlayerData value in playerData.Values)
				{
					value.level = 1;
					value.extract = 1;
					value.forfeit = false;
				}
			}
		}

		[Serializable]
		public class PlayerList
		{
			public List<string> players;
		}

		[Serializable]
		public class PlayerData
		{
			public int extract = 1;

			public int level = 1;

			public bool forfeit = false;

			public bool ready = false;
		}

		[Serializable]
		public class UpdateOutboundPacket
		{
			public string type;

			public string action;
		}

		[Serializable]
		public class SettingsPacket
		{
			public string type = "setting";

			public string setting;

			public string newValue;
		}

		[Serializable]
		public class UpdateInboundPacket
		{
			public string type;

			public string action;

			public string player;
		}

		[Serializable]
		public class FinishInboundPacket
		{
			public string type;

			public string winner;

			public string newSeed;
		}

		private static string adress = "https://repoversus.com";

		private static REPOInputField seedFieldHost;

		internal static void finishedExtract()
		{
			UpdateOutboundPacket updateOutboundPacket = new UpdateOutboundPacket();
			updateOutboundPacket.type = "update";
			updateOutboundPacket.action = "bounce extract";
			RepoVersus.sendWsMessage(JsonUtility.ToJson((object)updateOutboundPacket));
		}

		internal static void finishedLevel()
		{
			UpdateOutboundPacket updateOutboundPacket = new UpdateOutboundPacket();
			updateOutboundPacket.type = "update";
			updateOutboundPacket.action = "bounce level";
			RepoVersus.sendWsMessage(JsonUtility.ToJson((object)updateOutboundPacket));
		}

		internal static IEnumerator getRequest(string endpoint)
		{
			UnityWebRequest webRequest = UnityWebRequest.Get(adress + endpoint);
			try
			{
				yield return webRequest.SendWebRequest();
			}
			finally
			{
				((IDisposable)webRequest)?.Dispose();
			}
		}

		internal static IEnumerator postTextRequest(string endpoint, string message, Action<string>? callOnComplete = null)
		{
			byte[] messageB = Encoding.UTF8.GetBytes(message);
			UnityWebRequest www = new UnityWebRequest(adress + endpoint, "POST");
			try
			{
				www.uploadHandler = (UploadHandler)new UploadHandlerRaw(messageB);
				www.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				www.SetRequestHeader("Content-Type", "text/plain");
				yield return www.SendWebRequest();
				if ((int)www.result != 1)
				{
					RepoVersus.Logger.LogError((object)("POST Failed: " + www.error));
				}
				else
				{
					callOnComplete?.Invoke(www.downloadHandler.text);
				}
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		internal static IEnumerator postJsonRequest(string endpoint, object message, Action<string>? callOnComplete = null)
		{
			string json = JsonUtility.ToJson(message);
			byte[] messageB = Encoding.UTF8.GetBytes(json);
			UnityWebRequest www = new UnityWebRequest(adress + endpoint, "POST");
			try
			{
				www.uploadHandler = (UploadHandler)new UploadHandlerRaw(messageB);
				www.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				www.SetRequestHeader("Content-Type", "application/json");
				yield return www.SendWebRequest();
				if ((int)www.result != 1)
				{
					RepoVersus.Logger.LogError((object)("POST Failed: " + www.error));
				}
				else
				{
					callOnComplete?.Invoke(www.downloadHandler.text);
				}
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}
	}
	internal class TeamHandler : MonoBehaviour
	{
		[PunRPC]
		public void newToast(string text)
		{
			UIManager.SetToast(text);
		}

		[PunRPC]
		public void newToast(string text, int time)
		{
			UIManager.SetToast(text, time);
		}

		[PunRPC]
		public void setLobby(string lobbyJson)
		{
			ServerManager.GameSettings settings = RepoVersus.currentLobby.settings;
			RepoVersus.currentLobby = JsonConvert.DeserializeObject<ServerManager.Lobby>(lobbyJson);
			if (RepoVersus.currentLobby == null)
			{
				RepoVersus.currentLobby = new ServerManager.Lobby();
				RepoVersus.closeLobbyPage();
			}
			else if (RepoVersus.currentLobby.settings == null)
			{
				RepoVersus.closeLobbyPage();
			}
			else
			{
				settings?.updateFields();
			}
		}
	}
	internal static class UIManager
	{
		[HarmonyPatch(typeof(HealthUI))]
		private class HealthUIPatch
		{
			[HarmonyPatch("Start")]
			[HarmonyPostfix]
			private static void CloneHealthUI()
			{
				SetupToast();
			}
		}

		private static TextMeshProUGUI toastText;

		internal static void SetupToast()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)toastText != (Object)null))
			{
				GameObject gameObject = ((Component)((Component)HealthUI.instance).transform.Find("HealthMax")).gameObject;
				GameObject val = Object.Instantiate<GameObject>(gameObject);
				val.transform.parent = gameObject.transform.parent.parent;
				val.transform.position = Vector2.op_Implicit(new Vector2(590f, 315f));
				toastText = val.GetComponent<TextMeshProUGUI>();
				((Graphic)toastText).color = Color.yellow;
				((TMP_Text)toastText).lineSpacing = -50f;
				((TMP_Text)toastText).text = RepoVersus.newestToast;
			}
		}

		internal static void SetToast(string text)
		{
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("newToast", (RpcTarget)1, new object[1] { text });
			}
			((TMP_Text)toastText).text = text;
			RepoVersus.newestToast = text;
		}

		internal static void removeSliderBackground(REPOSlider slider)
		{
			((Component)((Component)slider).gameObject.transform.Find("SliderBG").Find("RawImage (3)")).gameObject.SetActive(false);
		}

		internal static IEnumerator SetToast(string text, int seconds)
		{
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("newToast", (RpcTarget)1, new object[2] { text, seconds });
			}
			((TMP_Text)toastText).text = text;
			yield return (object)new WaitForSeconds((float)seconds);
			if (((TMP_Text)toastText).text == text)
			{
				((TMP_Text)toastText).text = RepoVersus.newestToast;
			}
		}
	}
}