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.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(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}");
			}
		}
	}
	[BepInPlugin("Larsielol.RepoVersus", "RepoVersus", "1.0")]
	public class RepoVersus : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static BuilderDelegate <>9__25_2;

			public static ShouldCloseMenuDelegate <>9__27_0;

			public static Action<string> <>9__27_4;

			public static ScrollViewBuilderDelegate <>9__27_1;

			public static Action <>9__27_11;

			public static BuilderDelegate <>9__27_9;

			public static ScrollViewBuilderDelegate <>9__27_10;

			public static EventHandler <>9__34_0;

			public static EventHandler<CloseEventArgs> <>9__34_2;

			internal void <Awake>b__25_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__27_0()
			{
				lobbyPage = null;
				return true;
			}

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

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

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

			internal void <ConnectToLobbyWs>b__34_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__DisplayClass28_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__DisplayClass29_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__29 : 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__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 <JoinLobby>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.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__28 : 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__DisplayClass28_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__28(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__DisplayClass28_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__38 : 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__38(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__33 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool playerWon;

			public RepoVersus <>4__this;

			private RunManager <rm>5__1;

			private bool <startedInLobbyMenu>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<rm>5__1 = 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;
					<rm>5__1 = RunManager.instance;
					<startedInLobbyMenu>5__2 = false;
					if (SemiFunc.MenuLevel())
					{
						<startedInLobbyMenu>5__2 = true;
						<>4__this.showMatchEndedScreen();
					}
					goto IL_00b6;
				case 1:
					<>1__state = -1;
					goto IL_00b6;
				case 2:
					{
						<>1__state = -1;
						if (!<startedInLobbyMenu>5__2)
						{
							if (playerWon)
							{
								<>4__this.showWinScreen();
							}
							else
							{
								<>4__this.showLossScreen();
							}
						}
						return false;
					}
					IL_00b6:
					if (!SemiFunc.MenuLevel())
					{
						<rm>5__1.ChangeLevel(true, SemiFunc.RunIsArena(), (ChangeLevelType)3);
						<>2__current = (object)new WaitForSeconds(3f);
						<>1__state = 1;
						return true;
					}
					<rm>5__1.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 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			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)playerForfeit, parent, new Vector2(126f, 70f));
			});
			object obj = <>c.<>9__25_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__25_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_005b: 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: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			string text = "Lobby";
			if (currentLobby != null && currentLobby.name != null)
			{
				text = currentLobby.name;
			}
			lobbyPage = MenuAPI.CreateREPOPopupPage(text, (PresetSide)0, false, true, 1.5f);
			REPOPopupPage obj = lobbyPage;
			object obj2 = <>c.<>9__27_0;
			if (obj2 == null)
			{
				ShouldCloseMenuDelegate val = delegate
				{
					lobbyPage = null;
					return true;
				};
				<>c.<>9__27_0 = val;
				obj2 = (object)val;
			}
			obj.onEscapePressed = (ShouldCloseMenuDelegate)obj2;
			if (currentLobby == null || currentLobby.name == null)
			{
				REPOPopupPage obj3 = lobbyPage;
				object obj4 = <>c.<>9__27_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__27_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__27_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__27_9 = val3;
				obj6 = (object)val3;
			}
			obj5.AddElement((BuilderDelegate)obj6);
			REPOPopupPage obj7 = lobbyPage;
			object obj8 = <>c.<>9__27_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__27_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__28))]
		internal IEnumerator MakeLobby(string name, Action<bool> onCreate)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MakeLobby>d__28(0)
			{
				<>4__this = this,
				name = name,
				onCreate = onCreate
			};
		}

		[IteratorStateMachine(typeof(<JoinLobby>d__29))]
		internal IEnumerator JoinLobby(string name, Action<bool> onJoin)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <JoinLobby>d__29(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__33))]
		internal IEnumerator TryReturnToLobby(bool playerWon)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TryReturnToLobby>d__33(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";
					}
					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__38))]
		internal IEnumerator StartLobby()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartLobby>d__38(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();
			}
		}
	}
	internal static class ServerManager
	{
		internal static class ClientFields
		{
			public static REPOLabel levelsField;

			public static REPOLabel seedField;

			public static REPOLabel ffOnDeathField;

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

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

				public static Action<string> <>9__3_8;

				public static ScrollViewBuilderDelegate <>9__3_1;

				internal RectTransform <putInScrollView>b__3_6(Transform scrollView)
				{
					//IL_0022: Unknown result type (might be due to invalid IL or missing references)
					//IL_0028: 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_0055: Unknown result type (might be due to invalid IL or missing references)
					REPOLabel val = MenuAPI.CreateREPOLabel("Forfeit on death: " + RepoVersus.currentLobby.settings.forfeitOnDeath, 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__3_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__3_8(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 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_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 val7 = MenuAPI.CreateREPOLabel($"Levels: {levels}", scrollView, default(Vector2));
						((Transform)((REPOElement)val7).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
						((Graphic)val7.labelTMP).color = Color.gray;
						ClientFields.levelsField = val7;
						return ((REPOElement)val7).rectTransform;
					}, 0f, -10f);
					object obj = <>c.<>9__3_6;
					if (obj == null)
					{
						ScrollViewBuilderDelegate val = delegate(Transform scrollView)
						{
							//IL_0022: Unknown result type (might be due to invalid IL or missing references)
							//IL_0028: 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_0055: Unknown result type (might be due to invalid IL or missing references)
							REPOLabel val6 = MenuAPI.CreateREPOLabel("Forfeit on death: " + RepoVersus.currentLobby.settings.forfeitOnDeath, scrollView, default(Vector2));
							((Transform)((REPOElement)val6).rectTransform).localScale = Vector2.op_Implicit(new Vector2(0.7f, 0.7f));
							((Graphic)val6.labelTMP).color = Color.gray;
							ClientFields.ffOnDeathField = val6;
							return ((REPOElement)val6).rectTransform;
						};
						<>c.<>9__3_6 = 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 val5 = MenuAPI.CreateREPOToggle("Randomize seed", obj6, scrollView, default(Vector2), "ON", "OFF", flag2);
					return ((REPOElement)val5).rectTransform;
				}, 0f, 0f);
				object obj2 = <>c.<>9__3_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__3_1 = val2;
					obj2 = (object)val2;
				}
				page.AddElementToScrollView((ScrollViewBuilderDelegate)obj2, 0f, 0f);
				((REPOElement)seedFieldHost).repoScrollViewElement.visibility = setSeed;
				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> obj4 = delegate(int lvls)
					{
						levels = lvls;
						string message = JsonUtility.ToJson((object)new SettingsPacket
						{
							setting = "levels",
							newValue = levels.ToString()
						});
						RepoVersus.sendWsMessage(message);
					};
					int num = levels;
					REPOSlider val4 = MenuAPI.CreateREPOSlider("Levels", "", obj4, scrollView, default(Vector2), 1, 20, num, "", "", (BarBehavior)0);
					UIManager.removeSliderBackground(val4);
					return ((REPOElement)val4).rectTransform;
				}, 0f, 0f);
				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()
						}));
					};
					bool flag = forfeitOnDeath;
					REPOToggle val3 = MenuAPI.CreateREPOToggle("Forfeit on death", obj3, scrollView, default(Vector2), "ON", "OFF", flag);
					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
			};
		}
	}
}