using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Timers;
using AngryLevelLoader;
using AngryLevelLoader.Containers;
using AngryLevelLoader.Managers;
using AngryLevelLoader.Notifications;
using AngryLevelLoader.UserInterface;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using SettingsMenu.Components;
using SettingsMenu.Models;
using Steamworks;
using Steamworks.Data;
using TMPro;
using UltraBINGO;
using UltraBINGO.Components;
using UltraBINGO.NetworkMessages;
using UltraBINGO.UI_Elements;
using UltraEditor.Classes;
using UltraEditor.Classes.Canvas;
using UltraEditor.Libraries;
using UltrakillBingoClient;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using WebSocketSharp;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class BingoMapBrowser
{
	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		public static readonly <>c <>9 = new <>c();

		public static UnityAction<BaseEventData> <>9__41_0;

		public static UnityAction<BaseEventData> <>9__41_1;

		public static UnityAction<BaseEventData> <>9__41_4;

		public static UnityAction <>9__43_0;

		public static UnityAction <>9__43_1;

		public static UnityAction<int> <>9__43_2;

		internal void <Setup>b__41_0(BaseEventData data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			ShowMapData((PointerEventData)data);
		}

		internal void <Setup>b__41_1(BaseEventData data)
		{
			HideMapData();
		}

		internal void <Setup>b__41_4(BaseEventData data)
		{
			HideMapData();
		}

		internal void <Init>b__43_0()
		{
			ReturnToLobby();
		}

		internal void <Init>b__43_1()
		{
			GameManager.isUsingCustomMappool = true;
			GameManager.customMappool = selectedLevels;
			ReturnToLobby();
		}

		internal void <Init>b__43_2(int <p0>)
		{
			onCategoryUpdate(mapCategoryDropdown.value);
		}
	}

	public static GameObject LoadingText;

	public static GameObject MapBrowserWindow;

	public static GameObject SelectedMapsList;

	public static GameObject selectedMapsCount;

	public static GameObject BackButton;

	public static GameObject FinishButton;

	public static string angryCatalogURL = "https://raw.githubusercontent.com/eternalUnion/AngryLevels/release/V2/LevelCatalog.json";

	public static string angryThumbnailURL = "https://raw.githubusercontent.com/eternalUnion/AngryLevels/release/Levels/";

	public static string ultraEditorAPIURL = "https://duviz.xyz/api/ultraeditor/";

	public static string ultraEditorCatalogURL = "fetchlevels";

	public static string ultraEditorLevelURL = "getlevel/";

	public static string ultraEditorLevelImageURL = "getimg/";

	public static string ultraEditorDownloadURL = "downloadlevel/";

	public static GameObject CampaignCategory;

	public static GameObject AngryCategory;

	public static GameObject UltraEditorCategory;

	public static List<GameObject> categoryList = new List<GameObject>();

	public static GameObject MapTemplate;

	public static bool hasFetched = false;

	public static AngryMapCatalog catalog = null;

	public static List<string> ultraEditorCatalog = null;

	public static TMP_Dropdown mapCategoryDropdown = null;

	public static Dictionary<string, BingoMapSelectionID> selectedLevels = new Dictionary<string, BingoMapSelectionID>();

	public static List<string> selectedLevelNames = new List<string>();

	public static List<GameObject> campaignLevelCatalog = new List<GameObject>();

	public static List<GameObject> angryLevelCatalog = new List<GameObject>();

	public static List<GameObject> ultraEditorLevelCatalog = new List<GameObject>();

	public static List<int> campaignLevelIds;

	public static void ReturnToLobby()
	{
		BingoEncapsulator.BingoMapSelection.SetActive(false);
		BingoEncapsulator.BingoLobbyScreen.SetActive(true);
	}

	public static void ShowMapData(PointerEventData pointerEventData, AngryBundle parentBundle = null, AngryLevel level = null)
	{
	}

	public static void HideMapData()
	{
	}

	public static void ClearCategories()
	{
		angryLevelCatalog.Clear();
		ultraEditorLevelCatalog.Clear();
	}

	public static async Task<Texture2D> asyncFetchUltraEditorThumbnail(string imageName, string imageUrl)
	{
		if (File.Exists(Path.Combine(Main.ModFolder, "ThumbnailCache", imageName + ".png")))
		{
			Logging.Message("Loading " + imageName + ".png from thumbnail cache");
			byte[] array = File.ReadAllBytes(Path.Combine(Main.ModFolder, "ThumbnailCache", imageName + ".png"));
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array);
			return val;
		}
		Logging.Warn("Downloading " + imageName);
		UnityWebRequest texture = UnityWebRequestTexture.GetTexture(imageUrl);
		try
		{
			texture.SendWebRequest();
			while (!texture.isDone)
			{
				await Task.Yield();
			}
			if ((int)texture.result == 1)
			{
				Logging.Message("Saving " + imageName + ".png to thumbnail cache");
				byte[] bytes = ImageConversion.EncodeToPNG(DownloadHandlerTexture.GetContent(texture));
				File.WriteAllBytes(Path.Combine(Main.ModFolder, "ThumbnailCache", imageName + ".png"), bytes);
				return DownloadHandlerTexture.GetContent(texture);
			}
			Logging.Error("Error while trying to download image from thumbnail catalog!");
			Logging.Error(texture.responseCode.ToString());
			return null;
		}
		finally
		{
			((IDisposable)texture)?.Dispose();
		}
	}

	public static async Task<Texture2D> FetchThumbnail(string thumbnailGuid)
	{
		if (File.Exists(Path.Combine(Main.ModFolder, "ThumbnailCache", thumbnailGuid + ".png")))
		{
			byte[] array = File.ReadAllBytes(Path.Combine(Main.ModFolder, "ThumbnailCache", thumbnailGuid + ".png"));
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array);
			return val;
		}
		string text = angryThumbnailURL + "/" + thumbnailGuid + "/thumbnail.png";
		UnityWebRequest texture = UnityWebRequestTexture.GetTexture(text);
		try
		{
			texture.SendWebRequest();
			while (!texture.isDone)
			{
				await Task.Yield();
			}
			if ((int)texture.result == 1)
			{
				Logging.Message("Saving " + thumbnailGuid + ".png to thumbnail cache");
				byte[] bytes = ImageConversion.EncodeToPNG(DownloadHandlerTexture.GetContent(texture));
				File.WriteAllBytes(Path.Combine(Main.ModFolder, "ThumbnailCache", thumbnailGuid + ".png"), bytes);
				return DownloadHandlerTexture.GetContent(texture);
			}
			Logging.Error("Error while trying to download image from thumbnail catalog!");
			Logging.Error(texture.responseCode.ToString());
			return null;
		}
		finally
		{
			((IDisposable)texture)?.Dispose();
		}
	}

	public static void UpdateSelectedMaps()
	{
		int num = GameManager.CurrentGame.gameSettingsArray["gridSize"];
		int num2 = (3 + num) * (3 + num);
		((TMP_Text)SelectedMapsList.GetComponent<TextMeshProUGUI>()).text = string.Join("\n", selectedLevelNames);
		((TMP_Text)selectedMapsCount.GetComponent<TextMeshProUGUI>()).text = ((selectedLevels.Count >= num2) ? "<color=green>" : "<color=orange>") + selectedLevels.Count + "</color>/<color=orange>" + num2 + "</color>";
	}

	public static void ToggleMapSelection(ref GameObject levelPanel, string levelId, string levelName)
	{
		if (!selectedLevels.ContainsKey(levelId))
		{
			selectedLevels.Add(levelId, levelPanel.GetComponent<BingoMapSelectionID>());
			CommonFunctions.GetGameObjectChild(levelPanel, "SelectionIndicator").SetActive(true);
			selectedLevelNames.Add(levelName);
		}
		else
		{
			selectedLevels.Remove(levelId);
			CommonFunctions.GetGameObjectChild(levelPanel, "SelectionIndicator").SetActive(false);
			selectedLevelNames.Remove(levelName);
		}
		UpdateSelectedMaps();
	}

	public static async Task<int> fetchAngryCatalog()
	{
		try
		{
			catalog = JsonConvert.DeserializeObject<AngryMapCatalog>(await NetworkManager.FetchCatalog(angryCatalogURL));
			return 0;
		}
		catch (Exception ex)
		{
			Logging.Error(ex.ToString());
			return -1;
		}
	}

	public static void setupCampaignLevelIds()
	{
		campaignLevelIds = new List<int>();
		for (int i = 1; i < 34; i++)
		{
			campaignLevelIds.Add(i);
		}
		List<int> second = new List<int> { 100, 101 };
		List<int> second2 = new List<int> { 666, 667 };
		campaignLevelIds = campaignLevelIds.Concat(second).Concat(second2).ToList();
	}

	public static async Task asyncFetchUltraEditorThumbnails()
	{
		foreach (GameObject ultraeditorLevel in ultraEditorLevelCatalog)
		{
			Texture2D val = await asyncFetchUltraEditorThumbnail(ultraeditorLevel.GetComponent<BingoMapSelectionID>().UltraEditorImageName, ultraeditorLevel.GetComponent<BingoMapSelectionID>().UltraEditorImageURL);
			if ((Object)(object)val != (Object)null)
			{
				CommonFunctions.GetGameObjectChild(ultraeditorLevel, "BundleImage").GetComponent<Image>().sprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			}
		}
	}

	public static async Task asyncFetchAngryThumbnails()
	{
		foreach (GameObject angryLevel in angryLevelCatalog)
		{
			if (!((Object)angryLevel).name.Contains("Level "))
			{
				Texture2D val = await FetchThumbnail(angryLevel.GetComponent<BingoMapSelectionID>().angryBundleId);
				if ((Object)(object)val != (Object)null)
				{
					CommonFunctions.GetGameObjectChild(angryLevel, "BundleImage").GetComponent<Image>().sprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
				}
			}
		}
	}

	public static void ResetListPosition()
	{
		((TMP_Text)SelectedMapsList.GetComponent<TextMeshProUGUI>()).text = "";
		((TMP_Text)selectedMapsCount.GetComponent<TextMeshProUGUI>()).text = "";
	}

	public static async void Setup()
	{
		MapBrowserWindow.SetActive(true);
		if (hasFetched)
		{
			return;
		}
		setupCampaignLevelIds();
		GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CampaignCategory, "Grid"), "Scroll View"), "Viewport"), "Content"), "MapTemplate");
		foreach (int campaignLevel in campaignLevelIds)
		{
			GameObject levelPanel = Object.Instantiate<GameObject>(gameObjectChild, gameObjectChild.transform.parent);
			CommonFunctions.GetGameObjectChild(levelPanel, "BundleName").GetComponent<Text>().text = "CAMPAIGN";
			CommonFunctions.GetGameObjectChild(levelPanel, "MapName").GetComponent<Text>().text = GetMissionName.GetMissionNameOnly(campaignLevel);
			CommonFunctions.GetGameObjectChild(levelPanel, "SelectionIndicator").SetActive(false);
			Entry val = new Entry();
			val.eventID = (EventTriggerType)0;
			((UnityEvent<BaseEventData>)(object)val.callback).AddListener((UnityAction<BaseEventData>)delegate(BaseEventData data)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Expected O, but got Unknown
				ShowMapData((PointerEventData)data);
			});
			levelPanel.AddComponent<EventTrigger>();
			levelPanel.GetComponent<EventTrigger>().triggers.Add(val);
			((UnityEvent<BaseEventData>)(object)new Entry
			{
				eventID = (EventTriggerType)1
			}.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				HideMapData();
			});
			string text = "assets/bingo/lvlimg/campaign/" + GetMissionName.GetSceneName(campaignLevel) + ".png";
			Texture2D val2 = AssetLoader.Assets.LoadAsset<Texture2D>(text);
			Sprite sprite = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0.5f, 0.5f), 100f);
			CommonFunctions.GetGameObjectChild(levelPanel, "BundleImage").GetComponent<Image>().sprite = sprite;
			((Object)levelPanel).name = GetMissionName.GetSceneName(campaignLevel);
			levelPanel.SetActive(true);
			levelPanel.AddComponent<BingoMapSelectionID>();
			levelPanel.GetComponent<BingoMapSelectionID>().levelType = BingoLevelType.Campaign;
			levelPanel.GetComponent<BingoMapSelectionID>().levelName = GetMissionName.GetMissionNameOnly(campaignLevel);
			levelPanel.GetComponent<BingoMapSelectionID>().levelId = GetMissionName.GetSceneName(campaignLevel);
			levelPanel.AddComponent<Button>();
			((UnityEvent)levelPanel.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				ToggleMapSelection(ref levelPanel, GetMissionName.GetSceneName(campaignLevel), GetMissionName.GetMissionNameOnly(campaignLevel));
			});
			campaignLevelCatalog.Add(levelPanel);
		}
		Logging.Message("Fetching Angry map catalog...");
		if (await fetchAngryCatalog() == 0)
		{
			GameObject gameObjectChild2 = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(AngryCategory, "Grid"), "Scroll View"), "Viewport"), "Content"), "MapTemplate");
			foreach (AngryBundle bundle in catalog.Levels)
			{
				foreach (AngryLevel level in bundle.Levels)
				{
					GameObject levelPanel2 = Object.Instantiate<GameObject>(gameObjectChild2, gameObjectChild2.transform.parent);
					CommonFunctions.GetGameObjectChild(levelPanel2, "BundleName").GetComponent<Text>().text = bundle.Name;
					CommonFunctions.GetGameObjectChild(levelPanel2, "MapName").GetComponent<Text>().text = level.LevelName;
					CommonFunctions.GetGameObjectChild(levelPanel2, "SelectionIndicator").SetActive(false);
					Entry val3 = new Entry();
					val3.eventID = (EventTriggerType)0;
					((UnityEvent<BaseEventData>)(object)val3.callback).AddListener((UnityAction<BaseEventData>)delegate(BaseEventData data)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						//IL_001c: Expected O, but got Unknown
						ShowMapData((PointerEventData)data, bundle, level);
					});
					levelPanel2.AddComponent<EventTrigger>();
					levelPanel2.GetComponent<EventTrigger>().triggers.Add(val3);
					((UnityEvent<BaseEventData>)(object)new Entry
					{
						eventID = (EventTriggerType)1
					}.callback).AddListener((UnityAction<BaseEventData>)delegate
					{
						HideMapData();
					});
					levelPanel2.AddComponent<BingoMapSelectionID>();
					levelPanel2.GetComponent<BingoMapSelectionID>().levelType = BingoLevelType.Angry;
					levelPanel2.GetComponent<BingoMapSelectionID>().levelName = level.LevelName;
					levelPanel2.GetComponent<BingoMapSelectionID>().levelId = level.LevelId;
					levelPanel2.GetComponent<BingoMapSelectionID>().angryBundleId = bundle.Guid;
					levelPanel2.GetComponent<BingoMapSelectionID>().thumbnailPath = bundle.Guid;
					((Object)levelPanel2).name = level.LevelId;
					levelPanel2.SetActive(true);
					levelPanel2.AddComponent<Button>();
					((UnityEvent)levelPanel2.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						ToggleMapSelection(ref levelPanel2, level.LevelId, level.LevelName);
					});
					angryLevelCatalog.Add(levelPanel2);
				}
			}
		}
		Logging.Message("Fetching UltraEditor map catalog...");
		string urlToRequest = ultraEditorAPIURL + ultraEditorCatalogURL;
		try
		{
			int ultraEditorLevelCount = short.Parse(await NetworkManager.FetchCatalog(urlToRequest));
			if (ultraEditorLevelCount > 0)
			{
				GameObject gameObjectChild3 = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(UltraEditorCategory, "Grid"), "Scroll View"), "Viewport"), "Content");
				GameObject ultraeditorTemplate = CommonFunctions.GetGameObjectChild(gameObjectChild3, "MapTemplate");
				for (int x = 0; x < ultraEditorLevelCount - 1; x++)
				{
					UltraEditorLevelData levelData = JsonConvert.DeserializeObject<UltraEditorLevelData>(await NetworkManager.FetchCatalog(ultraEditorAPIURL + ultraEditorLevelURL + x));
					levelData.url = ultraEditorAPIURL + ultraEditorLevelURL + x;
					GameObject levelPanel3 = Object.Instantiate<GameObject>(ultraeditorTemplate, ultraeditorTemplate.transform.parent);
					ultraEditorLevelCatalog.Add(levelPanel3);
					levelPanel3.AddComponent<BingoMapSelectionID>();
					CommonFunctions.GetGameObjectChild(levelPanel3, "SelectionIndicator").SetActive(false);
					CommonFunctions.GetGameObjectChild(levelPanel3, "BundleName").GetComponent<Text>().text = "ULTRAEDITOR";
					CommonFunctions.GetGameObjectChild(levelPanel3, "MapName").GetComponent<Text>().text = levelData.name;
					levelPanel3.GetComponent<BingoMapSelectionID>().levelType = BingoLevelType.UltraEditor;
					levelPanel3.GetComponent<BingoMapSelectionID>().levelName = levelData.name;
					levelPanel3.GetComponent<BingoMapSelectionID>().levelId = levelData.guid;
					levelPanel3.GetComponent<BingoMapSelectionID>().UltraEditorLevelData = ultraEditorAPIURL + ultraEditorDownloadURL + x;
					levelPanel3.GetComponent<BingoMapSelectionID>().UltraEditorImageURL = ultraEditorAPIURL + ultraEditorLevelImageURL + x;
					levelPanel3.GetComponent<BingoMapSelectionID>().UltraEditorImageName = levelPanel3.GetComponent<BingoMapSelectionID>().levelId;
					levelPanel3.GetComponent<BingoMapSelectionID>().thumbnailPath = levelData.image;
					levelPanel3.AddComponent<Button>();
					((UnityEvent)levelPanel3.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						ToggleMapSelection(ref levelPanel3, levelData.name, levelData.guid);
					});
					((Object)levelPanel3).name = levelPanel3.GetComponent<BingoMapSelectionID>().levelId;
					levelPanel3.SetActive(true);
					ultraEditorLevelCatalog.Add(levelPanel3);
				}
			}
		}
		catch (Exception)
		{
			Logging.Error("Unable to fetch UltraEditor level catalog");
		}
		Logging.Warn("Loading Angry thumbnails");
		await asyncFetchAngryThumbnails();
		Logging.Warn("Loading UltraEditor thumbnails");
		await asyncFetchUltraEditorThumbnails();
		LoadingText.SetActive(false);
		hasFetched = true;
	}

	public static void onCategoryUpdate(int value)
	{
		foreach (GameObject category in categoryList)
		{
			category.SetActive(false);
		}
		categoryList[value].SetActive(true);
	}

	public static void Init(ref GameObject MapBrowser)
	{
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Expected O, but got Unknown
		//IL_00d6: 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)
		//IL_00e1: Expected O, but got Unknown
		LoadingText = CommonFunctions.GetGameObjectChild(MapBrowser, "DownloadingText");
		MapBrowserWindow = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(MapBrowser, "MapsCampaign"), "Grid"), "Scroll View"), "Viewport"), "Content");
		MapTemplate = CommonFunctions.GetGameObjectChild(MapBrowserWindow, "MapTemplate");
		BackButton = CommonFunctions.GetGameObjectChild(MapBrowser, "Back");
		ButtonClickedEvent onClick = BackButton.GetComponent<Button>().onClick;
		object obj = <>c.<>9__43_0;
		if (obj == null)
		{
			UnityAction val = delegate
			{
				ReturnToLobby();
			};
			<>c.<>9__43_0 = val;
			obj = (object)val;
		}
		((UnityEvent)onClick).AddListener((UnityAction)obj);
		FinishButton = CommonFunctions.GetGameObjectChild(MapBrowser, "Finish");
		ButtonClickedEvent onClick2 = FinishButton.GetComponent<Button>().onClick;
		object obj2 = <>c.<>9__43_1;
		if (obj2 == null)
		{
			UnityAction val2 = delegate
			{
				GameManager.isUsingCustomMappool = true;
				GameManager.customMappool = selectedLevels;
				ReturnToLobby();
			};
			<>c.<>9__43_1 = val2;
			obj2 = (object)val2;
		}
		((UnityEvent)onClick2).AddListener((UnityAction)obj2);
		SelectedMapsList = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(MapBrowser, "Summary"), "SelectedMaps"), "List");
		selectedMapsCount = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(MapBrowser, "Summary"), "TotalMapsNumber");
		((TMP_Text)selectedMapsCount.GetComponent<TextMeshProUGUI>()).text = "<color=orange>0</color>/<color=orange>0</color>";
		mapCategoryDropdown = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(MapBrowser, "MapsDropdown"), "Dropdown").GetComponent<TMP_Dropdown>();
		((UnityEvent<int>)(object)mapCategoryDropdown.onValueChanged).AddListener((UnityAction<int>)delegate
		{
			onCategoryUpdate(mapCategoryDropdown.value);
		});
		CampaignCategory = CommonFunctions.GetGameObjectChild(MapBrowser, "MapsCampaign");
		AngryCategory = CommonFunctions.GetGameObjectChild(MapBrowser, "MapsAngry");
		UltraEditorCategory = CommonFunctions.GetGameObjectChild(MapBrowser, "MapsUltraEditor");
		categoryList.Clear();
		categoryList.Add(CampaignCategory);
		categoryList.Add(AngryCategory);
		categoryList.Add(UltraEditorCategory);
	}
}
namespace UltrakillBingoClient
{
	public static class Logging
	{
		public static ManualLogSource BingoLogger = Logger.CreateLogSource("Baphomet's BINGO");

		public static void Debug(string text)
		{
			BingoLogger.LogDebug((object)text);
		}

		public static void Message(string text)
		{
			BingoLogger.LogMessage((object)text);
		}

		public static void Warn(string text)
		{
			BingoLogger.LogWarning((object)text);
		}

		public static void Error(string text)
		{
			BingoLogger.LogError((object)text);
		}

		public static void Fatal(string text)
		{
			BingoLogger.LogFatal((object)text);
		}

		public static void Info(string text)
		{
			BingoLogger.LogInfo((object)text);
		}
	}
	public enum State
	{
		NORMAL,
		INMENU,
		INLOBBY,
		INBROWSER,
		INGAME
	}
	public enum AsyncAction
	{
		None,
		Host,
		Join,
		ModCheck,
		RetrySend,
		ReconnectGame,
		FetchGames
	}
	public class SendMessage
	{
		public string messageType;
	}
	public class MessageResponse
	{
		public string messageType;
	}
	public class PlayerNotification
	{
		public string messageType;
	}
	public static class NetworkManager
	{
		public static AsyncAction pendingAction = AsyncAction.None;

		public static string pendingPassword = "";

		public static InitialChecksRequest pendingVmr = null;

		public static string QueuedMessage = "";

		public static State currentState = State.NORMAL;

		public static ConfigEntry<string> serverURLConfig;

		public static ConfigEntry<string> serverPortConfig;

		public static ConfigEntry<string> lastRankUsedConfig;

		public static string serverURL;

		private static readonly HttpClient Client = new HttpClient();

		public static bool startupDone = false;

		public static bool modlistCheckPassed = false;

		private static string steamTicket;

		public static string requestedRank = "";

		private static WebSocket ws;

		private static Timer heartbeatTimer;

		public static int maxReconnectionAttempts = 3;

		public static int currentReconnection = 0;

		public static string lastErrorString = "";

		public static Dictionary<string, (Type messageType, Action<object> messageHandler)> messages = new Dictionary<string, (Type, Action<object>)>
		{
			{
				"ChatMessage",
				(typeof(ChatMessageReceive), delegate(object msg)
				{
					ChatMessageReceiveHandler.handle((ChatMessageReceive)msg);
				})
			},
			{
				"ChatWarn",
				(typeof(ChatWarn), delegate(object msg)
				{
					ChatWarnHandler.handle((ChatWarn)msg);
				})
			},
			{
				"CheatNotification",
				(typeof(CheatNotification), delegate(object msg)
				{
					CheatNotificationHandler.handle((CheatNotification)msg);
				})
			},
			{
				"CreateRoomResponse",
				(typeof(CreateRoomResponse), delegate(object msg)
				{
					CreateRoomResponseHandler.handle((CreateRoomResponse)msg);
				})
			},
			{
				"DisconnectNotification",
				(typeof(DisconnectNotification), delegate(object msg)
				{
					DisconnectNotificationHandler.handle((DisconnectNotification)msg);
				})
			},
			{
				"FetchGamesResponse",
				(typeof(FetchGamesResponse), delegate(object msg)
				{
					FetchGamesReponseHandler.handle((FetchGamesResponse)msg);
				})
			},
			{
				"GameEnd",
				(typeof(EndGameSignal), delegate(object msg)
				{
					EndGameSignalHandler.handle((EndGameSignal)msg);
				})
			},
			{
				"JoinRoomResponse",
				(typeof(JoinRoomResponse), delegate(object msg)
				{
					JoinRoomResponseHandler.handle((JoinRoomResponse)msg);
				})
			},
			{
				"JoinRoomNotification",
				(typeof(PlayerJoiningMessage), delegate(object msg)
				{
					PlayerJoiningResponseHandler.handle((PlayerJoiningMessage)msg);
				})
			},
			{
				"Kicked",
				(typeof(KickHandler), delegate
				{
					KickHandler.handle();
				})
			},
			{
				"KickNotification",
				(typeof(KickNotification), delegate(object msg)
				{
					KickNotificationHandler.handle((KickNotification)msg);
				})
			},
			{
				"LevelClaimed",
				(typeof(LevelClaimNotification), delegate(object msg)
				{
					LevelClaimHandler.handle((LevelClaimNotification)msg);
				})
			},
			{
				"MapPing",
				(typeof(MapPingNotification), delegate(object msg)
				{
					MapPingNotificationHandler.handle((MapPingNotification)msg);
				})
			},
			{
				"MapPools",
				(typeof(MapPoolResponse), delegate(object msg)
				{
					MapPoolResponseHandler.handle((MapPoolResponse)msg);
				})
			},
			{
				"InitialCheckResponse",
				(typeof(InitialCheckResponse), delegate(object msg)
				{
					InitialCheckHandler.handle((InitialCheckResponse)msg);
				})
			},
			{
				"NewHostNotification",
				(typeof(HostMigration), delegate(object msg)
				{
					HostMigrationHandler.handle((HostMigration)msg);
				})
			},
			{
				"RerollVote",
				(typeof(RerollVoteNotification), delegate(object msg)
				{
					RerollVoteNotificationHandler.handle((RerollVoteNotification)msg);
				})
			},
			{
				"RerollSuccess",
				(typeof(RerollSuccessNotification), delegate(object msg)
				{
					RerollSuccessNotificationHandler.handle((RerollSuccessNotification)msg);
				})
			},
			{
				"RerollExpire",
				(typeof(RerollExpireNotification), delegate(object msg)
				{
					RerollExpireNotificationHandler.handle((RerollExpireNotification)msg);
				})
			},
			{
				"ReconnectResponse",
				(typeof(ReconnectResponse), delegate(object msg)
				{
					ReconnectResponseHandler.handle((ReconnectResponse)msg);
				})
			},
			{
				"RoomUpdate",
				(typeof(UpdateRoomSettingsNotification), delegate(object msg)
				{
					UpdateRoomSettingsHandler.handle((UpdateRoomSettingsNotification)msg);
				})
			},
			{
				"StartGame",
				(typeof(StartGameResponse), delegate(object msg)
				{
					StartGameResponseHandler.handle((StartGameResponse)msg);
				})
			},
			{
				"ServerDisconnection",
				(typeof(DisconnectSignal), delegate(object msg)
				{
					DisconnectSignalHandler.handle((DisconnectSignal)msg);
				})
			},
			{
				"TimeoutNotification",
				(typeof(TimeoutSignal), delegate(object msg)
				{
					TimeoutSignalHandler.handle((TimeoutSignal)msg);
				})
			},
			{
				"UpdateTeamsNotif",
				(typeof(UpdateTeamsNotification), delegate(object msg)
				{
					UpdateTeamsNotificationHandler.handle((UpdateTeamsNotification)msg);
				})
			}
		};

		public static void setState(State newState)
		{
			currentState = newState;
		}

		public static void HandleAsyncConnect()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			SetupHeartbeat();
			switch (pendingAction)
			{
			case AsyncAction.Host:
				CreateRoom();
				break;
			case AsyncAction.Join:
				JoinGame(pendingPassword);
				break;
			case AsyncAction.ModCheck:
				SendEncodedMessage(JsonConvert.SerializeObject((object)pendingVmr));
				break;
			case AsyncAction.RetrySend:
				SendEncodedMessage(JsonConvert.SerializeObject((object)QueuedMessage));
				QueuedMessage = "";
				break;
			case AsyncAction.ReconnectGame:
				Logging.Warn("Requesting to reconnect");
				SendEncodedMessage(JsonConvert.SerializeObject((object)new ReconnectRequest
				{
					steamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString(),
					roomId = GameManager.CurrentGame.gameId,
					ticket = CreateRegisterTicket()
				}));
				break;
			case AsyncAction.FetchGames:
				SendEncodedMessage(JsonConvert.SerializeObject((object)new FetchGamesRequest()));
				break;
			}
		}

		public static void SendModCheck(InitialChecksRequest vmr)
		{
			pendingAction = AsyncAction.ModCheck;
			pendingVmr = vmr;
			ConnectWebSocket();
		}

		public static string GetSteamTicket()
		{
			return steamTicket;
		}

		public static void SetSteamTicket(string ticket)
		{
			steamTicket = ticket;
		}

		public static async Task<string> FetchCatalog(string urlToRequest)
		{
			try
			{
				return await Client.GetStringAsync(urlToRequest);
			}
			catch (Exception ex)
			{
				Logging.Error("Something went wrong while fetching from the URL");
				Logging.Error(urlToRequest);
				Logging.Error(ex.Message);
				return null;
			}
		}

		public static bool IsConnectionUp()
		{
			return ws.IsAlive;
		}

		public static void Initialise(string url, string port, bool isDev = false)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			serverURL = (isDev ? "ws://127.0.0.1:2052" : ("ws://" + url + ":" + port));
			ws = new WebSocket(serverURL, Array.Empty<string>());
			ws.EnableRedirection = true;
			ws.WaitTime = TimeSpan.FromSeconds(15.0);
			ws.OnOpen += delegate
			{
				HandleAsyncConnect();
			};
			ws.OnMessage += delegate(object sender, MessageEventArgs e)
			{
				onMessageRecieved(e);
			};
			ws.OnError += delegate(object sender, ErrorEventArgs e)
			{
				HandleError(e);
			};
			ws.OnClose += delegate(object sender, CloseEventArgs e)
			{
				if (e.WasClean)
				{
					Logging.Message("Disconnected cleanly from server");
				}
				else
				{
					Logging.Error("Network connection error.");
					Logging.Error(e.Reason);
					Logging.Error(e.Code.ToString());
					lastErrorString = e.Reason + "(" + e.Code + ")";
				}
			};
		}

		public static void TryReconnect()
		{
			pendingAction = AsyncAction.ReconnectGame;
			ConnectWebSocket();
		}

		public static async void HandleError(ErrorEventArgs e)
		{
			Logging.Error("Network error happened");
			if (ws.IsAlive)
			{
				ws.CloseAsync();
				return;
			}
			switch (currentState)
			{
			case State.NORMAL:
				Logging.Error("Unable to perform startup connection to server");
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Failed to connect to Baphomet's Bingo server.", "", "", 0, false, false, true);
				break;
			case State.INMENU:
				Logging.Error("Unable to connect to server to join/host game");
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Failed to contact server.", "", "", 0, false, false, true);
				BingoMainMenu.UnlockUI();
				break;
			case State.INLOBBY:
				Logging.Error("Network error happened in lobby");
				Logging.Error(e.Message);
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Connection to the lobby was lost. Returning to menu.", "", "", 0, false, false, true);
				GameManager.ClearGameVariables();
				setState(State.INMENU);
				BingoEncapsulator.BingoCardScreen.SetActive(false);
				BingoEncapsulator.BingoLobbyScreen.SetActive(false);
				BingoEncapsulator.BingoEndScreen.SetActive(false);
				BingoEncapsulator.BingoMenu.SetActive(true);
				BingoLobby.UnlockUI();
				break;
			case State.INGAME:
				Logging.Error("Network error happened in-game");
				if (GameManager.IsInBingoLevel)
				{
					currentReconnection++;
					if (currentReconnection > maxReconnectionAttempts)
					{
						currentReconnection = 0;
						GameManager.ClearGameVariables();
						MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Failed to reconnect. Exitting game in 5 seconds.", "", "", 0, false, false, true);
						setState(State.NORMAL);
						await Task.Delay(5000);
						SceneHelper.LoadScene("Main Menu", false);
					}
					else
					{
						MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Connection to the game was lost.\nAttempting reconnection... <color=orange>(" + currentReconnection + "/" + maxReconnectionAttempts + ")</color>", "", "", 0, false, false, true);
						await Task.Delay(2000);
						TryReconnect();
					}
				}
				break;
			case State.INBROWSER:
				Logging.Error("Network error happened in-browser");
				if (!BingoBrowser.fetchDone)
				{
					BingoBrowser.DisplayError();
				}
				else
				{
					BingoBrowser.UnlockUI();
				}
				break;
			}
		}

		public static string DecodeMessage(string encodedMessage)
		{
			byte[] bytes = Convert.FromBase64String(encodedMessage);
			return Encoding.UTF8.GetString(bytes);
		}

		public static void SendEncodedMessage(string jsonToEncode)
		{
			if (!ws.IsAlive)
			{
				Logging.Warn("Queuing message & retrying connection");
				QueuedMessage = jsonToEncode;
				pendingAction = AsyncAction.RetrySend;
				ws.ConnectAsync();
				return;
			}
			string text = Convert.ToBase64String(Encoding.UTF8.GetBytes(jsonToEncode));
			ws.SendAsync(text, (Action<bool>)delegate(bool completed)
			{
				if (!completed)
				{
					Logging.Warn("Async not sent");
				}
			});
		}

		public static RegisterTicket CreateRegisterTicket()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return new RegisterTicket
			{
				steamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString(),
				steamTicket = GetSteamTicket(),
				steamUsername = SteamClient.Name,
				gameId = GameManager.CurrentGame.gameId
			};
		}

		public static void RegisterConnection()
		{
			Logging.Message("Registering connection with server");
			SendEncodedMessage(JsonConvert.SerializeObject((object)CreateRegisterTicket()));
		}

		public static void ConnectWebSocket()
		{
			if (!ws.IsAlive)
			{
				ws.ConnectAsync();
			}
		}

		public static void DisconnectWebSocket(ushort code = 1000, string reason = "Disconnect reason not specified")
		{
			ws.Close(code, reason);
		}

		public static void SetupHeartbeat()
		{
			heartbeatTimer = new Timer(10000.0);
			heartbeatTimer.Elapsed += SendPing;
			heartbeatTimer.AutoReset = true;
			heartbeatTimer.Enabled = true;
		}

		public static void SendPing(object source, ElapsedEventArgs e)
		{
			ws.Ping();
		}

		public static void CreateRoom()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			SendEncodedMessage(JsonConvert.SerializeObject((object)new CreateRoomRequest
			{
				roomName = "TestRoom",
				roomPassword = "password",
				maxPlayers = 8,
				pRankRequired = false,
				hostSteamName = CommonFunctions.sanitiseUsername(SteamClient.Name),
				hostSteamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString(),
				rank = (GameManager.hasRankAccess ? requestedRank : "")
			}));
		}

		public static void JoinGame(string password)
		{
			//IL_001d: 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)
			SendEncodedMessage(JsonConvert.SerializeObject((object)new JoinRoomRequest
			{
				password = password,
				username = CommonFunctions.sanitiseUsername(SteamClient.Name),
				steamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString(),
				rank = (GameManager.hasRankAccess ? requestedRank : "")
			}));
		}

		public static void SendStartGameSignal(int roomId)
		{
			//IL_0023: 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_0034: Expected O, but got Unknown
			SendEncodedMessage(JsonConvert.SerializeObject((object)new StartGameRequest
			{
				roomId = roomId,
				ticket = CreateRegisterTicket(),
				selectedMapIds = BingoMapBrowser.selectedLevels
			}, (Formatting)1, new JsonSerializerSettings
			{
				ReferenceLoopHandling = (ReferenceLoopHandling)1
			}));
		}

		public static void SubmitRun(SubmitRunRequest srr)
		{
			SendEncodedMessage(JsonConvert.SerializeObject((object)srr));
		}

		public static void SendLeaveGameRequest(int roomId)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			SendEncodedMessage(JsonConvert.SerializeObject((object)new LeaveGameRequest
			{
				username = CommonFunctions.sanitiseUsername(SteamClient.Name),
				steamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString(),
				roomId = roomId
			}));
		}

		public static void KickPlayer(string steamId)
		{
			SendEncodedMessage(JsonConvert.SerializeObject((object)new KickPlayer
			{
				gameId = GameManager.CurrentGame.gameId,
				playerToKick = steamId,
				ticket = CreateRegisterTicket()
			}));
		}

		public static void RequestGames()
		{
			pendingAction = AsyncAction.FetchGames;
			ws.ConnectAsync();
		}

		public static void onMessageRecieved(MessageEventArgs e)
		{
			Main.Queue(delegate
			{
				EncapsulatedMessage encapsulatedMessage = JsonConvert.DeserializeObject<EncapsulatedMessage>(DecodeMessage(e.Data));
				if (encapsulatedMessage.header != "Pong")
				{
					if (messages.TryGetValue(encapsulatedMessage.header, out (Type, Action<object>) value))
					{
						object obj = JsonConvert.DeserializeObject(encapsulatedMessage.contents, value.Item1);
						value.Item2(obj);
					}
					else
					{
						Logging.Warn("Unknown or unimplemented packet received from server (" + encapsulatedMessage.header + "), discarding");
					}
				}
			});
		}
	}
	[BepInPlugin("clearwater.ultrakillbingo.ultrakillbingo", "Baphomet's BINGO", "1.3.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Main : BaseUnityPlugin
	{
		public const string pluginId = "clearwater.ultrakillbingo.ultrakillbingo";

		public const string pluginName = "Baphomet's BINGO";

		public const string pluginVersion = "1.3.0";

		public static bool IsDevelopmentBuild = false;

		public static bool IsSteamAuthenticated = false;

		public static bool HasUnlocked = true;

		public static bool UpdateAvailable = false;

		public static List<string> LoadedMods = new List<string>();

		private static readonly ConcurrentQueue<Action> actions = new ConcurrentQueue<Action>();

		public static string ModFolder => Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		public static void Queue(Action action)
		{
			actions.Enqueue(action);
		}

		private void Awake()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Logging.Message("--Now loading Baphomet's Bingo...--");
			Debug.unityLogger.filterLogType = (LogType)2;
			Logging.Message("--Loading asset bundle...--");
			AssetLoader.LoadAssets();
			Logging.Message("--Applying patches...--");
			new Harmony("clearwater.ultrakillbingo.ultrakillbingo").PatchAll();
			Logging.Message("--Network manager init...--");
			NetworkManager.serverURLConfig = ((BaseUnityPlugin)this).Config.Bind<string>("ServerConfig", "serverUrl", "clearwaterbirb.uk", "Server URL");
			NetworkManager.serverPortConfig = ((BaseUnityPlugin)this).Config.Bind<string>("ServerConfig", "serverPort", "2052", "Server Port");
			NetworkManager.lastRankUsedConfig = ((BaseUnityPlugin)this).Config.Bind<string>("ServerConfig", "lastRankUsed", "None", "Last Rank Used (Only works if your SteamID has access to this rank)");
			if (!Directory.Exists(Path.Combine(ModFolder, "ThumbnailCache")))
			{
				Logging.Message("--Thumbnail cache folder doesn't exist, creating now---");
				Directory.CreateDirectory(Path.Combine(ModFolder, "ThumbnailCache"));
			}
			string value = NetworkManager.serverURLConfig.Value;
			string value2 = NetworkManager.serverPortConfig.Value;
			NetworkManager.Initialise(value, value2, IsDevelopmentBuild);
			Logging.Message("--Done!--");
			SceneManager.sceneLoaded += onSceneLoaded;
		}

		private void Update()
		{
			Action result;
			while (actions.TryDequeue(out result))
			{
				result();
			}
		}

		public bool Authenticate()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Logging.Message("Authenticating game ownership with Steam...");
			try
			{
				AuthTicket authSessionTicket = SteamUser.GetAuthSessionTicket(default(NetIdentity));
				string text = BitConverter.ToString(authSessionTicket.Data, 0, authSessionTicket.Data.Length).Replace("-", string.Empty);
				if (text.Length > 0)
				{
					IsSteamAuthenticated = true;
					NetworkManager.SetSteamTicket(text);
					return true;
				}
			}
			catch (Exception ex)
			{
				Logging.Error("Unable to authenticate with Steam!");
				Logging.Error(ex.ToString());
				return false;
			}
			return false;
		}

		public void VerifyModWhitelist()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!IsSteamAuthenticated)
			{
				Logging.Error("Failed to authenticate with Steam! Not running whitelist check");
				return;
			}
			Logging.Message("Validating current modlist...");
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				if (pluginInfo.Key != "clearwater.ultrakillbingo.ultrakillbingo")
				{
					string value = ((object)pluginInfo.Value).ToString().Split(new char[1] { ' ' })[0];
					dictionary.Add(pluginInfo.Key, value);
				}
			}
			NetworkManager.SendModCheck(new InitialChecksRequest(dictionary, ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString()));
		}

		public void onSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			GameManager.ResetVars();
			if (CommonFunctions.getSceneName() == "Main Menu")
			{
				HasUnlocked = CommonFunctions.hasUnlockedMod();
				if (!IsSteamAuthenticated)
				{
					Authenticate();
					VerifyModWhitelist();
				}
				if (GameManager.CurrentGame != null && GameManager.CurrentGame.isGameFinished())
				{
					BingoEnd.ShowEndScreen();
					MonoSingleton<AssistController>.Instance.majorEnabled = false;
					MonoSingleton<AssistController>.Instance.gameSpeed = 1f;
				}
				UIManager.ultrabingoLockedPanel = Object.Instantiate<GameObject>(AssetLoader.BingoLockedPanel, CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("Canvas"), "Difficulty Select (1)").transform);
				UIManager.ultrabingoErrorMessagePanel = Object.Instantiate<GameObject>(AssetLoader.BingoUnallowedModsPanel, CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("Canvas"), "Difficulty Select (1)").transform);
				((TMP_Text)CommonFunctions.GetGameObjectChild(BingoMainMenu.VersionInfo, "VersionNum").GetComponent<TextMeshProUGUI>()).text = "1.3.0";
				UIManager.ultrabingoLockedPanel.SetActive(false);
				UIManager.ultrabingoErrorMessagePanel.SetActive(false);
			}
			else
			{
				UIManager.RemoveLimit();
				if (GameManager.IsInBingoLevel && GameManager.CurrentGame.gameSettingsArray["disableCampaignAltExits"] == 1)
				{
					CampaignPatches.Apply(CommonFunctions.getSceneName());
				}
			}
		}
	}
}
namespace UltraBINGO
{
	public static class AssetLoader
	{
		public static AssetBundle Assets;

		public static TMP_FontAsset GameFont;

		public static Font GameFontLegacy;

		public static Sprite UISprite;

		public static GameObject BingoEntryButton;

		public static GameObject BingoPauseCard;

		public static GameObject BingoMainMenu;

		public static GameObject BingoLobbyMenu;

		public static GameObject BingoCardElements;

		public static GameObject BingoEndScreen;

		public static GameObject BingoSetTeams;

		public static GameObject BingoSetDifficulty;

		public static GameObject BingoCardButtonTemplate;

		public static GameObject BingoGameBrowser;

		public static GameObject BingoVotePanel;

		public static GameObject BingoDominationTimer;

		public static GameObject BingoChat;

		public static GameObject BingoMapSelection;

		public static GameObject BingoInGameGridPanel;

		public static GameObject BingoLockedPanel;

		public static GameObject BingoUnallowedModsPanel;

		public static AudioClip GameOverSound;

		public static void LoadAssets()
		{
			Assets = AssetBundle.LoadFromFile(Path.Combine(Main.ModFolder, "bingo.resource"));
			GameFont = Assets.LoadAsset<TMP_FontAsset>("VCR_OSD_MONO_EXTENDED_TMP");
			GameFontLegacy = Assets.LoadAsset<Font>("VCR_OSD_MONO_LEGACY");
			BingoEntryButton = Assets.LoadAsset<GameObject>("BingoEntryButton");
			BingoPauseCard = Assets.LoadAsset<GameObject>("BingoPauseCard");
			BingoMainMenu = Assets.LoadAsset<GameObject>("BingoMainMenu");
			BingoLobbyMenu = Assets.LoadAsset<GameObject>("BingoLobbyMenu");
			BingoCardElements = Assets.LoadAsset<GameObject>("BingoCard");
			BingoEndScreen = Assets.LoadAsset<GameObject>("BingoEndScreen");
			BingoSetDifficulty = Assets.LoadAsset<GameObject>("BingoSetDifficulty");
			BingoSetTeams = Assets.LoadAsset<GameObject>("BingoSetTeams");
			BingoCardButtonTemplate = Assets.LoadAsset<GameObject>("BingoGridButtonTemplate");
			BingoGameBrowser = Assets.LoadAsset<GameObject>("BingoMatchBrowser");
			BingoLockedPanel = Assets.LoadAsset<GameObject>("BingoLocked");
			BingoUnallowedModsPanel = Assets.LoadAsset<GameObject>("BingoUnallowedMods");
			BingoInGameGridPanel = Assets.LoadAsset<GameObject>("BingoInGameGrid");
			BingoDominationTimer = Assets.LoadAsset<GameObject>("BingoDominationTimer");
			BingoChat = Assets.LoadAsset<GameObject>("BingoChat");
			BingoMapSelection = Assets.LoadAsset<GameObject>("BingoMapSelection");
			UISprite = Assets.LoadAsset<Sprite>("UISprite");
			GameOverSound = Assets.LoadAsset<AudioClip>("gameEnd");
			BingoVotePanel = Assets.LoadAsset<GameObject>("BingoVotePanel");
		}
	}
	public class AngryMapCatalog
	{
		public List<AngryBundle> Levels;
	}
	public class AngryBundle
	{
		public List<AngryLevel> Levels;

		public string Name;

		public string Author;

		public int size;

		public string Guid;

		public string Hash;

		public string ThumbnailHash;

		public bool locked;
	}
	public class AngryLevel
	{
		public string LevelName;

		public string LevelId;
	}
	public class MapPoolContainer
	{
		public string mapPoolId;

		public string mapPoolName;

		public string description;

		public int numOfMaps;

		public List<string> mapList;

		public MapPoolContainer(string mapPoolId, string mapPoolName, string description, int numOfMaps, List<string> mapList)
		{
			this.mapPoolId = mapPoolId;
			this.mapPoolName = mapPoolName;
			this.description = description;
			this.numOfMaps = numOfMaps;
			this.mapList = mapList;
		}
	}
	public class Player
	{
		public string username;

		public string steamId;

		public string rank;
	}
	public class GameLevel
	{
		public string levelName;

		public string levelId;

		public string claimedBy;

		public string personToBeat;

		public float timeToBeat;

		public int row;

		public int column;

		public BingoLevelType LevelType;

		public string angryParentBundle;

		public string angryLevelId;

		public string UltraEditorLevelData;
	}
	public class GameGrid
	{
		public int size;

		public Dictionary<string, GameLevel> levelTable;
	}
	public class Game
	{
		public int gameId;

		public Dictionary<string, Player> currentPlayers;

		public GameGrid grid;

		public string gameHost;

		public int gameState;

		public Dictionary<string, int> gameSettingsArray;

		public Dictionary<string, int> difficultyOverride;

		public string winningTeam;

		public List<Player> getPlayers()
		{
			return currentPlayers.Values.ToList();
		}

		public bool isGameFinished()
		{
			return gameState == 2;
		}
	}
	public static class CampaignPatches
	{
		public static void Apply(string levelName)
		{
			if (levelName == null)
			{
				return;
			}
			int length = levelName.Length;
			if (length != 9)
			{
				return;
			}
			switch (levelName[6])
			{
			case '0':
				if (levelName == "Level 0-2")
				{
					CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("5B - Secret Arena"), "5B Nonstuff"), "Altar (Blue Skull) Variant").SetActive(false);
				}
				break;
			case '1':
				if (levelName == "Level 1-1")
				{
					GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("1 - First Field"), "1 Stuff"), "Fountain");
					((Behaviour)gameObjectChild.GetComponent<Door>()).enabled = false;
					GameObject gameObject = ((Component)gameObjectChild.transform.GetChild(0)).gameObject;
					GameObject gameObject2 = ((Component)gameObjectChild.transform.GetChild(1)).gameObject;
					gameObject.SetActive(false);
					gameObject2.SetActive(false);
					GameObject gameObjectChild2 = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("1 - First Field"), "1 Nonstuff"), "FinalRoom 1");
					gameObjectChild2.SetActive(false);
					((Behaviour)gameObjectChild2.GetComponent<FinalRoom>()).enabled = false;
					CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("1 - First Field"), "1 Nonstuff"), "FinalRoom SecretEntrance").SetActive(false);
				}
				break;
			case '2':
				if (levelName == "Level 2-3")
				{
					CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("4 - End Hallway"), "4 Nonstuff"), "ElectricityBox").SetActive(false);
					CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("2 - Sewer Arena"), "2 Nonstuff"), "Secret Level Entrance").SetActive(false);
				}
				break;
			case '3':
				if (levelName == "Level 3-1")
				{
					((Behaviour)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("6S - P Door"), "6S Nonstuff"), "HellgateLimboSwitch Variant").GetComponent<LimboSwitchLock>()).enabled = false;
				}
				break;
			case '4':
				if (levelName == "Level 4-2")
				{
					CommonFunctions.GetInactiveRootObject("GreedSwitch Variant").SetActive(false);
				}
				break;
			case '5':
				if (levelName == "Level 5-1")
				{
					((Behaviour)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("2 - Elevator"), "2B Secret"), "FinalRoom 1"), "FinalDoor").GetComponent<FinalDoor>()).enabled = false;
					CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("2 - Elevator"), "2B Secret"), "FinalRoom 1").SetActive(false);
					CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("2 - Elevator"), "2B Secret"), "FinalRoom SecretEntrance").SetActive(false);
				}
				break;
			case '6':
				if (levelName == "Level 6-2")
				{
					((Behaviour)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("1S - P Door"), "6S Nonstuff"), "ToActivate"), "HellgateLimboSwitch Variant").GetComponent<LimboSwitchLock>()).enabled = false;
				}
				break;
			case '7':
				if (levelName == "Level 7-3")
				{
					((Behaviour)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("Doors"), "1 -> S"), "Plane (1)").GetComponent<Flammable>()).enabled = false;
					CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("2 - Garden Maze"), "Secret"), "FinalRoom 1"), "Pit").SetActive(false);
					CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("2 - Garden Maze"), "Secret"), "FinalRoom SecretEntrance").SetActive(false);
				}
				break;
			}
		}
	}
	public static class CommonFunctions
	{
		public static string sanitiseUsername(string rawUsername)
		{
			return Regex.Replace(rawUsername, "\\p{Cs}", "");
		}

		public static bool checkIfLevelSaveExists(string savePath, string fileName)
		{
			return File.Exists(Path.Combine(savePath, string.Format("Slot{0}/" + fileName, GameProgressSaver.currentSlot + 1)));
		}

		public static bool hasUnlockedMod()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			return checkIfLevelSaveExists(Path.Combine(((int)SystemInfo.deviceType == 3) ? Directory.GetParent(Application.dataPath).FullName : Application.persistentDataPath, "Saves"), "lvl29progress.bepis");
		}

		public static string getSceneName()
		{
			return SceneHelper.CurrentScene;
		}

		public static GameObject GetInactiveRootObject(string objectName)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> list = new List<GameObject>();
			Scene activeScene = SceneManager.GetActiveScene();
			((Scene)(ref activeScene)).GetRootGameObjects(list);
			foreach (GameObject item in list)
			{
				if (((Object)item).name == objectName)
				{
					return item;
				}
			}
			return null;
		}

		public static IEnumerator WaitforSeconds(float seconds)
		{
			yield return (object)new WaitForSeconds(seconds);
		}

		public static GameObject GetGameObjectChild(GameObject parentObject, string childToFind)
		{
			try
			{
				return ((Component)parentObject.transform.Find(childToFind)).gameObject;
			}
			catch (Exception)
			{
				Logging.Warn("Couldn't find requested child gameObject " + childToFind + " in parent gameObject '" + ((Object)parentObject).name + "'");
				return null;
			}
		}

		public static TextMeshProUGUI GetTextMeshProGUI(GameObject objectToUse)
		{
			return objectToUse.GetComponent<TextMeshProUGUI>();
		}

		public static Text GetTextfromGameObject(GameObject objectToUse)
		{
			return objectToUse.GetComponent<Text>();
		}

		public static string getFormattedTime(float time)
		{
			float num = time;
			float num2 = 0f;
			while (num >= 60f)
			{
				num -= 60f;
				num2 += 1f;
			}
			return num2 + ":" + num.ToString("00.000");
		}
	}
	public static class GameManager
	{
		public static Game CurrentGame;

		public static bool IsInBingoLevel = false;

		public static bool ReturningFromBingoLevel = false;

		public static int CurrentRow = 0;

		public static int CurrentColumn = 0;

		public static string CurrentTeam = "";

		public static List<string> Teammates;

		public static bool HasSent = false;

		public static bool EnteringAngryLevel = false;

		public static bool TriedToActivateCheats = false;

		public static bool IsDownloadingLevel = false;

		public static bool IsSwitchingLevels = false;

		public static bool alreadyStartedVote = false;

		public static bool isUsingCustomMappool = false;

		public static Dictionary<string, BingoMapSelectionID> customMappool = new Dictionary<string, BingoMapSelectionID>();

		public static GameObject LevelBeingDownloaded = null;

		public static float dominationTimer = 0f;

		public static bool hasRankAccess = false;

		public static bool canUseChat = true;

		public static VoteData voteData = new VoteData(ongoing: false);

		public static Dictionary<string, ICheat> cheatList;

		public static Queue<string> chatHistory = new Queue<string>();

		public static async void SwapRerolledMap(string oldMapId, GameLevel level, int column, int row)
		{
			if (IsInBingoLevel && CurrentGame != null)
			{
				CurrentGame.grid.levelTable[column + "-" + row] = level;
				BingoLevelData component = CommonFunctions.GetGameObjectChild(BingoCardPauseMenu.Grid, column + "-" + row).GetComponent<BingoLevelData>();
				component.angryParentBundle = level.angryParentBundle;
				component.bingoLevelType = level.LevelType;
				component.angryLevelId = level.angryLevelId;
				component.levelName = level.levelName;
			}
			if (oldMapId == CommonFunctions.getSceneName())
			{
				Logging.Message("Currently on old map - switching in 5 seconds");
				await Task.Delay(5000);
				((UnityEvent)CommonFunctions.GetGameObjectChild(BingoCardPauseMenu.Grid, column + "-" + row).GetComponent<Button>().onClick).Invoke();
			}
		}

		public static void UpdateGridPosition(int row, int column)
		{
			CurrentRow = row;
			CurrentColumn = column;
		}

		public static void ClearGameVariables()
		{
			if (CurrentGame.gameSettingsArray["gameModifier"] > 0)
			{
				MonoSingleton<AssistController>.Instance.cheatsEnabled = true;
				MonoSingleton<CheatsManager>.Instance.SetCheatActive(cheatList["ultrakill.disable-enemy-spawns"], false, true);
				MonoSingleton<CheatsManager>.Instance.SetCheatActive(cheatList["ultrakill.hide-weapons"], false, true);
				MonoSingleton<AssistController>.Instance.cheatsEnabled = false;
			}
			CurrentGame = null;
			CurrentTeam = null;
			CurrentRow = 0;
			CurrentColumn = 0;
			IsInBingoLevel = false;
			ReturningFromBingoLevel = false;
			Teammates = null;
			voteData = null;
			chatHistory.Clear();
			if (CommonFunctions.getSceneName() == "Main Menu")
			{
				BingoCard.Cleanup();
				BingoChatManager.clearChatHistory();
			}
		}

		public static void HumiliateSelf()
		{
			//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)
			NetworkManager.SendEncodedMessage(JsonConvert.SerializeObject((object)new CheatActivation
			{
				username = CommonFunctions.sanitiseUsername(SteamClient.Name),
				gameId = CurrentGame.gameId,
				steamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString()
			}));
		}

		public static void LeaveGame(bool isInLevel = false)
		{
			NetworkManager.SendLeaveGameRequest(CurrentGame.gameId);
			Logging.Message("Closing connection");
			NetworkManager.DisconnectWebSocket(1000, "Normal close");
			ClearGameVariables();
			if (BingoMapBrowser.selectedLevels != null)
			{
				foreach (KeyValuePair<string, BingoMapSelectionID> selectedLevel in BingoMapBrowser.selectedLevels)
				{
					if ((Object)(object)selectedLevel.Value != (Object)null && !isInLevel)
					{
						CommonFunctions.GetGameObjectChild(((Component)selectedLevel.Value).gameObject, "SelectionIndicator").SetActive(false);
					}
				}
				BingoMapBrowser.selectedLevels.Clear();
			}
			if (BingoMapBrowser.selectedLevelNames != null)
			{
				BingoMapBrowser.selectedLevelNames.Clear();
			}
			if (!isInLevel)
			{
				BingoEncapsulator.BingoCardScreen.SetActive(false);
				BingoEncapsulator.BingoLobbyScreen.SetActive(false);
				BingoEncapsulator.BingoEndScreen.SetActive(false);
				BingoEncapsulator.BingoMenu.SetActive(true);
				NetworkManager.setState(State.INMENU);
				BingoMapBrowser.ResetListPosition();
			}
			else
			{
				BingoMapBrowser.hasFetched = false;
				BingoMapBrowser.ClearCategories();
				NetworkManager.setState(State.NORMAL);
			}
		}

		public static void MoveToCard(int gameType)
		{
			BingoCard.UpdateTitles(gameType);
			BingoLobby.UnlockUI();
			BingoEncapsulator.BingoLobbyScreen.SetActive(false);
			BingoEncapsulator.BingoCardScreen.SetActive(true);
		}

		public static bool PlayerIsHost()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString() == CurrentGame.gameHost;
		}

		public static bool PreStartChecks()
		{
			int num = CurrentGame.gameSettingsArray["gridSize"] + 3;
			int num2 = num * num;
			if (BingoMapBrowser.selectedLevels.Count < num2)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Not enough maps selected. Add more map pools, or reduce the grid size.\n(<color=orange>" + num2 + " </color>required, <color=orange>" + BingoMapBrowser.selectedLevels.Count + "</color> selected)", "", "", 0, false, false, true);
				return false;
			}
			if (CurrentGame.gameSettingsArray["teamComposition"] == 1 && CurrentGame.gameSettingsArray["hasManuallySetTeams"] == 0)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Teams must be set before starting the game.", "", "", 0, false, false, true);
				return false;
			}
			return true;
		}

		public static void ResetVars()
		{
			HasSent = false;
			EnteringAngryLevel = false;
			TriedToActivateCheats = false;
			IsSwitchingLevels = false;
		}

		public static void RefreshPlayerList()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Expected O, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!(CommonFunctions.getSceneName() == "Main Menu"))
				{
					return;
				}
				BingoLobby.PlayerList.SetActive(false);
				_ = CurrentGame.gameHost == ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString();
				GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(BingoLobby.PlayerList, "PlayerList");
				GameObject gameObjectChild2 = CommonFunctions.GetGameObjectChild(gameObjectChild, "PlayerTemplate");
				foreach (Transform item in gameObjectChild.transform)
				{
					Transform val = item;
					if (((Object)((Component)val).gameObject).name != "PlayerTemplate")
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
				}
				foreach (string steamId in CurrentGame.currentPlayers.Keys.ToList())
				{
					GameObject obj = Object.Instantiate<GameObject>(gameObjectChild2, gameObjectChild.transform);
					string text = "";
					if (steamId == CurrentGame.gameHost)
					{
						text = "<color=orange>" + Regex.Replace(CurrentGame.currentPlayers[steamId].username, "^<[^>]*>", "") + "</color>";
					}
					CommonFunctions.GetGameObjectChild(obj, "PlayerName").GetComponent<Text>().text = ((steamId == CurrentGame.gameHost) ? text : CurrentGame.currentPlayers[steamId].username) + ((CurrentGame.currentPlayers[steamId].rank != "") ? (" | " + CurrentGame.currentPlayers[steamId].rank) : "");
					((UnityEvent)CommonFunctions.GetGameObjectChild(obj, "Kick").GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						NetworkManager.KickPlayer(steamId);
					});
					CommonFunctions.GetGameObjectChild(obj, "Kick").transform.localScale = Vector3.one;
					CommonFunctions.GetGameObjectChild(obj, "Kick").SetActive(((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString() == CurrentGame.gameHost && steamId != ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString());
					obj.SetActive(true);
				}
				BingoLobby.PlayerList.SetActive(true);
			}
			catch (Exception ex)
			{
				Logging.Error("Something went wrong when trying to update player list");
				Logging.Error(ex.ToString());
			}
		}

		public static void SetupBingoCardDynamic()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: 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_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(BingoCard.Root, "BingoGrid");
			gameObjectChild.GetComponent<GridLayoutGroup>().constraintCount = CurrentGame.grid.size;
			gameObjectChild.GetComponent<GridLayoutGroup>().spacing = new Vector2(30f, 30f);
			gameObjectChild.GetComponent<GridLayoutGroup>().cellSize = new Vector2(150f, 50f);
			for (int i = 0; i < CurrentGame.grid.size; i++)
			{
				for (int j = 0; j < CurrentGame.grid.size; j++)
				{
					GameObject level = Object.Instantiate<GameObject>(AssetLoader.BingoCardButtonTemplate, gameObjectChild.transform);
					string lvlCoords = i + "-" + j;
					((Object)level).name = lvlCoords;
					GameLevel levelObject = CurrentGame.grid.levelTable[lvlCoords];
					CommonFunctions.GetGameObjectChild(level, "Text").GetComponent<Text>().text = ((CurrentGame.gameSettingsArray["hideLevelNames"] == 1) ? "???" : levelObject.levelName);
					level.AddComponent<BingoLevelData>();
					level.GetComponent<BingoLevelData>().column = i;
					level.GetComponent<BingoLevelData>().row = j;
					level.GetComponent<BingoLevelData>().bingoLevelType = levelObject.LevelType;
					level.GetComponent<BingoLevelData>().angryParentBundle = levelObject.angryParentBundle;
					level.GetComponent<BingoLevelData>().angryLevelId = levelObject.levelId;
					level.GetComponent<BingoLevelData>().levelName = levelObject.levelName;
					level.GetComponent<BingoLevelData>().ultraEditorLevelData = levelObject.UltraEditorLevelData;
					((UnityEventBase)level.GetComponent<Button>().onClick).RemoveAllListeners();
					((UnityEvent)level.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						BingoMenuController.LoadBingoLevel(levelObject.levelId, lvlCoords, level.GetComponent<BingoLevelData>());
					});
					level.transform.SetParent(BingoCard.Grid.transform);
					level.SetActive(true);
				}
			}
			switch (CurrentGame.grid.size)
			{
			case 3:
				gameObjectChild.transform.localPosition = new Vector3(-200f, 100f, 0f);
				break;
			case 4:
				gameObjectChild.transform.localPosition = new Vector3(-275f, 122f, 0f);
				break;
			case 5:
				gameObjectChild.transform.localPosition = new Vector3(-350f, 145f, 0f);
				break;
			}
			TextMeshProUGUI component = CommonFunctions.GetGameObjectChild(BingoCard.Teammates, "Players").GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = "";
			foreach (string teammate in Teammates)
			{
				((TMP_Text)component).text = ((TMP_Text)component).text + teammate + "\n";
			}
			alreadyStartedVote = false;
		}

		public static void SetupJoinMidgameDetails(Game game, string team, List<string> teammates, int remainingDominationTime, bool needsTeam)
		{
			CurrentGame = game;
			BingoEncapsulator.BingoMenu.SetActive(false);
			BingoEncapsulator.BingoGameBrowser.SetActive(false);
			CurrentTeam = team;
			Teammates = teammates;
			if (game.gameSettingsArray["gamemode"] == 1)
			{
				dominationTimer = remainingDominationTime;
			}
			NetworkManager.setState(State.INLOBBY);
			NetworkManager.RegisterConnection();
			BingoMenuController.StartGame(game.gameSettingsArray["gamemode"], isJoiningMidGame: true);
		}

		public static async void SetupGameDetails(Game game, string password, bool isHost = true)
		{
			CurrentGame = game;
			BingoEncapsulator.BingoMenu.SetActive(false);
			BingoEncapsulator.BingoGameBrowser.SetActive(false);
			TextMeshProUGUI[] componentsInChildren = BingoEncapsulator.BingoLobbyScreen.GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI text in componentsInChildren)
			{
				await Task.Delay(1);
				((TMP_Text)text).ForceMeshUpdate(false, false);
			}
			BingoEncapsulator.BingoLobbyScreen.SetActive(true);
			ShowGameId(password);
			RefreshPlayerList();
			Selectable[] array = (Selectable[])(object)new Selectable[15]
			{
				(Selectable)BingoLobby.MaxPlayers,
				(Selectable)BingoLobby.MaxTeams,
				(Selectable)BingoLobby.TimeLimit,
				(Selectable)BingoLobby.TeamComposition,
				(Selectable)BingoLobby.GridSize,
				(Selectable)BingoLobby.Gamemode,
				(Selectable)BingoLobby.Difficulty,
				(Selectable)BingoLobby.RequirePRank,
				(Selectable)BingoLobby.DisableCampaignAltExits,
				(Selectable)BingoLobby.GameVisibility,
				(Selectable)BingoLobby.AllowRejoin,
				(Selectable)BingoLobby.HideLevelNames,
				(Selectable)BingoLobby.HidePlayerTimes,
				(Selectable)BingoLobby.GameModifiers,
				(Selectable)BingoLobby.SetTeams.GetComponent<Button>()
			};
			GameObject[] array2 = (GameObject[])(object)new GameObject[4]
			{
				BingoLobby.StartGame,
				BingoLobby.SelectMaps,
				BingoLobby.RoomIdDisplay,
				BingoLobby.CopyId
			};
			Selectable[] array3 = array;
			for (int j = 0; j < array3.Length; j++)
			{
				array3[j].interactable = isHost;
			}
			GameObject[] array4 = array2;
			for (int j = 0; j < array4.Length; j++)
			{
				array4[j].SetActive(isHost);
			}
			if (isHost)
			{
				BingoLobby.MaxPlayers.text = 8.ToString();
				BingoLobby.MaxTeams.text = 4.ToString();
				BingoLobby.TeamComposition.value = 0;
				BingoLobby.GridSize.value = 0;
				BingoLobby.Gamemode.value = 0;
				BingoLobby.TimeLimit.text = 5.ToString();
				BingoLobby.RequirePRank.isOn = false;
				BingoLobby.DisableCampaignAltExits.isOn = false;
				BingoLobby.GameVisibility.value = 0;
				BingoLobby.AllowRejoin.isOn = false;
				BingoLobby.HideLevelNames.isOn = false;
				BingoLobby.HidePlayerTimes.isOn = false;
				BingoLobby.GameModifiers.value = 0;
			}
			else
			{
				BingoLobby.MaxPlayers.text = CurrentGame.gameSettingsArray["maxPlayers"].ToString();
				BingoLobby.MaxTeams.text = CurrentGame.gameSettingsArray["maxTeams"].ToString();
				BingoLobby.TimeLimit.text = CurrentGame.gameSettingsArray["timeLimit"].ToString();
				BingoLobby.TeamComposition.value = CurrentGame.gameSettingsArray["teamComposition"];
				BingoLobby.GridSize.value = CurrentGame.gameSettingsArray["gridSize"];
				BingoLobby.Gamemode.value = CurrentGame.gameSettingsArray["gamemode"];
				BingoLobby.RequirePRank.isOn = CurrentGame.gameSettingsArray["requiresPRank"] == 1;
				BingoLobby.DisableCampaignAltExits.isOn = CurrentGame.gameSettingsArray["disableCampaignAltExits"] == 1;
				BingoLobby.GameVisibility.value = CurrentGame.gameSettingsArray["gameVisibility"];
				BingoLobby.AllowRejoin.isOn = CurrentGame.gameSettingsArray["allowRejoin"] == 1;
				BingoLobby.HideLevelNames.isOn = CurrentGame.gameSettingsArray["hideLevelNames"] == 1;
				BingoLobby.HidePlayerTimes.isOn = CurrentGame.gameSettingsArray["hidePlayerTimes"] == 1;
				BingoLobby.GameModifiers.value = CurrentGame.gameSettingsArray["gameModifier"];
			}
			MonoSingleton<BingoChatManager>.Instance.updateChatPanel();
			NetworkManager.setState(State.INLOBBY);
			NetworkManager.RegisterConnection();
		}

		public static void ShowGameId(string password)
		{
			CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(BingoLobby.RoomIdDisplay, "Title"), "Text").GetComponent<Text>().text = "Game ID: " + password;
		}

		public static void StartGame()
		{
			NetworkManager.SendStartGameSignal(CurrentGame.gameId);
		}

		public static void UpdateCards(int row, int column, string team, string playername, float newTime)
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			string text = row + "-" + column;
			CurrentGame.grid.levelTable.Keys.ToList();
			if (!CurrentGame.grid.levelTable.ContainsKey(text))
			{
				Logging.Error("RECEIVED AN INVALID GRID POSITION TO UPDATE!");
				Logging.Error(text);
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("A level was claimed by someone but an <color=orange>invalid grid position</color> was given.\nCheck BepInEx console and report it to Clearwater!", "", "", 0, false, false, true);
				return;
			}
			try
			{
				CurrentGame.grid.levelTable[text].claimedBy = team;
				CurrentGame.grid.levelTable[text].timeToBeat = newTime;
				Color value;
				if (CommonFunctions.getSceneName() == "Main Menu")
				{
					GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(BingoEncapsulator.BingoCardScreen, "BingoGrid");
					((Graphic)CommonFunctions.GetGameObjectChild(gameObjectChild, text).GetComponent<Image>()).color = BingoCardPauseMenu.teamColors[team];
					CommonFunctions.GetGameObjectChild(gameObjectChild, text).GetComponent<BingoLevelData>().isClaimed = true;
					CommonFunctions.GetGameObjectChild(gameObjectChild, text).GetComponent<BingoLevelData>().claimedTeam = team;
					CommonFunctions.GetGameObjectChild(gameObjectChild, text).GetComponent<BingoLevelData>().claimedPlayer = playername;
					CommonFunctions.GetGameObjectChild(gameObjectChild, text).GetComponent<BingoLevelData>().timeRequirement = newTime;
				}
				else if (!BingoCardPauseMenu.teamColors.TryGetValue(team, out value))
				{
					Logging.Error("Unable to get color, throwing exception");
				}
				else
				{
					((Graphic)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(BingoCardPauseMenu.Root, "Card"), text).GetComponent<Image>()).color = BingoCardPauseMenu.teamColors[team];
					((Graphic)CommonFunctions.GetGameObjectChild(BingoCardPauseMenu.inGamePanel, text).GetComponent<Image>()).color = BingoCardPauseMenu.teamColors[team];
					BingoLevelData component = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(BingoCardPauseMenu.Root, "Card"), text).GetComponent<BingoLevelData>();
					component.isClaimed = true;
					component.claimedTeam = team;
					component.claimedPlayer = playername;
					component.timeRequirement = newTime;
				}
			}
			catch (Exception ex)
			{
				Logging.Error("THREW AN INVALID GRID POSITION TO UPDATE!");
				Logging.Error(ex.ToString());
				Logging.Error(text);
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("A level was claimed by someone but the grid could not be updated.\nCheck BepInEx console and report it to Clearwater!", "", "", 0, false, false, true);
			}
		}

		public static void RequestReroll(int row, int column)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (alreadyStartedVote)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("You have already used your reroll vote for this game.", "", "", 0, false, false, true);
			}
			else
			{
				NetworkManager.SendEncodedMessage(JsonConvert.SerializeObject((object)new RerollRequest
				{
					gameId = CurrentGame.gameId,
					steamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString(),
					row = row,
					column = column,
					steamTicket = NetworkManager.CreateRegisterTicket()
				}));
			}
			MonoSingleton<OptionsManager>.Instance.UnPause();
		}

		public static void PingMapForTeam(string team, int row, int column)
		{
			NetworkManager.SendEncodedMessage(JsonConvert.SerializeObject((object)new MapPing
			{
				gameId = CurrentGame.gameId,
				team = team,
				row = row,
				column = column,
				ticket = NetworkManager.CreateRegisterTicket()
			}));
		}
	}
	public static class UIManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__8_0;

			internal void <SetupElements>b__8_0()
			{
				Open();
			}
		}

		public static GameObject ultrabingoButtonObject = null;

		public static GameObject ultrabingoEncapsulator = null;

		public static GameObject ultrabingoLockedPanel = null;

		public static GameObject ultrabingoErrorMessagePanel = null;

		public static bool wasVsyncActive = false;

		public static int fpsLimit = -1;

		public static List<string> nonWhitelistedMods = new List<string>();

		public static void HandleGameSettingsUpdate()
		{
			if (GameManager.PlayerIsHost())
			{
				NetworkManager.SendEncodedMessage(JsonConvert.SerializeObject((object)new UpdateRoomSettingsRequest
				{
					roomId = GameManager.CurrentGame.gameId,
					updatedSettings = GameManager.CurrentGame.gameSettingsArray,
					ticket = NetworkManager.CreateRegisterTicket()
				}));
			}
		}

		public static void SetupElements(CanvasController __instance)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)((Transform)((Component)__instance).GetComponent<RectTransform>()).Find("Difficulty Select (1)")).gameObject;
			if ((Object)(object)ultrabingoButtonObject == (Object)null)
			{
				ultrabingoButtonObject = Object.Instantiate<GameObject>(AssetLoader.BingoEntryButton, gameObject.transform);
				((Object)ultrabingoButtonObject).name = "UltraBingoButton";
			}
			ButtonClickedEvent onClick = ultrabingoButtonObject.GetComponent<Button>().onClick;
			object obj = <>c.<>9__8_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					Open();
				};
				<>c.<>9__8_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			if ((Object)(object)ultrabingoEncapsulator == (Object)null)
			{
				ultrabingoEncapsulator = BingoEncapsulator.Init();
				((Object)ultrabingoEncapsulator).name = "UltraBingo";
				ultrabingoEncapsulator.transform.parent = ((Component)__instance).transform;
				ultrabingoEncapsulator.transform.localPosition = Vector3.zero;
				ultrabingoEncapsulator.AddComponent<BingoMenuManager>();
			}
			ultrabingoEncapsulator.SetActive(false);
		}

		public static string PopulateUnallowedMods()
		{
			string text = "<color=orange>";
			foreach (string nonWhitelistedMod in nonWhitelistedMods)
			{
				text = text + nonWhitelistedMod + "\n";
			}
			return text + "</color>";
		}

		public static void EnforceLimit()
		{
			wasVsyncActive = QualitySettings.vSyncCount == 1;
			fpsLimit = Application.targetFrameRate;
			Application.targetFrameRate = 60;
			QualitySettings.vSyncCount = 1;
		}

		public static void RemoveLimit()
		{
			Application.targetFrameRate = fpsLimit;
			QualitySettings.vSyncCount = (wasVsyncActive ? 1 : 0);
		}

		public static void showErrorMessage(string headerText, string paragraphText = "", string rowText = "")
		{
			GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(ultrabingoErrorMessagePanel, "BingoLockedPanel"), "Panel");
			TextMeshProUGUI component = CommonFunctions.GetGameObjectChild(gameObjectChild, "Text").GetComponent<TextMeshProUGUI>();
			TextMeshProUGUI component2 = CommonFunctions.GetGameObjectChild(gameObjectChild, "Text (1)").GetComponent<TextMeshProUGUI>();
			TextMeshProUGUI component3 = CommonFunctions.GetGameObjectChild(gameObjectChild, "ModList").GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = "<color=orange>" + headerText + "</color>";
			((TMP_Text)component2).text = paragraphText;
			((TMP_Text)component3).text = rowText;
			ultrabingoErrorMessagePanel.SetActive(true);
		}

		public static void Open()
		{
			if (!Main.IsSteamAuthenticated)
			{
				showErrorMessage("Avast matey", "Unable to authenticate with Steam.\n\nYou must be connected to the Steam servers (not running in offline mode), and own a legal copy of ULTRAKILL to play Baphomet's Bingo.");
			}
			else if (!NetworkManager.startupDone)
			{
				showErrorMessage("Unable to contact server", "ULTRAKILL failed to establish a connection to the Baphomet's Bingo server. Please restart your game to try again.\nIf this keeps happening, please check your internet connection & console for any errors.\n(<color=red>" + NetworkManager.lastErrorString + "</color>)");
			}
			else if (!NetworkManager.modlistCheckPassed)
			{
				string rowText = PopulateUnallowedMods();
				showErrorMessage("Non-whitelisted mods detected", "To ensure fair gameplay between players, please <color=orange>disable the following mods</color> and <color=orange>restart</color> to play Baphomet's Bingo:", rowText);
			}
			else if (Main.UpdateAvailable)
			{
				showErrorMessage("UPDATE AVAILABLE", "<color=orange>An update is available! Please update your mod to play Baphomet's Bingo.</color>");
			}
			else if (Main.HasUnlocked)
			{
				if (NetworkManager.IsConnectionUp())
				{
					NetworkManager.DisconnectWebSocket(1000);
					GameManager.ClearGameVariables();
				}
				EnforceLimit();
				((Component)ultrabingoButtonObject.transform.parent).gameObject.SetActive(false);
				BingoEncapsulator.BingoLobbyScreen.SetActive(false);
				BingoEncapsulator.Root.SetActive(true);
				BingoEncapsulator.BingoMenu.SetActive(true);
				NetworkManager.setState(State.INMENU);
			}
			else
			{
				ultrabingoLockedPanel.SetActive(true);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "UltraBINGO";

		public const string PLUGIN_NAME = "UltraBINGO";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace UltraBINGO.UI_Elements
{
	public static class BingoBrowser
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__10_0;

			internal void <Init>b__10_0()
			{
				BingoEncapsulator.BingoGameBrowser.SetActive(false);
				BingoEncapsulator.BingoMenu.SetActive(true);
				NetworkManager.setState(State.INMENU);
			}
		}

		public static GameObject Root;

		public static GameObject FetchText;

		public static GameObject GameTemplate;

		public static GameObject GameListWrapper;

		public static GameObject GameList;

		public static GameObject Back;

		public static bool fetchDone = false;

		public static List<GameObject> gameArray = new List<GameObject>();

		public static void LockUI()
		{
			_ = ((Component)GameTemplate.transform.parent).gameObject;
			foreach (GameObject item in gameArray)
			{
				((Selectable)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(item, "JoinWrapper"), "JoinButton").GetComponent<Button>()).interactable = false;
			}
		}

		public static void UnlockUI()
		{
			foreach (GameObject item in gameArray)
			{
				((Selectable)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(item, "JoinWrapper"), "JoinButton").GetComponent<Button>()).interactable = true;
			}
		}

		public static void Init(ref GameObject BingoGameBrowser)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			FetchText = CommonFunctions.GetGameObjectChild(BingoGameBrowser, "FetchText");
			Back = CommonFunctions.GetGameObjectChild(BingoGameBrowser, "Back");
			ButtonClickedEvent onClick = Back.GetComponent<Button>().onClick;
			object obj = <>c.<>9__10_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					BingoEncapsulator.BingoGameBrowser.SetActive(false);
					BingoEncapsulator.BingoMenu.SetActive(true);
					NetworkManager.setState(State.INMENU);
				};
				<>c.<>9__10_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			GameListWrapper = CommonFunctions.GetGameObjectChild(BingoGameBrowser, "GameList");
			GameList = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(GameListWrapper, "Viewport"), "Content");
			GameTemplate = CommonFunctions.GetGameObjectChild(GameList, "GameTemplate");
		}

		public static void clearOldGames()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			foreach (Transform item in GameList.transform)
			{
				Transform val = item;
				if (((Object)((Component)val).gameObject).name != "GameTemplate")
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			gameArray.Clear();
		}

		public static void PopulateGames(List<PublicGameData> games)
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			Dictionary<int, string> dictionary = new Dictionary<int, string>
			{
				{ 0, "HARMLESS" },
				{ 1, "LENIENT" },
				{ 2, "STANDARD" },
				{ 3, "VIOLENT" },
				{ 4, "BRUTAL" }
			};
			if (games.Count == 0)
			{
				((TMP_Text)FetchText.GetComponent<TextMeshProUGUI>()).text = "No public games currently available.";
				return;
			}
			clearOldGames();
			foreach (PublicGameData game in games)
			{
				GameObject val = Object.Instantiate<GameObject>(GameTemplate, GameTemplate.transform.parent);
				CommonFunctions.GetGameObjectChild(val, "HostName").GetComponent<Text>().text = game.C_USERNAME;
				CommonFunctions.GetGameObjectChild(val, "Difficulty").GetComponent<Text>().text = dictionary[game.R_DIFFICULTY];
				CommonFunctions.GetGameObjectChild(val, "Players").GetComponent<Text>().text = game.R_CURRENTPLAYERS + "/" + game.R_MAXPLAYERS;
				((UnityEvent)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(val, "JoinWrapper"), "JoinButton").GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					LockUI();
					BingoMenuController.JoinRoom(game.R_PASSWORD);
				});
				val.SetActive(true);
				gameArray.Add(val);
			}
			FetchText.SetActive(false);
			GameListWrapper.SetActive(true);
			GameList.SetActive(true);
			fetchDone = true;
		}

		public static void DisplayError()
		{
			((TMP_Text)FetchText.GetComponent<TextMeshProUGUI>()).text = "Unable to connect to server.";
		}

		public static void FetchGames()
		{
			FetchText.SetActive(true);
			GameListWrapper.SetActive(false);
			GameList.SetActive(false);
			((TMP_Text)FetchText.GetComponent<TextMeshProUGUI>()).text = "Fetching games, please wait...";
			fetchDone = false;
			NetworkManager.RequestGames();
		}
	}
	public class BingoCard
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__11_0;

			internal void <Init>b__11_0()
			{
				GameManager.LeaveGame();
			}
		}

		public static GameObject Root;

		public static GameObject Grid;

		public static GameObject ButtonTemplate;

		public static GameObject LeaveGame;

		public static GameObject TeamIndicator;

		public static GameObject ObjectiveIndicator;

		public static GameObject Teammates;

		public static GameObject CardElements;

		public static string team = "PLACEHOLDER";

		public static void Cleanup()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in Grid.transform)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
		}

		public static void UpdateTitles(int gameType)
		{
			string text = "Race to <color=orange>obtain the fastest time</color> for your team on each level.\nClaim " + GameManager.CurrentGame.grid.size + " levels horizontally, vertically or diagonally for your team to win!";
			string text2 = "Race to <color=orange>claim as many levels</color> for your team as possible.\nThe team with the most claims when time is up is the winner!";
			TeamIndicator.GetComponent<TMP_Text>().text = "-- You are on the <color=" + GameManager.CurrentTeam.ToLower() + ">" + GameManager.CurrentTeam + " team</color> --";
			ObjectiveIndicator.GetComponent<TMP_Text>().text = ((gameType == 0) ? text : text2);
			if (GameManager.CurrentGame.gameSettingsArray["requiresPRank"] == 1)
			{
				TMP_Text component = ObjectiveIndicator.GetComponent<TMP_Text>();
				component.text += "\n<color=#ffa200d9>P</color>-Ranks are <color=orange>required</color> to claim a level.";
			}
		}

		public static GameObject Init()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			if ((Object)(object)Root == (Object)null)
			{
				Root = new GameObject();
			}
			((Object)Root).name = "UltraBingoCard";
			CardElements = Object.Instantiate<GameObject>(AssetLoader.BingoCardElements, Root.transform);
			Grid = CommonFunctions.GetGameObjectChild(CardElements, "BingoGrid");
			((Object)Grid).name = "BingoGrid";
			Grid.transform.SetParent(Root.transform);
			if ((Object)(object)ButtonTemplate == (Object)null)
			{
				ButtonTemplate = new GameObject();
			}
			ButtonTemplate = Object.Instantiate<GameObject>(AssetLoader.BingoCardButtonTemplate, Root.transform);
			ButtonTemplate.transform.SetParent(Root.transform);
			ButtonTemplate.SetActive(false);
			LeaveGame = CommonFunctions.GetGameObjectChild(CardElements, "LeaveGame");
			ButtonClickedEvent onClick = LeaveGame.GetComponent<Button>().onClick;
			object obj = <>c.<>9__11_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					GameManager.LeaveGame();
				};
				<>c.<>9__11_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			TeamIndicator = CommonFunctions.GetGameObjectChild(CardElements, "TeamIndicator");
			((TMP_Text)TeamIndicator.GetComponent<TextMeshProUGUI>()).text = "-- You are on the " + team + " team -- ";
			ObjectiveIndicator = CommonFunctions.GetGameObjectChild(CardElements, "ObjectiveIndicator");
			Teammates = CommonFunctions.GetGameObjectChild(CardElements, "Teammates");
			Root.SetActive(false);
			return Root;
		}
	}
	public static class BingoCardPauseMenu
	{
		public static Dictionary<string, Color> teamColors = new Dictionary<string, Color>
		{
			{
				"NONE",
				new Color(1f, 1f, 1f, 1f)
			},
			{
				"Red",
				new Color(1f, 0f, 0f, 1f)
			},
			{
				"Green",
				new Color(0f, 1f, 0f, 1f)
			},
			{
				"Blue",
				new Color(0f, 0f, 1f, 1f)
			},
			{
				"Yellow",
				new Color(1f, 1f, 0f, 1f)
			}
		};

		public static GameObject Root;

		public static GameObject Grid;

		public static GameObject inGamePanel;

		public static GameObject DescriptorText;

		public static Outline pingedMap = null;

		public static void onMouseEnterLevelSquare(PointerEventData data)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Expected O, but got Unknown
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			string text = "assets/bingo/lvlimg/unknown.png";
			data.pointerEnter.gameObject.GetComponent<BingoLevelData>().levelName.ToLower();
			string text2 = GameManager.CurrentGame.grid.levelTable[((Object)data.pointerEnter.gameObject).name].levelId.ToLower();
			Sprite overrideSprite = null;
			if (GameManager.CurrentGame.gameSettingsArray["hideLevelNames"] == 1)
			{
				Texture2D val = AssetLoader.Assets.LoadAsset<Texture2D>(text);
				overrideSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			}
			else
			{
				switch (data.pointerEnter.gameObject.GetComponent<BingoLevelData>().bingoLevelType)
				{
				case BingoLevelType.Campaign:
				{
					string text3 = "assets/bingo/lvlimg/campaign/" + text2 + ".png";
					if (!AssetLoader.Assets.Contains(text3))
					{
						text3 = text;
					}
					Texture2D val6 = AssetLoader.Assets.LoadAsset<Texture2D>(text3);
					overrideSprite = Sprite.Create(val6, new Rect(0f, 0f, (float)((Texture)val6).width, (float)((Texture)val6).height), new Vector2(0.5f, 0.5f), 100f);
					break;
				}
				case BingoLevelType.Angry:
				{
					string angryParentBundle = data.pointerEnter.gameObject.GetComponent<BingoLevelData>().angryParentBundle;
					string path2 = Path.Combine(Main.ModFolder, "ThumbnailCache", angryParentBundle + ".png");
					if (File.Exists(path2))
					{
						byte[] array2 = File.ReadAllBytes(Path.Combine(Main.ModFolder, "ThumbnailCache", angryParentBundle + ".png"));
						Texture2D val4 = new Texture2D(2, 2);
						ImageConversion.LoadImage(val4, array2);
						overrideSprite = Sprite.Create(val4, new Rect(0f, 0f, (float)((Texture)val4).width, (float)((Texture)val4).height), new Vector2(0.5f, 0.5f), 100f);
					}
					else
					{
						path2 = text;
						Texture2D val5 = AssetLoader.Assets.LoadAsset<Texture2D>(path2);
						overrideSprite = Sprite.Create(val5, new Rect(0f, 0f, (float)((Texture)val5).width, (float)((Texture)val5).height), new Vector2(0.5f, 0.5f), 100f);
					}
					break;
				}
				case BingoLevelType.UltraEditor:
				{
					string angryLevelId = data.pointerEnter.gameObject.GetComponent<BingoLevelData>().angryLevelId;
					string path = Path.Combine(Main.ModFolder, "ThumbnailCache", angryLevelId + ".png");
					if (File.Exists(path))
					{
						byte[] array = File.ReadAllBytes(Path.Combine(Main.ModFolder, "ThumbnailCache", angryLevelId + ".png"));
						Texture2D val2 = new Texture2D(2, 2);
						ImageConversion.LoadImage(val2, array);
						overrideSprite = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0.5f, 0.5f), 100f);
					}
					else
					{
						path = text;
						Texture2D val3 = AssetLoader.Assets.LoadAsset<Texture2D>(path);
						overrideSprite = Sprite.Create(val3, new Rect(0f, 0f, (float)((Texture)val3).width, (float)((Texture)val3).height), new Vector2(0.5f, 0.5f), 100f);
					}
					break;
				}
				}
			}
			CommonFunctions.GetGameObjectChild(Root, "SelectedLevelImage").GetComponent<Image>().overrideSprite = overrideSprite;
			bool flag = !data.pointerEnter.gameObject.GetComponent<BingoLevelData>().isClaimed && !MonoSingleton<BingoVoteManager>.Instance.voteOngoing;
			GameLevel gameLevel = GameManager.CurrentGame.grid.levelTable[((Object)data.pointerEnter.gameObject).name];
			gameLevel.levelName = ((GameManager.CurrentGame.gameSettingsArray["hideLevelNames"] == 1) ? "???" : gameLevel.levelName);
			string text4 = ((GameManager.CurrentGame.gameSettingsArray["hidePlayerTimes"] == 1) ? "" : CommonFunctions.getFormattedTime(gameLevel.timeToBeat));
			((TMP_Text)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(Root, "SelectedLevel"), "Text (TMP)").GetComponent<TextMeshProUGUI>()).text = gameLevel.levelName + ((gameLevel.claimedBy != "NONE") ? ("\n<color=orange>" + text4 + "</color>") : "") + (flag ? "\n<color=orange>R: Start a reroll vote</color>" : "");
			CommonFunctions.GetGameObjectChild(Root, "SelectedLevel").SetActive(true);
			CommonFunctions.GetGameObjectChild(Root, "SelectedLevelImage").SetActive(true);
		}

		public static void ShowBingoCardInPauseMenu(ref OptionsManager __instance)
		{
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			Game currentGame = GameManager.CurrentGame;
			GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(Root, "Card"), "Image");
			gameObjectChild.SetActive(false);
			for (int i = 0; i < currentGame.grid.size; i++)
			{
				for (int j = 0; j < currentGame.grid.size; j++)
				{
					GameObject val = Object.Instantiate<GameObject>(gameObjectChild, ((Component)gameObjectChild.transform.parent).transform);
					((Object)val).name = i + "-" + j;
					GameLevel gameLevel = GameManager.CurrentGame.grid.levelTable[((Object)val).name];
					BingoLevelData bingoLevelData = val.AddComponent<BingoLevelData>();
					bingoLevelData.levelName = gameLevel.levelName;
					bingoLevelData.angryParentBundle = gameLevel.angryParentBundle;
					bingoLevelData.angryLevelId = gameLevel.levelId;
					bingoLevelData.bingoLevelType = gameLevel.LevelType;
					bingoLevelData.column = i;
					bingoLevelData.row = j;
					bingoLevelData.isClaimed = gameLevel.claimedBy != "NONE";
					bingoLevelData.claimedTeam = gameLevel.claimedBy;
					bingoLevelData.ultraEditorLevelData = gameLevel.UltraEditorLevelData;
					val.AddComponent<BingoLevelSquare>();
					((Graphic)val.GetComponent<Image>()).color = teamColors[currentGame.grid.levelTable[i + "-" + j].claimedBy];
					if (GameManager.CurrentRow == i && GameManager.CurrentColumn == j)
					{
						val.AddComponent<Outline>();
						((Shadow)val.GetComponent<Outline>()).effectColor = Color.magenta;
						((Shadow)val.GetComponent<Outline>()).effectDistance = new Vector2(2f, -2f);
					}
					val.AddComponent<EventTrigger>();
					Entry val2 = new Entry();
					val2.eventID = (EventTriggerType)0;
					((UnityEvent<BaseEventData>)(object)val2.callback).AddListener((UnityAction<BaseEventData>)delegate(BaseEventData data)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						//IL_000b: Expected O, but got Unknown
						onMouseEnterLevelSquare((PointerEventData)data);
					});
					val.GetComponent<EventTrigger>().triggers.Add(val2);
					val.SetActive(true);
				}
			}
			GameObject gameObjectChild2 = CommonFunctions.GetGameObjectChild(Root, "Card");
			switch (GameManager.CurrentGame.grid.size)
			{
			case 3:
				gameObjectChild2.transform.localPosition = new Vector3(-65f, 170f, 0f);
				gameObjectChild2.transform.localScale = new Vector3(1.25f, 1.25f, 1.25f);
				break;
			case 4:
				gameObjectChild2.transform.localPosition = new Vector3(-82.5f, 185f, 0f);
				gameObjectChild2.transform.localScale = new Vector3(1.1f, 1.1f, 1.1f);
				break;
			}
		}

		public static GameObject Init(ref OptionsManager __instance)
		{
			if ((Object)(object)Root == (Object)null)
			{
				Root = Object.Instantiate<GameObject>(AssetLoader.BingoPauseCard, __instance.pauseMenu.gameObject.transform);
			}
			((Object)Root).name = "BingoPauseCard";
			Grid = CommonFunctions.GetGameObjectChild(Root, "Card");
			Grid.GetComponent<GridLayoutGroup>().constraintCount = GameManager.CurrentGame.grid.size;
			DescriptorText = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(Root, "Descriptor"), "Text (TMP)");
			Root.SetActive(true);
			return Root;
		}
	}
	public static class BingoDominationTimer
	{
		public static GameObject Root;

		public static GameObject Timer;

		public static void Init(ref GameObject DominationTimer)
		{
			Timer = CommonFunctions.GetGameObjectChild(DominationTimer, "Timer");
		}
	}
	public static class BingoEncapsulator
	{
		public static GameObject Root;

		public static GameObject BingoMenu;

		public static GameObject BingoLobbyScreen;

		public static GameObject BingoCardScreen;

		public static GameObject BingoEndScreen;

		public static GameObject BingoSetTeams;

		public static GameObject BingoSetDifficulty;

		public static GameObject BingoGameBrowser;

		public static GameObject BingoMapSelection;

		public static GameObject Init()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if ((Object)(object)Root == (Object)null)
			{
				Root = new GameObject();
			}
			((Object)Root).name = "UltraBingo";
			BingoMenu = Object.Instantiate<GameObject>(AssetLoader.BingoMainMenu, Root.transform);
			BingoMainMenu.Init(ref BingoMenu);
			((Object)BingoMenu).name = "BingoMainMenu";
			BingoMenu.AddComponent<MenuEsc>();
			BingoMenu.GetComponent<MenuEsc>().previousPage = CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("Canvas"), "Difficulty Select (1)");
			BingoMenu.transform.SetParent(Root.transform);
			BingoLobbyScreen = Object.Instantiate<GameObject>(AssetLoader.BingoLobbyMenu, Root.transform);
			BingoLobby.Init(ref BingoLobbyScreen);
			BingoLobbyScreen.transform.SetParent(Root.transform);
			BingoCardScreen = BingoCard.Init();
			BingoCardScreen.transform.SetParent(Root.transform);
			BingoSetTeams = Object.Instantiate<GameObject>(AssetLoader.BingoSetTeams, Root.transform);
			BingoSetTeamsMenu.Init(ref BingoSetTeams);
			BingoSetTeams.transform.SetParent(Root.transform);
			BingoSetDifficulty = Object.Instantiate<GameObject>(AssetLoader.BingoSetDifficulty, Root.transform);
			BingoSetDifficultyMenu.Init(ref BingoSetDifficulty);
			BingoSetDifficulty.transform.SetParent(Root.transform);
			BingoEndScreen = Object.Instantiate<GameObject>(AssetLoader.BingoEndScreen, Root.transform);
			BingoEnd.Init(ref BingoEndScreen);
			BingoGameBrowser = Object.Instantiate<GameObject>(AssetLoader.BingoGameBrowser, Root.transform);
			BingoBrowser.Init(ref BingoGameBrowser);
			BingoMapSelection = Object.Instantiate<GameObject>(AssetLoader.BingoMapSelection, Root.transform);
			BingoMapBrowser.Init(ref BingoMapSelection);
			return Root;
		}
	}
	public static class BingoEnd
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__16_0;

			internal void <Init>b__16_0()
			{
				GameManager.LeaveGame();
			}
		}

		public static GameObject Root;

		public static GameObject WinnerIndicator;

		public static GameObject WinningPlayers;

		public static GameObject Stats;

		public static GameObject LeaveGame;

		public static string winningTeam;

		public static string winningPlayers;

		public static string timeElapsed;

		public static int numOfClaims;

		public static string firstMap;

		public static string lastMap;

		public static float bestStatValue;

		public static string bestStatName;

		public static int endCode;

		public static string tiedTeams;

		public static async void ShowEndScreen()
		{
			await Task.Delay(50);
			CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("Canvas"), "Main Menu (1)").SetActive(false);
			BingoEncapsulator.Root.SetActive(true);
			BingoEncapsulator.BingoMenu.SetActive(false);
			BingoEncapsulator.BingoCardScreen.SetActive(false);
			BingoEncapsulator.BingoLobbyScreen.SetActive(false);
			BingoEncapsulator.BingoEndScreen.SetActive(true);
			string text = "";
			switch (endCode)
			{
			case 0:
				text = "The <color=" + winningTeam.ToLower() + ">" + winningTeam + " </color>team has won the game!";
				break;
			case 1:
				text = "No team won the game.";
				break;
			case 2:
				text = "The " + tiedTeams + " teams have tied!";
				break;
			}
			((TMP_Text)WinnerIndicator.GetComponent<TextMeshProUGUI>()).text = text;
			((TMP_Text)CommonFunctions.GetGameObjectChild(WinningPlayers, "Text (TMP) (1)").GetComponent<TextMeshProUGUI>()).text = winningPlayers;
			((TMP_Text)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(Stats, "TimeElapsed"), "Value").GetComponent<TextMeshProUGUI>()).text = "<color=orange>" + timeElapsed + "</color>";
			((TMP_Text)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(Stats, "TotalClaims"), "Value").GetComponent<TextMeshProUGUI>()).text = "<color=orange>" + numOfClaims + "</color>";
			((TMP_Text)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(Stats, "FirstMap"), "Value").GetComponent<TextMeshProUGUI>()).text = "<color=orange>" + firstMap + "</color>";
			((TMP_Text)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(Stats, "LastMap"), "Value").GetComponent<TextMeshProUGUI>()).text = "<color=orange>" + lastMap + "</color>";
			((TMP_Text)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(Stats, "HighestStat"), "Value").GetComponent<TextMeshProUGUI>()).text = "<color=orange>" + bestStatValue + " </color>(<color=orange>" + bestStatName + "</color>)";
			Root.SetActive(true);
		}

		public static void Init(ref GameObject BingoEndScreen)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			if ((Object)(object)Root == (Object)null)
			{
				Root = new GameObject();
			}
			((Object)Root).name = "BingoEndScreen";
			WinnerIndicator = CommonFunctions.GetGameObjectChild(BingoEndScreen, "WinningTeam");
			WinningPlayers = CommonFunctions.GetGameObjectChild(BingoEndScreen, "WinningPlayers");
			Stats = CommonFunctions.GetGameObjectChild(BingoEndScreen, "Stats");
			LeaveGame = CommonFunctions.GetGameObjectChild(BingoEndScreen, "LeaveGame");
			ButtonClickedEvent onClick = LeaveGame.GetComponent<Button>().onClick;
			object obj = <>c.<>9__16_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					GameManager.LeaveGame();
				};
				<>c.<>9__16_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			LeaveGame.transform.SetParent(BingoEndScreen.transform);
			BingoEndScreen.SetActive(false);
		}
	}
	public static class BingoLobby
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__34_0;

			public static UnityAction <>9__34_1;

			public static UnityAction <>9__34_2;

			public static UnityAction <>9__34_3;

			public static UnityAction <>9__34_4;

			public static UnityAction<string> <>9__34_5;

			public static UnityAction<string> <>9__34_6;

			public static UnityAction<string> <>9__34_7;

			public static UnityAction<int> <>9__34_8;

			public static UnityAction<int> <>9__34_9;

			public static UnityAction<int> <>9__34_10;

			public static UnityAction <>9__34_11;

			public static UnityAction<bool> <>9__34_12;

			public static UnityAction<bool> <>9__34_13;

			public static UnityAction<int> <>9__34_14;

			public static UnityAction<bool> <>9__34_15;

			public static UnityAction<int> <>9__34_16;

			public static UnityAction<bool> <>9__34_17;

			public static UnityAction<bool> <>9__34_18;

			public static UnityAction<bool> <>9__34_19;

			public static UnityAction <>9__34_20;

			public static UnityAction <>9__34_21;

			internal void <Init>b__34_0()
			{
				GameManager.LeaveGame();
			}

			internal void <Init>b__34_1()
			{
				BingoEncapsulator.BingoLobbyScreen.SetActive(false);
				BingoEncapsulator.BingoMapSelection.SetActive(true);
				BingoMapBrowser.Setup();
			}

			internal void <Init>b__34_2()
			{
				BingoSetTeamsMenu.Setup();
				BingoEncapsulator.BingoLobbyScreen.SetActive(false);
				BingoEncapsulator.BingoSetTeams.SetActive(true);
			}

			internal void <Init>b__34_3()
			{
				if (GameManager.PreStartChecks())
				{
					LockUI();
					GameManager.StartGame();
				}
			}

			internal void <Init>b__34_4()
			{
				GUIUtility.systemCopyBuffer = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(RoomIdDisplay, "Title"), "Text").GetComponent<Text>().text.Split(new char[1] { ':' })[1];
			}

			internal void <Init>b__34_5(string <p0>)
			{
				onSettingUpdate("maxPlayers", int.Parse(MaxPlayers.text));
			}

			internal void <Init>b__34_6(string <p0>)
			{
				onSettingUpdate("maxTeams", int.Parse(MaxTeams.text));
			}

			internal void <Init>b__34_7(string <p0>)
			{
				onSettingUpdate("timeLimit", int.Parse(TimeLimit.text));
			}

			internal void <Init>b__34_8(int <p0>)
			{
				onSettingUpdate("teamComposition", TeamComposition.value);
			}

			internal void <Init>b__34_9(int <p0>)
			{
				onSettingUpdate("gamemode", Gamemode.value);
			}

			internal void <Init>b__34_10(int <p0>)
			{
				onSettingUpdate("gridSize", GridSize.value);
			}

			internal void <Init>b__34_11()
			{
				BingoSetDifficultyMenu.Setup();
				BingoEncapsulator.BingoLobbyScreen.SetActive(false);
				BingoEncapsulator.BingoSetDifficulty.SetActive(true);
			}

			internal void <Init>b__34_12(bool <p0>)
			{
				onSettingUpdate("requiresPRank", RequirePRank.isOn ? 1 : 0);
			}

			internal void <Init>b__34_13(bool <p0>)
			{
				onSettingUpdate("disableCampaignAltExits", DisableCampaignAltExits.isOn ? 1 : 0);
			}

			internal void <Init>b__34_14(int <p0>)
			{
				onSettingUpdate("gameVisibility", GameVisibility.value);
			}

			internal void <Init>b__34_15(bool <p0>)
			{
				onSettingUpdate("allowRejoin", AllowRejoin.isOn ? 1 : 0);
			}

			internal void <Init>b__34_16(int <p0>)
			{
				onSettingUpdate("gameModifier", GameModifiers.value);
			}

			internal void <Init>b__34_17(bool <p0>)
			{
				onSettingUpdate("hideLevelNames", HideLevelNames.isOn ? 1 : 0);
			}

			internal void <Init>b__34_18(bool <p0>)
			{
				onSettingUpdate("hidePlayerTimes", HidePlayerTimes.isOn ? 1 : 0);
			}

			internal void <Init>b__34_19(bool <p0>)
			{
				onSettingUpdate("hidePlayerTimes", HidePlayerTimes.isOn ? 1 : 0);
			}

			internal void <Init>b__34_20()
			{
				SwitchPage(-1);
			}

			internal void <Init>b__34_21()
			{
				SwitchPage(1);
			}
		}

		public static GameObject PlayerList;

		public static GameObject ReturnToBingoMenu;

		public static GameObject SelectMaps;

		public static GameObject SetTeams;

		public static GameObject StartGame;

		public static GameObject RoomIdDisplay;

		public static GameObject CopyId;

		public static GameObject GameOptions;

		public static TMP_InputField MaxPlayers;

		public static TMP_InputField MaxTeams;

		public static TMP_InputField TimeLimit;

		public static TMP_Dropdown Gamemode;

		public static TMP_Dropdown TeamComposition;

		public static TMP_Dropdown GridSize;

		public static Button Difficulty;

		public static Toggle RequirePRank;

		public static Toggle DisableCampaignAltExits;

		public static TMP_Dropdown GameVisibility;

		public static Toggle AllowRejoin;

		public static Toggle HideLevelNames;

		public static Toggle HidePlayerTimes;

		public static TMP_Dropdown GameModifiers;

		public static List<GameObject> settingPages;

		public static GameObject Controls;

		public static Button Back;

		public static TextMeshProUGUI PageCount;

		public static Button Forward;

		public static GameObject chatWindow;

		public static int pagePointer;

		public static void SwitchPage(int direction)
		{
			pagePointer = Mathf.Clamp(pagePointer + direction, 0, 1);
			((TMP_Text)PageCount).text = pagePointer + 1 + "/2";
			foreach (GameObject settingPage in settingPages)
			{
				settingPage.SetActive(((Object)settingPage).name == "Page" + (pagePointer + 1));
			}
		}

		public static void onSettingUpdate(string settingType, int value)
		{
			switch (settingType)
			{
			case "maxPlayers":
				GameManager.CurrentGame.gameSettingsArray["maxPlayers"] = Mathf.Clamp(Mathf.Max(value, GameManager.CurrentGame.currentPlayers.Count), 2, 16);
				MaxPlayers.text = Mathf.Clamp((float)value, (float)Mathf.Max(value, GameManager.CurrentGame.currentPlayers.Count), 16f).ToString();
				break;
			case "maxTeams":
				GameManager.CurrentGame.gameSettingsArray["maxTeams"] = Mathf.Clamp(value, 2, 4);
				MaxTeams.text = Mathf.Clamp((float)value, 2f, 4f).ToString();
				break;
			case "teamComposition":
				SetTeams.SetActive(value == 1 && GameManager.PlayerIsHost());
				break;
			case "timeLimit":
				GameManager.CurrentGame.gameSettingsArray["timeLimit"] = Mathf.Clamp(value, 5, 30);
				TimeLimit.text = Mathf.Clamp(value, 5, 30).ToString();
				break;
			case "gameModifier":
				if (value > 0)
				{
					GameManager.CurrentGame.gameSettingsArray["requiresPRank"] = 0;
					RequirePRank.isOn = false;
					((Selectable)RequirePRank).interactable = false;
				}
				else
				{
					((Selectable)RequirePRank).interactable = true;
				}
				break;
			}
			GameManager.CurrentGame.gameSettingsArray[settingType] = value;
			UIManager.HandleGameSettingsUpdate();
		}

		public static void updateFromNotification(UpdateRoomSettingsNotification newSettings)
		{
			MaxPlayers.text = newSettings.updatedSettings["maxPlayers"].ToString();
			MaxTeams.text = newSettings.updatedSettings["maxTeams"].ToString();
			TimeLimit.text = newSettings.updatedSettings["timeLimit"].ToString();
			Gamemode.value = newSettings.updatedSettings["gamemode"];
			TeamComposition.value = newSettings.updatedSettings["teamComposition"];
			RequirePRank.isOn = newSettings.updatedSettings["requiresPRank"] == 1;
			GridSize.value = newSettings.updatedSettings["gridSize"];
			AllowRejoin.isOn = newSettings.updatedSettings["allowRejoin"] == 1;
			HideLevelNames.isOn = newSettings.updatedSettings["hideLevelNames"] == 1;
			HidePlayerTimes.isOn = newSettings.updatedSettings["hidePlayerTimes"] == 1;
			DisableCampaignAltExits.isOn = newSettings.updatedSettings["disableCampaignAltExits"] == 1;
			GameVisibility.value = newSettings.updatedSettings["gameVisibility"];
			GameManager.CurrentGame.gameSettingsArray = newSettings.updatedSettings;
		}

		public static void LockUI()
		{
			((Selectable)StartGame.GetComponent<Button>()).interactable = false;
			((Selectable)ReturnToBingoMenu.GetComponent<Button>()).interactable = false;
			((Selectable)SelectMaps.GetComponent<Button>()).interactable = false;
		}

		public static void UnlockUI()
		{
			((Selectable)StartGame.GetComponent<Button>()).interactable = true;
			((Selectable)ReturnToBingoMenu.GetComponent<Button>()).interactable = true;
			((Selectable)SelectMaps.GetComponent<Button>()).interactable = true;
		}

		public static void Init(ref GameObject BingoLobby)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Expected O, but got Unknown
			//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Expected O, but got Unknown
			//IL_06fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0700: Unknown result type (might be due to invalid IL or missing references)
			//IL_0706: Expected O, but got Unknown
			PlayerList = CommonFunctions.GetGameObjectChild(BingoLobby, "BingoLobbyPlayers");
			ReturnToBingoMenu = CommonFunctions.GetGameObjectChild(BingoLobby, "LeaveGame");
			ButtonClickedEvent onClick = ReturnToBingoMenu.GetComponent<Button>().onClick;
			object obj = <>c.<>9__34_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					GameManager.LeaveGame();
				};
				<>c.<>9__34_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			SelectMaps = CommonFunctions.GetGameObjectChild(BingoLobby, "SelectMaps");
			ButtonClickedEvent onClick2 = SelectMaps.GetComponent<Button>().onClick;
			object obj2 = <>c.<>9__34_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					BingoEncapsulator.BingoLobbyScreen.SetActive(false);
					BingoEncapsulator.BingoMapSelection.SetActive(true);
					BingoMapBrowser.Setup();
				};
				<>c.<>9__34_1 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			SetTeams = CommonFunctions.GetGameObjectChild(BingoLobby, "SetTeams");
			ButtonClickedEvent onClick3 = SetTeams.GetComponent<Button>().onClick;
			object obj3 = <>c.<>9__34_2;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					BingoSetTeamsMenu.Setup();
					BingoEncapsulator.BingoLobbyScreen.SetActive(false);
					BingoEncapsulator.BingoSetTeams.SetActive(true);
				};
				<>c.<>9__34_2 = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			StartGame = CommonFunctions.GetGameObjectChild(BingoLobby, "StartGame");
			ButtonClickedEvent onClick4 = StartGame.GetComponent<Button>().onClick;
			object obj4 = <>c.<>9__34_3;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					if (GameManager.PreStartChecks())
					{
						LockUI();
						GameManager.StartGame();
					}
				};
				<>c.<>9__34_3 = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			RoomIdDisplay = CommonFunctions.GetGameObjectChild(BingoLobby, "BingoGameID");
			CopyId = CommonFunctions.GetGameObjectChild(BingoLobby, "CopyID");
			ButtonClickedEvent onClick5 = CopyId.GetComponent<Button>().onClick;
			object obj5 = <>c.<>9__34_4;
			if (obj5 == null)
			{
				UnityAction val5 = delegate
				{
					GUIUtility.systemCopyBuffer = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(RoomIdDisplay, "Title"), "Text").GetComponent<Text>().text.Split(new char[1] { ':' })[1];
				};
				<>c.<>9__34_4 = val5;
				obj5 = (object)val5;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
			GameOptions = CommonFunctions.GetGameObjectChild(BingoLobby, "BingoGameSettings");
			GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(GameOptions, "Pages");
			settingPages = new List<GameObject>();
			GameObject gameObjectChild2 = CommonFunctions.GetGameObjectChild(gameObjectChild, "Page1");
			settingPages.Add(gameObjectChild2);
			MaxPlayers = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild2, "MaxPlayers"), "Input").GetComponent<TMP_InputField>();
			((UnityEvent<string>)(object)MaxPlayers.onEndEdit).AddListener((UnityAction<string>)delegate
			{
				onSettingUpdate("maxPlayers", int.Parse(MaxPlayers.text));
			});
			MaxTeams = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild2, "MaxTeams"), "Input").GetComponent<TMP_InputField>();
			((UnityEvent<string>)(object)MaxTeams.onEndEdit).AddListener((UnityAction<string>)delegate
			{
				onSettingUpdate("maxTeams", int.Parse(MaxTeams.text));
			});
			TimeLimit = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild2, "TimeLimit"), "Input").GetComponent<TMP_InputField>();
			((UnityEvent<string>)(object)TimeLimit.onEndEdit).AddListener((UnityAction<string>)delegate
			{
				onSettingUpdate("timeLimit", int.Parse(TimeLimit.text));
			});
			TeamComposition = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild2, "TeamComposition"), "Dropdown").GetComponent<TMP_Dropdown>();
			((UnityEvent<int>)(object)TeamComposition.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				onSettingUpdate("teamComposition", TeamComposition.value);
			});
			Gamemode = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild2, "Gamemode"), "Dropdown").GetComponent<TMP_Dropdown>();
			((UnityEvent<int>)(object)Gamemode.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				onSettingUpdate("gamemode", Gamemode.value);
			});
			GridSize = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild2, "GridSize"), "Dropdown").GetComponent<TMP_Dropdown>();
			((UnityEvent<int>)(object)GridSize.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				onSettingUpdate("gridSize", GridSize.value);
			});
			Difficulty = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild2, "Difficulty"), "Configure").GetComponent<Button>();
			ButtonClickedEvent onClick6 = Difficulty.onClick;
			object obj6 = <>c.<>9__34_11;
			if (obj6 == null)
			{
				UnityAction val6 = delegate
				{
					BingoSetDifficultyMenu.Setup();
					BingoEncapsulator.BingoLobbyScreen.SetActive(false);
					BingoEncapsulator.BingoSetDifficulty.SetActive(true);
				};
				<>c.<>9__34_11 = val6;
				obj6 = (object)val6;
			}
			((UnityEvent)onClick6).AddListener((UnityAction)obj6);
			RequirePRank = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild2, "RequirePRank"), "Input").GetComponent<Toggle>();
			((UnityEvent<bool>)(object)RequirePRank.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				onSettingUpdate("requiresPRank", RequirePRank.isOn ? 1 : 0);
			});
			GameObject gameObjectChild3 = CommonFunctions.GetGameObjectChild(gameObjectChild, "Page2");
			settingPages.Add(gameObjectChild3);
			DisableCampaignAltExits = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild3, "DisableCampaignAltEnds"), "Input").GetComponent<Toggle>();
			((UnityEvent<bool>)(object)DisableCampaignAltExits.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				onSettingUpdate("disableCampaignAltExits", DisableCampaignAltExits.isOn ? 1 : 0);
			});
			GameVisibility = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild3, "GameVisibility"), "Dropdown").GetComponent<TMP_Dropdown>();
			((UnityEvent<int>)(object)GameVisibility.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				onSettingUpdate("gameVisibility", GameVisibility.value);
			});
			AllowRejoin = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild3, "AllowRejoin"), "Input").GetComponent<Toggle>();
			((UnityEvent<bool>)(object)AllowRejoin.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				onSettingUpdate("allowRejoin", AllowRejoin.isOn ? 1 : 0);
			});
			GameModifiers = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild3, "GameModifier"), "Dropdown").GetComponent<TMP_Dropdown>();
			((UnityEvent<int>)(object)GameModifiers.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				onSettingUpdate("gameModifier", GameModifiers.value);
			});
			HideLevelNames = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild3, "HideLevelNames"), "Input").GetComponent<Toggle>();
			((UnityEvent<bool>)(object)HideLevelNames.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				onSettingUpdate("hideLevelNames", HideLevelNames.isOn ? 1 : 0);
			});
			HidePlayerTimes = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild3, "HidePlayerTimes"), "Input").GetComponent<Toggle>();
			((UnityEvent<bool>)(object)HidePlayerTimes.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				onSettingUpdate("hidePlayerTimes", HidePlayerTimes.isOn ? 1 : 0);
			});
			HidePlayerTimes = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild3, "HidePlayerTimes"), "Input").GetComponent<Toggle>();
			((UnityEvent<bool>)(object)HidePlayerTimes.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				onSettingUpdate("hidePlayerTimes", HidePlayerTimes.isOn ? 1 : 0);
			});
			Controls = CommonFunctions.GetGameObjectChild(GameOptions, "Controls");
			Back = CommonFunctions.GetGameObjectChild(Controls, "Back").GetComponent<Button>();
			PageCount = CommonFunctions.GetGameObjectChild(Controls, "PageCount").GetComponent<TextMeshProUGUI>();
			Forward = CommonFunctions.GetGameObjectChild(Controls, "Forward").GetComponent<Button>();
			ButtonClickedEvent onClick7 = Back.onClick;
			object obj7 = <>c.<>9__34_20;
			if (obj7 == null)
			{
				UnityAction val7 = delegate
				{
					SwitchPage(-1);
				};
				<>c.<>9__34_20 = val7;
				obj7 = (object)val7;
			}
			((UnityEvent)onClick7).AddListener((UnityAction)obj7);
			ButtonClickedEvent onClick8 = Forward.onClick;
			object obj8 = <>c.<>9__34_21;
			if (obj8 == null)
			{
				UnityAction val8 = delegate
				{
					SwitchPage(1);
				};
				<>c.<>9__34_21 = val8;
				obj8 = (object)val8;
			}
			((UnityEvent)onClick8).AddListener((UnityAction)obj8);
			if ((Object)(object)chatWindow == (Object)null)
			{
				chatWindow = Object.Instantiate<GameObject>(AssetLoader.BingoChat, BingoLobby.transform);
				((Object)chatWindow).name = "BingoChat";
				chatWindow.AddComponent<BingoChatManager>();
				chatWindow.GetComponent<BingoChatManager>().Bind(chatWindow);
			}
			BingoLobby.SetActive(false);
		}
	}
	public static class BingoMainMenu
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__17_0;

			public static UnityAction <>9__17_1;

			public static UnityAction <>9__17_2;

			public static UnityAction <>9__17_3;

			public static UnityAction <>9__17_4;

			internal void <Init>b__17_0()
			{
				LockUI();
				BingoMenuController.CreateRoom();
			}

			internal void <Init>b__17_1()
			{
				LockUI();
				BingoMenuController.JoinRoom(CommonFunctions.GetGameObjectChild(JoinGameInput, "InputField (TMP)").GetComponent<TMP_InputField>().text);
			}

			internal void <Init>b__17_2()
			{
				BingoEncapsulator.BingoMenu.SetActive(false);
				BingoEncapsulator.BingoGameBrowser.SetActive(true);
				NetworkManager.setState(State.INBROWSER);
				BingoBrowser.FetchGames();
			}

			internal void <Init>b__17_3()
			{
				BingoMenuController.ReturnToMenu();
			}

			internal void <Init>b__17_4()
			{
				Application.OpenURL("https://discord.gg/VyzFJwEWtJ");
			}
		}

		public static GameObject Root;

		public static GameObject HostGame;

		public static GameObject JoinGame;

		public static GameObject JoinGameInput;

		public static GameObject GameBrowser;

		public static GameObject Back;

		public static GameObject DiscordButton;

		public static GameObject VersionInfo;

		public static TextMeshProUGUI VersionNum;

		public static GameObject MOTDContainer;

		public static TextMeshProUGUI MOTDText;

		public static string MOTD = "";

		public static GameObject RankSelection;

		public static TMP_Dropdown RankSelectionDropdown;

		public static List<string> ranks;

		public static void LockUI()
		{
			((Selectable)HostGame.GetComponent<Button>()).interactable = false;
			((Selectable)JoinGame.GetComponent<Button>()).interactable = false;
			((Selectable)GameBrowser.GetComponent<Button>()).interactable = false;
		}

		public static void UnlockUI()
		{
			((Selectable)HostGame.GetComponent<Button>()).interactable = true;
			((Selectable)JoinGame.GetComponent<Button>()).interactable = true;
			((Selectable)GameBrowser.GetComponent<Button>()).interactable = true;
		}

		public static GameObject Init(ref GameObject BingoMenu)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_007e: 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)
			//IL_0089: Expected O, but got Unknown
			//IL_00d6: 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)
			//IL_00e1: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			//IL_015e: 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_0169: Expected O, but got Unknown
			HostGame = CommonFunctions.GetGameObjectChild(BingoMenu, "Host Game");
			ButtonClickedEvent onClick = HostGame.GetComponent<Button>().onClick;
			object obj = <>c.<>9__17_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					LockUI();
					BingoMenuController.CreateRoom();
				};
				<>c.<>9__17_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			JoinGame = CommonFunctions.GetGameObjectChild(BingoMenu, "Join Game");
			ButtonClickedEvent onClick2 = JoinGame.GetComponent<Button>().onClick;
			object obj2 = <>c.<>9__17_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					LockUI();
					BingoMenuController.JoinRoom(CommonFunctions.GetGameObjectChild(JoinGameInput, "InputField (TMP)").GetComponent<TMP_InputField>().text);
				};
				<>c.<>9__17_1 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			JoinGameInput = CommonFunctions.GetGameObjectChild(JoinGame, "IdInput");
			GameBrowser = CommonFunctions.GetGameObjectChild(BingoMenu, "Match Browser");
			ButtonClickedEvent onClick3 = GameBrowser.GetComponent<Button>().onClick;
			object obj3 = <>c.<>9__17_2;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					BingoEncapsulator.BingoMenu.SetActive(false);
					BingoEncapsulator.BingoGameBrowser.SetActive(true);
					NetworkManager.setState(State.INBROWSER);
					BingoBrowser.FetchGames();
				};
				<>c.<>9__17_2 = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			Back = CommonFunctions.GetGameObjectChild(BingoMenu, "Back");
			ButtonClickedEvent onClick4 = Back.GetComponent<Button>().onClick;
			object obj4 = <>c.<>9__17_3;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					BingoMenuController.ReturnToMenu();
				};
				<>c.<>9__17_3 = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			DiscordButton = CommonFunctions.GetGameObjectChild(BingoMenu, "Discord");
			ButtonClickedEvent onClick5 = DiscordButton.GetComponent<Button>().onClick;
			object obj5 = <>c.<>9__17_4;
			if (obj5 == null)
			{
				UnityAction val5 = delegate
				{
					Application.OpenURL("https://discord.gg/VyzFJwEWtJ");
				};
				<>c.<>9__17_4 = val5;
				obj5 = (object)val5;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
			VersionInfo = CommonFunctions.GetGameObjectChild(BingoMenu, "Version");
			VersionNum = CommonFunctions.GetGameObjectChild(VersionInfo, "VersionNum").GetComponent<TextMeshProUGUI>();
			MOTDContainer = CommonFunctions.GetGameObjectChild(BingoMenu, "MOTD");
			MOTDText = CommonFunctions.GetGameObjectChild(MOTDContainer, "Content").GetComponent<TextMeshProUGUI>();
			((TMP_Text)MOTDText).text = MOTD;
			RankSelection = CommonFunctions.GetGameObjectChild(BingoMenu, "RankSelection");
			TMP_Dropdown rankSelector = CommonFunctions.GetGameObjectChild(RankSelection, "Dropdown").GetComponent<TMP_Dropdown>();
			RankSelectionDropdown = rankSelector;
			if (ranks != null)
			{
				rankSelector.ClearOptions();
				rankSelector.AddOptions(ranks);
			}
			((UnityEvent<int>)(object)rankSelector.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				NetworkManager.requestedRank = rankSelector.options[rankSelector.value].text;
				NetworkManager.lastRankUsedConfig.Value = NetworkManager.requestedRank;
			});
			return Root;
		}
	}
	public static class BingoMenuController
	{
		public static string currentlyDownloadingLevel = "";

		public static bool checkSteamAuthentication()
		{
			if (Main.UpdateAvailable)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("<color=orange>An update is available! Please update your mod to play Baphomet's Bingo.</color>", "", "", 0, false, false, true);
				return false;
			}
			if (!Main.IsSteamAuthenticated)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Unable to authenticate with Steam.\nYou must be connected to the Steam servers, and own a legal copy of ULTRAKILL to play Baphomet's Bingo.", "", "", 0, false, false, true);
				return false;
			}
			return Main.IsSteamAuthenticated;
		}

		public static void LoadBingoLevel(string levelName, string levelCoords, BingoLevelData levelData)
		{
			if (!GameManager.CurrentGame.isGameFinished())
			{
				MonoSingleton<PrefsManager>.Instance.SetBool("majorAssist", false);
				MonoSingleton<PrefsManager>.Instance.SetInt("difficulty", GameManager.CurrentGame.gameSettingsArray["difficulty"]);
				int row = int.Parse(levelCoords[0].ToString());
				int column = int.Parse(levelCoords[2].ToString());
				GameManager.IsInBingoLevel = true;
				switch (levelData.bingoLevelType)
				{
				case BingoLevelType.Campaign:
					handleCampaignLoad(levelName, row, column);
					break;
				case BingoLevelType.Angry:
					handleAngryLoad(levelData, row, column);
					break;
				case BingoLevelType.UltraEditor:
					HandleUltraEditorLoad(row, column, levelName, GameManager.CurrentGame.grid.levelTable[row + "-" + column].levelId, levelData.ultraEditorLevelData);
					break;
				default:
					Logging.Warn("Unknown level type id, can't load! " + levelData.bingoLevelType);
					break;
				}
			}
		}

		public static LoadScriptResult loadAngryScript(string scriptName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ScriptManager.AttemptLoadScriptWithCertificate(scriptName);
		}

		public static async Task<bool> DownloadAngryScript(string scriptName)
		{
			ScriptUpdateProgressField field = new ScriptUpdateProgressField();
			field.scriptName = scriptName;
			field.scriptStatus = (ScriptStatus)0;
			field.StartDownload();
			while (field.downloading)
			{
				await Task.Delay(500);
			}
			if (field.isDone)
			{
				Logging.Warn("Download finished");
				return true;
			}
			Logging.Error("Download failed!");
			return false;
		}

		public static async void handleCampaignLoad(string campaignLevelName, int row = 0, int column = 0)
		{
			if (!GameManager.CurrentGame.isGameFinished())
			{
				await Task.Delay(1000);
				NetworkManager.setState(State.INGAME);
				GameManager.UpdateGridPosition(row, column);
				SceneHelper.LoadScene(campaignLevelName, false);
			}
		}

		public unsafe static async void handleAngryLoad(BingoLevelData angryLevelData, int row = 0, int column = 0)
		{
			if (GameManager.CurrentGame.isGameFinished())
			{
				return;
			}
			if (GameManager.IsDownloadingLevel)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Please wait for the current download to complete before switching to a different level.", "", "", 0, false, false, true);
			}
			else if ((int)OnlineLevelsList.onlineLevels[angryLevelData.angryParentBundle]._status == 0)
			{
				await Task.Delay(1000);
				Dictionary<string, BundleContainer> angryBundles = Plugin.angryBundles;
				BundleContainer bundleContainer = angryBundles[angryLevelData.angryParentBundle];
				Logging.Message("Loading Angry level");
				GameManager.EnteringAngryLevel = true;
				if (AngrySceneManager.currentBundleContainer == null)
				{
					await bundleContainer.ReloadBundle(true, false);
					await Task.Delay(250);
				}
				else if (angryLevelData.angryParentBundle != AngrySceneManager.currentBundleContainer.bundleData.bundleGuid)
				{
					await bundleContainer.ReloadBundle(true, false);
					await Task.Delay(250);
				}
				if (bundleContainer.levels.TryGetValue(angryLevelData.angryLevelId, out var customLevel))
				{
					string text = ((CommonFunctions.getSceneName() != "Main Menu") ? ("MOVING TO <color=orange>" + angryLevelData.levelName + "</color>...") : ("LOADING <color=orange>" + angryLevelData.levelName + "</color>..."));
					if (CommonFunctions.getSceneName() == "Main Menu")
					{
						MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
					}
					else
					{
						((TMP_Text)BingoCardPauseMenu.DescriptorText.GetComponent<TextMeshProUGUI>()).text = text;
					}
					await Task.Delay(1000);
					NetworkManager.setState(State.INGAME);
					AngryDifficultyManager.SetDifficultyFromPrefs();
					List<string> requiredAngryScripts = ScriptManager.GetRequiredScriptsFromBundle(bundleContainer);
					if (requiredAngryScripts.Count > 0)
					{
						Logging.Message("Level requires custom scripts, checking if locally loaded");
						foreach (string scriptName in requiredAngryScripts)
						{
							if (!ScriptManager.ScriptExists(scriptName))
							{
								Logging.Message("Asking Angry to download " + scriptName);
								if (await DownloadAngryScript(scriptName))
								{
									LoadScriptResult val = loadAngryScript(scriptName);
									if ((int)val != 0)
									{
										Logging.Error("Failed to load script with reason: ");
										Logging.Error(((object)(*(LoadScriptResult*)(&val))/*cast due to .constrained prefix*/).ToString());
									}
								}
							}
							else
							{
								Logging.Message(scriptName + " is already downloaded");
							}
						}
						if (!GameManager.CurrentGame.isGameFinished())
						{
							GameManager.IsSwitchingLevels = true;
							ConfigManager.difficultyField.gamemodeListValueIndex = GameManager.CurrentGame.gameSettingsArray["gameModifier"];
							GameManager.UpdateGridPosition(row, column);
							AngrySceneManager.LoadLevelWithScripts(requiredAngryScripts, customLevel);
						}
					}
					else if (!GameManager.CurrentGame.isGameFinished())
					{
						GameManager.IsSwitchingLevels = true;
						ConfigManager.difficultyField.gamemodeListValueIndex = GameManager.CurrentGame.gameSettingsArray["gameModifier"];
						GameManager.UpdateGridPosition(row, column);
						AngrySceneManager.LoadLevel(customLevel, true);
					}
				}
				else
				{
					Logging.Error("Given level ID does not exist inside the bundle!");
					Logging.Error("Given level ID: " + angryLevelData.angryLevelId);
					MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("<color=orange>Failed to load level, something went wrong.</color>", "", "", 0, false, false, true);
				}
			}
			else if (GameManager.IsDownloadingLevel)
			{
				Logging.Warn("Trying to download a level but another one is already in progress!");
			}
			else
			{
				Logging.Message("Level does not already exist locally - Downloading from online repo");
				if (CommonFunctions.getSceneName() != "Main Menu")
				{
					MonoSingleton<OptionsManager>.Instance.UnPause();
				}
				GameManager.IsDownloadingLevel = true;
				GameManager.IsSwitchingLevels = false;
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("-- DOWNLOADING " + angryLevelData.levelName + " --\nYou can continue to play in the meantime.", "", "", 0, false, false, true);
				currentlyDownloadingLevel = angryLevelData.levelName;
				OnlineLevelsList.onlineLevels[angryLevelData.angryParentBundle].Download();
				while (OnlineLevelsList.onlineLevels[angryLevelData.angryParentBundle].Downloading)
				{
					await Task.Delay(500);
				}
			}
		}

		public static void HandleUltraEditorLoad(int row, int column, string levelName, string levelId, string levelDataUrl)
		{
			Logging.Warn("UltraEditorLoad...");
			Logging.Message(levelDataUrl);
			NetworkManager.setState(State.INGAME);
			GameManager.UpdateGridPosition(row, column);
			try
			{
				((MonoBehaviour)EmptySceneLoader.Instance).StartCoroutine(FetchLevels.GetStringFromUrl(levelDataUrl, (Action<string>)delegate(string str)
				{
					SceneHelper.ShowLoadingBlocker();
					SceneHelper.SetLoadingSubtext("UltraEditor bingo load test...");
					EmptySceneLoader.forceEditor = false;
					EmptySceneLoader.forceSave = "?";
					EmptySceneLoader.forceSaveData = str;
					EmptySceneLoader.forceLevelName = levelName;
					EmptySceneLoader.forceLevelLayer = "BINGO";
					EmptySceneLoader.forceLevelCanOpenEditor = false;
					EmptySceneLoader.forceLevelGUID = levelId;
					EmptySceneLoader.pTime = "1000";
					EmptySceneLoader.pKills = "20";
					EmptySceneLoader.pStyle = "1000";
					EditorManager.canOpenEditor = false;
					EmptySceneLoader.Instance.LoadLevel();
				}));
			}
			catch (Exception value)
			{
				Console.WriteLine(value);
				throw;
			}
		}

		public static async void LoadBingoLevelFromPauseMenu(string levelCoords, BingoLevelData levelData)
		{
			if (GameManager.CurrentGame.isGameFinished() || GameManager.IsSwitchingLevels)
			{
				return;
			}
			if (levelData.angryLevelId == CommonFunctions.getSceneName())
			{
				Logging.Warn("Trying to load level we're already in");
			}
			else if (!GameManager.CurrentGame.isGameFinished())
			{
				int row = int.Parse(levelCoords[0].ToString());
				int column = int.Parse(levelCoords[2].ToString());
				string levelName = GameManager.CurrentGame.grid.levelTable[levelCoords].levelName;
				string levelId = GameManager.CurrentGame.grid.levelTable[levelCoords].levelId;
				GameManager.voteData = (MonoSingleton<BingoVoteManager>.Instance.voteOngoing ? new VoteData(ongoing: true, MonoSingleton<BingoVoteManager>.Instance.hasVoted, MonoSingleton<BingoVoteManager>.Instance.voteThreshold, MonoSingleton<BingoVoteManager>.Instance.currentVotes, MonoSingleton<BingoVoteManager>.Instance.map, MonoSingleton<BingoVoteManager>.Instance.timeRemaining) : new VoteData(ongoing: false));
				string text = "MOVING TO <color=orange>" + levelName + "</color>...";
				((TMP_Text)BingoCardPauseMenu.DescriptorText.GetComponent<TextMeshProUGUI>()).text = text;
				GameManager.IsSwitchingLevels = true;
				switch (levelData.bingoLevelType)
				{
				case BingoLevelType.Campaign:
					handleCampaignLoad(levelId, row, column);
					break;
				case BingoLevelType.Angry:
					handleAngryLoad(levelData, row, column);
					break;
				case BingoLevelType.UltraEditor:
					HandleUltraEditorLoad(row, column, levelData.angryLevelId, GameManager.CurrentGame.grid.levelTable[row + "-" + column].levelId, levelData.ultraEditorLevelData);
					break;
				default:
					Logging.Warn("Unknown level type id, can't load! " + levelData.bingoLevelType);
					break;
				}
			}
		}

		public static void ReturnToMenu()
		{
			UIManager.RemoveLimit();
			BingoEncapsulator.Root.SetActive(false);
			CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("Canvas"), "Difficulty Select (1)").SetActive(true);
			NetworkManager.setState(State.NORMAL);
		}

		public static void CreateRoom()
		{
			if (checkSteamAuthentication())
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Creating room...", "", "", 0, false, false, true);
				NetworkManager.pendingAction = AsyncAction.Host;
				NetworkManager.ConnectWebSocket();
			}
		}

		public static void JoinRoom(string roomPassword)
		{
			if (checkSteamAuthentication())
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Joining room...", "", "", 0, false, false, true);
				NetworkManager.pendingAction = AsyncAction.Join;
				NetworkManager.pendingPassword = roomPassword;
				NetworkManager.ConnectWebSocket();
			}
		}

		public static void StartGame(int gameType, bool isJoiningMidGame = false)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			GameManager.SetupBingoCardDynamic();
			if (GameManager.CurrentGame.difficultyOverride.ContainsKey(((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString()) && GameManager.CurrentGame.difficultyOverride[((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString()] > 0)
			{
				GameManager.CurrentGame.gameSettingsArray["difficulty"] = GameManager.CurrentGame.difficultyOverride[((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString()] - 1;
			}
			string text = (isJoiningMidGame ? "Joined game in progress." : "The game has begun!");
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
			if (GameManager.CurrentGame.gameSettingsArray["gamemode"] == 1)
			{
				CommonFunctions.GetInactiveRootObject("Canvas").AddComponent<DominationTimeManager>();
			}
			GameManager.MoveToCard(gameType);
		}
	}
	public static class BingoSetDifficultyMenu
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__7_0;

			public static UnityAction <>9__7_1;

			internal void <Init>b__7_0()
			{
				ReturnToLobbyMenu();
			}

			internal void <Init>b__7_1()
			{
				UpdateDifficulties();
				ReturnToLobbyMenu();
			}
		}

		public static TMP_Dropdown BaseDifficulty;

		public static GameObject PlayerList;

		public static GameObject PlayerTemplate;

		public static Button Cancel;

		public static Button Finish;

		public static Dictionary<string, int> difficultyOverrides = new Dictionary<string, int>();

		public static void UpdateDifficulties()
		{
			NetworkManager.SendEncodedMessage(JsonConvert.SerializeObject((object)new DifficultySettings
			{
				gameId = GameManager.CurrentGame.gameId,
				baseDifficulty = BaseDifficulty.value,
				difficultyOverride = difficultyOverrides,
				ticket = NetworkManager.CreateRegisterTicket()
			}));
			ReturnToLobbyMenu();
		}

		public static void Init(ref GameObject BingoSetDifficulty)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			BaseDifficulty = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(BingoSetDifficulty, "BaseDifficulty"), "Dropdown").GetComponent<TMP_Dropdown>();
			PlayerList = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(BingoSetDifficulty, "PlayerList"), "Grid"), "Scroll View"), "Viewport"), "Content");
			PlayerTemplate = CommonFunctions.GetGameObjectChild(PlayerList, "PlayerTemplate");
			Cancel = CommonFunctions.GetGameObjectChild(BingoSetDifficulty, "Cancel").GetComponent<Button>();
			ButtonClickedEvent onClick = Cancel.onClick;
			object obj = <>c.<>9__7_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					ReturnToLobbyMenu();
				};
				<>c.<>9__7_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			Finish = CommonFunctions.GetGameObjectChild(BingoSetDifficulty, "Finish").GetComponent<Button>();
			ButtonClickedEvent onClick2 = Finish.onClick;
			object obj2 = <>c.<>9__7_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					UpdateDifficulties();
					ReturnToLobbyMenu();
				};
				<>c.<>9__7_1 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
		}

		public static void Setup()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			List<string> list = GameManager.CurrentGame.currentPlayers.Keys.ToList();
			difficultyOverrides.Clear();
			foreach (string item in list)
			{
				_ = item;
				foreach (Transform item2 in UnityExtensions[PlayerTemplate].transform)
				{
					Transform val = item2;
					if (((Object)((Component)val).gameObject).name != "PlayerTemplate")
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
				}
			}
			foreach (string id in list)
			{
				string username = GameManager.CurrentGame.currentPlayers[id].username;
				GameObject val2 = Object.Instantiate<GameObject>(PlayerTemplate, UnityExtensions[PlayerTemplate].transform);
				((Object)val2).name = id;
				((TMP_Text)CommonFunctions.GetGameObjectChild(val2, "Text").GetComponent<TextMeshProUGUI>()).text = username;
				TMP_Dropdown selectedDifficulty = CommonFunctions.GetGameObjectChild(val2, "Dropdown").GetComponent<TMP_Dropdown>();
				difficultyOverrides.Add(id, 0);
				((UnityEvent<int>)(object)selectedDifficulty.onValueChanged).AddListener((UnityAction<int>)delegate
				{
					difficultyOverrides[id] = selectedDifficulty.value;
				});
				val2.SetActive(true);
			}
		}

		public static void ReturnToLobbyMenu()
		{
			BingoEncapsulator.BingoSetDifficulty.SetActive(false);
			BingoEncapsulator.BingoLobbyScreen.SetActive(true);
		}
	}
	public class BingoSetTeamsMenu
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__22_0;

			public static UnityAction <>9__22_1;

			public static UnityAction <>9__22_2;

			public static UnityAction <>9__22_3;

			public static UnityAction <>9__22_4;

			public static UnityAction <>9__22_5;

			public static UnityAction <>9__22_6;

			public static UnityAction <>9__22_7;

			internal void <Init>b__22_0()
			{
				updatePlayerTeam(1);
			}

			internal void <Init>b__22_1()
			{
				updatePlayerTeam(2);
			}

			internal void <Init>b__22_2()
			{
				updatePlayerTeam(3);
			}

			internal void <Init>b__22_3()
			{
				updatePlayerTeam(4);
			}

			internal void <Init>b__22_4()
			{
				TeamSelectionPanel.SetActive(false);
			}

			internal void <Init>b__22_5()
			{
				Cancel();
			}

			internal void <Init>b__22_6()
			{
				Discard();
			}

			internal void <Init>b__22_7()
			{
				Submit();
			}
		}

		public static Dictionary<int, Color> teamColors = new Dictionary<int, Color>
		{
			{
				0,
				new Color(1f, 1f, 1f, 1f)
			},
			{
				1,
				new Color(1f, 0f, 0f, 1f)
			},
			{
				2,
				new Color(0f, 1f, 0f, 1f)
			},
			{
				3,
				new Color(0f, 0f, 1f, 1f)
			},
			{
				4,
				new Color(1f, 1f, 0f, 1f)
			}
		};

		public static GameObject Root;

		public static GameObject PlayerGrid;

		public static GameObject ButtonTemplate;

		public static GameObject CancelButton;

		public static GameObject ResetButton;

		public static GameObject FinishButton;

		public static GameObject TeamSelectionPanel;

		public static GameObject TeamSelectionBackButton;

		public static GameObject currentPlayerObject = null;

		public static List<GameObject> TeamSelectionPanelButtons = new List<GameObject>();

		public static Dictionary<string, int> currentTeamChanges = new Dictionary<string, int>();

		public static int playersMapped = 0;

		public static int playersToMap = 0;

		public static void ReturnToLobbyMenu()
		{
			BingoEncapsulator.BingoSetTeams.SetActive(false);
			BingoEncapsulator.BingoLobbyScreen.SetActive(true);
		}

		public static void Cancel()
		{
			currentTeamChanges.Clear();
			foreach (GameObject teamSelectionPanelButton in TeamSelectionPanelButtons)
			{
				teamSelectionPanelButton.SetActive(true);
			}
			ReturnToLobbyMenu();
		}

		public static void Discard()
		{
			NetworkManager.SendEncodedMessage(JsonConvert.SerializeObject((object)new ClearTeamSettings
			{
				gameId = GameManager.CurrentGame.gameId,
				ticket = NetworkManager.CreateRegisterTicket()
			}));
			ReturnToLobbyMenu();
		}

		public static void Submit()
		{
			if (playersToMap != playersMapped)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("One or more players have not been assigned to a team.", "", "", 0, false, false, true);
				return;
			}
			NetworkManager.SendEncodedMessage(JsonConvert.SerializeObject((object)new TeamSettings
			{
				gameId = GameManager.CurrentGame.gameId,
				teams = currentTeamChanges,
				ticket = NetworkManager.CreateRegisterTicket()
			}));
			ReturnToLobbyMenu();
		}

		public static void PrepareChanges()
		{
			foreach (string item in GameManager.CurrentGame.currentPlayers.Keys.ToList())
			{
				currentTeamChanges[item] = 0;
			}
		}

		public static void OpenTeamColorPanel(ref GameObject player, string playerSteamId, string playerName)
		{
			if (currentTeamChanges.ContainsKey(playerSteamId))
			{
				currentPlayerObject = player;
				((TMP_Text)CommonFunctions.GetGameObjectChild(TeamSelectionPanel, "PlayerName").GetComponent<TextMeshProUGUI>()).text = "<color=orange>" + playerName + "</color>";
				TeamSelectionPanel.SetActive(true);
			}
			else
			{
				Logging.Warn("Tried to update team for SteamID " + playerSteamId + " but it's not set in the dict!");
			}
		}

		public static void updatePlayerTeam(int teamId)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (currentTeamChanges[((Object)currentPlayerObject).name] == 0)
			{
				playersMapped++;
			}
			currentTeamChanges[((Object)currentPlayerObject).name] = teamId;
			((Graphic)currentPlayerObject.GetComponent<Image>()).color = teamColors[teamId];
			TeamSelectionPanel.SetActive(false);
		}

		public static void Setup()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Expected O, but got Unknown
			Dictionary<string, Player> currentPlayers = GameManager.CurrentGame.currentPlayers;
			playersToMap = currentPlayers.Count;
			playersMapped = 0;
			List<string> list = currentPlayers.Keys.ToList();
			foreach (Transform item in PlayerGrid.transform)
			{
				Transform val = item;
				if (((Object)((Component)val).gameObject).name != "PlayerTemplate")
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			currentTeamChanges.Clear();
			foreach (string id in list)
			{
				string playerName = GameManager.CurrentGame.currentPlayers[id].username;
				GameObject playerTeamButton = Object.Instantiate<GameObject>(ButtonTemplate, PlayerGrid.transform);
				((Object)playerTeamButton).name = id;
				((TMP_Text)CommonFunctions.GetGameObjectChild(playerTeamButton, "Text").GetComponent<TextMeshProUGUI>()).text = playerName;
				((UnityEvent)playerTeamButton.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					OpenTeamColorPanel(ref playerTeamButton, id, playerName);
				});
				playerTeamButton.SetActive(true);
			}
			for (int num = GameManager.CurrentGame.gameSettingsArray["maxTeams"]; num < TeamSelectionPanelButtons.Count; num++)
			{
				TeamSelectionPanelButtons[num].SetActive(false);
			}
			PrepareChanges();
		}

		public static void Init(ref GameObject BingoSetTeams)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//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_01ec: Expected O, but got Unknown
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Expected O, but got Unknown
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Expected O, but got Unknown
			if ((Object)(object)ButtonTemplate == (Object)null)
			{
				ButtonTemplate = new GameObject();
			}
			PlayerGrid = CommonFunctions.GetGameObjectChild(BingoSetTeams, "PlayerContainer");
			ButtonTemplate = CommonFunctions.GetGameObjectChild(PlayerGrid, "PlayerTemplate");
			ButtonTemplate.SetActive(false);
			TeamSelectionPanel = CommonFunctions.GetGameObjectChild(BingoSetTeams, "TeamSelection");
			GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(TeamSelectionPanel, "TeamColorContainer");
			TeamSelectionPanelButtons.Clear();
			TeamSelectionPanelButtons.Add(CommonFunctions.GetGameObjectChild(gameObjectChild, "Red"));
			TeamSelectionPanelButtons.Add(CommonFunctions.GetGameObjectChild(gameObjectChild, "Green"));
			TeamSelectionPanelButtons.Add(CommonFunctions.GetGameObjectChild(gameObjectChild, "Blue"));
			TeamSelectionPanelButtons.Add(CommonFunctions.GetGameObjectChild(gameObjectChild, "Yellow"));
			ButtonClickedEvent onClick = CommonFunctions.GetGameObjectChild(gameObjectChild, "Red").GetComponent<Button>().onClick;
			object obj = <>c.<>9__22_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					updatePlayerTeam(1);
				};
				<>c.<>9__22_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = CommonFunctions.GetGameObjectChild(gameObjectChild, "Green").GetComponent<Button>().onClick;
			object obj2 = <>c.<>9__22_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					updatePlayerTeam(2);
				};
				<>c.<>9__22_1 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			ButtonClickedEvent onClick3 = CommonFunctions.GetGameObjectChild(gameObjectChild, "Blue").GetComponent<Button>().onClick;
			object obj3 = <>c.<>9__22_2;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					updatePlayerTeam(3);
				};
				<>c.<>9__22_2 = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			ButtonClickedEvent onClick4 = CommonFunctions.GetGameObjectChild(gameObjectChild, "Yellow").GetComponent<Button>().onClick;
			object obj4 = <>c.<>9__22_3;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					updatePlayerTeam(4);
				};
				<>c.<>9__22_3 = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			TeamSelectionBackButton = CommonFunctions.GetGameObjectChild(TeamSelectionPanel, "Back");
			ButtonClickedEvent onClick5 = TeamSelectionBackButton.GetComponent<Button>().onClick;
			object obj5 = <>c.<>9__22_4;
			if (obj5 == null)
			{
				UnityAction val5 = delegate
				{
					TeamSelectionPanel.SetActive(false);
				};
				<>c.<>9__22_4 = val5;
				obj5 = (object)val5;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
			CancelButton = CommonFunctions.GetGameObjectChild(BingoSetTeams, "Cancel");
			ButtonClickedEvent onClick6 = CancelButton.GetComponent<Button>().onClick;
			object obj6 = <>c.<>9__22_5;
			if (obj6 == null)
			{
				UnityAction val6 = delegate
				{
					Cancel();
				};
				<>c.<>9__22_5 = val6;
				obj6 = (object)val6;
			}
			((UnityEvent)onClick6).AddListener((UnityAction)obj6);
			ResetButton = CommonFunctions.GetGameObjectChild(BingoSetTeams, "Reset");
			ButtonClickedEvent onClick7 = ResetButton.GetComponent<Button>().onClick;
			object obj7 = <>c.<>9__22_6;
			if (obj7 == null)
			{
				UnityAction val7 = delegate
				{
					Discard();
				};
				<>c.<>9__22_6 = val7;
				obj7 = (object)val7;
			}
			((UnityEvent)onClick7).AddListener((UnityAction)obj7);
			FinishButton = CommonFunctions.GetGameObjectChild(BingoSetTeams, "Finish");
			ButtonClickedEvent onClick8 = FinishButton.GetComponent<Button>().onClick;
			object obj8 = <>c.<>9__22_7;
			if (obj8 == null)
			{
				UnityAction val8 = delegate
				{
					Submit();
				};
				<>c.<>9__22_7 = val8;
				obj8 = (object)val8;
			}
			((UnityEvent)onClick8).AddListener((UnityAction)obj8);
		}
	}
	public static class BingoVotePanel
	{
		public static GameObject Root;

		public static GameObject RerollText;

		public static GameObject RerollVotes;

		public static GameObject RerollTimer;

		public static BingoVoteManager manager;

		public static void Init(ref GameObject votePanel)
		{
			RerollText = CommonFunctions.GetGameObjectChild(votePanel, "RerollText");
			RerollVotes = CommonFunctions.GetGameObjectChild(votePanel, "RerollVotes");
			RerollTimer = CommonFunctions.GetGameObjectChild(votePanel, "RerollTimer");
		}
	}
	public static class UIHelper
	{
		public static GameObject CreateText(string textString = "Text", int fontSize = 32, string idName = "Text")
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			GameObject val = new GameObject
			{
				name = idName
			};
			val.AddComponent<RectTransform>();
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(200f, 50f);
			val.AddComponent<CanvasRenderer>();
			val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val.GetComponent<TextMeshProUGUI>()).text = textString;
			((TMP_Text)val.GetComponent<TextMeshProUGUI>()).font = AssetLoader.GameFont;
			((TMP_Text)val.GetComponent<TextMeshProUGUI>()).fontSize = fontSize;
			((TMP_Text)val.GetComponent<TextMeshProUGUI>()).alignment = (TextAlignmentOptions)514;
			((Graphic)val.GetComponent<TextMeshProUGUI>()).color = Color.white;
			((TMP_Text)val.GetComponent<TextMeshProUGUI>()).enableWordWrapping = false;
			return val;
		}

		public static GameObject CreateButtonLegacy(string buttonText = "Text", string buttonName = "Button", float rectX = 200f, float rectY = 50f, int fontSize = 32)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = new Color(1f, 1f, 1f, 1f);
			((ColorBlock)(ref val)).highlightedColor = new Color(1f, 1f, 1f, 0.502f);
			((ColorBlock)(ref val)).pressedColor = new Color(1f, 0f, 0f, 1f);
			((ColorBlock)(ref val)).selectedColor = new Color(1f, 1f, 1f, 1f);
			((ColorBlock)(ref val)).disabledColor = new Color(0f, 0f, 0f, 1f);
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			ColorBlock colors = val;
			GameObject val2 = new GameObject();
			((Object)val2).name = buttonName;
			val2.AddComponent<RectTransform>();
			val2.GetComponent<RectTransform>().sizeDelta = new Vector2(rectX, rectY);
			val2.AddComponent<CanvasRenderer>();
			val2.AddComponent<Image>();
			val2.GetComponent<Image>().sprite = AssetLoader.UISprite;
			val2.GetComponent<Image>().fillCenter = false;
			val2.GetComponent<Image>().fillClockwise = true;
			val2.GetComponent<Image>().type = (Type)1;
			val2.AddComponent<Button>();
			((Selectable)val2.GetComponent<Button>()).targetGraphic = (Graphic)(object)val2.GetComponent<Image>();
			GameObject obj = CreateTextLegacy(buttonText, fontSize);
			((Selectable)val2.GetComponent<Button>()).colors = colors;
			((Transform)obj.GetComponent<RectTransform>()).SetParent((Transform)(object)val2.GetComponent<RectTransform>());
			obj.GetComponent<RectTransform>().sizeDelta = new Vector2(150f, 50f);
			((Object)obj).name = "Text";
			return val2;
		}

		public static GameObject CreateTextLegacy(string textString = "Text", int fontSize = 32, string idName = "Text")
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			GameObject val = new GameObject
			{
				name = idName
			};
			val.AddComponent<RectTransform>();
			val.AddComponent<CanvasRenderer>();
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(200f, 50f);
			val.AddComponent<Text>();
			val.GetComponent<Text>().text = textString;
			val.GetComponent<Text>().font = AssetLoader.GameFontLegacy;
			val.GetComponent<Text>().fontSize = fontSize;
			val.GetComponent<Text>().alignment = (TextAnchor)4;
			((Graphic)val.GetComponent<Text>()).color = Color.white;
			return val;
		}
	}
}
namespace UltraBINGO.NetworkMessages
{
	public class ChatMessageSend : SendMessage
	{
		public new string messageType = "ChatMessage";

		public bool isGlobal;

		public string username;

		public int gameId;

		public string steamId;

		public string chatMessage;

		public RegisterTicket ticket;
	}
	public class ChatMessageReceive : MessageResponse
	{
		public string username;

		public bool isGlobal;

		public string message;

		public int channelType;
	}
	public static class ChatMessageReceiveHandler
	{
		public static void handle(ChatMessageReceive response)
		{
			MonoSingleton<BingoChatManager>.Instance.updateChatHistory(response);
		}
	}
	public class ChatWarn : MessageResponse
	{
		public int warnLevel;
	}
	public static class ChatWarnHandler
	{
		public static void handle(ChatWarn response)
		{
			MonoSingleton<BingoChatManager>.Instance.handleWarning(response);
		}
	}
	public class CheatActivation : SendMessage
	{
		public new string messageType = "CheatActivation";

		public int gameId;

		public string username;

		public string steamId;
	}
	public class CheatNotification : MessageResponse
	{
		public string playerToHumil;
	}
	public static class CheatNotificationHandler
	{
		public static List<string> messages = new List<string>
		{
			"Unfortunately, I ate them all.", "Their punishment is one ranked match of League.", "What a silly person.", "They may have spontaneously imploded.", "Their death was a canon event.", "Jakito does not approve.", "Their punishment is 1 hour of grinding 1-4.", "Their attempt was a futile struggle, doomed from the very start.", "Hakita told them to shut the fuck up.", "They were misinformed on the internet.",
			"Point and laugh at this person."
		};

		public static void handle(CheatNotification response)
		{
			Random random = new Random();
			string text = response.playerToHumil + " tried to enable cheats.\n" + messages[random.Next(messages.Count)];
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
		}
	}
	public class CreateRoomRequest : SendMessage
	{
		public new string messageType = "CreateRoom";

		public string roomName;

		public string roomPassword;

		public int maxPlayers;

		public bool pRankRequired;

		public string hostSteamName;

		public string hostSteamId;

		public string rank;
	}
	public class CreateRoomResponse : MessageResponse
	{
		public string status;

		public int roomId;

		public Game roomDetails;

		public string roomPassword;
	}
	public static class CreateRoomResponseHandler
	{
		public static void handle(CreateRoomResponse response)
		{
			if (response.status == "ban")
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("<color=orange>You have been banned from playing Baphomet's Bingo.</color>", "", "", 0, false, false, true);
			}
			else if (response.roomId == 0)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Failed to create room.", "", "", 0, false, false, true);
			}
			else
			{
				Logging.Message("Got details for room " + response.roomId);
				GameManager.SetupGameDetails(response.roomDetails, response.roomPassword);
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Joined game: " + response.roomId, "", "", 0, false, false, true);
			}
			BingoMainMenu.UnlockUI();
			BingoBrowser.UnlockUI();
		}
	}
	public class DifficultySettings : SendMessage
	{
		public new string messageType = "DifficultyOverride";

		public int gameId;

		public int baseDifficulty;

		public Dictionary<string, int> difficultyOverride = new Dictionary<string, int>();

		public RegisterTicket ticket;
	}
	public class DisconnectSignal : MessageResponse
	{
		public int disconnectCode;

		public string disconnectMessage;
	}
	public static class DisconnectSignalHandler
	{
		public static async void handle(DisconnectSignal response = null)
		{
			string text = response.disconnectMessage switch
			{
				"HOSTLEFTGAME" => "The host has left the game. The game will be ended.", 
				"HOSTDROPPED" => "The host has lost connection. The game will be ended.", 
				"RECONNECTFAILED" => "Failed to reconnect.", 
				"GAMEENDED" => "The game has already ended.", 
				_ => "Disconnected for an unspecified reason (check console).\nThe game will be ended.", 
			};
			GameManager.ClearGameVariables();
			if (CommonFunctions.getSceneName() == "Main Menu")
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
				BingoEncapsulator.BingoCardScreen.SetActive(false);
				BingoEncapsulator.BingoLobbyScreen.SetActive(false);
				BingoEncapsulator.BingoEndScreen.SetActive(false);
				BingoEncapsulator.BingoMenu.SetActive(true);
			}
			else
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text + "\nExiting in 5 seconds...", "", "", 0, false, false, true);
				await Task.Delay(5000);
				SceneHelper.LoadScene("Main Menu", false);
			}
		}
	}
	public class DisconnectNotification : MessageResponse
	{
		public string username;

		public string steamId;
	}
	public static class DisconnectNotificationHandler
	{
		public static void handle(DisconnectNotification response)
		{
			string text = response.username + " has left the game.";
			if (GameManager.PlayerIsHost() && BingoLobby.TeamComposition.value == 1 && !GameManager.IsInBingoLevel)
			{
				text += "\n Please recalibrate teams.";
			}
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
			GameManager.CurrentGame.currentPlayers.Remove(response.steamId);
			GameManager.RefreshPlayerList();
		}
	}
	public class EncapsulatedMessage
	{
		public string header;

		public string contents;
	}
	public class EndGameSignal
	{
		public string winningTeam;

		public List<string> winningPlayers;

		public string timeElapsed;

		public int claims;

		public string firstMapClaimed;

		public string lastMapClaimed;

		public float bestStatValue;

		public string bestStatMap;

		public int endStatus;

		public List<string> tiedTeams;
	}
	public static class EndGameSignalHandler
	{
		public static void PlayEndSound()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			GameObject val = new GameObject();
			Transform transform = ((Component)MonoSingleton<NewMovement>.Instance).transform;
			GameObject obj = Object.Instantiate<GameObject>(val, transform.position, Quaternion.identity, transform);
			obj.AddComponent<AudioSource>();
			obj.GetComponent<AudioSource>().playOnAwake = false;
			obj.GetComponent<AudioSource>().clip = AssetLoader.GameOverSound;
			obj.GetComponent<AudioSource>().Play();
		}

		public static async void handle(EndGameSignal response)
		{
			BingoEnd.winningTeam = ((response.endStatus == 0) ? response.winningTeam : ((response.endStatus == 2) ? string.Join("&", response.winningPlayers) : ""));
			BingoEnd.winningPlayers = ((response.endStatus == 0) ? string.Join(",", response.winningPlayers) : "");
			BingoEnd.timeElapsed = response.timeElapsed;
			BingoEnd.numOfClaims = response.claims;
			BingoEnd.firstMap = response.firstMapClaimed;
			BingoEnd.lastMap = response.lastMapClaimed;
			BingoEnd.bestStatValue = response.bestStatValue;
			BingoEnd.bestStatName = response.bestStatMap;
			BingoEnd.endCode = response.endStatus;
			if (response.endStatus == 2)
			{
				BingoEnd.tiedTeams = string.Join(" & ", response.tiedTeams);
			}
			await Task.Delay(250);
			GameManager.CurrentGame.gameState = 2;
			string text = "<color=orange>GAME OVER!</color>";
			switch (response.endStatus)
			{
			case 0:
				text = text + "The <color=" + response.winningTeam.ToLower() + ">" + response.winningTeam + " </color>team has <color=orange>won the game</color>!";
				break;
			case 1:
				text += "No winning team has been declared.";
				break;
			case 2:
				text = text + "The " + string.Join("&", response.tiedTeams) + " teams have <color=orange>tied for the win!</color>";
				break;
			}
			GameManager.CurrentGame.winningTeam = response.winningTeam;
			if (CommonFunctions.getSceneName() != "Main Menu" && GameManager.IsInBingoLevel)
			{
				PlayEndSound();
				MonoSingleton<MusicManager>.Instance.ForceStopMusic();
				MonoSingleton<AssistController>.Instance.majorEnabled = true;
				MonoSingleton<AssistController>.Instance.gameSpeed = 0.35f;
				text += "\n Exiting mission in 5 seconds...";
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
				await Task.Delay(5000);
				SceneHelper.LoadScene("Main Menu", false);
			}
			else
			{
				text += "\n Displaying results in 5 seconds...";
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
				await Task.Delay(5000);
				BingoEnd.ShowEndScreen();
			}
		}
	}
	public class FetchGamesRequest : SendMessage
	{
		public new string messageType = "FetchGames";
	}
	public class FetchGamesResponse : MessageResponse
	{
		public string status;

		public string gameData;
	}
	public class PublicGameData
	{
		public string R_PASSWORD;

		public int R_CURRENTPLAYERS;

		public string C_USERNAME;

		public int R_MAXPLAYERS;

		public int R_DIFFICULTY;
	}
	public static class FetchGamesReponseHandler
	{
		public static void handle(FetchGamesResponse response)
		{
			List<PublicGameData> games = JsonConvert.DeserializeObject<List<PublicGameData>>(response.gameData);
			NetworkManager.DisconnectWebSocket(1000, "GameList");
			BingoBrowser.PopulateGames(games);
		}
	}
	public class HostMigration : MessageResponse
	{
		public string oldHost;

		public string hostSteamId;

		public string hostUsername;
	}
	public static class HostMigrationHandler
	{
		public static void handle(HostMigration response)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			string text = "The current host (" + response.oldHost + ") has lost connection.\n" + ((response.hostSteamId == ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString()) ? "You are now the new host." : ("The new host is now " + response.hostUsername + "."));
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
			GameManager.CurrentGame.gameHost = response.hostSteamId;
		}
	}
	public class JoinRoomRequest : SendMessage
	{
		public new string messageType = "JoinRoom";

		public string password;

		public string username;

		public string steamId;

		public string rank;
	}
	public class JoinRoomResponse : MessageResponse
	{
		public int status;

		public int roomId;

		public Game roomDetails;

		public string joinMidgameTeam;

		public List<string> joinMidgameTeammates;

		public int joinMidGameDominationTime;

		public bool needsTeam;

		public string joinMidGameTeam;
	}
	public static class JoinRoomResponseHandler
	{
		public static Dictionary<int, string> messages = new Dictionary<int, string>
		{
			{ -6, "You have been kicked from this game." },
			{ -5, "<color=orange>You are banned from playing Baphomet's Bingo.</color>" },
			{ -4, "Game has already started." },
			{ -3, "Game is not accepting new players." },
			{ -2, "Game has already started." },
			{ -1, "Game does not exist." }
		};

		public static void handle(JoinRoomResponse response)
		{
			string text = "Failed to join: ";
			if (response.status < 0)
			{
				text += messages[response.status];
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
			}
			else
			{
				Logging.Warn("Mid join-status code: " + response.status);
				if (response.status == 1)
				{
					MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Joined game in progress.", "", "", 0, false, false, true);
					GameManager.SetupJoinMidgameDetails(response.roomDetails, response.joinMidgameTeam, response.joinMidgameTeammates, response.joinMidGameDominationTime, response.needsTeam);
				}
				else
				{
					MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Joined game.", "", "", 0, false, false, true);
					GameManager.SetupGameDetails(response.roomDetails, "", isHost: false);
				}
			}
			BingoMainMenu.UnlockUI();
			BingoBrowser.UnlockUI();
		}
	}
	public class KickPlayer : SendMessage
	{
		public new string messageType = "KickPlayer";

		public int gameId;

		public string playerToKick;

		public RegisterTicket ticket;
	}
	public class Kicked : MessageResponse
	{
	}
	public static class KickHandler
	{
		public static void handle()
		{
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("You were kicked from the game.", "", "", 0, false, false, true);
			NetworkManager.DisconnectWebSocket(1000);
			GameManager.ClearGameVariables();
			BingoEncapsulator.BingoCardScreen.SetActive(false);
			BingoEncapsulator.BingoLobbyScreen.SetActive(false);
			BingoEncapsulator.BingoEndScreen.SetActive(false);
			BingoEncapsulator.BingoMenu.SetActive(true);
		}
	}
	public class KickNotification : MessageResponse
	{
		public string playerToKick;

		public string steamId;
	}
	public static class KickNotificationHandler
	{
		public static void handle(KickNotification response)
		{
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(response.playerToKick + " was kicked from the game.", "", "", 0, false, false, true);
			GameManager.CurrentGame.currentPlayers.Remove(response.steamId);
			if (CommonFunctions.getSceneName() == "Main Menu")
			{
				GameManager.RefreshPlayerList();
			}
		}
	}
	public class LeaveGameRequest : SendMessage
	{
		public new string messageType = "LeaveGame";

		public int roomId;

		public string username;

		public string steamId;
	}
	public class MapPing : SendMessage
	{
		public new string messageType = "MapPing";

		public int gameId;

		public string team;

		public int row;

		public int column;

		public RegisterTicket ticket;
	}
	public class MapPingNotification : MessageResponse
	{
		public int row;

		public int column;
	}
	public static class MapPingNotificationHandler
	{
		public static void handle(MapPingNotification response)
		{
			//IL_006e: 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)
			string childToFind = response.row + "-" + response.column;
			string levelName = CommonFunctions.GetGameObjectChild(BingoCardPauseMenu.Grid, childToFind).GetComponent<BingoLevelData>().levelName;
			if ((Object)(object)BingoCardPauseMenu.pingedMap != (Object)null)
			{
				Object.Destroy((Object)(object)BingoCardPauseMenu.pingedMap);
			}
			Outline obj = CommonFunctions.GetGameObjectChild(BingoCardPauseMenu.Grid, childToFind).AddComponent<Outline>();
			((Shadow)obj).effectColor = new Color(1f, 0.5f, 0f);
			((Shadow)obj).effectDistance = new Vector2(2f, -2f);
			BingoCardPauseMenu.pingedMap = obj;
			levelName = ((GameManager.CurrentGame.gameSettingsArray["hideLevelNames"] == 1) ? "a level" : ("<color=orange>" + levelName + "</color>"));
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Your team has pinged " + levelName + ".", "", "", 0, false, false, true);
		}
	}
	public class MapPool
	{
		public int MapPoolId;

		public string MapPoolName;

		public string MapPoolDescription;

		public int MapPoolLevelCount;
	}
	public class MapPoolResponse : MessageResponse
	{
		public List<MapPool> mapPools;
	}
	public static class MapPoolResponseHandler
	{
		public static void handle(MapPoolResponse response)
		{
		}
	}
	public class PlayerJoiningMessage : MessageResponse
	{
		public string username;

		public string steamId;

		public string rank;
	}
	public static class PlayerJoiningResponseHandler
	{
		public static void handle(PlayerJoiningMessage response)
		{
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(response.username + " has joined the game.", "", "", 0, false, false, true);
			Player player = new Player();
			player.username = response.username;
			player.rank = response.rank;
			GameManager.CurrentGame.currentPlayers[response.steamId] = player;
			GameManager.RefreshPlayerList();
		}
	}
	public class ReconnectRequest : SendMessage
	{
		public new string messageType = "ReconnectRequest";

		public int roomId;

		public string steamId;

		public RegisterTicket ticket;
	}
	public class ReconnectResponse : MessageResponse
	{
		public string status;

		public Game gameData;
	}
	public static class ReconnectResponseHandler
	{
		public static async void handle(ReconnectResponse response)
		{
			string status = response.status;
			if (!(status == "OK"))
			{
				if (status == "end")
				{
					DisconnectSignalHandler.handle(new DisconnectSignal
					{
						disconnectMessage = "GAMEENDED"
					});
					return;
				}
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Failed to reconnect. Leaving game in 5 seconds...", "", "", 0, false, false, true);
				GameManager.ClearGameVariables();
				await Task.Delay(5000);
				SceneHelper.LoadScene("Main Menu", false);
			}
			else
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Reconnected successfully.", "", "", 0, false, false, true);
			}
		}
	}
	public class RegisterTicket : SendMessage
	{
		public new string messageType = "RegisterTicket";

		public string steamTicket;

		public string steamId;

		public string steamUsername;

		public int gameId;
	}
	public class RerollRequest : SendMessage
	{
		public new string messageType = "RerollRequest";

		public RegisterTicket steamTicket;

		public string steamId;

		public int gameId;

		public int row;

		public int column;
	}
	public class RerollExpireNotification : MessageResponse
	{
		public string mapName;
	}
	public static class RerollExpireNotificationHandler
	{
		public static void handle(RerollExpireNotification response)
		{
			string text = "Vote to reroll <color=orange>" + response.mapName + "</color> has expired.";
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
		}
	}
	public class RerollVoteNotification : MessageResponse
	{
		public string mapName;

		public string voteStarter;

		public string voteStarterSteamId;

		public string numVotes;

		public int votesRequired;

		public int notifType;

		public int timer;
	}
	public static class RerollVoteNotificationHandler
	{
		public static void handle(RerollVoteNotification response)
		{
			string text = ((response.notifType == 0) ? " started a vote to reroll " : " voted to reroll ");
			string text2 = response.voteStarter + text + "<color=orange>" + response.mapName + "</color>. (" + response.numVotes + "/" + response.votesRequired + " votes)";
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text2, "", "", 0, false, false, true);
			if (response.notifType == 0)
			{
				MonoSingleton<BingoVoteManager>.Instance.Start();
				MonoSingleton<BingoVoteManager>.Instance.startVote(response.voteStarterSteamId, response.timer + 1, response.mapName, response.votesRequired);
			}
			else
			{
				MonoSingleton<BingoVoteManager>.Instance.addVote();
			}
			GameManager.voteData = new VoteData(ongoing: true, MonoSingleton<BingoVoteManager>.Instance.hasVoted, MonoSingleton<BingoVoteManager>.Instance.voteThreshold, MonoSingleton<BingoVoteManager>.Instance.currentVotes, MonoSingleton<BingoVoteManager>.Instance.map, MonoSingleton<BingoVoteManager>.Instance.timeRemaining);
		}
	}
	public class RerollSuccessNotification : MessageResponse
	{
		public string oldMapId;

		public string oldMapName;

		public GameLevel mapData;

		public int locationX;

		public int locationY;
	}
	public static class RerollSuccessNotificationHandler
	{
		public static void handle(RerollSuccessNotification response)
		{
			MonoSingleton<BingoVoteManager>.Instance.stopVote();
			string text = "VOTE SUCCESSFUL - <color=orange>" + response.oldMapName + " </color>has rerolled to <color=orange>" + response.mapData.levelName + "</color>.";
			if (response.oldMapId == CommonFunctions.getSceneName())
			{
				text += "\nChanging levels in 5 seconds...";
			}
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
			GameManager.SwapRerolledMap(response.oldMapId, response.mapData, response.locationX, response.locationY);
		}
	}
	public class UpdateRoomSettingsRequest : SendMessage
	{
		public new string messageType = "UpdateRoomSettings";

		public int roomId;

		public Dictionary<string, int> updatedSettings;

		public RegisterTicket ticket;
	}
	public class UpdateRoomSettingsNotification : MessageResponse
	{
		public Dictionary<string, int> updatedSettings;

		public bool wereTeamsReset;
	}
	public static class UpdateRoomSettingsHandler
	{
		public static void handle(UpdateRoomSettingsNotification response)
		{
			BingoLobby.updateFromNotification(response);
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("The host has updated the room settings.", "", "", 0, false, false, true);
		}
	}
	public class StartGameRequest : SendMessage
	{
		public new string messageType = "StartGame";

		public int roomId;

		public RegisterTicket ticket;

		public Dictionary<string, BingoMapSelectionID> selectedMapIds;
	}
	public class StartGameResponse : MessageResponse
	{
		public Game game;

		public string teamColor;

		public List<string> teammates;

		public Dictionary<string, int> difficultyOverride;

		public GameGrid grid;
	}
	public static class StartGameResponseHandler
	{
		public static void handle(StartGameResponse response)
		{
			GameManager.CurrentGame = response.game;
			GameManager.CurrentTeam = response.teamColor;
			GameManager.Teammates = response.teammates;
			GameManager.CurrentGame.grid = response.grid;
			GameManager.CurrentGame.difficultyOverride = response.difficultyOverride;
			if (response.game.gameSettingsArray["gamemode"] == 1)
			{
				GameManager.dominationTimer = response.game.gameSettingsArray["timeLimit"] * 60;
			}
			BingoMenuController.StartGame(response.game.gameSettingsArray["gamemode"]);
		}
	}
	public class SubmitRunRequest : SendMessage
	{
		public new string messageType = "SubmitRun";

		public string team;

		public int gameId;

		public int column;

		public int row;

		public string levelName;

		public string levelId;

		public string playerName;

		public string steamId;

		public float time;

		public RegisterTicket ticket;
	}
	public class LevelClaimNotification : PlayerNotification
	{
		public int claimType;

		public string username;

		public string levelname;

		public string team;

		public int row;

		public int column;

		public float newTimeRequirement;

		public bool isMapVoted;
	}
	public static class LevelClaimHandler
	{
		public static void handle(LevelClaimNotification response)
		{
			try
			{
				if (response == null)
				{
					Logging.Error("Level claim response was null!");
					throw new ArgumentNullException();
				}
				string text = "";
				switch (response.claimType)
				{
				case 0:
					text = "claimed ";
					break;
				case 1:
					text = "improved ";
					break;
				case 2:
					text = "reclaimed ";
					break;
				}
				float num = response.newTimeRequirement;
				float num2 = 0f;
				while (num >= 60f)
				{
					num -= 60f;
					num2 += 1f;
				}
				string text2 = ((GameManager.CurrentGame.gameSettingsArray["hidePlayerTimes"] == 1) ? "" : ("(" + num2 + ":" + num.ToString("00.000") + ")"));
				response.levelname = ((GameManager.CurrentGame.gameSettingsArray["hideLevelNames"] == 1) ? "a level" : ("<color=orange>" + response.levelname + "</color>"));
				string text3 = "<color=" + response.team.ToLower() + ">" + response.username + "</color> has " + text + response.levelname + " for the <color=" + response.team.ToLower() + ">" + response.team + " </color>team <color=orange>" + text2 + "</color>.";
				if (response.isMapVoted)
				{
					text3 += "\n Cancelling reroll vote.";
				}
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text3, "", "", 0, false, false, true);
				GameManager.UpdateCards(response.row, response.column, response.team, response.username, response.newTimeRequirement);
			}
			catch (Exception ex)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("A level was claimed by someone but was unable to update the grid.\nCheck BepInEx console and report it to Clearwater!", "", "", 0, false, false, true);
				Logging.Error(ex.Message);
			}
		}
	}
	public class TeamSettings : SendMessage
	{
		public new string messageType = "UpdateTeamSettings";

		public int gameId;

		public Dictionary<string, int> teams;

		public RegisterTicket ticket;
	}
	public class UpdateTeamsNotification : MessageResponse
	{
		public int status;
	}
	public static class UpdateTeamsNotificationHandler
	{
		public static void handle(UpdateTeamsNotification response)
		{
			string text;
			if (GameManager.PlayerIsHost())
			{
				text = ((response.status == 0) ? "Teams have been set. The room has been locked." : "Teams have been cleared. The room has been unlocked.");
				GameManager.CurrentGame.gameSettingsArray["hasManuallySetTeams"] = 1;
			}
			else
			{
				text = ((response.status == 0) ? "The host has set the teams. The room has been locked." : "The host has cleared the teams. The room has been unlocked.");
				GameManager.CurrentGame.gameSettingsArray["hasManuallySetTeams"] = 0;
			}
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(text, "", "", 0, false, false, true);
		}
	}
	public class ClearTeamSettings : SendMessage
	{
		public new string messageType = "ClearTeams";

		public int gameId;

		public RegisterTicket ticket;
	}
	public class TimeoutSignal : MessageResponse
	{
		public string username;

		public string steamId;
	}
	public static class TimeoutSignalHandler
	{
		public static void handle(TimeoutSignal response)
		{
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage(GameManager.CurrentGame.currentPlayers[response.steamId].username + " has lost connection to the game.", "", "", 0, false, false, true);
			GameManager.CurrentGame.currentPlayers.Remove(response.steamId);
			if (CommonFunctions.getSceneName() == "Main Menu")
			{
				GameManager.RefreshPlayerList();
			}
		}
	}
	public class InitialChecksRequest : SendMessage
	{
		public new string messageType = "InitialChecks";

		public Dictionary<string, string> clientModList;

		public string steamId;

		public InitialChecksRequest(Dictionary<string, string> clientModList, string steamId)
		{
			this.clientModList = clientModList;
			this.steamId = steamId;
		}
	}
	public class InitialCheckResponse : MessageResponse
	{
		public List<string> nonWhitelistedMods;

		public string latestVersion;

		public string motd;

		public string availableRanks;

		public bool canUseChat;
	}
	public static class InitialCheckHandler
	{
		public static void handle(InitialCheckResponse response)
		{
			NetworkManager.modlistCheckPassed = response.nonWhitelistedMods.Count == 0;
			if (!NetworkManager.modlistCheckPassed)
			{
				UIManager.nonWhitelistedMods = response.nonWhitelistedMods;
			}
			NetworkManager.startupDone = true;
			Version version = new Version("1.3.0");
			Version value = new Version(response.latestVersion);
			try
			{
				((TMP_Text)BingoMainMenu.VersionNum).text = "1.3.0";
			}
			catch (Exception ex)
			{
				Logging.Warn("Wasn't able to access BingoMainMenu.VersionNum component for some reason");
				Logging.Warn(ex.ToString());
			}
			if (version.CompareTo(value) == -1)
			{
				Logging.Message("--UPDATE AVAILABLE--");
				Main.UpdateAvailable = true;
				CommonFunctions.GetGameObjectChild(BingoMainMenu.VersionInfo, "UpdateText").SetActive(true);
			}
			else
			{
				Main.UpdateAvailable = false;
			}
			string motd = response.motd;
			BingoMainMenu.MOTD = motd;
			Main.Queue(delegate
			{
				((TMP_Text)BingoMainMenu.MOTDText).text = motd;
			});
			if (response.availableRanks != "")
			{
				Main.Queue(delegate
				{
					BingoMainMenu.RankSelectionDropdown.ClearOptions();
					List<string> list = response.availableRanks.Split(new char[1] { ',' }).ToList();
					BingoMainMenu.RankSelectionDropdown.AddOptions(list);
					BingoMainMenu.ranks = list;
					NetworkManager.requestedRank = BingoMainMenu.RankSelectionDropdown.options[0].text;
					if (list.Contains(NetworkManager.lastRankUsedConfig.Value))
					{
						BingoMainMenu.RankSelectionDropdown.value = list.IndexOf(NetworkManager.lastRankUsedConfig.Value);
					}
					GameManager.hasRankAccess = true;
				});
			}
			else
			{
				BingoMainMenu.RankSelection.SetActive(false);
			}
			GameManager.canUseChat = response.canUseChat;
			NetworkManager.DisconnectWebSocket(1000, "ModCheckDone");
			if (!NetworkManager.modlistCheckPassed)
			{
				Logging.Warn("Mod whitelist check failed");
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Baphomet's Bingo mod whitelist check failed.\nPlease click on the Baphomet's Bingo option in the difficulty select menu for more details.", "", "", 0, false, false, true);
			}
			else if (Main.UpdateAvailable)
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Baphomet's Bingo update available!\nPlease update to play this gamemode.", "", "", 0, false, false, true);
			}
			else
			{
				Main.Queue(delegate
				{
					MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Baphomet's Bingo is ready to go!", "", "", 0, false, false, true);
				});
			}
		}
	}
}
namespace UltraBINGO.HarmonyPatches
{
	[HarmonyPatch(typeof(Plugin), "ProcessPath")]
	public static class Patch
	{
		[HarmonyPostfix]
		public static void notifyDownloadComplete(BundleContainer __instance)
		{
			if (GameManager.CurrentGame != null && !GameManager.EnteringAngryLevel && BingoMenuController.currentlyDownloadingLevel.Length > 0)
			{
				Logging.Info("Download of " + BingoMenuController.currentlyDownloadingLevel + " finished");
				GameManager.IsDownloadingLevel = false;
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("<color=orange>" + BingoMenuController.currentlyDownloadingLevel + "</color> has finished downloading.\nClick level button again to enter!", "", "", 0, false, false, true);
				BingoMenuController.currentlyDownloadingLevel = "";
				if (GameManager.IsInBingoLevel)
				{
					((TMP_Text)BingoCardPauseMenu.DescriptorText.GetComponent<TextMeshProUGUI>()).text = "";
				}
			}
		}
	}
	[HarmonyPatch(typeof(AngrySceneManager), "LevelButtonPressed")]
	public static class AngryStopNormalLoadPatch
	{
		[HarmonyPrefix]
		public static bool preventNormalLoadInBingoGame(LevelContainer levelContainer)
		{
			if (GameManager.IsInBingoLevel && !GameManager.CurrentGame.isGameFinished())
			{
				MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Cannot load Angry levels while in a bingo game.", "", "", 0, false, false, true);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CanvasController), "Awake")]
	public static class MainMenu
	{
		[HarmonyPostfix]
		public static void addBingoButton(ref CanvasController __instance)
		{
			if (CommonFunctions.getSceneName() == "Main Menu")
			{
				UIManager.SetupElements(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(CheatsController), "ProcessInput")]
	public class CheatCombinationDisabler
	{
		[HarmonyPostfix]
		public static void disableCheatingAttempts(GameObject ___consentScreen, int ___sequenceIndex)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.IsInBingoLevel && !GameManager.TriedToActivateCheats && ___consentScreen.activeSelf)
			{
				MonoSingleton<OptionsManager>.Instance.UnPause();
				___consentScreen.SetActive(false);
				GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("Canvas"), "BlackScreen"), "YouDiedText");
				((Behaviour)gameObjectChild.GetComponents(typeof(Component))[3]).enabled = false;
				CommonFunctions.GetTextfromGameObject(gameObjectChild).text = "NUH UH\n\n\n\n\nNOW DON'T DO IT AGAIN";
				Shotgun componentInChildren = GameObject.Find("Player/Main Camera/Guns/Shotgun Pump(Clone)").GetComponentInChildren<Shotgun>();
				GameObject.Find("Player").GetComponentInChildren<NewMovement>().hp = 1;
				Object.Instantiate<GameObject>(componentInChildren.explosion, ((Component)componentInChildren).transform.position, ((Component)componentInChildren).transform.rotation);
				GameManager.HumiliateSelf();
				GameManager.TriedToActivateCheats = true;
			}
		}
	}
	[HarmonyPatch(typeof(CheatsController), "Start")]
	public class ForceDisableKeepEnabledCheat
	{
		[HarmonyPrefix]
		public static bool forceDisableKeepEnabeldCheat()
		{
			if (GameManager.IsInBingoLevel)
			{
				MonoSingleton<PrefsManager>.Instance.SetBool("cheat.ultrakill.keep-enabled", false);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CheatsManager), "Start")]
	public class RemoveCheatFlagInBingo
	{
		[HarmonyPostfix]
		public static void disableCheatFlagInBingo(CheatsManager __instance, ref Dictionary<string, ICheat> ___idToCheat)
		{
			if (!GameManager.IsInBingoLevel)
			{
				return;
			}
			if (GameManager.CurrentGame.gameSettingsArray["gameModifier"] > 0 && CommonFunctions.getSceneName().Contains("Level "))
			{
				GameManager.cheatList = ___idToCheat;
				MonoSingleton<AssistController>.Instance.cheatsEnabled = true;
				MonoSingleton<CheatsManager>.Instance.SetCheatActive(___idToCheat["ultrakill.disable-enemy-spawns"], true, false);
				if (GameManager.CurrentGame.gameSettingsArray["gameModifier"] == 2)
				{
					MonoSingleton<CheatsManager>.Instance.SetCheatActive(___idToCheat["ultrakill.hide-weapons"], true, false);
				}
			}
			MonoSingleton<AssistController>.Instance.cheatsEnabled = false;
		}
	}
	[HarmonyPatch(typeof(DifficultyTitle), "Check")]
	public static class LevelEndPanel
	{
		public static bool displayUltraBingoTitle(DifficultyTitle __instance, ref TMP_Text ___txt2)
		{
			if (GameManager.IsInBingoLevel)
			{
				string text = "-- ULTRABINGO -- ";
				if (!Object.op_Implicit((Object)(object)___txt2))
				{
					___txt2 = ((Component)__instance).GetComponent<TMP_Text>();
				}
				if (Object.op_Implicit((Object)(object)___txt2))
				{
					___txt2.text = text;
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(FinalRank), "LevelChange")]
	public static class LevelEndChanger
	{
		[HarmonyPrefix]
		public static bool handleBingoLevelChange(FinalRank __instance, float ___savedTime, bool force = false)
		{
			if (GameManager.IsInBingoLevel && !GameManager.CurrentGame.isGameFinished())
			{
				MonoSingleton<OptionsMenuToManager>.Instance.RestartMissionNoConfirm();
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(LeaderboardController), "SubmitLevelScore")]
	public class preventBingoLeaderboardSubmission
	{
		[HarmonyPrefix]
		public static bool preventBingoLeaderboardSubmissionPatch(string levelName, int difficulty, float seconds, int kills, int style, int restartCount, bool pRank = false)
		{
			if (GameManager.IsInBingoLevel)
			{
				Logging.Warn("In bingo game, preventing leaderboard submission");
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(FinalRank), "Update")]
	public class FinalRankFanfare
	{
		[HarmonyPostfix]
		public static void sendResult(FinalRank __instance, float ___savedTime, int ___savedStyle)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			if (!GameManager.IsInBingoLevel || GameManager.HasSent || GameManager.CurrentGame.isGameFinished())
			{
				return;
			}
			if (GameManager.CurrentGame.gameSettingsArray["requiresPRank"] == 1)
			{
				StatsManager instance = MonoSingleton<StatsManager>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					if (!(instance.seconds <= (float)instance.timeRanks.Last()) || instance.kills < instance.killRanks.Last() || instance.stylePoints < instance.styleRanks.Last() || instance.restarts != 0)
					{
						Logging.Message("P-Rank not obtained, rejecting run");
						MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("You must finish the level with a <color=yellow>P</color>-Rank to claim it.", "", "", 0, false, false, true);
						GameManager.HasSent = true;
						return;
					}
				}
				else
				{
					Logging.Warn("Unable to get StatsManager?");
				}
			}
			if (!((double)___savedTime <= 0.0))
			{
				NetworkManager.SubmitRun(new SubmitRunRequest
				{
					playerName = CommonFunctions.sanitiseUsername(SteamClient.Name),
					steamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString(),
					team = GameManager.CurrentTeam,
					gameId = GameManager.CurrentGame.gameId,
					time = ___savedTime,
					levelName = (CommonFunctions.getSceneName().StartsWith("UltraEditor.") ? CommonFunctions.getSceneName().Substring("UltraEditor.".Length) : CommonFunctions.getSceneName()),
					levelId = GameManager.CurrentGame.grid.levelTable[GameManager.CurrentRow + "-" + GameManager.CurrentColumn].levelId,
					column = GameManager.CurrentColumn,
					row = GameManager.CurrentRow,
					ticket = NetworkManager.CreateRegisterTicket()
				});
				GameManager.HasSent = true;
			}
		}
	}
	[HarmonyPatch(typeof(LevelStatsEnabler), "Start")]
	public static class LevelStatsPanelPatchStart
	{
		[HarmonyPostfix]
		public static async void loadInGameBingoUI(LevelStatsEnabler __instance)
		{
			await Task.Delay(250);
			GameObject inactiveRootObject = CommonFunctions.GetInactiveRootObject("Canvas");
			GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(inactiveRootObject, "PauseMenu");
			if (GameManager.IsInBingoLevel && CommonFunctions.getSceneName() != "Main Menu")
			{
				GameObject val = Object.Instantiate<GameObject>(AssetLoader.BingoChat, gameObjectChild.transform);
				((Object)val).name = "BingoChatMenu";
				inactiveRootObject.AddComponent<BingoChatManager>();
				inactiveRootObject.GetComponent<BingoChatManager>().Bind(val);
				((Component)__instance).gameObject.SetActive(true);
				GameObject val2 = Object.Instantiate<GameObject>(AssetLoader.BingoInGameGridPanel, ((Component)__instance).gameObject.transform);
				((Object)val2).name = "BingoInGamePanel";
				GameObject gameObjectChild2 = CommonFunctions.GetGameObjectChild(val2, "Grid");
				GameObject val3 = Object.Instantiate<GameObject>(BingoCardPauseMenu.Grid, gameObjectChild2.transform);
				((Object)val3).name = "Card";
				if (MonoSingleton<PrefsManager>.Instance.GetInt("weaponHoldPosition", 0) == 2)
				{
					Transform transform = val2.transform;
					transform.localPosition += new Vector3(-425f, 0f, 0f);
				}
				else
				{
					Transform transform2 = val2.transform;
					transform2.localPosition += new Vector3(-10f, 0f, 0f);
				}
				switch (GameManager.CurrentGame.grid.size)
				{
				case 3:
					val3.transform.localPosition = new Vector3(2.5f, -2.5f, 0f);
					val3.transform.localScale = new Vector3(0.75f, 0.75f, 0.75f);
					break;
				case 4:
					val3.transform.localPosition = new Vector3(-2.5f, 0f, 0f);
					val3.transform.localScale = new Vector3(0.55f, 0.55f, 0.5f);
					break;
				case 5:
					val3.transform.localPosition = new Vector3(-5f, 5f, 0f);
					val3.transform.localScale = new Vector3(0.45f, 0.45f, 0.45f);
					break;
				}
				BingoCardPauseMenu.inGamePanel = val3;
				BingoVotePanel.Init(ref AssetLoader.BingoVotePanel);
				GameObject obj = Object.Instantiate<GameObject>(AssetLoader.BingoVotePanel, ((Component)__instance).gameObject.transform.parent);
				obj.AddComponent<BingoVoteManager>();
				((Object)obj).name = "VotePanel";
				obj.SetActive(false);
				MonoSingleton<BingoVoteManager>.Instance.CheckOngoingVote();
				if (GameManager.CurrentGame.gameSettingsArray["gamemode"] == 1)
				{
					GameObject val4 = Object.Instantiate<GameObject>(AssetLoader.BingoDominationTimer, inactiveRootObject.transform);
					inactiveRootObject.AddComponent<DominationTimeManager>();
					inactiveRootObject.GetComponent<DominationTimeManager>().Bind(val4);
					((Object)val4).name = "BingoDominationTimer";
					val4.SetActive(true);
					Transform transform3 = val4.transform;
					transform3.localPosition -= new Vector3(0f, 5f, 0f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(LevelStatsEnabler), "Update")]
	public static class LevelStatsPanelPatchUpdate
	{
		[HarmonyPostfix]
		public static void showBingoPanel(ref LevelStatsEnabler __instance, LevelStats ___levelStats, bool ___keepOpen)
		{
			if (GameManager.IsInBingoLevel && CommonFunctions.getSceneName() != "Main Menu")
			{
				GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(((Component)__instance).gameObject, "BingoInGamePanel");
				if (GameManager.IsInBingoLevel && CommonFunctions.getSceneName() != "Main Menu" && (Object)(object)gameObjectChild != (Object)null && (Object)(object)___levelStats != (Object)null)
				{
					gameObjectChild.SetActive(MonoSingleton<InputManager>.Instance.InputSource.Stats.IsPressed || ___keepOpen);
				}
			}
		}
	}
	[HarmonyPatch(typeof(SettingsPageBuilder), "BuildPage")]
	public static class OptionsMenuPatcher
	{
		[HarmonyPostfix]
		public static void DisableMajorAssistsOptions(ref SettingsPage settingsPage)
		{
			if (GameManager.IsInBingoLevel && !GameManager.CurrentGame.isGameFinished())
			{
				SettingsMenu optionsMenu = MonoSingleton<OptionsMenuToManager>.Instance.optionsMenu;
				try
				{
					CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(((Component)optionsMenu).gameObject, "Navigation Rail"), "PluginConfiguratorButton(Clone)").SetActive(false);
				}
				catch (Exception ex)
				{
					Logging.Warn("Couldn't find PluginConfigurator button in options - Is it not working?");
					Logging.Error(ex.ToString());
				}
				if (((Object)settingsPage).name == "Assist")
				{
					GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(((Component)optionsMenu).gameObject, "Pages"), "Assist"), "Scroll Rect"), "Contents");
					CommonFunctions.GetGameObjectChild(gameObjectChild, "-- Major Assists --").SetActive(false);
					CommonFunctions.GetGameObjectChild(gameObjectChild, "Game Speed").SetActive(false);
					CommonFunctions.GetGameObjectChild(gameObjectChild, "Damage Taken").SetActive(false);
					CommonFunctions.GetGameObjectChild(gameObjectChild, "Boss Fight Difficulty Override").SetActive(false);
					CommonFunctions.GetGameObjectChild(gameObjectChild, "Infinite Stamina").SetActive(false);
					CommonFunctions.GetGameObjectChild(gameObjectChild, "Disable Whiplash Hard Damage").SetActive(false);
					CommonFunctions.GetGameObjectChild(gameObjectChild, "Disable All Hard Damage").SetActive(false);
					CommonFunctions.GetGameObjectChild(gameObjectChild, "Disable Weapon Freshness").SetActive(false);
					CommonFunctions.GetGameObjectChild(gameObjectChild, "Disable Assist Popup").SetActive(false);
					UIHelper.CreateText("Major assists are <color=orange>disabled</color> while playing Baphomet's Bingo.", 26, "TextDisabled").transform.SetParent(gameObjectChild.transform);
				}
			}
		}
	}
	[HarmonyPatch(typeof(OptionsMenuToManager), "QuitMissionNoConfirm")]
	public static class LeaveBingoGame
	{
		[HarmonyPrefix]
		public static bool leaveBingoGame()
		{
			if (GameManager.IsInBingoLevel)
			{
				GameManager.LeaveGame(isInLevel: true);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(AngrySceneManager), "LoadLevel", new Type[]
	{
		typeof(LevelContainer),
		typeof(bool)
	})]
	public static class preventAngryAutoloadLinkedLevel
	{
		[HarmonyPrefix]
		public static bool preventLoadLinkedLevel(LevelContainer levelContainer, bool showBlocker = true)
		{
			if (GameManager.IsInBingoLevel && CommonFunctions.getSceneName() != "Main Menu" && !GameManager.EnteringAngryLevel)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(OptionsManager), "QuitMission")]
	public static class preventAngryQuit
	{
		[HarmonyPrefix]
		public static bool preventAngryQuitOverride()
		{
			if (GameManager.IsInBingoLevel)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(OptionsMenuToManager), "QuitMission")]
	public static class ConfirmLeaveGame
	{
		[HarmonyPrefix]
		public static bool confirmLeaveInGame(ref OptionsMenuToManager __instance)
		{
			if (GameManager.IsInBingoLevel)
			{
				TextMeshProUGUI component = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(((Component)__instance.quitDialog).gameObject, "Panel"), "Text (2)").GetComponent<TextMeshProUGUI>();
				if (GameManager.PlayerIsHost())
				{
					((TMP_Text)component).text = "<color=orange>WARNING</color>: YOU ARE THE HOST. Leaving now will <color=orange>end the game</color> for all players.\nAre you sure?";
				}
				else
				{
					((TMP_Text)component).text = "Leave game in progress?" + ((GameManager.CurrentGame.gameSettingsArray["allowRejoin"] == 0) ? "\n(<color=orange>WARNING</color>: You will not be able to rejoin.)" : "");
				}
				__instance.quitDialog.ShowDialog();
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(OptionsManager), "Awake")]
	public static class PauseMenu
	{
		[HarmonyPostfix]
		public static async void patchPauseMenu(OptionsManager __instance)
		{
			await Task.Delay(200);
			if (GameManager.IsInBingoLevel && CommonFunctions.getSceneName() != "Main Menu")
			{
				GameObject val = CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("Canvas"), "PauseMenu");
				if ((Object)(object)val == (Object)null)
				{
					Logging.Warn("Pause menu is null, waiting and trying again");
					val = __instance.pauseMenu;
				}
				((TMP_Text)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(val, "Quit Mission"), "Text").GetComponent<TextMeshProUGUI>()).text = "LEAVE GAME";
				BingoCardPauseMenu.Init(ref __instance);
				BingoCardPauseMenu.ShowBingoCardInPauseMenu(ref __instance);
			}
		}
	}
	[HarmonyPatch(typeof(OptionsMenuToManager), "QuitMissionNoConfirm")]
	public static class QuitLevel
	{
		[HarmonyPrefix]
		public static bool returnFromBingoLevel()
		{
			GameManager.IsInBingoLevel = false;
			GameManager.ReturningFromBingoLevel = true;
			GameManager.HasSent = false;
			return true;
		}
	}
	[HarmonyPatch(typeof(ShopZone), "TurnOn")]
	public class ShopAddLevelInfo
	{
		[HarmonyPostfix]
		public static void AddBingoLevelInfo(ShopZone __instance, Canvas ___shopCanvas)
		{
			if (!GameManager.IsInBingoLevel || !((Object)(object)___shopCanvas != (Object)null) || ((Object)((Component)___shopCanvas).gameObject).name.Contains("Shop"))
			{
				return;
			}
			try
			{
				TMP_Text tipOfTheDay = __instance.tipOfTheDay;
				string key = GameManager.CurrentRow + "-" + GameManager.CurrentColumn;
				string claimedBy = GameManager.CurrentGame.grid.levelTable[key].claimedBy;
				float num = GameManager.CurrentGame.grid.levelTable[key].timeToBeat;
				float num2 = 0f;
				while (num >= 60f)
				{
					num -= 60f;
					num2 += 1f;
				}
				string text = ((GameManager.CurrentGame.gameSettingsArray["hidePlayerTimes"] == 1) ? "" : (num2 + ":" + num.ToString("00.000")));
				string text2 = "This level is currently <color=orange>unclaimed</color>.\nHurry and be the first to <color=green>claim it for your team</color>!";
				string text3 = "This level is currently <color=green>claimed by your team</color>.\n<color=orange>Choose another level</color> to claim, or <color=orange>try and improve the current requirement</color> to make it harder for other teams to reclaim!";
				string text4 = "This level is currently claimed by another team.\n<color=orange>Beat</color> the current requirement to <color=green>reclaim it for your team</color>!";
				if (claimedBy == "NONE")
				{
					tipOfTheDay.text = text2;
				}
				else if (GameManager.CurrentGame.gameSettingsArray["hidePlayerTimes"] == 1)
				{
					tipOfTheDay.text = "";
				}
				else
				{
					tipOfTheDay.text = "Claimed by: <color=" + claimedBy.ToLower() + ">" + claimedBy + "</color> team\n\n" + ((GameManager.CurrentGame.gameSettingsArray["hidePlayerTimes"] == 1) ? ("TIME TO BEAT: <color=orange>" + text + "</color>") : "") + "\n\n" + ((claimedBy == GameManager.CurrentTeam) ? text3 : text4);
				}
				GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(((Component)___shopCanvas).gameObject, "Background"), "Main Panel"), "Main Menu");
				CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild, "Buttons"), "CyberGrindButton").SetActive(false);
				CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(gameObjectChild, "Buttons"), "SandboxButton").SetActive(false);
			}
			catch (Exception ex)
			{
				Logging.Warn("This shop isn't vanilla or an error occured");
				Logging.Error(ex.ToString());
			}
		}
	}
	[HarmonyPatch(typeof(HellMap), "Start")]
	public class HideHellmap
	{
		[HarmonyPrefix]
		public static bool HideHellmapPatch(ref LevelStats __instance)
		{
			if (GameManager.IsInBingoLevel && GameManager.CurrentGame.gameSettingsArray["hideLevelNames"] == 1)
			{
				((Component)__instance).gameObject.SetActive(false);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ViewModelFlip), "OnPrefChanged")]
	public class WeaponPosPanelPatch
	{
		[HarmonyPostfix]
		public static void changeBingoPanelPos(string key, object value)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (key == "weaponHoldPosition" && GameManager.IsInBingoLevel && !GameManager.CurrentGame.isGameFinished())
			{
				GameObject gameObjectChild = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(CommonFunctions.GetInactiveRootObject("Canvas"), "Level Stats Controller"), "BingoInGamePanel");
				if (MonoSingleton<PrefsManager>.Instance.GetInt("weaponHoldPosition", 0) == 2)
				{
					gameObjectChild.transform.localPosition = new Vector3(-425f, 0f, 0f);
				}
				else
				{
					gameObjectChild.transform.localPosition = new Vector3(300f, 0f, 0f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(LevelStats), "Start")]
	public class StatWindowStart
	{
		public static GameObject originalChallengeText;

		[HarmonyPostfix]
		public static void setupStatWindow(ref LevelStats __instance)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			if (!GameManager.IsInBingoLevel)
			{
				return;
			}
			if (GameManager.CurrentGame.gameSettingsArray["hideLevelNames"] == 1)
			{
				__instance.levelName.text = "???";
			}
			if (CommonFunctions.getSceneName().Contains("P-") || CommonFunctions.getSceneName().Contains("-E"))
			{
				((TMP_Text)((Component)__instance.majorAssists.transform.parent).gameObject.GetComponent<TextMeshProUGUI>()).text = "TO BEAT:";
				originalChallengeText = CommonFunctions.GetGameObjectChild(((Component)__instance).gameObject, "Challenge Title");
				((TMP_Text)originalChallengeText.GetComponent<TextMeshProUGUI>()).text = "CLAIMED BY:";
				originalChallengeText.SetActive(true);
				((Component)__instance).GetComponent<RectTransform>().sizeDelta = new Vector2(285f, 285f);
			}
			else
			{
				if (__instance.secrets.Length != 0)
				{
					((Component)((Component)__instance.secrets[0]).transform.parent).gameObject.SetActive(false);
				}
				((TMP_Text)((Component)__instance.challenge.transform.parent).gameObject.GetComponent<TextMeshProUGUI>()).text = "TO BEAT:";
				((TMP_Text)((Component)__instance.majorAssists.transform.parent).gameObject.GetComponent<TextMeshProUGUI>()).text = "CLAIMED BY:";
			}
		}
	}
	[HarmonyPatch(typeof(LevelStats), "CheckStats")]
	public class StatWindow
	{
		public static GameObject originalChallengeText;

		[HarmonyPostfix]
		public static void showRequirements(ref LevelStats __instance)
		{
			if (GameManager.IsInBingoLevel)
			{
				string key = GameManager.CurrentRow + "-" + GameManager.CurrentColumn;
				string claimedBy = GameManager.CurrentGame.grid.levelTable[key].claimedBy;
				float num = GameManager.CurrentGame.grid.levelTable[key].timeToBeat;
				float num2 = 0f;
				while (num >= 60f)
				{
					num -= 60f;
					num2 += 1f;
				}
				string text = num2 + ":" + num.ToString("00.000");
				if (text == "0:00.000")
				{
					text = "<size=14>FINISH TO CLAIM" + ((GameManager.CurrentGame.gameSettingsArray["requiresPRank"] == 1) ? "(<color=#ffa200d9>P</color>)" : "") + "</size>";
				}
				else if (GameManager.CurrentGame.gameSettingsArray["hidePlayerTimes"] == 1)
				{
					text = "??:??.????";
				}
				string text2 = ((claimedBy != "NONE") ? ("<color=" + GameManager.CurrentGame.grid.levelTable[key].claimedBy.ToLower() + ">" + claimedBy + "</color>") : "NONE");
				if (CommonFunctions.getSceneName().Contains("P-") || CommonFunctions.getSceneName().Contains("-E"))
				{
					((TMP_Text)((Component)__instance.majorAssists).GetComponent<TextMeshProUGUI>()).text = text;
					((TMP_Text)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(((Component)__instance).gameObject, "Challenge Title"), "Challenge").GetComponent<TextMeshProUGUI>()).text = text2;
					((TMP_Text)CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(((Component)__instance).gameObject, "Challenge Title"), "Challenge").GetComponent<TextMeshProUGUI>()).fontSize = 20f;
				}
				else
				{
					((TMP_Text)((Component)__instance.challenge).GetComponent<TextMeshProUGUI>()).text = text;
					((TMP_Text)((Component)__instance.majorAssists).GetComponent<TextMeshProUGUI>()).text = text2;
					((TMP_Text)((Component)__instance.majorAssists).GetComponent<TextMeshProUGUI>()).fontSize = 20f;
				}
			}
		}
	}
}
namespace UltraBINGO.Components
{
	public class BingoChatManager : MonoSingleton<BingoChatManager>
	{
		public const int CHAT_HISTORY = 6;

		public static Queue<GameObject> ChatHistory = new Queue<GameObject>();

		public GameObject ChatWindow;

		private GameObject ChatTemplate;

		public TMP_InputField messageContents;

		public TextMeshProUGUI ChannelIndicator;

		public bool isGlobalMessage = true;

		public bool ready;

		public void Bind(GameObject bindingObject)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			ChatWindow = bindingObject;
			ChatTemplate = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(ChatWindow, "Chat"), "Example");
			messageContents = CommonFunctions.GetGameObjectChild(ChatWindow, "MessageInput").GetComponent<TMP_InputField>();
			ChannelIndicator = CommonFunctions.GetGameObjectChild(CommonFunctions.GetGameObjectChild(ChatWindow, "ChannelIndicator"), "Text").GetComponent<TextMeshProUGUI>();
			if (!GameManager.IsInBingoLevel)
			{
				((Component)((TMP_Text)ChannelIndicator).transform.parent).gameObject.SetActive(false);
				((Component)messageContents).transform.localPosition = new Vector3(-17.5f, -157.5f, 0f);
				((TMP_Text)((Component)messageContents.placeholder).GetComponent<TextMeshProUGUI>()).text = "Type a message...";
			}
			((UnityEvent<string>)(object)messageContents.onEndEdit).AddListener((UnityAction<string>)delegate
			{
				if (messageContents.text.Length > 0 && (Input.GetKey((KeyCode)13) || Input.GetKey((KeyCode)271)))
				{
					if (GameManager.canUseChat)
					{
						SendChatMessage(messageContents.text);
					}
					messageContents.text = "";
				}
			});
			if (!GameManager.canUseChat)
			{
				((Component)messageContents).gameObject.SetActive(false);
				((Component)((TMP_Text)ChannelIndicator).transform.parent).gameObject.SetActive(false);
			}
			ready = true;
			loadChatHistory();
		}

		public void updateChatPanel()
		{
			if (!GameManager.canUseChat)
			{
				((Component)messageContents).gameObject.SetActive(false);
				((Component)((TMP_Text)ChannelIndicator).transform.parent).gameObject.SetActive(false);
			}
		}

		public void Update()
		{
			if (!ready)
			{
				return;
			}
			if (messageContents.isFocused && Input.GetKeyUp((KeyCode)9) && GameManager.IsInBingoLevel)
			{
				messageContents.text = messageContents.text.Replace("\t", "");
				isGlobalMessage = !isGlobalMessage;
			}
			if (GameManager.IsInBingoLevel)
			{
				if (isGlobalMessage)
				{
					((TMP_Text)ChannelIndicator).text = "<color=orange>[ALL]</color>";
				}
				else
				{
					((TMP_Text)ChannelIndicator).text = "<color=red>[TEAM]</color>";
				}
			}
		}

		public static void clearChatHistory()
		{
			while (ChatHistory.Count > 0)
			{
				GameObject val = ChatHistory.Dequeue();
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		public void SendChatMessage(string message)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager.SendEncodedMessage(JsonConvert.SerializeObject((object)new ChatMessageSend
			{
				isGlobal = isGlobalMessage,
				username = CommonFunctions.sanitiseUsername(SteamClient.Name),
				gameId = GameManager.CurrentGame.gameId,
				steamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString(),
				chatMessage = message,
				ticket = NetworkManager.CreateRegisterTicket()
			}));
		}

		public void handleWarning(ChatWarn warnLevel)
		{
			string text = "Offensive and derogatory terms are disallowed.";
			switch (warnLevel.warnLevel)
			{
			case 0:
				text += "<color=orange>Further attempts at usage will result in a chat ban.</color>";
				break;
			case 1:
				text += "<color=red>THIS IS YOUR FINAL WARNING.</color>";
				break;
			case 2:
				text = "<color=red>Your access to Baphomet's Bingo chat has been revoked.</color>";
				break;
			}
			ChatMessageReceive chatMessageReceive = new ChatMessageReceive();
			chatMessageReceive.username = "SYSTEM";
			chatMessageReceive.message = text;
			updateChatHistory(chatMessageReceive);
			if (warnLevel.warnLevel == 2)
			{
				((Component)messageContents).gameObject.SetActive(false);
				GameManager.canUseChat = false;
			}
		}

		public void loadChatHistory()
		{
			ChatHistory.Clear();
			foreach (string item in GameManager.chatHistory)
			{
				GameObject val = Object.Instantiate<GameObject>(ChatTemplate, ChatTemplate.transform.parent);
				((Object)val).name = "ChatMessage";
				CommonFunctions.GetGameObjectChild(val, "Contents").GetComponent<Text>().text = item;
				val.SetActive(true);
				ChatHistory.Enqueue(val);
			}
		}

		public void updateChatHistory(ChatMessageReceive messageData)
		{
			if (ChatHistory.Count >= 6)
			{
				Object.Destroy((Object)(object)ChatHistory.Dequeue());
			}
			GameObject val = Object.Instantiate<GameObject>(ChatTemplate, ChatTemplate.transform.parent);
			((Object)val).name = "ChatMessage";
			string text = "";
			text = ((!(messageData.username == "SYSTEM")) ? (text + ((messageData.channelType == 0) ? "[<color=orange>ALL</color>]" : ("[<color=" + GameManager.CurrentTeam.ToLower() + ">TEAM</color>]")) + messageData.username + ": " + messageData.message) : (text + "[<color=red>SYSTEM</color>] " + messageData.message));
			CommonFunctions.GetGameObjectChild(val, "Contents").GetComponent<Text>().text = text;
			val.SetActive(true);
			ChatHistory.Enqueue(val);
			if (GameManager.chatHistory.Count >= 6)
			{
				GameManager.chatHistory.Dequeue();
			}
			GameManager.chatHistory.Enqueue(text);
		}
	}
	public enum BingoLevelType
	{
		Campaign,
		Angry,
		UltraEditor
	}
	public class BingoLevelData : MonoBehaviour
	{
		public bool isClaimed;

		public string claimedTeam = "none";

		public string claimedPlayer = "none";

		public int row;

		public int column;

		public float timeRequirement;

		public string levelName = "";

		public string angryParentBundle = "";

		public string angryLevelId = "";

		public string ultraEditorLevelData;

		public BingoLevelType bingoLevelType;

		public string thumbnailPath = "";
	}
	public class BingoLevelSquare : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, IPointerClickHandler
	{
		private BingoLevelData levelData;

		private bool isHovered;

		public void OnPointerEnter(PointerEventData data)
		{
			isHovered = true;
		}

		public void OnPointerExit(PointerEventData data)
		{
			isHovered = false;
		}

		public void Start()
		{
			levelData = ((Component)this).GetComponentInParent<BingoLevelData>();
		}

		public void Update()
		{
			if (Input.GetKeyDown((KeyCode)114) && isHovered && !MonoSingleton<BingoVoteManager>.Instance.voteOngoing && !levelData.isClaimed)
			{
				GameManager.RequestReroll(levelData.row, levelData.column);
			}
		}

		public void OnPointerClick(PointerEventData data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			InputButton button = data.button;
			if ((int)button != 0)
			{
				if ((int)button == 1)
				{
					GameManager.PingMapForTeam(GameManager.CurrentTeam, levelData.row, levelData.column);
				}
			}
			else
			{
				BingoMenuController.LoadBingoLevelFromPauseMenu(((Object)((Component)this).gameObject).name, ((Component)this).gameObject.GetComponent<BingoLevelData>());
			}
		}
	}
	[JsonObject(/*Could not decode attribute arguments.*/)]
	public class BingoMapSelectionID : MonoBehaviour
	{
		[JsonProperty]
		public string levelName = "";

		[JsonProperty]
		public string levelId = "";

		[JsonProperty]
		public BingoLevelType levelType;

		[JsonProperty]
		public string UltraEditorLevelData;

		[JsonProperty]
		public string UltraEditorImageURL;

		[JsonProperty]
		public string UltraEditorImageName;

		[JsonProperty]
		public string angryBundleId = "";

		[JsonProperty]
		public string thumbnailPath = "";
	}
	public class BingoMenuManager : MonoBehaviour
	{
		private UnityEvent tryResetUI = new UnityEvent();

		public void OnEnable()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			tryResetUI.AddListener(new UnityAction(resetUI));
		}

		public void Update()
		{
			if (Input.GetKeyDown((KeyCode)291))
			{
				tryResetUI.Invoke();
			}
		}

		public async void resetUI()
		{
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Resetting bingo UI...", "", "", 0, false, false, true);
			((Component)this).gameObject.SetActive(false);
			await Task.Delay(1000);
			((Component)this).gameObject.SetActive(true);
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("UI reset.", "", "", 0, false, false, true);
		}
	}
	public class BingoVoteManager : MonoSingleton<BingoVoteManager>
	{
		public GameObject Panel;

		public float timeRemaining;

		public bool voteOngoing;

		public bool hasVoted;

		public string map = "";

		public int currentVotes;

		public int voteThreshold;

		public const string votePrompt = "(<color=orange>F1</color> to vote)";

		public static TextMeshProUGUI RerollText;

		public static TextMeshProUGUI RerollVotes;

		public static TextMeshProUGUI RerollTimer;

		public void Bind(GameObject source)
		{
			Panel = source;
		}

		public void CheckOngoingVote()
		{
			if (GameManager.voteData != null && GameManager.voteData.voteOngoing)
			{
				LoadOngoingVote();
			}
		}

		public void LoadOngoingVote()
		{
			voteOngoing = true;
			timeRemaining = GameManager.voteData.timeLeft;
			hasVoted = GameManager.voteData.hasVoted;
			currentVotes = GameManager.voteData.currentVotes;
			voteThreshold = GameManager.voteData.minimumVotesRequired;
			map = GameManager.voteData.mapName;
			((Component)this).gameObject.SetActive(true);
		}

		public void Start()
		{
			RerollText = CommonFunctions.GetGameObjectChild(((Component)this).gameObject, "RerollText").GetComponent<TextMeshProUGUI>();
			RerollVotes = CommonFunctions.GetGameObjectChild(((Component)this).gameObject, "RerollVotes").GetComponent<TextMeshProUGUI>();
			RerollTimer = CommonFunctions.GetGameObjectChild(((Component)this).gameObject, "RerollTimer").GetComponent<TextMeshProUGUI>();
		}

		public void Update()
		{
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (voteOngoing && timeRemaining > 0f)
			{
				timeRemaining = Mathf.MoveTowards(timeRemaining, 0f, Time.unscaledDeltaTime);
				((TMP_Text)RerollText).text = "Reroll <color=orange>" + map + "</color>?" + ((!hasVoted) ? "(<color=orange>F1</color> to vote)" : "");
				((TMP_Text)RerollVotes).text = "<color=orange>" + currentVotes + "</color>/" + voteThreshold + " votes";
				((TMP_Text)RerollTimer).text = "Ends in <color=orange>" + (int)timeRemaining + "</color>s";
			}
			else if (voteOngoing && timeRemaining == 0f)
			{
				stopVote();
			}
			if (Input.GetKeyDown((KeyCode)282))
			{
				if (hasVoted)
				{
					Logging.Warn("Tried to vote, but alreadyVoted set to true!");
					return;
				}
				NetworkManager.SendEncodedMessage(JsonConvert.SerializeObject((object)new RerollRequest
				{
					gameId = GameManager.CurrentGame.gameId,
					steamId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString(),
					row = 0,
					column = 0,
					steamTicket = NetworkManager.CreateRegisterTicket()
				}));
				hasVoted = true;
			}
		}

		public void stopVote()
		{
			timeRemaining = 0f;
			voteOngoing = false;
			hasVoted = false;
			((Component)this).gameObject.SetActive(false);
		}

		public void startVote(string voteStarter, float voteTime, string mapName, int votesRequired)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			map = mapName;
			currentVotes = 1;
			voteThreshold = votesRequired;
			if (voteStarter == ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString())
			{
				hasVoted = true;
				GameManager.alreadyStartedVote = true;
			}
			timeRemaining = voteTime;
			voteOngoing = true;
			((Component)this).gameObject.SetActive(true);
		}

		public void addVote()
		{
			currentVotes++;
		}
	}
	public class VoteData
	{
		public float timeLeft;

		public bool voteOngoing;

		public bool hasVoted;

		public int minimumVotesRequired;

		public int currentVotes;

		public string mapName;

		public VoteData(bool ongoing)
		{
			voteOngoing = false;
		}

		public VoteData(bool ongoing, bool hasVoted, int minVotes, int curVotes, string mapName, float timeLeft)
		{
			this.timeLeft = timeLeft - 1f;
			voteOngoing = ongoing;
			this.hasVoted = hasVoted;
			minimumVotesRequired = minVotes;
			currentVotes = curVotes;
			this.mapName = mapName;
		}
	}
	public class DominationTimeManager : MonoBehaviour
	{
		public static GameObject Panel;

		public static TextMeshProUGUI Timer;

		public float timeRemaining;

		public bool started;

		public void Bind(GameObject source)
		{
			Panel = source;
		}

		public void Start()
		{
			if (GameManager.CurrentGame.gameSettingsArray["gamemode"] == 1 && (Object)(object)((Component)this).gameObject != (Object)null)
			{
				if (GameManager.IsInBingoLevel)
				{
					Timer = CommonFunctions.GetGameObjectChild(Panel, "Timer").GetComponent<TextMeshProUGUI>();
					Panel.SetActive(false);
				}
				timeRemaining = GameManager.dominationTimer;
			}
		}

		public void Update()
		{
			if (!GameManager.IsInBingoLevel || GameManager.CurrentGame.gameSettingsArray["gamemode"] != 1)
			{
				return;
			}
			timeRemaining = Mathf.MoveTowards(timeRemaining, 0f, Time.unscaledDeltaTime);
			GameManager.dominationTimer = timeRemaining;
			float num = timeRemaining;
			float num2 = 0f;
			while (num >= 60f)
			{
				num -= 60f;
				num2 += 1f;
			}
			if (GameManager.IsInBingoLevel && (Object)(object)Panel != (Object)null)
			{
				((TMP_Text)Timer).text = "<color=orange>" + num2 + ":" + ((num < 10f) ? ((int)num).ToString("D2") : ((object)(int)num))?.ToString() + "</color>";
				if (MonoSingleton<InputManager>.Instance.InputSource.Stats.WasPerformedThisFrame || PlayerPrefs.GetInt("LevStaOpe") == 1)
				{
					Panel.SetActive(true);
				}
				else if (MonoSingleton<InputManager>.Instance.InputSource.Stats.WasCanceledThisFrame)
				{
					Panel.SetActive(false);
				}
			}
		}
	}
	public class MapPoolData : MonoBehaviour
	{
		public int mapPoolId;

		public string mapPoolName = "MapPoolName";

		public string mapPoolDescription = "Desc";

		public bool mapPoolEnabled;

		public int mapPoolNumOfMaps;

		public List<string> mapPoolMapList;

		public void Toggle()
		{
			mapPoolEnabled = !mapPoolEnabled;
		}
	}
	public class UltraEditorLevelData
	{
		public string url = "";

		public string author;

		public string data;

		public string image;

		public string guid;

		public string name;
	}
}