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 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]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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);
			}
		}

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

			private object <>2__current;

			public MenuButton button;

			public Vector3 pos;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: 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 = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((Component)button).transform.localPosition = pos;
					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 <setSizeDelayed>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MenuButton button;

			public Vector2 sizeDelta;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: 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 = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					button.rectTransform.sizeDelta = sizeDelta;
					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 <setTextDelayed>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MenuButton button;

			public string text;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((TMP_Text)button.buttonText).SetText(text, 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();
			}
		}

		private static MenuButton startButton;

		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		public static void setup(MenuButton __instance)
		{
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Expected O, but got Unknown
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Expected O, but got Unknown
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Expected O, but got Unknown
			MenuButton button = __instance;
			if (((TMP_Text)button.buttonText).text != "start game" && (Object)(object)button != (Object)(object)startButton)
			{
				if (((TMP_Text)button.buttonText).text == "Leave")
				{
					for (int i = 0; i < ((UnityEventBase)button.menuButtonPopUp.option1Event).GetPersistentEventCount(); i++)
					{
						Debug.LogError((object)((UnityEventBase)button.menuButtonPopUp.option1Event).GetPersistentTarget(i));
						Debug.LogError((object)((UnityEventBase)button.menuButtonPopUp.option1Event).GetPersistentMethodName(i));
					}
					button.menuButtonPopUp.option1Event.AddListener(new UnityAction(RepoVersus.Instance.leaveLobby));
				}
				else if (((TMP_Text)button.buttonText).text.ToLower() == "join friend")
				{
					((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setTextDelayed(button, "Join Teammate"));
					((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setPositionDelayed(button, new Vector3(0f, 202f, 0f)));
					((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setSizeDelayed(button, new Vector2(124f, 36f)));
				}
				else if (((TMP_Text)button.buttonText).text == "Private Game")
				{
					button.menuButtonPopUp = null;
					((UnityEventBase)button.button.onClick).RemoveAllListeners();
					ButtonClickedEvent onClick = button.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(button, "Create team"));
				}
				else
				{
					if (!(((TMP_Text)button.buttonText).text.ToLower() == "Versus Lobby"))
					{
						return;
					}
					if (SemiFunc.IsMasterClientOrSingleplayer())
					{
						((UnityEventBase)button.button.onClick).RemoveAllListeners();
						((UnityEvent)button.button.onClick).AddListener(new UnityAction(RepoVersus.Instance.openLobbyPage));
						return;
					}
					((UnityEventBase)button.button.onClick).RemoveAllListeners();
					ButtonClickedEvent onClick2 = button.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 = button;
			button.menuButtonPopUp = null;
			((UnityEventBase)button.button.onClick).RemoveAllListeners();
			if (RepoVersus.currentLobby.host == SteamClient.Name)
			{
				((UnityEvent)button.button.onClick).AddListener((UnityAction)delegate
				{
					((Behaviour)button).enabled = false;
					RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new ServerManager.UpdateOutboundPacket
					{
						type = "start",
						action = ""
					}));
				});
			}
			else
			{
				((UnityEvent)button.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)button.buttonText).SetText("Unready", true);
						RepoVersus.currentLobby.playerData[SteamClient.Name].ready = true;
					}
					else
					{
						((TMP_Text)button.buttonText).SetText("Ready up", true);
						RepoVersus.currentLobby.playerData[SteamClient.Name].ready = false;
					}
				});
			}
			if (!RepoVersus.currentLobby.playerData.ContainsKey(SteamClient.Name) || RepoVersus.currentLobby.started)
			{
				((Graphic)button.buttonText).color = new Color(0.25f, 0.25f, 0.25f);
				((Behaviour)button).enabled = false;
			}
			else
			{
				((Graphic)button.buttonText).color = new Color(0.5f, 0.5f, 0.5f);
				((Behaviour)button).enabled = true;
			}
			updateStartButton(setupAgain: false);
			if (RepoVersus.currentLobby.host == SteamClient.Name)
			{
				((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setTextDelayed(button, "Start match"));
			}
			else if (!RepoVersus.currentLobby.playerData.ContainsKey(SteamClient.Name) || !RepoVersus.currentLobby.playerData[SteamClient.Name].ready)
			{
				((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setTextDelayed(button, "Ready up"));
			}
			else
			{
				((MonoBehaviour)RepoVersus.Instance).StartCoroutine(setTextDelayed(button, "Unready"));
			}
		}

		[IteratorStateMachine(typeof(<setTextDelayed>d__2))]
		private static IEnumerator setTextDelayed(MenuButton button, string text)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <setTextDelayed>d__2(0)
			{
				button = button,
				text = text
			};
		}

		[IteratorStateMachine(typeof(<setPositionDelayed>d__3))]
		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 decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <setPositionDelayed>d__3(0)
			{
				button = button,
				pos = pos
			};
		}

		[IteratorStateMachine(typeof(<setSizeDelayed>d__4))]
		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 decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <setSizeDelayed>d__4(0)
			{
				button = button,
				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;
				}
				RepoSeeded.setSeed(RepoVersus.currentLobby.seed);
				RunManager.instance.ResetProgress();
				MenuPageLobby.instance.ButtonStart();
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(RoundDirector))]
	internal static class ExtractTracking
	{
		[HarmonyPrefix]
		[HarmonyPatch("ExtractionCompleted")]
		private static void SendExtractionMessage()
		{
			ServerManager.finishedExtract();
		}
	}
	[HarmonyPatch(typeof(MenuPageEsc))]
	internal class LeaveLobbyOnLeaveREPOLobby
	{
		[HarmonyPatch("ButtonEventQuitToMenu")]
		[HarmonyPrefix]
		private static void leaveVersusLobby()
		{
			RepoVersus.Instance.leaveLobby();
		}
	}
	[HarmonyPatch(typeof(RunManager))]
	internal class LevelFilter
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetRunLevel")]
		private static void filterLevel()
		{
			if (!(RepoVersus.currentLobby.settings.levelFilter != "All"))
			{
				return;
			}
			RepoVersus.Logger.LogInfo((object)"filtering map");
			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 (value == RepoVersus.currentLobby.playerData[SteamClient.Name].level)
			{
				ServerManager.finishedLevel();
			}
			else if (value > RepoVersus.currentLobby.playerData[SteamClient.Name].level)
			{
				RepoVersus.Logger.LogError((object)$"SOMEHOW WE SKIPPED A LEVEL?? LEvel {value}");
			}
		}
	}
	[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;
		}
	}
	[BepInPlugin("Larsielol.RepoVersus", "RepoVersus", "1.0.1")]
	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__28_0;

			public static Action<string> <>9__28_4;

			public static ScrollViewBuilderDelegate <>9__28_1;

			public static Action <>9__28_11;

			public static BuilderDelegate <>9__28_9;

			public static ScrollViewBuilderDelegate <>9__28_10;

			public static EventHandler <>9__35_0;

			public static EventHandler<CloseEventArgs> <>9__35_2;

			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__28_0()
			{
				lobbyPage = null;
				return true;
			}

			internal RectTransform <openLobbyPage>b__28_1(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__28_4(string code)
			{
				currentCode = code.Replace(" ", "").ToUpper();
			}

			internal void <openLobbyPage>b__28_9(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__28_11()
			{
				ws.Close();
				lobbyPage.ClosePage(true);
				ChangeMenuButtons.updateStartButton();
			}

			internal RectTransform <openLobbyPage>b__28_10(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__35_0(object sender, EventArgs e)
			{
				Console.WriteLine("Connected to the websocket.");
				if (wsOn)
				{
					ws.Close();
				}
				else
				{
					wsOn = true;
				}
			}

			internal void <ConnectToLobbyWs>b__35_2(object sender, CloseEventArgs e)
			{
				Console.WriteLine("The websocket to the lobby was closed");
				wsOn = false;
				currentLobby.settings.clearSeedFields();
				currentLobby = new ServerManager.Lobby();
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass29_0
		{
			public RepoVersus <>4__this;

			public Action<bool> onCreate;

			internal void <MakeLobby>b__0(string response)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				bool flag = !response.Contains("error");
				if (flag)
				{
					<>4__this.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);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass30_0
		{
			public RepoVersus <>4__this;

			public Action<bool> onJoin;

			internal void <JoinLobby>b__0(string response)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				bool flag = !response.Contains("error");
				if (flag)
				{
					<>4__this.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);
			}
		}

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

			private object <>2__current;

			public string name;

			public Action<bool> onJoin;

			public RepoVersus <>4__this;

			private <>c__DisplayClass30_0 <>8__1;

			private ServerManager.GenericUnsafeRequest <req>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass30_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.onJoin = onJoin;
					Logger.LogMessage((object)("Joining lobby " + name + ".\n"));
					<req>5__2 = new ServerManager.GenericUnsafeRequest();
					<req>5__2.name = name;
					<req>5__2.player = SteamClient.Name;
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(ServerManager.postJsonRequest("/api/join", <req>5__2, delegate(string response)
					{
						//IL_003d: Unknown result type (might be due to invalid IL or missing references)
						bool flag = !response.Contains("error");
						if (flag)
						{
							<>8__1.<>4__this.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);
						}
						<>8__1.onJoin(flag);
					}));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					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 <MakeLobby>d__29 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string name;

			public Action<bool> onCreate;

			public RepoVersus <>4__this;

			private <>c__DisplayClass29_0 <>8__1;

			private ServerManager.GenericUnsafeRequest <req>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass29_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.onCreate = onCreate;
					<req>5__2 = new ServerManager.GenericUnsafeRequest();
					<req>5__2.name = name;
					<req>5__2.player = SteamClient.Name;
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(ServerManager.postJsonRequest("/api/createlobby", <req>5__2, delegate(string response)
					{
						//IL_003d: Unknown result type (might be due to invalid IL or missing references)
						bool flag = !response.Contains("error");
						if (flag)
						{
							<>8__1.<>4__this.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);
						}
						<>8__1.onCreate(flag);
					}));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					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 <StartLobby>d__39 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RepoVersus <>4__this;

			private ServerManager.GenericSafeRequest <request>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<request>5__1 = new ServerManager.GenericSafeRequest();
					<request>5__1.name = currentLobby.name;
					<request>5__1.player = SteamClient.Name;
					<request>5__1.key = key;
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(ServerManager.postJsonRequest("/api/startlobby", <request>5__1));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					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 <TryReturnToLobby>d__34 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool playerWon;

			public RepoVersus <>4__this;

			private bool <startedInLobbyMenu>5__1;

			private RunManager <rm>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (returningToLobby)
					{
						return false;
					}
					returningToLobby = true;
					<startedInLobbyMenu>5__1 = false;
					<rm>5__2 = RunManager.instance;
					if (SemiFunc.MenuLevel())
					{
						<startedInLobbyMenu>5__1 = true;
						<>4__this.showMatchEndedScreen();
					}
					goto IL_00b6;
				case 1:
					<>1__state = -1;
					goto IL_00b6;
				case 2:
					{
						<>1__state = -1;
						if (!<startedInLobbyMenu>5__1 && SemiFunc.MenuLevel())
						{
							if (playerWon)
							{
								<>4__this.showWinScreen();
							}
							else
							{
								<>4__this.showLossScreen();
							}
						}
						return false;
					}
					IL_00b6:
					if (!SemiFunc.MenuLevel())
					{
						<rm>5__2.ChangeLevel(true, SemiFunc.RunIsArena(), (ChangeLevelType)3);
						<>2__current = (object)new WaitForSeconds(3f);
						<>1__state = 1;
						return true;
					}
					<rm>5__2.ResetProgress();
					currentLobby.reset();
					ChangeMenuButtons.updateStartButton();
					returningToLobby = false;
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 2;
					return true;
				}
			}

			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 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()
		{
			if (ws != null)
			{
				ws.Close();
			}
		}

		private void Awake()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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.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 val9 = MenuAPI.CreateREPOButton("Versus Lobby", (Action)openLobbyPage, parent, Vector2.op_Implicit(new Vector3(128f, 64f, 0f)));
			});
			MenuAPI.AddElementToEscapeMenu((BuilderDelegate)delegate(Transform parent)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				REPOButton val8 = 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!");
		}

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

		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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: 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__28_0;
			if (obj2 == null)
			{
				ShouldCloseMenuDelegate val = delegate
				{
					lobbyPage = null;
					return true;
				};
				<>c.<>9__28_0 = val;
				obj2 = (object)val;
			}
			obj.onEscapePressed = (ShouldCloseMenuDelegate)obj2;
			if (currentLobby == null || currentLobby.name == null)
			{
				REPOPopupPage obj3 = lobbyPage;
				object obj4 = <>c.<>9__28_1;
				if (obj4 == null)
				{
					ScrollViewBuilderDelegate val2 = 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> obj9 = delegate(string code)
						{
							currentCode = code.Replace(" ", "").ToUpper();
						};
						string text2 = currentCode;
						REPOInputField val11 = MenuAPI.CreateREPOInputField("Lobby name", obj9, scrollView, default(Vector2), false, "", text2);
						return ((REPOElement)val11).rectTransform;
					};
					<>c.<>9__28_1 = val2;
					obj4 = (object)val2;
				}
				obj3.AddElementToScrollView((ScrollViewBuilderDelegate)obj4, 0f, 0f);
				lobbyPage.AddElement((BuilderDelegate)delegate(Transform page)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					REPOButton val10 = MenuAPI.CreateREPOButton("Create Lobby", (Action)delegate
					{
						((MonoBehaviour)this).StartCoroutine(MakeLobby(currentCode, delegate(bool created)
						{
							if (created && (Object)(object)lobbyPage != (Object)null)
							{
								ChangeMenuButtons.updateStartButton();
								refreshLobbyPage();
							}
						}));
					}, 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 val9 = MenuAPI.CreateREPOButton("Join Lobby", (Action)delegate
					{
						((MonoBehaviour)this).StartCoroutine(JoinLobby(currentCode, delegate(bool joined)
						{
							if (joined && (Object)(object)lobbyPage != (Object)null)
							{
								ChangeMenuButtons.updateStartButton();
								refreshLobbyPage();
							}
						}));
					}, page, new Vector2(190f, 240f));
				});
				lobbyPage.OpenPage(false);
				return;
			}
			REPOPopupPage obj5 = lobbyPage;
			object obj6 = <>c.<>9__28_9;
			if (obj6 == null)
			{
				BuilderDelegate val3 = 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__28_9 = val3;
				obj6 = (object)val3;
			}
			obj5.AddElement((BuilderDelegate)obj6);
			REPOPopupPage obj7 = lobbyPage;
			object obj8 = <>c.<>9__28_10;
			if (obj8 == null)
			{
				ScrollViewBuilderDelegate val4 = 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 val7 = MenuAPI.CreateREPOLabel("Players", scrollView, default(Vector2));
					((Transform)((REPOElement)val7).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.8f, 0.85f));
					return ((REPOElement)val7).rectTransform;
				};
				<>c.<>9__28_10 = val4;
				obj8 = (object)val4;
			}
			obj7.AddElementToScrollView((ScrollViewBuilderDelegate)obj8, 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 val6 = MenuAPI.CreateREPOLabel(p ?? "", scrollView, default(Vector2));
					((Transform)((REPOElement)val6).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
					((Graphic)val6.labelTMP).color = Color.gray;
					return ((REPOElement)val6).rectTransform;
				}, 0f, -10f);
			}
			lobbyPage.OpenPage(false);
			REPOPopupPage val5 = MenuAPI.CreateREPOPopupPage("Settings", (PresetSide)1, false, false, 0f);
			currentLobby.settings.putInScrollView(val5, currentLobby.host == SteamClient.Name);
			val5.OpenPage(true);
		}

		[IteratorStateMachine(typeof(<MakeLobby>d__29))]
		internal IEnumerator MakeLobby(string name, Action<bool> onCreate)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MakeLobby>d__29(0)
			{
				<>4__this = this,
				name = name,
				onCreate = onCreate
			};
		}

		[IteratorStateMachine(typeof(<JoinLobby>d__30))]
		internal IEnumerator JoinLobby(string name, Action<bool> onJoin)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <JoinLobby>d__30(0)
			{
				<>4__this = this,
				name = name,
				onJoin = onJoin
			};
		}

		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("");
			}
		}

		[IteratorStateMachine(typeof(<TryReturnToLobby>d__34))]
		internal IEnumerator TryReturnToLobby(bool playerWon)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TryReturnToLobby>d__34(0)
			{
				<>4__this = this,
				playerWon = playerWon
			};
		}

		internal void ConnectToLobbyWs()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			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;
				}
			};
			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")
				{
					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();
					}
					((MonoBehaviour)this).StartCoroutine(TryReturnToLobby(finishInboundPacket.winner == SteamClient.Name));
					currentLobby.started = false;
				}
			};
			ws.OnClose += delegate
			{
				Console.WriteLine("The websocket to the lobby was closed");
				wsOn = false;
				currentLobby.settings.clearSeedFields();
				currentLobby = new ServerManager.Lobby();
			};
			ws.ConnectAsync();
		}

		internal static void sendWsMessage(string message)
		{
			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();
		}

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

		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();
			}
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)108))
			{
				playerWon();
			}
		}
	}
	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)
				{
					((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;
				}
				if ((Object)(object)levelFilterField != (Object)null)
				{
					string levelFilter = RepoVersus.currentLobby.settings.levelFilter;
					((TMP_Text)levelFilterField.labelTMP).text = "Level filter: " + ((levelFilter == "All") ? levelFilter : ("Only " + levelFilter));
				}
			}
		}

		[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_9;

				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
						}));
					};
					string seed = RepoVersus.currentLobby.seed;
					seedFieldHost = MenuAPI.CreateREPOInputField("Seed", obj, scrollView, default(Vector2), false, "", seed);
					return ((REPOElement)seedFieldHost).rectTransform;
				}

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

			public bool setSeed = false;

			public int levels;

			public bool forfeitOnDeath = false;

			public string levelFilter = "All";

			public void putInScrollView(REPOPopupPage page, bool hosting)
			{
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Expected O, but got Unknown
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Expected O, but got Unknown
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Expected O, but got Unknown
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Expected O, but got Unknown
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Expected O, but got Unknown
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: 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 val8 = MenuAPI.CreateREPOLabel($"Levels: {levels}", scrollView, default(Vector2));
						((Transform)((REPOElement)val8).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
						((Graphic)val8.labelTMP).color = Color.gray;
						ClientFields.levelsField = val8;
						return ((REPOElement)val8).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 val7 = MenuAPI.CreateREPOLabel("Forfeit on death: " + (RepoVersus.currentLobby.settings.forfeitOnDeath ? "On" : "Off"), scrollView, default(Vector2));
							((Transform)((REPOElement)val7).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
							((Graphic)val7.labelTMP).color = Color.gray;
							ClientFields.ffOnDeathField = val7;
							return ((REPOElement)val7).rectTransform;
						};
						<>c.<>9__4_7 = val;
						obj = (object)val;
					}
					page.AddElementToScrollView((ScrollViewBuilderDelegate)obj, 0f, -10f);
					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> obj6 = 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()
						}));
					};
					bool flag2 = !setSeed;
					REPOToggle val6 = MenuAPI.CreateREPOToggle("Randomize seed", obj6, scrollView, default(Vector2), "ON", "OFF", flag2);
					return ((REPOElement)val6).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> obj5 = delegate(string newSeed)
						{
							RepoVersus.setSeed(newSeed);
							RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new SettingsPacket
							{
								setting = "seed",
								newValue = newSeed
							}));
						};
						string seed = RepoVersus.currentLobby.seed;
						seedFieldHost = MenuAPI.CreateREPOInputField("Seed", obj5, 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> obj4 = delegate(bool ffOnDeath)
					{
						forfeitOnDeath = ffOnDeath;
						RepoVersus.sendWsMessage(JsonUtility.ToJson((object)new SettingsPacket
						{
							setting = "forfeitOnDeath",
							newValue = forfeitOnDeath.ToString()
						}));
					};
					bool flag = forfeitOnDeath;
					REPOToggle val5 = MenuAPI.CreateREPOToggle("Forfeit on death", obj4, scrollView, default(Vector2), "ON", "OFF", flag);
					return ((REPOElement)val5).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 message2 = JsonUtility.ToJson((object)new SettingsPacket
						{
							setting = "levels",
							newValue = levels.ToString()
						});
						RepoVersus.sendWsMessage(message2);
					};
					int num = levels;
					REPOSlider val4 = MenuAPI.CreateREPOSlider("Levels", "", obj3, scrollView, default(Vector2), 1, 20, num, "", "", (BarBehavior)0);
					UIManager.removeSliderBackground(val4);
					return ((REPOElement)val4).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);
					}, 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;
		}

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

			private object <>2__current;

			public string endpoint;

			private UnityWebRequest <webRequest>5__1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<webRequest>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<webRequest>5__1 = UnityWebRequest.Get(adress + endpoint);
						<>1__state = -3;
						<>2__current = <webRequest>5__1.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						<>m__Finally1();
						<webRequest>5__1 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<webRequest>5__1 != null)
				{
					((IDisposable)<webRequest>5__1).Dispose();
				}
			}

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

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

			private object <>2__current;

			public string endpoint;

			public object message;

			public Action<string> callOnComplete;

			private string <json>5__1;

			private byte[] <messageB>5__2;

			private UnityWebRequest <www>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<json>5__1 = null;
				<messageB>5__2 = null;
				<www>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Expected O, but got Unknown
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Expected O, but got Unknown
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<json>5__1 = JsonUtility.ToJson(message);
						<messageB>5__2 = Encoding.UTF8.GetBytes(<json>5__1);
						<www>5__3 = new UnityWebRequest(adress + endpoint, "POST");
						<>1__state = -3;
						<www>5__3.uploadHandler = (UploadHandler)new UploadHandlerRaw(<messageB>5__2);
						<www>5__3.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<www>5__3.SetRequestHeader("Content-Type", "application/json");
						<>2__current = <www>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<www>5__3.result != 1)
						{
							RepoVersus.Logger.LogError((object)("POST Failed: " + <www>5__3.error));
						}
						else
						{
							RepoVersus.Logger.LogMessage((object)("POST Success: " + <www>5__3.downloadHandler.text));
							if (callOnComplete != null)
							{
								callOnComplete(<www>5__3.downloadHandler.text);
							}
						}
						<>m__Finally1();
						<www>5__3 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<www>5__3 != null)
				{
					((IDisposable)<www>5__3).Dispose();
				}
			}

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

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

			private object <>2__current;

			public string endpoint;

			public string message;

			public Action<string> callOnComplete;

			private byte[] <messageB>5__1;

			private UnityWebRequest <www>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<messageB>5__1 = null;
				<www>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Expected O, but got Unknown
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<messageB>5__1 = Encoding.UTF8.GetBytes(message);
						<www>5__2 = new UnityWebRequest(adress + endpoint, "POST");
						<>1__state = -3;
						<www>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(<messageB>5__1);
						<www>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<www>5__2.SetRequestHeader("Content-Type", "text/plain");
						<>2__current = <www>5__2.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<www>5__2.result != 1)
						{
							RepoVersus.Logger.LogError((object)("POST Failed: " + <www>5__2.error));
						}
						else
						{
							if (callOnComplete != null)
							{
								callOnComplete(<www>5__2.downloadHandler.text);
							}
							RepoVersus.Logger.LogMessage((object)("POST Success: " + <www>5__2.downloadHandler.text));
						}
						<>m__Finally1();
						<www>5__2 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<www>5__2 != null)
				{
					((IDisposable)<www>5__2).Dispose();
				}
			}

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

		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));
		}

		[IteratorStateMachine(typeof(<getRequest>d__16))]
		internal static IEnumerator getRequest(string endpoint)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <getRequest>d__16(0)
			{
				endpoint = endpoint
			};
		}

		[IteratorStateMachine(typeof(<postTextRequest>d__17))]
		internal static IEnumerator postTextRequest(string endpoint, string message, Action<string>? callOnComplete = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <postTextRequest>d__17(0)
			{
				endpoint = endpoint,
				message = message,
				callOnComplete = callOnComplete
			};
		}

		[IteratorStateMachine(typeof(<postJsonRequest>d__18))]
		internal static IEnumerator postJsonRequest(string endpoint, object message, Action<string>? callOnComplete = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <postJsonRequest>d__18(0)
			{
				endpoint = endpoint,
				message = message,
				callOnComplete = callOnComplete
			};
		}
	}
	internal static class UIManager
	{
		[HarmonyPatch(typeof(HealthUI))]
		private class HealthUIPatch
		{
			[HarmonyPatch("Start")]
			[HarmonyPostfix]
			private static void CloneHealthUI()
			{
				SetupToast();
			}
		}

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

			private object <>2__current;

			public string text;

			public int seconds;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((TMP_Text)toastText).text = text;
					<>2__current = (object)new WaitForSeconds((float)seconds);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((TMP_Text)toastText).text == text)
					{
						((TMP_Text)toastText).text = RepoVersus.newestToast;
					}
					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 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)
		{
			((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);
		}

		[IteratorStateMachine(typeof(<SetToast>d__5))]
		internal static IEnumerator SetToast(string text, int seconds)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetToast>d__5(0)
			{
				text = text,
				seconds = seconds
			};
		}
	}
}