using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using ApClient;
using ApClient.data;
using ApClient.mapping;
using ApClient.patches;
using ApClientl;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.BounceFeatures.DeathLink;
using Archipelago.MultiClient.Net.Converters;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.Models;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using I2.Loc;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("ApClient")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.4.0.0")]
[assembly: AssemblyInformationalVersion("0.4.0+05ff11feb22ac1180d6a7d8281a465f4a8a3c676")]
[assembly: AssemblyProduct("Ap Client For TCG Sim")]
[assembly: AssemblyTitle("ApClient")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.4.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class APConsole : MonoBehaviour
{
	[Serializable]
	public class LogEntry
	{
		public double Timestamp;

		public float Lifetime = 50f;

		public float TotalLifetime = 50f;

		public float RiseSpeed = 5f;

		public TextMeshProUGUI RenderedText;

		public string Message;

		public LogEntry(string message, double timestamp)
		{
			Message = message;
			Timestamp = timestamp;
		}
	}

	private static readonly Dictionary<string, string> keywordColors = new Dictionary<string, string>
	{
		{ "license", "#FF5151" },
		{ "card", "#3089FF" },
		{ "money", "#FFBF62" }
	};

	private static readonly Regex keywordRegex = new Regex(string.Join("|", keywordColors.Keys.Select(Regex.Escape)), RegexOptions.IgnoreCase);

	private bool showConsole = true;

	private Transform messageParent;

	private readonly List<LogEntry> visibleEntries = new List<LogEntry>();

	private readonly Queue<LogEntry> cachedEntries = new Queue<LogEntry>();

	private Queue<TextMeshProUGUI> messagePool = new Queue<TextMeshProUGUI>();

	private float lastUpdate;

	private const float MessageDelay = 0.05f;

	private const float MessageTime = 6f;

	private static float animationDuration = 6f;

	private static float MessageHeight = 10f;

	private static float ConsoleHeight = 280f;

	private static int MaxMessages = (int)((double)ConsoleHeight / ((double)MessageHeight * 1.5));

	public static APConsole Instance { get; private set; }

	public static void Create()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected O, but got Unknown
		if (!((Object)(object)Instance != (Object)null))
		{
			GameObject val = new GameObject("ArchipelagoConsoleUI");
			Object.DontDestroyOnLoad((Object)(object)val);
			APConsole aPConsole = val.AddComponent<APConsole>();
			aPConsole.CreateConsoleCanvas();
			Instance = aPConsole;
		}
	}

	private void Update()
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		if (Time.time - lastUpdate >= 6f / (ConsoleHeight / (MessageHeight * 2f)))
		{
			UpdateVisibleMessages();
			lastUpdate = Time.time;
		}
		UpdateUI();
		if (Input.GetKeyDown(Settings.Instance.ConsoleHotkey.Value))
		{
			if (showConsole)
			{
				Log("Disabling AP Console");
				showConsole = false;
			}
			else
			{
				showConsole = true;
				Log("AP Console Enabled");
			}
		}
	}

	private void UpdateUI()
	{
		foreach (LogEntry visibleEntry in visibleEntries)
		{
			if (Object.op_Implicit((Object)(object)visibleEntry.RenderedText))
			{
				Animate(visibleEntry.RenderedText, visibleEntry.Timestamp);
			}
			((TMP_Text)visibleEntry.RenderedText).text = Colorize(visibleEntry.Message);
		}
	}

	private void Animate(TextMeshProUGUI text, double timestamp)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: 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)
		float num = (float)(UnixTimeConverter.ToUnixTimeStamp(DateTime.Now) - timestamp);
		float num2 = Mathf.Clamp01(num / animationDuration);
		float y = num2 * ConsoleHeight;
		Vector2 anchoredPosition = ((TMP_Text)text).rectTransform.anchoredPosition;
		anchoredPosition.y = y;
		((TMP_Text)text).rectTransform.anchoredPosition = anchoredPosition;
		((TMP_Text)text).alpha = Mathf.Lerp(1f, 0f, Mathf.Clamp01(num - animationDuration + 2f));
	}

	private string Colorize(string input)
	{
		return keywordRegex.Replace(input, delegate(Match match)
		{
			string key = match.Value.ToLower();
			string value;
			return keywordColors.TryGetValue(key, out value) ? ("<color=" + value + ">" + match.Value + "</color>") : match.Value;
		});
	}

	private void UpdateVisibleMessages()
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Expected O, but got Unknown
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		double now = UnixTimeConverter.ToUnixTimeStamp(DateTime.Now);
		visibleEntries.RemoveAll(delegate(LogEntry e)
		{
			if (now - e.Timestamp > 6.0)
			{
				RecycleMessage(e);
				return true;
			}
			return false;
		});
		if (visibleEntries.Count < MaxMessages && cachedEntries.Count != 0)
		{
			LogEntry logEntry = cachedEntries.Dequeue();
			logEntry.Timestamp = now;
			GameObject val = new GameObject("ConsoleMessage");
			val.transform.SetParent(messageParent, false);
			TextMeshProUGUI pooledMessage = GetPooledMessage();
			((TMP_Text)pooledMessage).enableWordWrapping = false;
			((TMP_Text)pooledMessage).text = logEntry.Message;
			((TMP_Text)pooledMessage).fontSize = 20f;
			((TMP_Text)pooledMessage).alignment = (TextAlignmentOptions)513;
			((Graphic)pooledMessage).color = new Color(1f, 1f, 1f, 1f);
			((TMP_Text)pooledMessage).rectTransform.anchoredPosition = new Vector2(MessageHeight, 0f);
			logEntry.RenderedText = pooledMessage;
			visibleEntries.Add(logEntry);
		}
	}

	public void Log(string text)
	{
		if (showConsole)
		{
			LogEntry item = new LogEntry(text, UnixTimeConverter.ToUnixTimeStamp(DateTime.Now));
			cachedEntries.Enqueue(item);
		}
	}

	private void CreateConsoleCanvas()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_0053: 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)
		//IL_0070: Expected O, but got Unknown
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("ArchipelagoConsoleCanvas");
		val.transform.SetParent(((Component)this).transform);
		Canvas val2 = val.AddComponent<Canvas>();
		val2.renderMode = (RenderMode)0;
		val2.sortingOrder = 1000;
		CanvasScaler val3 = val.AddComponent<CanvasScaler>();
		val3.uiScaleMode = (ScaleMode)1;
		val3.referenceResolution = new Vector2(1920f, 1080f);
		val.AddComponent<GraphicRaycaster>();
		GameObject val4 = new GameObject("Messages");
		RectTransform val5 = val4.AddComponent<RectTransform>();
		((Transform)val5).SetParent(val.transform, false);
		val5.anchorMin = new Vector2(0f, 0f);
		val5.anchorMax = new Vector2(0f, 0f);
		val5.pivot = new Vector2(0f, 0f);
		val5.anchoredPosition = new Vector2(60f, 35f);
		messageParent = val4.transform;
	}

	private TextMeshProUGUI GetPooledMessage()
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Expected O, but got Unknown
		if (messagePool.Count > 0)
		{
			TextMeshProUGUI val = messagePool.Dequeue();
			((Component)val).gameObject.SetActive(true);
			return val;
		}
		GameObject val2 = new GameObject("ConsoleMessage");
		val2.transform.SetParent(messageParent, false);
		TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
		((TMP_Text)val3).enableWordWrapping = false;
		return val3;
	}

	private void RecycleMessage(LogEntry msg)
	{
		((Component)msg.RenderedText).gameObject.SetActive(false);
		messagePool.Enqueue(msg.RenderedText);
	}
}
namespace ApClientl
{
	public class APGui : MonoBehaviour
	{
		public static bool showGUI = true;

		public static string ipporttext = Settings.Instance.LastUsedIP.Value;

		public static string password = Settings.Instance.LastUsedPassword.Value;

		public static string slot = Settings.Instance.LastUsedSlot.Value;

		public static string state = "Not Connected";

		private void OnGUI()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_004b: 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)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			if (showGUI)
			{
				GUI.Box(new Rect(10f, 10f, 200f, 300f), "AP Client");
				GUIStyle val = new GUIStyle();
				val.fontSize = 12;
				val.normal.textColor = Color.white;
				GUI.Label(new Rect(20f, 40f, 300f, 30f), "Address:port", val);
				ipporttext = GUI.TextField(new Rect(20f, 60f, 180f, 25f), ipporttext, 25);
				GUI.Label(new Rect(20f, 90f, 300f, 30f), "Password", val);
				password = GUI.TextField(new Rect(20f, 110f, 180f, 25f), password, 25);
				GUI.Label(new Rect(20f, 140f, 300f, 30f), "Slot", val);
				slot = GUI.TextField(new Rect(20f, 160f, 180f, 25f), slot, 25);
				if (GUI.Button(new Rect(20f, 210f, 180f, 30f), "Connect"))
				{
					Debug.Log((object)"Button Pressed!");
					Plugin.m_SessionHandler.connect(ipporttext, password, slot);
				}
				GUI.Label(new Rect(20f, 240f, 300f, 30f), state, val);
			}
		}

		private void Update()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown(Settings.Instance.MyHotkey.Value))
			{
				showGUI = !showGUI;
			}
		}
	}
}
namespace ApClient
{
	public class APClientSaveManager
	{
		[Serializable]
		public class SaveDataWrapper
		{
			public CGameData gameData;

			public int ProcessedIndex;

			public List<int> newCards = new List<int>();

			public float MoneyMultiplier;

			public int Luck;

			public int TetramonCommonChecksFound;

			public int DestinyCommonChecksFound;

			public int TetramonRareChecksFound;

			public int DestinyRareChecksFound;

			public int TetramonEpicChecksFound;

			public int DestinyEpicChecksFound;

			public int TetramonLegendaryChecksFound;

			public int DestinyLegendaryChecksFound;

			public int TetramonCommonChecksSold;

			public int DestinyCommonChecksSold;

			public int TetramonRareChecksSold;

			public int DestinyRareChecksSold;

			public int TetramonEpicChecksSold;

			public int DestinyEpicChecksSold;

			public int TetramonLegendaryChecksSold;

			public int DestinyLegendaryChecksSold;

			public int GhostCardsSold;

			public int EventGamesPlayed;

			public int LicensesReceived;

			public int StoredXP;
		}

		private APSaveData aPSaveData;

		private int cachedTetramonCheckCount = -1;

		private int cachedDestinyCheckCount = -1;

		public int cachedCommonChecks = -1;

		public int cachedRareChecks = -1;

		public int cachedEpicChecks = -1;

		public int cachedLegendaryChecks = -1;

		public int customersPlayedGames = 0;

		public APClientSaveManager()
		{
			Clear();
		}

		public void Clear()
		{
			aPSaveData = new APSaveData();
			aPSaveData.ProcessedIndex = 0;
			aPSaveData.MoneyMultiplier = 1f;
			aPSaveData.StoredXP = 0;
			cachedTetramonCheckCount = -1;
			cachedDestinyCheckCount = -1;
			cachedCommonChecks = -1;
			cachedRareChecks = -1;
			cachedEpicChecks = -1;
			cachedLegendaryChecks = -1;
			customersPlayedGames = 0;
		}

		public void setConnectionData(string seed, string slot)
		{
			aPSaveData.seed = seed;
			aPSaveData.slotname = slot;
		}

		public void setProcessedIndex(int index)
		{
			aPSaveData.ProcessedIndex = index;
		}

		public void IncreaseProcessedIndex()
		{
			aPSaveData.ProcessedIndex++;
		}

		public int GetProcessedIndex()
		{
			return aPSaveData.ProcessedIndex;
		}

		public void IncreaselicensesReceived()
		{
			aPSaveData.LicensesReceived++;
		}

		public int GetlicensesReceived()
		{
			return aPSaveData.LicensesReceived;
		}

		public void IncreaseMoneyMult()
		{
			aPSaveData.MoneyMultiplier = (aPSaveData.MoneyMultiplier += 0.1f);
		}

		public float GetMoneyMult()
		{
			if (aPSaveData.MoneyMultiplier < 1f)
			{
				aPSaveData.MoneyMultiplier = 1f;
			}
			return aPSaveData.MoneyMultiplier;
		}

		public int GetLuck()
		{
			return aPSaveData.Luck;
		}

		public void IncreaseLuck()
		{
			aPSaveData.Luck++;
		}

		public int GetEventGamesPlayed()
		{
			return aPSaveData.EventGamesPlayed;
		}

		public void IncreaseCustomersPlayed()
		{
			customersPlayedGames++;
			if (customersPlayedGames % 2 == 0)
			{
				aPSaveData.EventGamesPlayed++;
			}
		}

		public void DecreaseLuck()
		{
			if (aPSaveData.Luck > 0)
			{
				aPSaveData.Luck--;
			}
		}

		public void IncreaseCardChecks(ECollectionPackType packType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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_002b: Expected I4, but got Unknown
			switch ((int)packType)
			{
			case 0:
				aPSaveData.TetramonCommonChecksFound++;
				break;
			case 1:
				aPSaveData.TetramonRareChecksFound++;
				break;
			case 2:
				aPSaveData.TetramonEpicChecksFound++;
				break;
			case 3:
				aPSaveData.TetramonLegendaryChecksFound++;
				break;
			case 4:
				aPSaveData.DestinyCommonChecksFound++;
				break;
			case 5:
				aPSaveData.DestinyRareChecksFound++;
				break;
			case 6:
				aPSaveData.DestinyEpicChecksFound++;
				break;
			case 7:
				aPSaveData.DestinyLegendaryChecksFound++;
				break;
			}
		}

		public void IncreaseCardSold(ECardExpansionType expansionType, ERarity rarity)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected I4, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0027: Expected I4, but got Unknown
			if ((int)expansionType == 0)
			{
				switch ((int)rarity)
				{
				case 0:
					aPSaveData.TetramonCommonChecksSold++;
					break;
				case 1:
					aPSaveData.TetramonRareChecksSold++;
					break;
				case 2:
					aPSaveData.TetramonEpicChecksSold++;
					break;
				case 3:
					aPSaveData.TetramonLegendaryChecksSold++;
					break;
				}
			}
			else
			{
				switch ((int)rarity)
				{
				case 0:
					aPSaveData.DestinyCommonChecksSold++;
					break;
				case 1:
					aPSaveData.DestinyRareChecksSold++;
					break;
				case 2:
					aPSaveData.DestinyEpicChecksSold++;
					break;
				case 3:
					aPSaveData.DestinyLegendaryChecksSold++;
					break;
				}
			}
		}

		public int GetCardsSold(ECardExpansionType expansionType, ERarity rarity)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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)
			//IL_0083: Expected I4, but got Unknown
			//IL_000a: 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)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected I4, but got Unknown
			if ((int)expansionType == 0)
			{
				switch ((int)rarity)
				{
				case 0:
					return aPSaveData.TetramonCommonChecksSold;
				case 1:
					return aPSaveData.TetramonRareChecksSold;
				case 2:
					return aPSaveData.TetramonEpicChecksSold;
				case 3:
					return aPSaveData.TetramonLegendaryChecksSold;
				}
			}
			else
			{
				switch ((int)rarity)
				{
				case 0:
					return aPSaveData.DestinyCommonChecksSold;
				case 1:
					return aPSaveData.DestinyRareChecksSold;
				case 2:
					return aPSaveData.DestinyEpicChecksSold;
				case 3:
					return aPSaveData.DestinyLegendaryChecksSold;
				}
			}
			return -1;
		}

		public void IncreaseGhostChecks()
		{
			aPSaveData.GhostCardsSold++;
		}

		public int getTotalExpansionChecks(ECardExpansionType cardExpansionType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_003e: 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)
			//IL_0043: Invalid comparison between Unknown and I4
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Invalid comparison between Unknown and I4
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Invalid comparison between Unknown and I4
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Invalid comparison between Unknown and I4
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Invalid comparison between Unknown and I4
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Invalid comparison between Unknown and I4
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Invalid comparison between I4 and Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Invalid comparison between I4 and Unknown
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Invalid comparison between I4 and Unknown
			if ((int)cardExpansionType == 2)
			{
				if (Plugin.m_SessionHandler.GetSlotData().Goal == 2)
				{
					return Plugin.m_SessionHandler.GetSlotData().GhostGoalAmount;
				}
				return 0;
			}
			if ((int)cardExpansionType != 0 && (int)cardExpansionType != 1)
			{
				return 0;
			}
			if ((int)cardExpansionType == 0 && cachedTetramonCheckCount != -1)
			{
				Plugin.Log("-1");
				return cachedTetramonCheckCount;
			}
			if ((int)cardExpansionType == 1 && cachedDestinyCheckCount != -1)
			{
				Plugin.Log("-1");
				return cachedDestinyCheckCount;
			}
			cachedCommonChecks = 0;
			cachedRareChecks = 0;
			cachedEpicChecks = 0;
			cachedLegendaryChecks = 0;
			int num = 0;
			for (int i = 0; i < InventoryBase.GetShownMonsterList(cardExpansionType).Count; i++)
			{
				ERarity rarity = InventoryBase.GetMonsterData(InventoryBase.GetShownMonsterList(cardExpansionType)[i]).Rarity;
				int num2 = (((int)cardExpansionType == 1) ? 4 : 0);
				if ((int)rarity == 0)
				{
					Plugin.Log("common");
					cachedCommonChecks += 12;
					if (Plugin.m_SessionHandler.GetSlotData().CardSanity > num2)
					{
						num += (Plugin.m_SessionHandler.GetSlotData().BorderInSanity + 1) * ((!Plugin.m_SessionHandler.GetSlotData().FoilInSanity) ? 1 : 2);
					}
				}
				if (1 == (int)rarity)
				{
					cachedRareChecks += 12;
					if (Plugin.m_SessionHandler.GetSlotData().CardSanity > num2 + 1)
					{
						num += (Plugin.m_SessionHandler.GetSlotData().BorderInSanity + 1) * ((!Plugin.m_SessionHandler.GetSlotData().FoilInSanity) ? 1 : 2);
					}
				}
				if (2 == (int)rarity)
				{
					cachedEpicChecks += 12;
					if (Plugin.m_SessionHandler.GetSlotData().CardSanity > num2 + 2)
					{
						num += (Plugin.m_SessionHandler.GetSlotData().BorderInSanity + 1) * ((!Plugin.m_SessionHandler.GetSlotData().FoilInSanity) ? 1 : 2);
					}
				}
				if (3 == (int)rarity)
				{
					cachedLegendaryChecks += 12;
					if (Plugin.m_SessionHandler.GetSlotData().CardSanity > num2 + 3)
					{
						num += (Plugin.m_SessionHandler.GetSlotData().BorderInSanity + 1) * ((!Plugin.m_SessionHandler.GetSlotData().FoilInSanity) ? 1 : 2);
					}
				}
			}
			if ((int)cardExpansionType == 0)
			{
				cachedTetramonCheckCount = num;
			}
			if ((int)cardExpansionType == 1)
			{
				cachedDestinyCheckCount = num;
			}
			return num;
		}

		public int GetTotalCountedCards(ECollectionPackType packType)
		{
			//IL_0009: 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_000b: 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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected I4, but got Unknown
			getTotalExpansionChecks((ECardExpansionType)0);
			return (int)packType switch
			{
				0 => cachedCommonChecks, 
				1 => cachedRareChecks, 
				2 => cachedEpicChecks, 
				3 => cachedLegendaryChecks, 
				4 => cachedCommonChecks, 
				5 => cachedRareChecks, 
				6 => cachedEpicChecks, 
				7 => cachedLegendaryChecks, 
				_ => -1, 
			};
		}

		public int GetExpansionChecks(ECardExpansionType type)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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_0017: Expected I4, but got Unknown
			return (int)type switch
			{
				0 => GetTetramonChecks(), 
				1 => GetDestinyChecks(), 
				2 => GetGhostChecks(), 
				_ => 0, 
			};
		}

		public int GetTetramonChecks()
		{
			return aPSaveData.TetramonCommonChecksFound + aPSaveData.TetramonRareChecksFound + aPSaveData.TetramonEpicChecksFound + aPSaveData.TetramonLegendaryChecksFound;
		}

		public int GetDestinyChecks()
		{
			return aPSaveData.DestinyCommonChecksFound + aPSaveData.DestinyRareChecksFound + aPSaveData.DestinyEpicChecksFound + aPSaveData.DestinyLegendaryChecksFound;
		}

		public int GetCardChecks(ECollectionPackType packType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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_002b: Expected I4, but got Unknown
			return (int)packType switch
			{
				0 => aPSaveData.TetramonCommonChecksFound, 
				1 => aPSaveData.TetramonRareChecksFound, 
				2 => aPSaveData.TetramonEpicChecksFound, 
				3 => aPSaveData.TetramonLegendaryChecksFound, 
				4 => aPSaveData.DestinyCommonChecksFound, 
				5 => aPSaveData.DestinyRareChecksFound, 
				6 => aPSaveData.DestinyEpicChecksFound, 
				7 => aPSaveData.DestinyLegendaryChecksFound, 
				_ => -1, 
			};
		}

		public int GetSentChecks(ECollectionPackType packType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_003d: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected I4, but got Unknown
			int totalCountedCards = Plugin.m_SaveManager.GetTotalCountedCards(packType);
			float num = (float)totalCountedCards * ((float)Plugin.m_SessionHandler.GetSlotData().CardCollectPercentage / 100f);
			float num2 = num / (float)Plugin.m_SessionHandler.GetSlotData().ChecksPerPack;
			return (int)packType switch
			{
				0 => (int)((float)aPSaveData.TetramonCommonChecksFound / num2), 
				1 => (int)((float)aPSaveData.TetramonRareChecksFound / num2), 
				2 => (int)((float)aPSaveData.TetramonEpicChecksFound / num2), 
				3 => (int)((float)aPSaveData.TetramonLegendaryChecksFound / num2), 
				4 => (int)((float)aPSaveData.DestinyCommonChecksFound / num2), 
				5 => (int)((float)aPSaveData.DestinyRareChecksFound / num2), 
				6 => (int)((float)aPSaveData.DestinyEpicChecksFound / num2), 
				7 => (int)((float)aPSaveData.DestinyLegendaryChecksFound / num2), 
				_ => -1, 
			};
		}

		public int GetGhostChecks()
		{
			return aPSaveData.GhostCardsSold;
		}

		public int GetStoredXP(int maxToGrab)
		{
			if (aPSaveData.StoredXP > maxToGrab)
			{
				aPSaveData.StoredXP -= maxToGrab;
				return maxToGrab;
			}
			return aPSaveData.StoredXP;
		}

		public int TotalStoredXP()
		{
			return aPSaveData.StoredXP;
		}

		public void IncreaseStoredXP(int xp)
		{
			Plugin.Log($"xp: {xp}");
			aPSaveData.StoredXP += xp;
		}

		private string GetBaseDirectory()
		{
			return Path.GetDirectoryName(GetType().Assembly.Location);
		}

		private string getGdSavePath()
		{
			return GetBaseDirectory() + "/Saves/ApClient_" + aPSaveData.slotname + "_" + aPSaveData.seed + ".gd";
		}

		private string getJsonSavePath()
		{
			return GetBaseDirectory() + "/Saves/ApClient_" + aPSaveData.slotname + "_" + aPSaveData.seed + ".json";
		}

		public bool doesSaveExist()
		{
			return File.Exists(getJsonSavePath()) || File.Exists(getGdSavePath());
		}

		public void Save(int saveSlotIndex)
		{
			Directory.CreateDirectory(GetBaseDirectory() + "/Saves/");
			CSaveLoad.m_SavedGame = CGameData.instance;
			SaveDataWrapper saveDataWrapper = new SaveDataWrapper
			{
				gameData = CGameData.instance,
				ProcessedIndex = aPSaveData.ProcessedIndex,
				MoneyMultiplier = aPSaveData.MoneyMultiplier,
				Luck = aPSaveData.Luck,
				TetramonCommonChecksFound = aPSaveData.TetramonCommonChecksFound,
				DestinyCommonChecksFound = aPSaveData.DestinyCommonChecksFound,
				TetramonRareChecksFound = aPSaveData.TetramonRareChecksFound,
				DestinyRareChecksFound = aPSaveData.DestinyRareChecksFound,
				TetramonEpicChecksFound = aPSaveData.TetramonEpicChecksFound,
				DestinyEpicChecksFound = aPSaveData.DestinyEpicChecksFound,
				TetramonLegendaryChecksFound = aPSaveData.TetramonLegendaryChecksFound,
				DestinyLegendaryChecksFound = aPSaveData.DestinyLegendaryChecksFound,
				TetramonCommonChecksSold = aPSaveData.TetramonCommonChecksSold,
				DestinyCommonChecksSold = aPSaveData.DestinyCommonChecksSold,
				TetramonRareChecksSold = aPSaveData.TetramonRareChecksSold,
				DestinyRareChecksSold = aPSaveData.DestinyRareChecksSold,
				TetramonEpicChecksSold = aPSaveData.TetramonEpicChecksSold,
				DestinyEpicChecksSold = aPSaveData.DestinyEpicChecksSold,
				TetramonLegendaryChecksSold = aPSaveData.TetramonLegendaryChecksSold,
				DestinyLegendaryChecksSold = aPSaveData.DestinyLegendaryChecksSold,
				GhostCardsSold = aPSaveData.GhostCardsSold,
				EventGamesPlayed = aPSaveData.EventGamesPlayed,
				LicensesReceived = aPSaveData.LicensesReceived,
				StoredXP = aPSaveData.LicensesReceived
			};
			try
			{
				string contents = JsonUtility.ToJson((object)saveDataWrapper, true);
				File.WriteAllText(getJsonSavePath(), contents);
			}
			catch (Exception ex)
			{
				Plugin.Log("Error saving JSON: " + ex);
			}
		}

		public bool Load()
		{
			string jsonSavePath = getJsonSavePath();
			if (!File.Exists(jsonSavePath))
			{
				return false;
			}
			try
			{
				string text = File.ReadAllText(jsonSavePath);
				SaveDataWrapper saveDataWrapper = JsonConvert.DeserializeObject<SaveDataWrapper>(text);
				if (saveDataWrapper == null)
				{
					return false;
				}
				CSaveLoad.m_SavedGame = saveDataWrapper.gameData;
				aPSaveData.ProcessedIndex = saveDataWrapper.ProcessedIndex;
				aPSaveData.MoneyMultiplier = saveDataWrapper.MoneyMultiplier;
				aPSaveData.Luck = saveDataWrapper.Luck;
				aPSaveData.TetramonCommonChecksFound = saveDataWrapper.TetramonCommonChecksFound;
				aPSaveData.DestinyCommonChecksFound = saveDataWrapper.DestinyCommonChecksFound;
				aPSaveData.TetramonRareChecksFound = saveDataWrapper.TetramonRareChecksFound;
				aPSaveData.DestinyRareChecksFound = saveDataWrapper.DestinyRareChecksFound;
				aPSaveData.TetramonEpicChecksFound = saveDataWrapper.TetramonEpicChecksFound;
				aPSaveData.DestinyEpicChecksFound = saveDataWrapper.DestinyEpicChecksFound;
				aPSaveData.TetramonLegendaryChecksFound = saveDataWrapper.TetramonLegendaryChecksFound;
				aPSaveData.DestinyLegendaryChecksFound = saveDataWrapper.DestinyLegendaryChecksFound;
				aPSaveData.TetramonCommonChecksSold = saveDataWrapper.TetramonCommonChecksSold;
				aPSaveData.DestinyCommonChecksSold = saveDataWrapper.DestinyCommonChecksSold;
				aPSaveData.TetramonRareChecksSold = saveDataWrapper.TetramonRareChecksSold;
				aPSaveData.DestinyRareChecksSold = saveDataWrapper.DestinyRareChecksSold;
				aPSaveData.TetramonEpicChecksSold = saveDataWrapper.TetramonEpicChecksSold;
				aPSaveData.DestinyEpicChecksSold = saveDataWrapper.DestinyEpicChecksSold;
				aPSaveData.TetramonLegendaryChecksSold = saveDataWrapper.TetramonLegendaryChecksSold;
				aPSaveData.DestinyLegendaryChecksSold = saveDataWrapper.DestinyLegendaryChecksSold;
				aPSaveData.GhostCardsSold = saveDataWrapper.GhostCardsSold;
				aPSaveData.EventGamesPlayed = saveDataWrapper.EventGamesPlayed;
				aPSaveData.LicensesReceived = saveDataWrapper.LicensesReceived;
				aPSaveData.StoredXP = saveDataWrapper.StoredXP;
				return true;
			}
			catch
			{
				Plugin.Log("Failed to retrieve save data");
			}
			return false;
		}
	}
	public class CardHelper
	{
		private ERarity[] CardRarities = (ERarity[])(object)new ERarity[122];

		private bool initialized = false;

		public CardHelper()
		{
			initialized = false;
		}

		public void Initialize()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected I4, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			CardRarities[0] = (ERarity)(-1);
			for (int i = 1; i < CardRarities.Length; i++)
			{
				try
				{
					CardRarities[i] = (ERarity)(int)InventoryBase.GetMonsterData((EMonsterType)i).Rarity;
				}
				catch (Exception)
				{
					Plugin.Log("Failed to get monster data");
				}
			}
			initialized = true;
			ERarity[] cardRarities = CardRarities;
			foreach (ERarity val in cardRarities)
			{
				Console.WriteLine(val);
			}
			Plugin.Log("initialized card helper");
		}

		public CardData RandomNewCard(ECardExpansionType expansion, HashSet<ERarity> allowedRarities, int borderlimit, bool foils)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Invalid comparison between Unknown and I4
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Expected O, but got Unknown
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: 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)
			Plugin.Log($"RandomNewCard {((object)(ECardExpansionType)(ref expansion)).ToString()} {allowedRarities.Count} {borderlimit} {foils}");
			foreach (ERarity allowedRarity in allowedRarities)
			{
				Console.WriteLine($"allowed: {allowedRarity}");
			}
			try
			{
				if (!initialized)
				{
					Initialize();
				}
				List<bool> isCardCollectedList = CPlayerData.GetIsCardCollectedList(expansion, false);
				int num = (foils ? 12 : 6);
				int num2 = 121;
				List<int> list = new List<int>();
				for (int i = 1; i < num2; i++)
				{
					if (!allowedRarities.Contains(CardRarities[i]))
					{
						continue;
					}
					int num3 = i * 12;
					for (int j = 0; j < num; j++)
					{
						if (j % 6 <= borderlimit)
						{
							int num4 = num3 + j;
							if (!isCardCollectedList[num4])
							{
								list.Add(num4);
							}
						}
					}
				}
				if (list.Count == 0)
				{
					Plugin.Log("No new cards");
					return CardRoller((ECollectionPackType)Random.Range(0, 4));
				}
				int num5 = list[Random.Range(0, list.Count)];
				int num6 = num5 % 12;
				int num7 = (num5 - num6) / 12;
				CardData val = new CardData
				{
					isFoil = (num6 > 5),
					isDestiny = ((int)expansion == 1),
					borderType = (ECardBorderType)(num6 % 6),
					monsterType = (EMonsterType)num7,
					expansionType = expansion,
					isChampionCard = false,
					isNew = true
				};
				Plugin.Log($"{val.monsterType} {val.borderType} {val.expansionType} {val.isFoil}");
				return val;
			}
			catch (Exception ex)
			{
				Plugin.Log(ex.Message);
				throw;
			}
		}

		public CardData CardRoller(ECollectionPackType collectionPackType)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_0082: Expected O, but got Unknown
			ECardExpansionType val = (ECardExpansionType)(!((double)Random.Range(0f, 1f) > 0.5));
			return new CardData
			{
				isFoil = ((double)Random.Range(0f, 1f) > 0.5),
				isDestiny = ((int)val == 1),
				borderType = (ECardBorderType)Random.Range(0, 6),
				monsterType = (EMonsterType)Random.Range(0, 122),
				expansionType = val,
				isChampionCard = false,
				isNew = true
			};
		}
	}
	public class CoroutineRunner : MonoBehaviour
	{
		private static readonly Queue<Action> _mainThreadQueue = new Queue<Action>();

		private static CoroutineRunner _instance;

		public static CoroutineRunner Instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("CoroutineRunner");
					Object.DontDestroyOnLoad((Object)(object)val);
					_instance = val.AddComponent<CoroutineRunner>();
				}
				return _instance;
			}
		}

		public static void RunOnMainThread(Action action)
		{
			CoroutineRunner instance = Instance;
			lock (_mainThreadQueue)
			{
				_mainThreadQueue.Enqueue(action);
			}
		}

		private void Update()
		{
			lock (_mainThreadQueue)
			{
				while (_mainThreadQueue.Count > 0)
				{
					_mainThreadQueue.Dequeue()();
				}
			}
		}
	}
	public class ItemHandler
	{
		private Coroutine cashOnlyCoroutine;

		private float remainingTime = 0f;

		private bool timerRunning = false;

		public bool cashOnly = false;

		public void processNewItem(ItemInfo itemReceived)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Invalid comparison between Unknown and I4
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Expected O, but got Unknown
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0507: Unknown result type (might be due to invalid IL or missing references)
			if ((int)itemReceived.ItemId == TrashMapping.smallMoney)
			{
				CEventManager.QueueEvent((CEvent)new CEventPlayer_AddCoin((float)(10 * Math.Min(CPlayerData.m_ShopLevel + 1, 25)), false));
			}
			else if ((int)itemReceived.ItemId == TrashMapping.mediumMoney)
			{
				CEventManager.QueueEvent((CEvent)new CEventPlayer_AddCoin((float)(20 * Math.Min(CPlayerData.m_ShopLevel + 1, 25)), false));
			}
			else if ((int)itemReceived.ItemId == TrashMapping.largeMoney)
			{
				CEventManager.QueueEvent((CEvent)new CEventPlayer_AddCoin((float)(40 * Math.Min(CPlayerData.m_ShopLevel + 1, 25)), false));
			}
			else if ((int)itemReceived.ItemId == TrashMapping.smallXp)
			{
				CEventManager.QueueEvent((CEvent)new CEventPlayer_AddShopExp(Math.Min((int)((double)CPlayerData.GetExpRequiredToLevelUp() * 0.1), (CPlayerData.m_ShopLevel + 1 > 20) ? ((int)((double)(300 * (CPlayerData.m_ShopLevel + 1)) * 0.2)) : 400), false));
			}
			else if ((int)itemReceived.ItemId == TrashMapping.mediumXp)
			{
				CEventManager.QueueEvent((CEvent)new CEventPlayer_AddShopExp(Math.Min((int)((double)CPlayerData.GetExpRequiredToLevelUp() * 0.17), (CPlayerData.m_ShopLevel + 1 > 20) ? ((int)((double)(600 * (CPlayerData.m_ShopLevel + 1)) * 0.2)) : 800), false));
			}
			else if ((int)itemReceived.ItemId == TrashMapping.largeXp)
			{
				CEventManager.QueueEvent((CEvent)new CEventPlayer_AddShopExp(Math.Min((int)((double)CPlayerData.GetExpRequiredToLevelUp() * 0.25), (CPlayerData.m_ShopLevel + 1 > 20) ? ((int)((double)(1000 * (CPlayerData.m_ShopLevel + 1)) * 0.2)) : 1500), false));
			}
			else if ((int)itemReceived.ItemId == TrashMapping.randomcard)
			{
				Array values = Enum.GetValues(typeof(ECollectionPackType));
				ECollectionPackType collectionPackType = (ECollectionPackType)values.GetValue(Random.Range(0, (Plugin.m_SessionHandler.GetSlotData().CardSanity == 0) ? 8 : Plugin.m_SessionHandler.GetSlotData().CardSanity));
				CardData val = Plugin.m_CardHelper.CardRoller(collectionPackType);
				CPlayerData.AddCard(val, 1);
			}
			else if ((int)itemReceived.ItemId == TrashMapping.randomNewCard)
			{
				CardData newCard = Plugin.getNewCard();
				CPlayerData.AddCard(newCard, 1);
			}
			else
			{
				if ((int)PlayTableMapping.GetFormatFromInt((int)itemReceived.ItemId) != -1)
				{
					return;
				}
				if ((int)itemReceived.ItemId == TrashMapping.ProgressiveCustomerMoney)
				{
					Plugin.m_SaveManager.IncreaseMoneyMult();
				}
				else if ((int)itemReceived.ItemId == TrashMapping.IncreaseCardLuck)
				{
					if (Plugin.m_SaveManager.GetLuck() >= 100)
					{
						CEventManager.QueueEvent((CEvent)new CEventPlayer_AddCoin((float)(40 * Math.Min(CPlayerData.m_ShopLevel + 1, 25)), false));
					}
					else
					{
						Plugin.m_SaveManager.IncreaseLuck();
					}
				}
				else if ((int)itemReceived.ItemId == TrashMapping.DecreaseCardLuck)
				{
					Plugin.m_SaveManager.DecreaseLuck();
				}
				else if ((int)itemReceived.ItemId == TrashMapping.CurrencyTrap)
				{
					CSingleton<CGameManager>.Instance.m_CurrencyType = (EMoneyCurrencyType)Random.RandomRangeInt(0, 8);
				}
				else
				{
					if ((int)itemReceived.ItemId == TrashMapping.stinkTrap)
					{
						FieldInfo field = typeof(CustomerManager).GetField("m_CustomerList", BindingFlags.Instance | BindingFlags.NonPublic);
						if (field == null)
						{
							return;
						}
						List<Customer> list = (List<Customer>)field.GetValue(CSingleton<CustomerManager>.Instance);
						{
							foreach (Customer item in list)
							{
								item.SetSmelly();
							}
							return;
						}
					}
					if ((int)itemReceived.ItemId == TrashMapping.lightTrap)
					{
						((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(ToggleLightMultipleTimes());
					}
					else if ((int)itemReceived.ItemId == TrashMapping.CreditCardFailure)
					{
						remainingTime += 60f;
						if (!timerRunning)
						{
							cashOnlyCoroutine = ((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(CashOnlyTimerCoroutine());
						}
					}
					else if ((int)itemReceived.ItemId == TrashMapping.MarketChangeTrap)
					{
						CSingleton<PriceChangeManager>.Instance.EvaluatePriceChange();
						CSingleton<PriceChangeManager>.Instance.EvaluatePriceCrash();
						CPlayerData.UpdateItemPricePercentChange();
						CPlayerData.UpdatePastCardPricePercentChange();
					}
					else if (itemReceived.ItemId == LicenseMapping.BASIC_CARD_PACK_ID || (itemReceived.ItemId < 125 && LicenseMapping.mapping.ContainsKey((EItemType)itemReceived.ItemId)))
					{
						EItemType val2 = (EItemType)((itemReceived.ItemId != LicenseMapping.BASIC_CARD_PACK_ID) ? itemReceived.ItemId : 0);
						Plugin.m_SaveManager.IncreaselicensesReceived();
						CoroutineRunner.RunOnMainThread(delegate
						{
							CSingleton<GameUIScreen>.Instance.EvaluateShopLevelAndExp();
						});
					}
					else if ((int)itemReceived.ItemId == ExpansionMapping.progressiveA)
					{
						if (Plugin.m_SessionHandler.GetSlotData().AutoRenovate)
						{
							CoroutineRunner.RunOnMainThread(delegate
							{
								CSingleton<UnlockRoomManager>.Instance.StartUnlockNextRoom();
							});
						}
					}
					else if ((int)itemReceived.ItemId == ExpansionMapping.progressiveB)
					{
						if (Plugin.m_SessionHandler.itemCount(itemReceived.ItemId) == 1)
						{
							CoroutineRunner.RunOnMainThread(delegate
							{
								CSingleton<UnlockRoomManager>.Instance.SetUnlockWarehouseRoom(true);
							});
							SoundManager.PlayAudio("SFX_CustomerBuy", 0.6f, 1f);
						}
						else if (Plugin.m_SessionHandler.GetSlotData().AutoRenovate)
						{
							CoroutineRunner.RunOnMainThread(delegate
							{
								CSingleton<UnlockRoomManager>.Instance.StartUnlockNextWarehouseRoom();
							});
						}
					}
					else if (EmployeeMapping.getindexFromId((int)itemReceived.ItemId) != -1)
					{
						int num = EmployeeMapping.getindexFromId((int)itemReceived.ItemId);
						HireWorkerScreen val3 = Object.FindObjectOfType<HireWorkerScreen>();
						HireWorkerPanelUI[] array = Object.FindObjectsOfType<HireWorkerPanelUI>();
						HireWorkerPanelUI val4 = null;
						HireWorkerPanelUI[] array2 = array;
						foreach (HireWorkerPanelUI val5 in array2)
						{
							FieldInfo field2 = typeof(HireWorkerPanelUI).GetField("m_Index", BindingFlags.Instance | BindingFlags.NonPublic);
							if (field2 == null)
							{
								return;
							}
							int num2 = (int)field2.GetValue(val5);
							if (num2 == num)
							{
								val4 = val5;
								break;
							}
						}
						if (!((Object)(object)val4 == (Object)null))
						{
							Plugin.Log("detected Hire Worker Screen");
							Plugin.Log("Found Hire Worker Panel");
							val4.m_HiredText.SetActive(false);
							val4.m_PurchaseBtn.SetActive(true);
							Plugin.Log($"Recieved Worker While panel was open: {(int)itemReceived.ItemId}");
						}
					}
					else if (FurnatureMapping.getindexFromId((int)itemReceived.ItemId) != -1)
					{
						int num3 = FurnatureMapping.getindexFromId((int)itemReceived.ItemId);
						FurnitureShopPanelUI val6 = null;
						FurnitureShopPanelUI[] array3 = Object.FindObjectsOfType<FurnitureShopPanelUI>();
						FurnitureShopPanelUI[] array4 = array3;
						foreach (FurnitureShopPanelUI val7 in array4)
						{
							FieldInfo field3 = typeof(FurnitureShopPanelUI).GetField("m_Index", BindingFlags.Instance | BindingFlags.NonPublic);
							if (field3 == null)
							{
								return;
							}
							int num4 = (int)field3.GetValue(val7);
							if (num4 == num3)
							{
								val6 = val7;
								break;
							}
						}
						if (!((Object)(object)val6 == (Object)null))
						{
							FurnaturePatches.EnableFurnature(val6, num3);
						}
					}
					else if ((int)itemReceived.ItemId == CardMapping.oneghostcard)
					{
						addRandomGhost();
					}
					else if ((int)itemReceived.ItemId == CardMapping.twoghostcard)
					{
						for (int k = 0; k < 2; k++)
						{
							addRandomGhost();
						}
					}
					else if ((int)itemReceived.ItemId == CardMapping.threeghostcard)
					{
						for (int l = 0; l < 3; l++)
						{
							addRandomGhost();
						}
					}
					else if ((int)itemReceived.ItemId == CardMapping.fourghostcard)
					{
						for (int m = 0; m < 4; m++)
						{
							Plugin.Log("Ghost");
							addRandomGhost();
						}
					}
					else if ((int)itemReceived.ItemId == CardMapping.fiveghostcard)
					{
						for (int n = 0; n < 5; n++)
						{
							addRandomGhost();
						}
					}
				}
			}
		}

		private void addRandomGhost()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			List<EMonsterType> shownMonsterList = InventoryBase.GetShownMonsterList((ECardExpansionType)2);
			CPlayerData.AddCard(new CardData
			{
				isFoil = ((double)Random.Range(0f, 1f) > 0.5),
				isDestiny = ((double)Random.Range(0f, 1f) > 0.5),
				borderType = (ECardBorderType)0,
				monsterType = InventoryBase.GetMonsterData(shownMonsterList[Random.Range(0, shownMonsterList.Count())]).MonsterType,
				expansionType = (ECardExpansionType)2,
				isChampionCard = false,
				isNew = true
			}, 1);
		}

		private IEnumerator ToggleLightMultipleTimes()
		{
			int repeats = Random.Range(1, 6) * 2 - 1;
			for (int i = 0; i < repeats; i++)
			{
				CSingleton<LightManager>.Instance.ToggleShopLight();
				SoundManager.PlayAudio("SFX_ButtonLightTap", 0.6f, 0.5f);
				float delay = Random.Range(0.5f, 2f);
				yield return (object)new WaitForSeconds(delay);
			}
		}

		private IEnumerator CashOnlyTimerCoroutine()
		{
			timerRunning = true;
			for (cashOnly = true; remainingTime > 0f; remainingTime -= Time.deltaTime)
			{
				yield return null;
			}
			cashOnly = false;
			timerRunning = false;
		}
	}
	[BepInPlugin("ApClient", "Ap Client For TCG Sim", "0.4.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		private readonly Harmony m_Harmony = new Harmony("ApClient");

		public static APClientSaveManager m_SaveManager = new APClientSaveManager();

		public static ItemHandler m_ItemHandler = new ItemHandler();

		public static SessionHandler m_SessionHandler = new SessionHandler();

		public static CardHelper m_CardHelper = new CardHelper();

		private static bool SceneLoaded = false;

		private Plugin()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			m_Harmony.PatchAll();
		}

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Settings.Instance.Load(this);
			Logger.LogInfo((object)"Plugin ApClient is loaded!");
			SceneManager.sceneLoaded += OnSceneLoad;
		}

		private void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("MyGUI");
			val.AddComponent<APGui>();
			Object.DontDestroyOnLoad((Object)(object)val);
			APConsole.Create();
		}

		private void OnDestroy()
		{
			m_Harmony.UnpatchSelf();
		}

		public static bool isSceneLoaded()
		{
			return SceneLoaded;
		}

		public static void onSceneLoadLogic()
		{
			SceneLoaded = true;
			m_SessionHandler.ProcessCachedItems();
		}

		public static bool OverrideTrades()
		{
			return m_SessionHandler.GetSlotData().TradesAreNew;
		}

		public static float getNumLuckItems()
		{
			return m_SaveManager.GetLuck();
		}

		public static bool isCashOnly()
		{
			return m_ItemHandler.cashOnly;
		}

		public static CardData getNewCard()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Invalid comparison between Unknown and I4
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Invalid comparison between Unknown and I4
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				int num = 8;
				int borderlimit = 5;
				bool foils = true;
				if (m_SessionHandler.GetSlotData().CardSanity != 0)
				{
					borderlimit = m_SessionHandler.GetSlotData().BorderInSanity;
					foils = m_SessionHandler.GetSlotData().FoilInSanity;
					num = m_SessionHandler.GetSlotData().CardSanity;
				}
				ECardExpansionType val = (ECardExpansionType)(Random.Range(0, num) > 4);
				HashSet<ERarity> hashSet = new HashSet<ERarity>();
				if ((int)val == 1)
				{
					for (int i = 0; i < num - 4; i++)
					{
						hashSet.Add((ERarity)i);
					}
				}
				if ((int)val == 0)
				{
					for (int j = 0; j < num && j < 4; j++)
					{
						hashSet.Add((ERarity)j);
					}
				}
				return m_CardHelper.RandomNewCard(val, hashSet, borderlimit, foils);
			}
			catch (Exception ex)
			{
				Log(ex.ToString());
				APConsole.Instance.Log("Error in New Card Randomization");
				return m_CardHelper.CardRoller((ECollectionPackType)7);
			}
		}

		private void OnSceneLoad(Scene scene, LoadSceneMode mode)
		{
			Log(" Scene Load: " + ((Scene)(ref scene)).name);
			if (((Scene)(ref scene)).name == "Title")
			{
				m_SaveManager = new APClientSaveManager();
				setTitleInteractable(interactable: false);
				SceneLoaded = false;
			}
			if (((Scene)(ref scene)).name == "Start")
			{
				APGui.showGUI = false;
			}
		}

		public static void RunTitleInteractableSaveLogic()
		{
			TitleScreen val = Object.FindFirstObjectByType<TitleScreen>();
			GameObject val2 = GameObject.Find("NewGameBtn");
			Button val3 = null;
			if ((Object)(object)val2 != (Object)null)
			{
				val3 = val2.GetComponentInChildren<Button>();
			}
			if (m_SaveManager.doesSaveExist())
			{
				((Selectable)val.m_LoadGameButton).interactable = true;
				((Selectable)val3).interactable = false;
			}
			else
			{
				((Selectable)val.m_LoadGameButton).interactable = false;
				((Selectable)val3).interactable = true;
			}
		}

		public static void setTitleInteractable(bool interactable)
		{
			TitleScreen val = Object.FindFirstObjectByType<TitleScreen>();
			((Selectable)val.m_LoadGameButton).interactable = interactable;
			GameObject val2 = GameObject.Find("NewGameBtn");
			if ((Object)(object)val2 != (Object)null)
			{
				Button componentInChildren = val2.GetComponentInChildren<Button>();
				((Selectable)componentInChildren).interactable = interactable;
			}
		}

		public static void Log(string s)
		{
			Logger.LogInfo((object)s);
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)98))
			{
			}
			if (!Input.GetKeyDown((KeyCode)104))
			{
			}
		}
	}
	public class SessionHandler
	{
		private class ItemCache
		{
			public ItemInfo info { get; set; }

			public int index { get; set; }
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Func<string, int> <0>__Parse;

			public static MessageReceivedHandler <1>__OnMessageReceived;
		}

		private ArchipelagoSession session;

		private SlotData slotData = new SlotData();

		private Queue<ItemCache> cachedItems = new Queue<ItemCache>();

		private LoginResult result = null;

		private DeathLinkService deathLinkService = null;

		private bool isConnected = false;

		public SlotData GetSlotData()
		{
			return slotData;
		}

		public int itemCount(long id)
		{
			return session.Items.AllItemsReceived.Where((ItemInfo i) => i.ItemId == id).Count();
		}

		public bool ControlTrades()
		{
			return slotData.TradesAreNew;
		}

		public bool hasItem(long id)
		{
			if (id == 0)
			{
				id = 190L;
			}
			return itemCount(id) > 0;
		}

		public bool isEventUnlocked(EGameEventFormat format)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return hasItem(PlayTableMapping.FormatStartingId + format);
		}

		public void SendGoalCompletion()
		{
			session.SetGoalAchieved();
		}

		public void CompleteLocationChecks(params long[] ids)
		{
			session.Locations.CompleteLocationChecks(ids);
		}

		public bool isStartingItem(int id)
		{
			return slotData.startingItems.Contains(id);
		}

		public int[] startingids()
		{
			return slotData.startingItems.ToArray();
		}

		public int GetRemainingLicenses(int currentLevelStart)
		{
			//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)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<EItemType, int> dictionary = new Dictionary<EItemType, int>();
			foreach (DictionaryEntry item in slotData.pg1IndexMapping)
			{
				EItemType key = (EItemType)item.Key;
				int num = (int)item.Value;
				if (num < currentLevelStart && !dictionary.ContainsKey(key))
				{
					dictionary[key] = num;
				}
			}
			foreach (DictionaryEntry item2 in slotData.pg2IndexMapping)
			{
				EItemType key2 = (EItemType)item2.Key;
				int num2 = (int)item2.Value;
				if (num2 < currentLevelStart && !dictionary.ContainsKey(key2))
				{
					dictionary[key2] = num2;
				}
			}
			foreach (DictionaryEntry item3 in slotData.pg3IndexMapping)
			{
				EItemType key3 = (EItemType)item3.Key;
				int num3 = (int)item3.Value;
				if (num3 < currentLevelStart && !dictionary.ContainsKey(key3))
				{
					dictionary[key3] = num3;
				}
			}
			foreach (DictionaryEntry item4 in slotData.ttIndexMapping)
			{
				EItemType key4 = (EItemType)item4.Key;
				int num4 = (int)item4.Value;
				if (num4 < currentLevelStart && !dictionary.ContainsKey(key4))
				{
					dictionary[key4] = num4;
				}
			}
			if (dictionary.Count == 0)
			{
				return 0;
			}
			int requiredLicenses = slotData.RequiredLicenses;
			int num5 = currentLevelStart;
			int num6 = 0;
			int num7 = 0;
			if (currentLevelStart > 25)
			{
				num5 = 25;
				num6 = currentLevelStart - 25;
			}
			if (currentLevelStart > 50)
			{
				num6 = 25;
				num7 = currentLevelStart - 50;
			}
			int num8 = num5 / 5 * slotData.RequiredLicenses;
			num8 += num6 / 5 * 3;
			num8 += num7 / 5 * 2;
			int num9 = dictionary.Keys.Count((EItemType itemId) => hasItem((long)itemId));
			int num10 = num8 - num9;
			return (num10 > 0) ? num10 : 0;
		}

		private OrderedDictionary PgStrToDict(string str)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			JObject val = JObject.Parse(str);
			OrderedDictionary orderedDictionary = new OrderedDictionary();
			foreach (JProperty item in val.Properties())
			{
				try
				{
					int num = int.Parse(item.Name);
					EItemType val2 = (EItemType)((num != 190) ? num : 0);
					int num2 = (int)item.Value;
					orderedDictionary.Add(val2, num2);
				}
				catch
				{
					Plugin.Log($" FAILED {item.Name} : {item.Value}");
				}
			}
			return orderedDictionary;
		}

		private List<int> StrToList(string str)
		{
			int num;
			return (from s in str.Trim('[', ']').Split(',')
				select s.Trim() into s
				where int.TryParse(s, out num)
				select s).Select(int.Parse).ToList();
		}

		public void sendDeath()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			if (slotData.Deathlink)
			{
				Plugin.Log("Sent Death!");
				deathLinkService.SendDeathLink(new DeathLink(Settings.Instance.LastUsedSlot.Value, Settings.Instance.LastUsedSlot.Value + " Died to Not Paying Bills."));
			}
		}

		public bool GetIsConnected()
		{
			return isConnected;
		}

		public void connect(string ip, string password, string slot)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Expected O, but got Unknown
			APGui.state = "Connecting";
			session = ArchipelagoSessionFactory.CreateSession(ip, 38281);
			IMessageLogHelper messageLog = session.MessageLog;
			object obj = <>O.<1>__OnMessageReceived;
			if (obj == null)
			{
				MessageReceivedHandler val = OnMessageReceived;
				<>O.<1>__OnMessageReceived = val;
				obj = (object)val;
			}
			messageLog.OnMessageReceived += (MessageReceivedHandler)obj;
			session.Items.ItemReceived += (ItemReceivedHandler)delegate(ReceivedItemsHelper receivedItemsHelper)
			{
				if (!Plugin.isSceneLoaded())
				{
					Plugin.Log("Not In Scene");
					cachedItems.Enqueue(new ItemCache
					{
						info = receivedItemsHelper.DequeueItem(),
						index = receivedItemsHelper.Index
					});
					Plugin.Log("Enqueue");
				}
				else if (Plugin.m_SaveManager.GetProcessedIndex() <= receivedItemsHelper.Index)
				{
					Plugin.m_SaveManager.IncreaseProcessedIndex();
					ItemInfo itemReceived = receivedItemsHelper.DequeueItem();
					Plugin.m_ItemHandler.processNewItem(itemReceived);
					CSingleton<CGameManager>.Instance.SaveGameData(3);
				}
			};
			try
			{
				result = session.TryConnectAndLogin("TCG Card Shop Simulator", slot, (ItemsHandlingFlags)7, (Version)null, (string[])null, (string)null, password, true);
			}
			catch (Exception ex)
			{
				APGui.state = "Connection Failed";
				result = (LoginResult)new LoginFailure(ex.GetBaseException().Message);
				Plugin.Log(ex.GetBaseException().Message);
			}
			if (result.Successful)
			{
				isConnected = true;
				Plugin.m_SaveManager.setConnectionData(session.RoomState.Seed, slot);
				session.Socket.SocketClosed += (SocketClosedHandler)delegate
				{
					isConnected = false;
					APGui.showGUI = true;
					APGui.state = "AP Disconnected";
					APConsole.Instance.Log("Connection Closed");
				};
				LoginSuccessful val2 = (LoginSuccessful)result;
				string text = val2.SlotData.GetValueOrDefault("ModVersion").ToString();
				if (!text.Equals("0.4.0"))
				{
					APGui.state = "AP Expects Mod v" + text;
				}
				else
				{
					APGui.state = "Connected";
					Plugin.RunTitleInteractableSaveLogic();
				}
				slotData.MaxLevel = int.Parse(val2.SlotData.GetValueOrDefault("MaxLevel").ToString());
				slotData.RequiredLicenses = int.Parse(val2.SlotData.GetValueOrDefault("RequiredLicenses").ToString());
				slotData.Goal = int.Parse(val2.SlotData.GetValueOrDefault("Goal").ToString());
				slotData.GhostGoalAmount = int.Parse(val2.SlotData.GetValueOrDefault("GhostGoalAmount").ToString());
				slotData.AutoRenovate = val2.SlotData.GetValueOrDefault("AutoRenovate").ToString() == "1";
				slotData.TradesAreNew = val2.SlotData.GetValueOrDefault("BetterTrades").ToString() == "1";
				slotData.ExtraStartingItemChecks = int.Parse(val2.SlotData.GetValueOrDefault("ExtraStartingItemChecks").ToString());
				slotData.SellCheckAmount = int.Parse(val2.SlotData.GetValueOrDefault("SellCheckAmount").ToString());
				slotData.ChecksPerPack = int.Parse(val2.SlotData.GetValueOrDefault("ChecksPerPack").ToString());
				slotData.CardCollectPercentage = int.Parse(val2.SlotData.GetValueOrDefault("CardCollectPercentage").ToString());
				slotData.NumberOfGameChecks = int.Parse(val2.SlotData.GetValueOrDefault("PlayTableChecks").ToString());
				slotData.GamesPerCheck = int.Parse(val2.SlotData.GetValueOrDefault("GamesPerCheck").ToString());
				slotData.NumberOfSellCardChecks = int.Parse(val2.SlotData.GetValueOrDefault("NumberOfSellCardChecks").ToString());
				slotData.SellCardsPerCheck = int.Parse(val2.SlotData.GetValueOrDefault("SellCardsPerCheck").ToString());
				slotData.Deathlink = val2.SlotData.GetValueOrDefault("Deathlink").ToString() == "1";
				slotData.CardSanity = int.Parse(val2.SlotData.GetValueOrDefault("CardSanity").ToString());
				slotData.FoilInSanity = val2.SlotData.GetValueOrDefault("FoilInSanity").ToString() == "1";
				slotData.BorderInSanity = int.Parse(val2.SlotData.GetValueOrDefault("BorderInSanity").ToString());
				if (slotData.Deathlink)
				{
					deathLinkService = DeathLinkProvider.CreateDeathLinkService(session);
					deathLinkService.EnableDeathLink();
					deathLinkService.OnDeathLinkReceived += (DeathLinkReceivedHandler)delegate(DeathLink deathLinkObject)
					{
						//IL_0057: Unknown result type (might be due to invalid IL or missing references)
						//IL_0061: Expected O, but got Unknown
						if (slotData.Deathlink && Plugin.isSceneLoaded())
						{
							APConsole.Instance.Log(deathLinkObject.Cause ?? "");
							CSingleton<LightManager>.Instance.m_HasDayEnded = true;
							CSingleton<LightManager>.Instance.m_TimeHour = 21;
							CSingleton<LightManager>.Instance.EvaluateTimeClock();
							CEventManager.QueueEvent((CEvent)new CEventPlayer_OnDayEnded());
						}
					};
				}
				slotData.pg1IndexMapping = PgStrToDict(val2.SlotData.GetValueOrDefault("ShopPg1Mapping").ToString());
				slotData.pg2IndexMapping = PgStrToDict(val2.SlotData.GetValueOrDefault("ShopPg2Mapping").ToString());
				slotData.pg3IndexMapping = PgStrToDict(val2.SlotData.GetValueOrDefault("ShopPg3Mapping").ToString());
				slotData.ttIndexMapping = PgStrToDict(val2.SlotData.GetValueOrDefault("ShopTTMapping").ToString());
				slotData.startingItems = StrToList(val2.SlotData.GetValueOrDefault("StartingIds").ToString());
				Settings.Instance.SaveNewConnectionInfo(ip, password, slot);
			}
			else
			{
				LoginFailure val3 = (LoginFailure)result;
				string seed = "Failed to Connect to " + ip + " as " + slot + ":";
				seed = val3.Errors.Aggregate(seed, (string current, string error) => current + "\n    " + error);
				seed = val3.ErrorCodes.Aggregate(seed, (string current, ConnectionRefusedError error) => current + $"\n    {error}");
				APConsole.Instance.Log(seed);
			}
		}

		private static void OnMessageReceived(LogMessage message)
		{
			APConsole.Instance.Log(((object)message).ToString() ?? string.Empty);
		}

		public void ProcessCachedItems()
		{
			while (cachedItems.Any())
			{
				ItemCache itemCache = cachedItems.Dequeue();
				if (Plugin.m_SaveManager.GetProcessedIndex() <= itemCache.index)
				{
					Plugin.m_SaveManager.IncreaseProcessedIndex();
					Plugin.Log("Item on load " + itemCache.info.ItemName);
					Plugin.m_ItemHandler.processNewItem(itemCache.info);
				}
			}
			cachedItems.Clear();
			CSingleton<CGameManager>.Instance.SaveGameData(3);
		}
	}
	public class Settings
	{
		private static Settings m_instance;

		private Plugin plugin;

		public ConfigEntry<int> StartingMoney;

		public ConfigEntry<int> XpMultiplier;

		public ConfigEntry<KeyCode> MyHotkey;

		public ConfigEntry<KeyCode> ConsoleHotkey;

		public ConfigEntry<bool> disabledeathlink;

		public ConfigEntry<string> LastUsedIP;

		public ConfigEntry<string> LastUsedPassword;

		public ConfigEntry<string> LastUsedSlot;

		public static Settings Instance
		{
			get
			{
				if (m_instance == null)
				{
					m_instance = new Settings();
				}
				return m_instance;
			}
		}

		public void Load(Plugin plugin)
		{
			this.plugin = plugin;
			disabledeathlink = ((BaseUnityPlugin)plugin).Config.Bind<bool>("1. GamePlay", "Force Deathlink Off", false, "If this is on, Deathlink is forced off");
			MyHotkey = ((BaseUnityPlugin)plugin).Config.Bind<KeyCode>("2. Hotkeys", "Toggle Connection Window", (KeyCode)289, "Press this key to toggle AP Connection GUI");
			ConsoleHotkey = ((BaseUnityPlugin)plugin).Config.Bind<KeyCode>("2. Hotkeys", "Toggle AP Console", (KeyCode)290, "Press this key to toggle AP Console Output");
			LastUsedIP = ((BaseUnityPlugin)plugin).Config.Bind<string>("Connection", "LastUsedIP", "", "The last server IP entered.");
			LastUsedPassword = ((BaseUnityPlugin)plugin).Config.Bind<string>("Connection", "LastUsedPassword", "", "The last server password entered.");
			LastUsedSlot = ((BaseUnityPlugin)plugin).Config.Bind<string>("Connection", "LastUsedSlot", "", "The last player slot name entered.");
		}

		public void SaveNewConnectionInfo(string ip, string password, string slot)
		{
			LastUsedIP.Value = ip;
			LastUsedPassword.Value = password;
			LastUsedSlot.Value = slot;
			((BaseUnityPlugin)plugin).Config.Save();
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ApClient";

		public const string PLUGIN_NAME = "Ap Client For TCG Sim";

		public const string PLUGIN_VERSION = "0.4.0";
	}
}
namespace ApClient.patches
{
	public class BillPatches
	{
		[HarmonyPatch(typeof(RentBillScreen))]
		public class NewDay
		{
			[HarmonyPatch("EvaluateNewDayBill")]
			[HarmonyPostfix]
			private static void PostFix(RentBillScreen __instance)
			{
				BillData bill = CPlayerData.GetBill((EBillType)1);
				BillData bill2 = CPlayerData.GetBill((EBillType)2);
				BillData bill3 = CPlayerData.GetBill((EBillType)3);
				bool flag = false;
				if (bill != null && !BillRentDeath && __instance.m_DueDayMax - CPlayerData.GetBill((EBillType)1).billDayPassed <= -1)
				{
					flag = true;
					BillRentDeath = true;
				}
				if (bill2 != null && !BillElectricDeath && __instance.m_DueDayMax - CPlayerData.GetBill((EBillType)2).billDayPassed <= -1)
				{
					flag = true;
					BillElectricDeath = true;
				}
				if (bill3 != null && !BillEmployeeDeath && __instance.m_DueDayMax - CPlayerData.GetBill((EBillType)3).billDayPassed <= -1)
				{
					flag = true;
					BillEmployeeDeath = true;
				}
				if (flag)
				{
					Plugin.m_SessionHandler.sendDeath();
				}
			}
		}

		[HarmonyPatch(typeof(RentBillScreen))]
		public class PaidRent
		{
			[HarmonyPatch("OnPressPayRentBill")]
			[HarmonyPostfix]
			private static void PostFix(RentBillScreen __instance)
			{
				BillRentDeath = false;
			}
		}

		[HarmonyPatch(typeof(RentBillScreen))]
		public class PaidElectric
		{
			[HarmonyPatch("OnPressPayElectricBill")]
			[HarmonyPostfix]
			private static void PostFix(RentBillScreen __instance)
			{
				BillElectricDeath = false;
			}
		}

		[HarmonyPatch(typeof(RentBillScreen))]
		public class PaidSalery
		{
			[HarmonyPatch("OnPressPaySalaryBill")]
			[HarmonyPostfix]
			private static void PostFix(RentBillScreen __instance)
			{
				BillEmployeeDeath = false;
			}
		}

		[HarmonyPatch(typeof(RentBillScreen))]
		public class PaidAll
		{
			[HarmonyPatch("OnPressPayAllBill")]
			[HarmonyPostfix]
			private static void PostFix(RentBillScreen __instance)
			{
				BillRentDeath = false;
				BillElectricDeath = false;
				BillEmployeeDeath = false;
			}
		}

		private static bool BillRentDeath;

		private static bool BillElectricDeath;

		private static bool BillEmployeeDeath;
	}
	public class BinderPagePatches
	{
		[HarmonyPatch(typeof(CollectionBinderUI))]
		public class Awake
		{
			[HarmonyPatch("Awake")]
			[HarmonyPostfix]
			private static void Postfix(CollectionBinderUI __instance)
			{
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//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_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Invalid comparison between Unknown and I4
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				//IL_0216: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_023b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_0256: Unknown result type (might be due to invalid IL or missing references)
				//IL_0265: Unknown result type (might be due to invalid IL or missing references)
				//IL_026a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0280: Unknown result type (might be due to invalid IL or missing references)
				//IL_028f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0294: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: 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)
				commonText = Object.Instantiate<TextMeshProUGUI>(__instance.m_CardCollectedText, ((TMP_Text)__instance.m_CardCollectedText).transform.parent);
				rareText = Object.Instantiate<TextMeshProUGUI>(__instance.m_CardCollectedText, ((TMP_Text)__instance.m_CardCollectedText).transform.parent);
				epicText = Object.Instantiate<TextMeshProUGUI>(__instance.m_CardCollectedText, ((TMP_Text)__instance.m_CardCollectedText).transform.parent);
				legendaryText = Object.Instantiate<TextMeshProUGUI>(__instance.m_CardCollectedText, ((TMP_Text)__instance.m_CardCollectedText).transform.parent);
				((TMP_Text)commonText).text = "";
				((TMP_Text)rareText).text = "";
				((TMP_Text)epicText).text = "";
				((TMP_Text)legendaryText).text = "";
				sanityText = Object.Instantiate<TextMeshProUGUI>(__instance.m_CardCollectedText, ((TMP_Text)__instance.m_CardCollectedText).transform.parent);
				RectTransform rectTransform = ((TMP_Text)sanityText).rectTransform;
				rectTransform.anchoredPosition += new Vector2(0f, -80f);
				ECardExpansionType expansionType = __instance.m_CollectionAlbum.m_ExpansionType;
				if ((int)expansionType == 2)
				{
					((TMP_Text)sanityText).text = "";
					if (Plugin.m_SessionHandler.GetSlotData().Goal == 2)
					{
						((TMP_Text)sanityText).text = $"Sold {Plugin.m_SaveManager.GetExpansionChecks(expansionType)} / {Plugin.m_SaveManager.getTotalExpansionChecks(expansionType)} {((object)(ECardExpansionType)(ref expansionType)).ToString()} Checks";
					}
					return;
				}
				if (Plugin.m_SessionHandler.GetSlotData().CardSanity > 0)
				{
					((TMP_Text)sanityText).text = $"{Plugin.m_SaveManager.GetExpansionChecks(expansionType)} / {Plugin.m_SaveManager.getTotalExpansionChecks(expansionType)} {((object)(ECardExpansionType)(ref expansionType)).ToString()} Checks";
					return;
				}
				updatepackText(expansionType);
				RectTransform rectTransform2 = ((TMP_Text)commonText).rectTransform;
				rectTransform2.anchoredPosition += new Vector2(-100f, -60f);
				RectTransform rectTransform3 = ((TMP_Text)rareText).rectTransform;
				rectTransform3.anchoredPosition += new Vector2(100f, -60f);
				RectTransform rectTransform4 = ((TMP_Text)epicText).rectTransform;
				rectTransform4.anchoredPosition += new Vector2(-100f, -120f);
				RectTransform rectTransform5 = ((TMP_Text)legendaryText).rectTransform;
				rectTransform5.anchoredPosition += new Vector2(100f, -120f);
			}
		}

		[HarmonyPatch(typeof(CollectionBinderUI))]
		public class SetCardCollected
		{
			[HarmonyPatch("SetCardCollected")]
			[HarmonyPostfix]
			private static void Postfix(CollectionBinderUI __instance, int current, ECardExpansionType expansionType)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Invalid comparison between Unknown and I4
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				if ((int)expansionType == 2)
				{
					((TMP_Text)sanityText).text = "";
					if (Plugin.m_SessionHandler.GetSlotData().Goal == 2)
					{
						((TMP_Text)sanityText).text = $"Sold {Plugin.m_SaveManager.GetExpansionChecks(expansionType)} / {Plugin.m_SaveManager.getTotalExpansionChecks(expansionType)} {((object)(ECardExpansionType)(ref expansionType)).ToString()} Checks";
					}
					((TMP_Text)commonText).text = "";
					((TMP_Text)rareText).text = "";
					((TMP_Text)epicText).text = "";
					((TMP_Text)legendaryText).text = "";
				}
				else if (Plugin.m_SessionHandler.GetSlotData().CardSanity > 0)
				{
					ECardExpansionType expansionType2 = __instance.m_CollectionAlbum.m_ExpansionType;
					((TMP_Text)sanityText).text = $"{Plugin.m_SaveManager.GetExpansionChecks(expansionType2)} / {Plugin.m_SaveManager.getTotalExpansionChecks(expansionType2)} {((object)(ECardExpansionType)(ref expansionType2)).ToString()} Checks";
				}
				else
				{
					ECardExpansionType expansionType3 = __instance.m_CollectionAlbum.m_ExpansionType;
					updatepackText(expansionType3);
				}
			}
		}

		[HarmonyPatch(typeof(CollectionBinderUI))]
		public class CardText
		{
			[HarmonyPatch("OnPressSwitchExpansion")]
			[HarmonyPostfix]
			private static void Postfix(CollectionBinderUI __instance, int expansionIndex)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Invalid comparison between Unknown and I4
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: 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)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				ECardExpansionType val = (ECardExpansionType)expansionIndex;
				if (Plugin.m_SessionHandler.GetSlotData().Goal == 2 && (int)val == 2)
				{
					((TMP_Text)sanityText).text = "";
					if (Plugin.m_SessionHandler.GetSlotData().Goal == 2)
					{
						((TMP_Text)sanityText).text = $"Sold {Plugin.m_SaveManager.GetExpansionChecks(val)} / {Plugin.m_SaveManager.getTotalExpansionChecks(val)} {((object)(ECardExpansionType)(ref val)).ToString()} Checks";
					}
					((TMP_Text)commonText).text = "";
					((TMP_Text)rareText).text = "";
					((TMP_Text)epicText).text = "";
					((TMP_Text)legendaryText).text = "";
				}
				else if (Plugin.m_SessionHandler.GetSlotData().CardSanity > 0)
				{
					ECardExpansionType expansionType = __instance.m_CollectionAlbum.m_ExpansionType;
					((TMP_Text)sanityText).text = $"{Plugin.m_SaveManager.GetExpansionChecks(expansionType)} / {Plugin.m_SaveManager.getTotalExpansionChecks(expansionType)} {((object)(ECardExpansionType)(ref expansionType)).ToString()} Checks";
				}
				else
				{
					ECardExpansionType expansionType2 = __instance.m_CollectionAlbum.m_ExpansionType;
					updatepackText(expansionType2);
				}
			}
		}

		[HarmonyPatch(typeof(BinderPageGrp))]
		public class single
		{
			[HarmonyPatch("SetSingleCard")]
			[HarmonyPostfix]
			private static void SetSingleCard(BinderPageGrp __instance, int cardIndex, CardData cardData, int cardCount, ECollectionSortingType sortingType)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Invalid comparison between Unknown and I4
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Invalid comparison between Unknown and I4
				int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
				if (CPlayerData.GetIsCardCollectedList(cardData.expansionType, (int)cardData.expansionType == 2)[cardSaveIndex] && cardCount <= 0 && cardData != null)
				{
					if ((int)cardData.expansionType != 2)
					{
						SetCardUIAlpha(__instance.m_CardList[cardIndex], 0.35f);
						__instance.m_CardList[cardIndex].m_CardUI.SetCardUI(cardData);
						__instance.m_CardList[cardIndex].SetVisibility(true);
						((TMP_Text)__instance.m_CardList[cardIndex].m_CardCountText).text = "Check Collected";
						__instance.m_CardList[cardIndex].SetCardCountTextVisibility(true);
					}
				}
				else
				{
					SetCardUIAlpha(__instance.m_CardList[cardIndex], 1f);
				}
			}
		}

		[HarmonyPatch(typeof(CollectionBinderFlipAnimCtrl))]
		public class onclick
		{
			[HarmonyPatch("OnMouseButtonUp")]
			[HarmonyPrefix]
			private static bool Prefix(CollectionBinderFlipAnimCtrl __instance)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance.m_CurrentRaycastedInteractableCard3d == (Object)null)
				{
					return true;
				}
				CardData cardData = __instance.m_CurrentRaycastedInteractableCard3d.m_Card3dUI.m_CardUI.GetCardData();
				int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
				int cardAmountByIndex = CPlayerData.GetCardAmountByIndex(cardSaveIndex, cardData.expansionType, cardData.isDestiny);
				if (cardAmountByIndex <= 0)
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(CollectionBinderFlipAnimCtrl))]
		public class onrightclick
		{
			[HarmonyPatch("OnRightMouseButtonUp")]
			[HarmonyPrefix]
			private static bool Prefix(CollectionBinderFlipAnimCtrl __instance)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance.m_CurrentRaycastedInteractableCard3d == (Object)null)
				{
					return true;
				}
				CardData cardData = __instance.m_CurrentRaycastedInteractableCard3d.m_Card3dUI.m_CardUI.GetCardData();
				int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
				int cardAmountByIndex = CPlayerData.GetCardAmountByIndex(cardSaveIndex, cardData.expansionType, cardData.isDestiny);
				if (cardAmountByIndex <= 0)
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(CollectionBinderFlipAnimCtrl))]
		public class Anim
		{
			[HarmonyPatch("UpdateBinderAllCardUI")]
			[HarmonyPostfix]
			private static void UpdateBinderAllCardUI(CollectionBinderFlipAnimCtrl __instance, int binderIndex, int pageIndex)
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Invalid comparison between Unknown and I4
				//IL_0062: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Expected O, but got Unknown
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: 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_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				if (pageIndex <= 0 || pageIndex > __instance.m_MaxIndex)
				{
					return;
				}
				for (int i = 0; i < __instance.m_BinderPageGrpList[binderIndex].m_CardList.Count; i++)
				{
					int num = (pageIndex - 1) * 12 + i;
					if (num >= __instance.m_SortedIndexList.Count)
					{
						int num2 = __instance.m_SortedIndexList[num];
						bool isDestiny = false;
						if ((int)__instance.m_ExpansionType == 2 && num2 >= InventoryBase.GetShownMonsterList(__instance.m_ExpansionType).Count * CPlayerData.GetCardAmountPerMonsterType(__instance.m_ExpansionType, true))
						{
							isDestiny = true;
							num2 -= InventoryBase.GetShownMonsterList(__instance.m_ExpansionType).Count * CPlayerData.GetCardAmountPerMonsterType(__instance.m_ExpansionType, true);
						}
						CardData val = new CardData();
						val.monsterType = CPlayerData.GetMonsterTypeFromCardSaveIndex(num2, __instance.m_ExpansionType);
						val.isFoil = num2 % CPlayerData.GetCardAmountPerMonsterType(__instance.m_ExpansionType, true) >= CPlayerData.GetCardAmountPerMonsterType(__instance.m_ExpansionType, false);
						val.borderType = (ECardBorderType)(num2 % CPlayerData.GetCardAmountPerMonsterType(__instance.m_ExpansionType, false));
						val.isDestiny = isDestiny;
						val.expansionType = __instance.m_ExpansionType;
						__instance.m_BinderPageGrpList[binderIndex].SetSingleCard(i, val, 0, __instance.m_SortingType);
					}
				}
			}
		}

		[HarmonyPatch(typeof(BinderPageGrp))]
		public class set
		{
			[HarmonyPatch("SetCard")]
			[HarmonyPostfix]
			private static void PostFix(BinderPageGrp __instance, int index, ECardExpansionType cardExpansionType, bool isDimensionCard)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Invalid comparison between Unknown and I4
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Expected O, but got Unknown
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: 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_007c: 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_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Invalid comparison between Unknown and I4
				for (int i = 0; i < __instance.m_CardList.Count; i++)
				{
					int num = (index - 1) * CPlayerData.GetCardAmountPerMonsterType(cardExpansionType, true) + i;
					int cardAmountByIndex = CPlayerData.GetCardAmountByIndex(num, cardExpansionType, isDimensionCard);
					if (CPlayerData.GetIsCardCollectedList(cardExpansionType, isDimensionCard)[num] && cardAmountByIndex <= 0)
					{
						bool isDestiny = false;
						if ((int)cardExpansionType != 2)
						{
							CardData val = new CardData();
							ECardBorderType borderType = (ECardBorderType)(i % CPlayerData.GetCardAmountPerMonsterType(cardExpansionType, false));
							val.monsterType = CPlayerData.GetMonsterTypeFromCardSaveIndex(num, cardExpansionType);
							val.borderType = borderType;
							val.expansionType = cardExpansionType;
							val.isDestiny = isDestiny;
							val.isNew = false;
							val.isFoil = i >= CPlayerData.GetCardAmountPerMonsterType(cardExpansionType, false);
							__instance.m_CardList[i].m_CardUI.SetCardUI(val);
							__instance.m_CardList[i].SetVisibility(true);
							((TMP_Text)__instance.m_CardList[i].m_CardCountText).text = (((int)cardExpansionType == 2) ? "Ghost Found" : "Check Collected");
							__instance.m_CardList[i].SetCardCountTextVisibility(true);
							SetCardUIAlpha(__instance.m_CardList[i], 0.35f);
						}
					}
				}
			}
		}

		private static TextMeshProUGUI sanityText;

		private static TextMeshProUGUI commonText;

		private static TextMeshProUGUI rareText;

		private static TextMeshProUGUI epicText;

		private static TextMeshProUGUI legendaryText;

		private static void updatepackText(ECardExpansionType eCardExpansionType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)eCardExpansionType == 0)
			{
				((TMP_Text)commonText).text = $"{Plugin.m_SaveManager.GetSentChecks((ECollectionPackType)0)} / {Plugin.m_SessionHandler.GetSlotData().ChecksPerPack} Basic Pack Checks";
				((TMP_Text)rareText).text = $"{Plugin.m_SaveManager.GetSentChecks((ECollectionPackType)1)} / {Plugin.m_SessionHandler.GetSlotData().ChecksPerPack} Rare Pack Checks";
				((TMP_Text)epicText).text = $"{Plugin.m_SaveManager.GetSentChecks((ECollectionPackType)2)} / {Plugin.m_SessionHandler.GetSlotData().ChecksPerPack} Epic Pack Checks";
				((TMP_Text)legendaryText).text = $"{Plugin.m_SaveManager.GetSentChecks((ECollectionPackType)3)} / {Plugin.m_SessionHandler.GetSlotData().ChecksPerPack} Legendary Pack Checks";
			}
			else
			{
				((TMP_Text)commonText).text = $"{Plugin.m_SaveManager.GetSentChecks((ECollectionPackType)4)} / {Plugin.m_SessionHandler.GetSlotData().ChecksPerPack} Destiny Basic Pack Checks";
				((TMP_Text)rareText).text = $"{Plugin.m_SaveManager.GetSentChecks((ECollectionPackType)5)} / {Plugin.m_SessionHandler.GetSlotData().ChecksPerPack} Destiny Rare Pack Checks";
				((TMP_Text)epicText).text = $"{Plugin.m_SaveManager.GetSentChecks((ECollectionPackType)6)} / {Plugin.m_SessionHandler.GetSlotData().ChecksPerPack} Destiny Epic Pack Checks";
				((TMP_Text)legendaryText).text = $"{Plugin.m_SaveManager.GetSentChecks((ECollectionPackType)7)} / {Plugin.m_SessionHandler.GetSlotData().ChecksPerPack} Destiny Legendary Pack Checks";
			}
			((TMP_Text)sanityText).text = "";
		}

		private static void SetCardUIAlpha(Card3dUIGroup cardUI, float alpha)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cardUI == (Object)null)
			{
				return;
			}
			Image[] array = (Image[])(object)new Image[5]
			{
				cardUI.m_CardUI.m_CardBGImage,
				cardUI.m_CardUI.m_CardBorderImage,
				cardUI.m_CardUI.m_MonsterImage,
				cardUI.m_CardUI.m_MonsterMaskImage,
				cardUI.m_CardUI.m_RarityImage
			};
			Material val = new Material(((Graphic)cardUI.m_CardUI.m_CardBackImage).material);
			val.SetColor("_Color", new Color(1f, 1f, 1f, 0f));
			((Graphic)cardUI.m_CardUI.m_CardBackImage).material = val;
			Image[] array2 = array;
			foreach (Image val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Material val3 = new Material(((Graphic)val2).material);
					val3.SetColor("_Color", new Color(1f, 1f, 1f, alpha));
					((Graphic)val2).material = val3;
				}
			}
			TextMeshProUGUI[] componentsInChildren = ((Component)cardUI.m_CardUI).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val4 in componentsInChildren)
			{
				Color color = ((Graphic)val4).color;
				color.a = 0.5f;
				color.r /= 2f;
				color.b /= 2f;
				color.g /= 2f;
				((Graphic)val4).color = color;
			}
			((Graphic)cardUI.m_CardCountText).color = Color.white;
		}

		private static void DisableInteractability(CardUI cardUI)
		{
			Image[] componentsInChildren = ((Component)cardUI).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				((Graphic)val).raycastTarget = false;
			}
			TextMeshProUGUI[] componentsInChildren2 = ((Component)cardUI).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val2 in componentsInChildren2)
			{
				((Graphic)val2).raycastTarget = false;
			}
		}
	}
	public class CardOpeningPatches
	{
		[HarmonyPatch(typeof(CardOpeningSequence), "GetPackContent")]
		private class Patch_TargetMethod
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: Expected O, but got Unknown
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Expected O, but got Unknown
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Expected O, but got Unknown
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Expected O, but got Unknown
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Expected O, but got Unknown
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Expected O, but got Unknown
				List<CodeInstruction> list = new List<CodeInstruction>(instructions);
				Dictionary<float, float> dictionary = new Dictionary<float, float>
				{
					{ 5f, 0.45f },
					{ 20f, 0f },
					{ 8f, 0.12f },
					{ 4f, 0.26f },
					{ 1f, 0.29f },
					{ 0.25f, 0.5f }
				};
				HashSet<float> hashSet = new HashSet<float>();
				MethodInfo methodInfo = AccessTools.Method(typeof(Plugin), "getNumLuckItems", (Type[])null, (Type[])null);
				for (int i = 0; i < list.Count - 1; i++)
				{
					CodeInstruction val = list[i];
					if (val.opcode == OpCodes.Ldc_R4 && dictionary.TryGetValue((float)val.operand, out var value))
					{
						float item = (float)val.operand;
						if (!hashSet.Contains(item) && list[i + 1].opcode.Name.StartsWith("stloc"))
						{
							object operand = list[i + 1].operand;
							list.InsertRange(i + 2, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[6]
							{
								new CodeInstruction(OpCodes.Ldloc, operand),
								new CodeInstruction(OpCodes.Call, (object)methodInfo),
								new CodeInstruction(OpCodes.Ldc_R4, (object)value),
								new CodeInstruction(OpCodes.Mul, (object)null),
								new CodeInstruction(OpCodes.Add, (object)null),
								new CodeInstruction(OpCodes.Stloc, operand)
							});
							hashSet.Add(item);
							i += 6;
						}
					}
				}
				return list;
			}
		}
	}
	public class CustomerPatches
	{
		[HarmonyPatch(typeof(Customer), "EvaluateFinishScanItem")]
		public static class FinishScan
		{
			[HarmonyPostfix]
			public static void Postf