using System;
using System.Collections;
using System.Collections.Generic;
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.Enums;
using Archipelago.MultiClient.Net.Helpers;
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 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.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+a9e83673d04db92b1b0a59e4e3c6006510262a1c")]
[assembly: AssemblyProduct("Ap Client For TCG Sim")]
[assembly: AssemblyTitle("ApClient")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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;
		}
	}
}
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_003a: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown((KeyCode)104))
			{
				CSingleton<PriceChangeManager>.Instance.EvaluatePriceChange();
				CSingleton<PriceChangeManager>.Instance.EvaluatePriceCrash();
				CPlayerData.UpdateItemPricePercentChange();
				CPlayerData.UpdatePastCardPricePercentChange();
			}
			if (Input.GetKeyDown(Settings.Instance.MyHotkey.Value))
			{
				showGUI = !showGUI;
			}
		}
	}
}
namespace ApClient
{
	public class APClientSaveManager
	{
		private APSaveData aPSaveData;

		public APClientSaveManager()
		{
			aPSaveData = new APSaveData();
			Clear();
		}

		public void Clear()
		{
			aPSaveData.ProcessedIndex = 0;
			aPSaveData.MoneyMultiplier = 1f;
			aPSaveData.Luck = 0;
			aPSaveData.newCards = new List<int>();
			for (int i = 1; i < 122; i++)
			{
				aPSaveData.newCards.Add(i);
			}
		}

		public void setSeed(string seed)
		{
			aPSaveData.seed = seed;
		}

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

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

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

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

		public float GetMoneyMult()
		{
			return aPSaveData.MoneyMultiplier;
		}

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

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

		public List<int> GetIncompleteCards()
		{
			return aPSaveData.newCards;
		}

		public void CompleteCardId(int id)
		{
			aPSaveData.newCards.Remove(id);
		}

		public void setIncompleteCards(List<int> list)
		{
			aPSaveData.newCards = list;
		}

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

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

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

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

		public void Save(int saveSlotIndex)
		{
			Directory.CreateDirectory(GetBaseDirectory() + "/Saves/");
			Plugin.Log("AP Save saveSlotIndex " + saveSlotIndex);
			CSaveLoad.m_SavedGame = CGameData.instance;
			try
			{
				string text = JsonUtility.ToJson((object)CSaveLoad.m_SavedGame);
				string text2 = JsonConvert.SerializeObject((object)aPSaveData.newCards);
				string contents = text.TrimEnd('}') + $", \"processedItems\": \"{aPSaveData.ProcessedIndex}\", \"newCardIds\": {text2} , \"maxMoney\": \"{aPSaveData.MoneyMultiplier}\", \"luck\": \"{aPSaveData.Luck}\"}}";
				File.WriteAllText(getJsonSavePath(), contents);
			}
			catch
			{
				Debug.Log((object)"Error saving JSON");
			}
		}

		public bool Load()
		{
			string gdSavePath = getGdSavePath();
			string jsonSavePath = getJsonSavePath();
			bool flag = false;
			if (File.Exists(jsonSavePath))
			{
				try
				{
					string text = File.ReadAllText(jsonSavePath);
					if (!(text == "") && text != null)
					{
						Match match = Regex.Match(text, "\"maxMoney\":\\s*\"([^\"]*)\"");
						if (match.Success)
						{
							string value = match.Groups[1].Value;
							int.TryParse(value, out var result);
							aPSaveData.MoneyMultiplier = result;
							Debug.Log((object)$"Extracted maxMoney: {result}");
						}
						text = Regex.Replace(text, ",\\s*\"maxMoney\":\\s*\"[^\"]*\"", "");
						match = Regex.Match(text, "\"luck\":\\s*\"([^\"]*)\"");
						if (match.Success)
						{
							string value2 = match.Groups[1].Value;
							int.TryParse(value2, out var result2);
							aPSaveData.Luck = result2;
							Debug.Log((object)$"Extracted luck: {result2}");
						}
						text = Regex.Replace(text, ",\\s*\"luck\":\\s*\"[^\"]*\"", "");
						Match match2 = Regex.Match(text, "\"newCardIds\"\\s*:\\s*\\{(.*?)\\}\\s*(,|})", RegexOptions.Singleline);
						if (match2.Success)
						{
							string text2 = "{" + match2.Groups[1].Value + "}";
							aPSaveData.newCards = JsonConvert.DeserializeObject<List<int>>(text2);
						}
						string text3 = Regex.Replace(text, "\"newCardIds\"\\s*:\\s*\\{(.*?)\\}\\s*(,|})", "", RegexOptions.Singleline);
						match = Regex.Match(text, "\"processedItems\":\\s*\"([^\"]*)\"");
						if (match.Success)
						{
							string value3 = match.Groups[1].Value;
							int.TryParse(value3, out var result3);
							aPSaveData.ProcessedIndex = result3;
							Debug.Log((object)$"Extracted processedItems: {result3}");
						}
						text = Regex.Replace(text, ",\\s*\"processedItems\":\\s*\"[^\"]*\"", "");
						Debug.Log((object)"Modified JSON before deserialization");
						CSaveLoad.m_SavedGame = JsonUtility.FromJson<CGameData>(text);
						return true;
					}
					flag = true;
				}
				catch
				{
					flag = true;
				}
			}
			return false;
		}
	}
	public class CoroutineRunner : MonoBehaviour
	{
		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 class ItemHandler
	{
		private Coroutine cashOnlyCoroutine;

		private float remainingTime = 0f;

		private bool timerRunning = false;

		public bool cashOnly = false;

		public void processNewItem(ItemInfo itemReceived)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Expected O, but got Unknown
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Expected O, but got Unknown
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b13: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b18: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b28: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b34: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b39: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b3e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b40: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b4c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b59: Expected O, but got Unknown
			Plugin.Log(itemReceived.ItemName);
			if ((int)itemReceived.ItemId == ExpansionMapping.warehouseKey)
			{
				CSingleton<UnlockRoomManager>.Instance.SetUnlockWarehouseRoom(true);
				AchievementManager.OnShopLotBUnlocked();
				CPlayerData.m_GameReportDataCollect.upgradeCost -= 5000f;
				CPlayerData.m_GameReportDataCollectPermanent.upgradeCost -= 5000f;
				SoundManager.PlayAudio("SFX_CustomerBuy", 0.6f, 1f);
				PopupTextPatches.ShowCustomText("Warehouse Key Found");
			}
			else 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));
				CPlayerData.AddCard(cardRoller(collectionPackType), 1);
			}
			else if ((int)itemReceived.ItemId == TrashMapping.randomNewCard)
			{
				CardData val = RandomNewCard();
				Plugin.Log($"Card is: {val.monsterType} and {val.expansionType}");
				CPlayerData.AddCard(val, 1);
			}
			else if ((int)itemReceived.ItemId == TrashMapping.ProgressiveCustomerMoney)
			{
				Plugin.m_SaveManager.IncreaseMoneyMult();
			}
			else if ((int)itemReceived.ItemId == TrashMapping.IncreaseCardLuck)
			{
				Plugin.m_SaveManager.IncreaseLuck();
			}
			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)
					{
						return;
					}
					if (LicenseMapping.getKeyValue((int)itemReceived.ItemId).Key != -1)
					{
						PopupTextPatches.ShowCustomText("New License Unlocked");
						KeyValuePair<int, (int, string, int, int, EItemType)> keyValue = LicenseMapping.getKeyValue((int)itemReceived.ItemId, Plugin.m_SessionHandler.itemCount((int)itemReceived.ItemId));
						RestockItemPanelUI val2 = null;
						RestockItemPanelUI[] array = Object.FindObjectsOfType<RestockItemPanelUI>();
						RestockItemPanelUI[] array2 = array;
						foreach (RestockItemPanelUI val3 in array2)
						{
							if (val3.GetIndex() == (float)keyValue.Key)
							{
								val2 = val3;
								break;
							}
						}
						if (!((Object)(object)val2 == (Object)null))
						{
							RestockItemPanelUIPatches.runLicenseBtnLogic(val2, hasItem: true, keyValue.Key);
							Plugin.Log($"Recieved Item While panel was open: {(int)itemReceived.ItemId} and {keyValue.Key}");
						}
					}
					else if ((int)itemReceived.ItemId == ExpansionMapping.progressiveA)
					{
						ExpansionShopUIScreen val4 = Object.FindObjectOfType<ExpansionShopUIScreen>();
						if ((Object)(object)val4 != (Object)null)
						{
							FieldInfo field2 = typeof(ExpansionShopUIScreen).GetField("m_IsShopB", BindingFlags.Instance | BindingFlags.NonPublic);
							if (!(bool)field2.GetValue(val4))
							{
								ExpansionShopPanelUI val5 = val4.m_ExpansionShopPanelUIList[Plugin.m_SessionHandler.itemCount((int)itemReceived.ItemId) - 1];
								val5.m_LockPurchaseBtn.gameObject.SetActive(false);
								val5.m_PurchasedBtn.gameObject.SetActive(false);
							}
						}
					}
					else if ((int)itemReceived.ItemId == ExpansionMapping.progressiveB)
					{
						ExpansionShopUIScreen val6 = Object.FindObjectOfType<ExpansionShopUIScreen>();
						if (!((Object)(object)val6 != (Object)null))
						{
							return;
						}
						FieldInfo field3 = typeof(ExpansionShopUIScreen).GetField("m_IsShopB", BindingFlags.Instance | BindingFlags.NonPublic);
						if (!(bool)field3.GetValue(val6))
						{
							return;
						}
						ExpansionShopPanelUI val7 = val6.m_ExpansionShopPanelUIList[Plugin.m_SessionHandler.itemCount((int)itemReceived.ItemId) - 1];
						FieldInfo field4 = typeof(ExpansionShopPanelUI).GetField("m_LevelRequired", BindingFlags.Instance | BindingFlags.NonPublic);
						if (!(field4 == null))
						{
							int num = (int)field4.GetValue(val7);
							if (CPlayerData.m_ShopLevel + 1 < num)
							{
								val7.m_LockPurchaseBtn.gameObject.SetActive(false);
								val7.m_PurchasedBtn.gameObject.SetActive(false);
								((Component)val7.m_LevelRequirementText).gameObject.SetActive(false);
							}
							else
							{
								((TMP_Text)val7.m_LevelRequirementText).text = $"Shop Level {val7.m_LevelRequired} Required";
							}
						}
					}
					else if (EmployeeMapping.getKeyValue((int)itemReceived.ItemId).Key != -1)
					{
						KeyValuePair<int, (int, string, int)> keyValue2 = EmployeeMapping.getKeyValue((int)itemReceived.ItemId);
						Plugin.Log($"worker recieved id: {EmployeeMapping.getKeyValue((int)itemReceived.ItemId).Key}");
						HireWorkerScreen val8 = Object.FindObjectOfType<HireWorkerScreen>();
						HireWorkerPanelUI[] array3 = Object.FindObjectsOfType<HireWorkerPanelUI>();
						HireWorkerPanelUI val9 = null;
						HireWorkerPanelUI[] array4 = array3;
						foreach (HireWorkerPanelUI val10 in array4)
						{
							FieldInfo field5 = typeof(HireWorkerPanelUI).GetField("m_Index", BindingFlags.Instance | BindingFlags.NonPublic);
							if (field5 == null)
							{
								return;
							}
							int num2 = (int)field5.GetValue(val10);
							if (num2 == keyValue2.Key)
							{
								val9 = val10;
								break;
							}
						}
						if (!((Object)(object)val9 == (Object)null))
						{
							Plugin.Log("detected Hire Worker Screen");
							Plugin.Log("Found Hire Worker Panel");
							val9.m_HiredText.SetActive(false);
							val9.m_PurchaseBtn.SetActive(true);
							Plugin.Log($"Recieved Worker While panel was open: {(int)itemReceived.ItemId}");
						}
					}
					else if (FurnatureMapping.getKeyValue((int)itemReceived.ItemId).Key != -1)
					{
						KeyValuePair<int, (int, string, int)> keyValue3 = FurnatureMapping.getKeyValue((int)itemReceived.ItemId, Plugin.m_SessionHandler.itemCount((int)itemReceived.ItemId));
						FurnitureShopPanelUI val11 = null;
						FurnitureShopPanelUI[] array5 = Object.FindObjectsOfType<FurnitureShopPanelUI>();
						FurnitureShopPanelUI[] array6 = array5;
						foreach (FurnitureShopPanelUI val12 in array6)
						{
							FieldInfo field6 = typeof(FurnitureShopPanelUI).GetField("m_Index", BindingFlags.Instance | BindingFlags.NonPublic);
							if (field6 == null)
							{
								return;
							}
							int num3 = (int)field6.GetValue(val12);
							if (num3 == keyValue3.Key)
							{
								val11 = val12;
								break;
							}
						}
						if (!((Object)(object)val11 == (Object)null))
						{
							FurnaturePatches.EnableFurnature(val11, keyValue3.Key);
						}
					}
					else
					{
						if ((int)itemReceived.ItemId != CardMapping.ghostProgressive)
						{
							return;
						}
						bool flag = false;
						int num4 = 0;
						List<bool> isCardCollectedList = CPlayerData.GetIsCardCollectedList((ECardExpansionType)2, flag);
						num4 = isCardCollectedList.FindAll((bool i) => i).Count;
						if (num4 >= 36)
						{
							flag = true;
							isCardCollectedList = CPlayerData.GetIsCardCollectedList((ECardExpansionType)2, flag);
							num4 += isCardCollectedList.FindAll((bool i) => i).Count;
						}
						if (Plugin.m_SessionHandler.GetSlotData().Goal == 2 && Plugin.m_SessionHandler.GetSlotData().GhostGoalAmount <= num4)
						{
							Plugin.m_SessionHandler.SendGoalCompletion();
							PopupTextPatches.ShowCustomText($"Congrats! You Collected {num4} Ghost Cards and Completed Your Goal!");
						}
						List<EMonsterType> shownMonsterList = InventoryBase.GetShownMonsterList((ECardExpansionType)2);
						bool isFoil = false;
						int index = 0;
						for (int m = 0; m < shownMonsterList.Count; m++)
						{
							int num5 = m * CPlayerData.GetCardAmountPerMonsterType((ECardExpansionType)2, true) + 5;
							if (isCardCollectedList[num5])
							{
								num5 += CPlayerData.GetCardAmountPerMonsterType((ECardExpansionType)2, false);
								if (!isCardCollectedList[num5])
								{
									isFoil = true;
									index = m;
									break;
								}
								continue;
							}
							index = m;
							break;
						}
						CPlayerData.AddCard(new CardData
						{
							isFoil = isFoil,
							isDestiny = flag,
							borderType = (ECardBorderType)5,
							monsterType = shownMonsterList[index],
							expansionType = (ECardExpansionType)2,
							isChampionCard = false,
							isNew = true
						}, 1);
					}
				}
			}
		}

		public CardData RandomNewCard()
		{
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Expected O, but got Unknown
			Plugin.Log("random new card");
			int border_sanity = 5;
			bool flag = true;
			if (Plugin.m_SessionHandler.GetSlotData().CardSanity != 0)
			{
				border_sanity = Plugin.m_SessionHandler.GetSlotData().BorderInSanity;
				flag = Plugin.m_SessionHandler.GetSlotData().FoilInSanity;
			}
			List<int> incompleteCards = Plugin.m_SaveManager.GetIncompleteCards();
			if (incompleteCards.Count == 0)
			{
				Plugin.m_SaveManager.setIncompleteCards(PlayerDataPatches.GetValidTypeIdsForSanity());
				incompleteCards = Plugin.m_SaveManager.GetIncompleteCards();
			}
			int num = incompleteCards[Random.Range(0, incompleteCards.Count)];
			int index = (num - 1) * CPlayerData.GetCardAmountPerMonsterType((ECardExpansionType)0, true);
			List<int> list = (from x in CPlayerData.GetIsCardCollectedList((ECardExpansionType)0, false).GetRange(index, flag ? 12 : 6).Select((bool val, int idx) => new { val, idx })
				where !x.val && x.idx % 6 <= border_sanity
				select x.idx).ToList();
			Plugin.Log($"border <= {border_sanity}");
			Plugin.Log(string.Join(", ", list));
			index = (num - 1) * CPlayerData.GetCardAmountPerMonsterType((ECardExpansionType)1, true);
			List<int> list2 = (from x in CPlayerData.GetIsCardCollectedList((ECardExpansionType)1, false).GetRange(index, flag ? 12 : 6).Select((bool val, int idx) => new { val, idx })
				where !x.val && x.idx % 6 <= border_sanity
				select x.idx).ToList();
			int num2 = 0;
			bool flag2 = false;
			if (list.Count > 0)
			{
				num2 = list[Random.Range(0, list.Count)];
			}
			else
			{
				if (list2.Count <= 0 || Plugin.m_SessionHandler.GetSlotData().CardSanity <= 4)
				{
					Plugin.Log($"You have collected all Cards for {(object)(EMonsterType)num}");
					Plugin.m_SaveManager.CompleteCardId(num);
					return cardRoller((ECollectionPackType)7);
				}
				num2 = list2[Random.Range(0, list2.Count)];
				flag2 = true;
				if (list2.Count == 1)
				{
					Plugin.m_SaveManager.CompleteCardId(num);
				}
			}
			ECardExpansionType val2 = (ECardExpansionType)(flag2 ? 1 : 0);
			return new CardData
			{
				isFoil = (num2 > 5),
				isDestiny = flag2,
				borderType = CPlayerData.GetCardBorderType(num2 % 6, val2),
				monsterType = (EMonsterType)num,
				expansionType = val2,
				isChampionCard = false,
				isNew = true
			};
		}

		private static 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, 7),
				monsterType = (EMonsterType)Random.Range(0, 122),
				expansionType = val,
				isChampionCard = false,
				isNew = true
			};
		}

		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.1.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();

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

		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()
		{
			Log($"Luck: {m_SaveManager.GetLuck()}");
			return m_SaveManager.GetLuck();
		}

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

		public static CardData getNewCard()
		{
			return m_ItemHandler.RandomNewCard();
		}

		private void OnSceneLoad(Scene scene, LoadSceneMode mode)
		{
			Log(" Scene Load: " + ((Scene)(ref scene)).name);
			if (((Scene)(ref scene)).name == "Title")
			{
				m_SaveManager.Clear();
				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);
		}
	}
	public class SessionHandler
	{
		private class ItemCache
		{
			public ItemInfo info { get; set; }

			public int index { get; set; }
		}

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

			public static Func<string, string> <>9__13_0;

			public static Func<string, bool> <>9__13_1;

			public static Func<KeyValuePair<int, (int itemid, string name, int count, int locid, EItemType)>, int> <>9__19_0;

			public static SocketClosedHandler <>9__22_0;

			internal string <StrToList>b__13_0(string s)
			{
				return s.Trim();
			}

			internal bool <StrToList>b__13_1(string s)
			{
				int result;
				return int.TryParse(s, out result);
			}

			internal int <addStartingChecks>b__19_0(KeyValuePair<int, (int itemid, string name, int count, int locid, EItemType)> kvp)
			{
				return kvp.Value.count;
			}

			internal void <connect>b__22_0(string reason)
			{
				APGui.showGUI = true;
			}
		}

		private ArchipelagoSession session;

		private SlotData slotData = new SlotData();

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

		private LoginResult result = null;

		private Coroutine autoSaveCoroutine;

		private float remainingTime = 0f;

		private bool timerRunning = false;

		private int startingCounter = 200;

		private DeathLinkService deathLinkService = null;

		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)
		{
			return itemCount(id) > 0;
		}

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

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

		public bool isStartingItem(int id)
		{
			return id == Plugin.m_SessionHandler.GetSlotData().pg1IndexMapping[0] || id == Plugin.m_SessionHandler.GetSlotData().pg2IndexMapping[0] || id == Plugin.m_SessionHandler.GetSlotData().pg3IndexMapping[0];
		}

		public int[] startingids()
		{
			return new int[3]
			{
				Plugin.m_SessionHandler.GetSlotData().pg1IndexMapping[0],
				Plugin.m_SessionHandler.GetSlotData().pg2IndexMapping[0],
				Plugin.m_SessionHandler.GetSlotData().pg3IndexMapping[0]
			};
		}

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

		private IEnumerator AutoSaveTimerCoroutine()
		{
			for (timerRunning = true; remainingTime > 0f; remainingTime -= Time.deltaTime)
			{
				yield return null;
			}
			timerRunning = false;
		}

		private void addStartingChecks(List<int> mapping, int startingId)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			(int, string, int, int, EItemType) valueOrEmpty = LicenseMapping.getValueOrEmpty(mapping[0]);
			for (int i = 0; i < 8; i++)
			{
				int num = LicenseMapping.GetKeyValueFromType(valueOrEmpty.Item5).Min((KeyValuePair<int, (int itemid, string name, int count, int locid, EItemType)> kvp) => kvp.Value.count);
				LicenseMapping.mapping.Add(startingCounter + i, (-1, "Unknown", (i + 3) * num, startingId + i, valueOrEmpty.Item5));
			}
			startingCounter += 8;
			Plugin.Log($"Goal Amount for {valueOrEmpty.Item2} is {LicenseMapping.GetKeyValueFromType(valueOrEmpty.Item5).Count()}");
		}

		public void sendDeath()
		{
		}

		public void connect(string ip, string password, string slot)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_003b: 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_0046: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			APGui.state = "Connecting";
			session = ArchipelagoSessionFactory.CreateSession(ip, 38281);
			IArchipelagoSocketHelper socket = session.Socket;
			object obj = <>c.<>9__22_0;
			if (obj == null)
			{
				SocketClosedHandler val = delegate
				{
					APGui.showGUI = true;
				};
				<>c.<>9__22_0 = val;
				obj = (object)val;
			}
			socket.SocketClosed += (SocketClosedHandler)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
					});
				}
				else
				{
					Plugin.Log($"{receivedItemsHelper.Index} : {Plugin.m_SaveManager.GetProcessedIndex()}");
					if (Plugin.m_SaveManager.GetProcessedIndex() <= receivedItemsHelper.Index)
					{
						Plugin.m_SaveManager.IncreaseProcessedIndex();
						ItemInfo itemReceived = receivedItemsHelper.DequeueItem();
						Plugin.m_ItemHandler.processNewItem(itemReceived);
						if (receivedItemsHelper.Index % 25 == 0 && !timerRunning)
						{
							CSingleton<CGameManager>.Instance.SaveGameData(3);
							remainingTime += 60f;
							if (!timerRunning)
							{
								autoSaveCoroutine = ((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(AutoSaveTimerCoroutine());
							}
						}
					}
				}
			};
			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)
			{
				Plugin.m_SaveManager.setSeed(session.RoomState.Seed);
				LoginSuccessful val2 = (LoginSuccessful)result;
				string text = val2.SlotData.GetValueOrDefault("ModVersion").ToString();
				if (!text.Equals("0.1.0"))
				{
					APGui.state = "AP Expects Mod v" + text;
				}
				else
				{
					APGui.state = "Connected";
					Plugin.RunTitleInteractableSaveLogic();
				}
				slotData.CardSanity = int.Parse(val2.SlotData.GetValueOrDefault("CardSanity").ToString());
				slotData.Goal = int.Parse(val2.SlotData.GetValueOrDefault("Goal").ToString());
				slotData.ShopExpansionGoal = int.Parse(val2.SlotData.GetValueOrDefault("ShopExpansionGoal").ToString());
				slotData.ShopExpansionGoal = int.Parse(val2.SlotData.GetValueOrDefault("ShopExpansionGoal").ToString());
				slotData.LevelGoal = int.Parse(val2.SlotData.GetValueOrDefault("LevelGoal").ToString());
				slotData.GhostGoalAmount = int.Parse(val2.SlotData.GetValueOrDefault("GhostGoalAmount").ToString());
				slotData.TradesAreNew = val2.SlotData.GetValueOrDefault("BetterTrades").ToString() == "1";
				slotData.FoilInSanity = val2.SlotData.GetValueOrDefault("FoilInSanity").ToString() == "1";
				slotData.BorderInSanity = int.Parse(val2.SlotData.GetValueOrDefault("BorderInSanity").ToString());
				slotData.SellCheckAmount = int.Parse(val2.SlotData.GetValueOrDefault("SellCheckAmount").ToString());
				slotData.pg1IndexMapping = StrToList(val2.SlotData.GetValueOrDefault("ShopPg1Mapping").ToString());
				Plugin.Log(string.Join(", ", slotData.pg1IndexMapping));
				slotData.pg2IndexMapping = StrToList(val2.SlotData.GetValueOrDefault("ShopPg2Mapping").ToString());
				Plugin.Log(string.Join(", ", slotData.pg2IndexMapping));
				slotData.pg3IndexMapping = StrToList(val2.SlotData.GetValueOrDefault("ShopPg3Mapping").ToString());
				Plugin.Log(string.Join(", ", slotData.pg3IndexMapping));
				slotData.ttIndexMapping = StrToList(val2.SlotData.GetValueOrDefault("ShopTTMapping").ToString());
				Plugin.Log(string.Join(", ", slotData.ttIndexMapping));
				addStartingChecks(slotData.pg1IndexMapping, LicenseMapping.locs1Starting);
				Plugin.Log($"Mapping is {slotData.pg2IndexMapping.Count}");
				addStartingChecks(slotData.pg2IndexMapping, LicenseMapping.locs2Starting);
				addStartingChecks(slotData.pg3IndexMapping, LicenseMapping.locs3Starting);
				Settings.Instance.SaveNewConnectionInfo(ip, password, slot);
			}
		}

		public void ProcessCachedItems()
		{
			CPlayerData.SetUnlockItemLicense(slotData.pg1IndexMapping[0]);
			CPlayerData.SetUnlockItemLicense(slotData.pg2IndexMapping[0]);
			CPlayerData.SetUnlockItemLicense(slotData.pg3IndexMapping[0]);
			while (cachedItems.Any())
			{
				ItemCache itemCache = cachedItems.Dequeue();
				Plugin.Log($"{Plugin.m_SaveManager.GetProcessedIndex()} : {itemCache.index}");
				if (Plugin.m_SaveManager.GetProcessedIndex() > itemCache.index)
				{
					return;
				}
				Plugin.m_SaveManager.IncreaseProcessedIndex();
				Plugin.Log("Item on load " + itemCache.info.ItemName);
				Plugin.m_ItemHandler.processNewItem(itemCache.info);
			}
			cachedItems.Clear();
		}
	}
	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<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)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			this.plugin = plugin;
			StartingMoney = ((BaseUnityPlugin)plugin).Config.Bind<int>("1. GamePlay", "Starting Money", 1000, new ConfigDescription("The Amount of Money you Start With", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, int.MaxValue), Array.Empty<object>()));
			MyHotkey = ((BaseUnityPlugin)plugin).Config.Bind<KeyCode>("2. Hotkeys", "Toggle Connection Window", (KeyCode)289, "Press this key to op AP Connection GUI");
			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.1.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 && __instance.m_DueDayMax - CPlayerData.GetBill((EBillType)1).billDayPassed <= 0)
				{
					flag = true;
				}
				if (bill2 != null && __instance.m_DueDayMax - CPlayerData.GetBill((EBillType)2).billDayPassed <= 0)
				{
					flag = true;
				}
				if (bill3 != null && __instance.m_DueDayMax - CPlayerData.GetBill((EBillType)3).billDayPassed <= 0)
				{
					flag = true;
				}
				if (flag)
				{
					Plugin.m_SessionHandler.sendDeath();
				}
			}
		}
	}
	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.5f },
					{ 20f, 0.25f },
					{ 8f, 0.2f },
					{ 4f, 0.1f },
					{ 1f, 0.05f },
					{ 0.25f, 0.05f }
				};
				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 Postfix(Customer __instance)
			{
				if (Plugin.isCashOnly())
				{
					__instance.m_CustomerCash.SetIsCard(false);
					CSingleton<CustomerManager>.Instance.ResetCustomerExactChangeChance();
					__instance.m_CurrentQueueCashierCounter.SetCustomerPaidAmount(false, __instance.GetRandomPayAmount(__instance.m_TotalScannedItemCost));
				}
			}
		}

		[HarmonyPatch(typeof(Customer), "OnItemScanned")]
		public static class OnScan
		{
			[HarmonyPostfix]
			public static void Postfix(Item item)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Expected I4, but got Unknown
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected I4, but got Unknown
				//IL_0067: 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)
				CPlayerData.m_StockSoldList[(int)item.GetItemType()]++;
				Plugin.Log($"{item} has sold {CPlayerData.m_StockSoldList[(int)item.GetItemType()]} times");
				IEnumerable<KeyValuePair<int, (int, string, int, int, EItemType)>> enumerable = from i in LicenseMapping.GetKeyValueFromType(item.GetItemType())
					where i.Value.count <= CPlayerData.m_StockSoldList[(int)item.GetItemType()]
					select i;
				foreach (KeyValuePair<int, (int, string, int, int, EItemType)> item2 in enumerable)
				{
					Plugin.Log($"{item.GetItemType()} has {enumerable.Count()} goals left");
					Plugin.m_SessionHandler.CompleteLocationChecks(item2.Value.Item4);
				}
			}
		}

		[HarmonyPatch(typeof(Customer), "ActivateCustomer")]
		public static class Activate
		{
			[HarmonyPostfix]
			public static void Postfix(Customer __instance, bool canSpawnSmelly)
			{
				float maxMoney = __instance.m_MaxMoney;
				__instance.m_MaxMoney *= Plugin.m_SaveManager.GetMoneyMult();
				Plugin.Log($"Customer spawned with {__instance.m_MaxMoney} instead of {maxMoney}");
			}
		}

		[HarmonyPatch(typeof(CustomerTradeCardScreen), "SetCustomer")]
		public static class CustomerTradeScreen_SetCustomer_Transpiler
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
			{
				FieldInfo field_CardDataL = AccessTools.Field(typeof(CustomerTradeCardScreen), "m_CardData_L");
				MethodInfo originalGetCardData = AccessTools.Method(typeof(CPlayerData), "GetCardData", new Type[3]
				{
					typeof(int),
					typeof(ECardExpansionType),
					typeof(bool)
				}, (Type[])null);
				MethodInfo myCustomMethod = AccessTools.Method(typeof(Plugin), "getNewCard", (Type[])null, (Type[])null);
				MethodInfo controlTradesMethod = AccessTools.Method(typeof(Plugin), "OverrideTrades", (Type[])null, (Type[])null);
				List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
				Label skipCustom = il.DefineLabel();
				Label endIf = il.DefineLabel();
				bool patchApplied = false;
				for (int i = 0; i < codes.Count; i++)
				{
					CodeInstruction code = codes[i];
					int num;
					if (!patchApplied && code.opcode == OpCodes.Call)
					{
						object operand = code.operand;
						if (operand is MethodInfo mi)
						{
							num = ((mi == originalGetCardData) ? 1 : 0);
							goto IL_0193;
						}
					}
					num = 0;
					goto IL_0193;
					IL_0193:
					if (num != 0)
					{
						List<CodeInstruction> newInstructions = new List<CodeInstruction>
						{
							new CodeInstruction(OpCodes.Ldarg_2, (object)null),
							new CodeInstruction(OpCodes.Ldnull, (object)null),
							new CodeInstruction(OpCodes.Ceq, (object)null),
							new CodeInstruction(OpCodes.Brfalse_S, (object)skipCustom),
							new CodeInstruction(OpCodes.Call, (object)controlTradesMethod),
							new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
							new CodeInstruction(OpCodes.Ceq, (object)null),
							new CodeInstruction(OpCodes.Brtrue_S, (object)skipCustom),
							new CodeInstruction(OpCodes.Pop, (object)null),
							new CodeInstruction(OpCodes.Pop, (object)null),
							new CodeInstruction(OpCodes.Pop, (object)null),
							new CodeInstruction(OpCodes.Call, (object)myCustomMethod),
							new CodeInstruction(OpCodes.Br_S, (object)endIf)
						};
						CodeInstruction labelOriginal = new CodeInstruction(OpCodes.Nop, (object)null)
						{
							labels = new List<Label> { skipCustom }
						};
						newInstructions.Add(labelOriginal);
						foreach (CodeInstruction item in newInstructions)
						{
							yield return item;
						}
						yield return code;
						patchApplied = true;
						continue;
					}
					int num2;
					if (patchApplied && code.opcode == OpCodes.Stfld)
					{
						object operand = code.operand;
						if (operand is FieldInfo field)
						{
							num2 = ((field == field_CardDataL) ? 1 : 0);
							goto IL_042c;
						}
					}
					num2 = 0;
					goto IL_042c;
					IL_042c:
					if (num2 != 0)
					{
						code.labels.Add(endIf);
						yield return code;
						patchApplied = false;
					}
					else
					{
						yield return code;
					}
				}
			}
		}
	}
	public class EmployeePatches
	{
		[HarmonyPatch(typeof(HireWorkerPanelUI), "Init")]
		public class Init
		{
			private static void Postfix(HireWorkerPanelUI __instance, HireWorkerScreen hireWorkerScreen, int index)
			{
				Plugin.Log($"Employee Index: {index}");
				(int, string, int) valueOrDefault = EmployeeMapping.mapping.GetValueOrDefault(index, (-1, "", -1));
				((TMP_Text)__instance.m_LevelRequirementText).text = "Requires AP Worker Unlock";
				if (valueOrDefault.Item3 != -1 && Plugin.m_SessionHandler.hasItem(valueOrDefault.Item1))
				{
					((Component)__instance.m_LevelRequirementText).gameObject.SetActive(false);
					((Component)__instance.m_HireFeeText).gameObject.SetActive(true);
					__instance.m_LockPurchaseBtn.SetActive(false);
				}
				else
				{
					((Component)__instance.m_LevelRequirementText).gameObject.SetActive(true);
					((Component)__instance.m_HireFeeText).gameObject.SetActive(false);
					__instance.m_LockPurchaseBtn.gameObject.SetActive(true);
				}
			}
		}

		[HarmonyPatch(typeof(HireWorkerPanelUI), "OnPressHireButton")]
		public class OnClick
		{
			private static bool Prefix(HireWorkerPanelUI __instance)
			{
				FieldInfo field = typeof(HireWorkerPanelUI).GetField("m_Index", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					return false;
				}
				int num = (int)field.GetValue(__instance);
				(int, string, int) valueOrDefault = EmployeeMapping.mapping.GetValueOrDefault(num, (-1, "", -1));
				Plugin.Log($"at employee hire {valueOrDefault.Item2} {valueOrDefault.Item1} {valueOrDefault.Item3 != -1 && Plugin.m_SessionHandler.hasItem(valueOrDefault.Item1)}");
				if (valueOrDefault.Item3 != -1 && Plugin.m_SessionHandler.hasItem(valueOrDefault.Item1))
				{
					HireEmployee(__instance, num);
				}
				return true;
			}
		}

		public static void HireEmployee(HireWorkerPanelUI __instance, int index)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			if (CPlayerData.GetIsWorkerHired(index))
			{
				return;
			}
			FieldInfo field = typeof(HireWorkerPanelUI).GetField("m_TotalHireFee", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				return;
			}
			float num = (float)field.GetValue(__instance);
			CEventManager.QueueEvent((CEvent)new CEventPlayer_ReduceCoin(num, false));
			CPlayerData.SetIsWorkerHired(index, true);
			CSingleton<WorkerManager>.Instance.ActivateWorker(index, true);
			CPlayerData.m_GameReportDataCollect.employeeCost -= num;
			CPlayerData.m_GameReportDataCollectPermanent.employeeCost -= num;
			int num2 = 0;
			for (int i = 0; i < CPlayerData.m_IsWorkerHired.Count; i++)
			{
				if (CPlayerData.m_IsWorkerHired[i])
				{
					num2++;
				}
			}
			FieldInfo field2 = typeof(HireWorkerPanelUI).GetField("m_IsHired", BindingFlags.Instance | BindingFlags.NonPublic);
			if (!(field2 == null))
			{
				AchievementManager.OnStaffHired(num2);
				SoundManager.PlayAudio("SFX_CustomerBuy", 0.6f, 1f);
				field2.SetValue(__instance, CPlayerData.GetIsWorkerHired(index));
				if (CPlayerData.GetIsWorkerHired(index))
				{
					__instance.m_HiredText.SetActive(true);
					__instance.m_PurchaseBtn.SetActive(false);
					((Component)__instance.m_HireFeeText).gameObject.SetActive(false);
				}
				else
				{
					__instance.m_HiredText.SetActive(false);
					__instance.m_PurchaseBtn.SetActive(true);
				}
			}
		}
	}
	public class ExpansionShopPatches
	{
		[HarmonyPatch(typeof(ExpansionShopPanelUI), "Init")]
		public class Init
		{
			[HarmonyPostfix]
			private static void Postfix(ExpansionShopPanelUI __instance, ExpansionShopUIScreen expansionShopUIScreen, int index, bool isShopB)
			{
				FieldInfo field = typeof(ExpansionShopPanelUI).GetField("m_LevelRequired", BindingFlags.Instance | BindingFlags.NonPublic);
				if (!(field == null))
				{
					int num = (int)field.GetValue(__instance);
					bool flag = false;
					flag = ((!isShopB) ? (Plugin.m_SessionHandler.itemCount(ExpansionMapping.progressiveA) > index) : (Plugin.m_SessionHandler.itemCount(ExpansionMapping.progressiveB) > index));
					bool flag2 = CPlayerData.m_ShopLevel + 1 >= num;
					if (!flag && flag2)
					{
						((Component)__instance.m_LevelRequirementText).gameObject.SetActive(true);
						((TMP_Text)__instance.m_LevelRequirementText).text = "Needs Progressive Shop Expansion " + (isShopB ? "B" : "A");
					}
					else if (!flag)
					{
						((TMP_Text)__instance.m_LevelRequirementText).text = ((TMP_Text)__instance.m_LevelRequirementText).text + " and AP Progressive " + (isShopB ? "B" : "A");
					}
					if (isShopB && CPlayerData.m_UnlockWarehouseRoomCount > index)
					{
						__instance.m_LockPurchaseBtn.gameObject.SetActive(false);
						__instance.m_PurchasedBtn.gameObject.SetActive(true);
					}
					else if (!isShopB && CPlayerData.m_UnlockRoomCount > index)
					{
						__instance.m_LockPurchaseBtn.gameObject.SetActive(false);
						__instance.m_PurchasedBtn.gameObject.SetActive(true);
					}
					else if (flag && flag2)
					{
						__instance.m_LockPurchaseBtn.gameObject.SetActive(false);
						__instance.m_PurchasedBtn.gameObject.SetActive(false);
					}
					else
					{
						__instance.m_LockPurchaseBtn.gameObject.SetActive(true);
						__instance.m_PurchasedBtn.gameObject.SetActive(false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(ExpansionShopPanelUI), "OnPressButton")]
		public class OnClick
		{
			private static bool Prefix(ExpansionShopPanelUI __instance)
			{
				FieldInfo field = typeof(ExpansionShopPanelUI).GetField("m_Index", BindingFlags.Instance | BindingFlags.NonPublic);
				int num = (int)field.GetValue(__instance);
				FieldInfo field2 = typeof(ExpansionShopPanelUI).GetField("m_LevelRequired", BindingFlags.Instance | BindingFlags.NonPublic);
				int num2 = (int)field2.GetValue(__instance);
				FieldInfo fieldInfo = AccessTools.Field(typeof(ExpansionShopPanelUI), "m_IsShopB");
				bool flag = (bool)fieldInfo.GetValue(__instance);
				bool flag2 = false;
				flag2 = ((!flag) ? (Plugin.m_SessionHandler.itemCount(ExpansionMapping.progressiveA) > num) : (Plugin.m_SessionHandler.itemCount(ExpansionMapping.progressiveB) > num));
				bool flag3 = CPlayerData.m_ShopLevel + 1 >= num2;
				if (flag2 && flag3)
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch]
		private class CreateData
		{
			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(typeof(ExpansionShopUIScreen), "EvaluateCartCheckout", (Type[])null, (Type[])null);
			}

			[HarmonyPrefix]
			public static void Prefix(float totalCost, int index, bool isShopB)
			{
				Plugin.m_SessionHandler.CompleteLocationChecks(ExpansionMapping.locstartval + index + (isShopB ? 30 : 0));
				if (!isShopB && Plugin.m_SessionHandler.GetSlotData().Goal == 0 && index + 1 >= Plugin.m_SessionHandler.GetSlotData().ShopExpansionGoal)
				{
					Plugin.m_SessionHandler.SendGoalCompletion();
					PopupTextPatches.ShowCustomText("Congrats! Your Shop Has Expanded To Your Goal!");
				}
				Plugin.Log("Prefix executed on EvaluateCartCheckout for Expansion");
			}
		}

		[HarmonyPatch]
		private class PanelUI
		{
			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(typeof(ExpansionShopUIScreen), "EvaluateShopPanelUI", (Type[])null, (Type[])null);
			}

			[HarmonyPostfix]
			public static void Postfix(ExpansionShopUIScreen __instance)
			{
				if (__instance.m_IsShopB && !CPlayerData.m_IsWarehouseRoomUnlocked)
				{
					((Behaviour)__instance.m_ShopB_LevelRequirementText).enabled = true;
					((TMP_Text)__instance.m_ShopB_LevelRequirementText).text = "Needs AP Warehouse Key";
					__instance.m_ShopB_LockPurchaseBtn.SetActive(true);
				}
			}
		}
	}
	public class FurnaturePatches
	{
		[HarmonyPatch(typeof(FurnitureShopPanelUI), "Init")]
		public class Init
		{
			[HarmonyPrefix]
			private static void Prefix(FurnitureShopPanelUI __instance, FurnitureShopUIScreen furnitureShopUIScreen, int index)
			{
				__instance.m_Index = FurnatureMapping.reorder[index];
			}

			[HarmonyPostfix]
			private static void Postfix(FurnitureShopPanelUI __instance, FurnitureShopUIScreen furnitureShopUIScreen, int index)
			{
				if (index != 0)
				{
					(int, string, int) valueOrEmpty = FurnatureMapping.getValueOrEmpty(__instance.m_Index);
					if (valueOrEmpty.Item1 == -1)
					{
						Plugin.Log($"Failed to find index: {__instance.m_Index}");
						return;
					}
					bool hasItem = Plugin.m_SessionHandler.itemCount(valueOrEmpty.Item1) >= valueOrEmpty.Item3;
					runFurnatureBtnLogic(__instance, hasItem, __instance.m_Index);
				}
			}
		}

		[HarmonyPatch(typeof(FurnitureShopPanelUI), "OnPressButton")]
		public class OnClick
		{
			private static bool Prefix(FurnitureShopPanelUI __instance)
			{
				FieldInfo field = typeof(FurnitureShopPanelUI).GetField("m_Index", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					return false;
				}
				int num = (int)field.GetValue(__instance);
				if (((TMP_Text)__instance.m_LevelRequirementText).text.Equals("License Locked by AP"))
				{
					return false;
				}
				return true;
			}
		}

		public static void runFurnatureBtnLogic(FurnitureShopPanelUI __instance, bool hasItem, int index)
		{
			if (!hasItem)
			{
				((TMP_Text)__instance.m_LevelRequirementText).text = "License Locked by AP";
				((Component)__instance.m_LevelRequirementText).gameObject.SetActive(true);
				__instance.m_CompanyTitle.gameObject.SetActive(false);
				__instance.m_LockPurchaseBtn.gameObject.SetActive(true);
			}
			else
			{
				EnableFurnature(__instance, index);
				((TMP_Text)__instance.m_LevelRequirementText).text = "";
			}
		}

		public static void EnableFurnature(FurnitureShopPanelUI __instance, int index)
		{
			FieldInfo field = typeof(FurnitureShopPanelUI).GetField("m_LevelRequired", BindingFlags.Instance | BindingFlags.NonPublic);
			if (!(field == null))
			{
				int num = (int)field.GetValue(__instance);
				field.SetValue(__instance, 1);
				((Component)__instance.m_LevelRequirementText).gameObject.SetActive(false);
				__instance.m_CompanyTitle.gameObject.SetActive(true);
				__instance.m_LockPurchaseBtn.gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(CGameManager))]
	public class CGameManagerPatches
	{
		[HarmonyPatch("LoadData")]
		[HarmonyPostfix]
		private static void PostFix()
		{
			CPlayerData.m_TutorialIndex = 16;
			if (CPlayerData.PlayerName != "My Card Shop" || CPlayerData.m_TutorialIndex > 0)
			{
				CSingleton<TutorialManager>.Instance.m_TutorialTargetIndicator.SetActive(false);
				((Component)CSingleton<TutorialManager>.Instance).gameObject.SetActive(false);
				CPlayerData.m_HasFinishedTutorial = true;
			}
			Plugin.Log("Processing cache Items");
			Plugin.onSceneLoadLogic();
		}
	}
	public class OpenCloseSignPatches
	{
		[HarmonyPatch(typeof(InteractableOpenCloseSign))]
		public class OverrideTutorialCheck
		{
			[HarmonyPatch("OnMouseButtonUp")]
			[HarmonyPrefix]
			private static bool Prefix(InteractableOpenCloseSign __instance)
			{
				if (!__instance.m_IsSwapping)
				{
					CPlayerData.m_IsShopOpen = !CPlayerData.m_IsShopOpen;
					if (!CPlayerData.m_IsShopOnceOpen && CPlayerData.m_IsShopOpen)
					{
						CPlayerData.m_IsShopOnceOpen = true;
					}
					__instance.m_IsSwapping = true;
					__instance.m_Anim.Play();
					((MonoBehaviour)__instance).StartCoroutine(__instance.DelaySwapMesh());
					SoundManager.GenericPop(1f, 1f);
				}
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(PauseScreen))]
	public class PauseScreenPatches
	{
		[HarmonyPatch("OpenSaveGameSlotScreen")]
		[HarmonyPrefix]
		private static bool SavePrefix()
		{
			Plugin.Log("Start Saving");
			CSingleton<CGameManager>.Instance.m_CurrentSaveLoadSlotSelectedIndex = 3;
			CSingleton<CGameManager>.Instance.m_IsManualSaveLoad = true;
			CSingleton<ShelfManager>.Instance.SaveInteractableObjectData(false);
			CSingleton<CGameManager>.Instance.SaveGameData(3);
			SaveLoadGameSlotSelectScreen val = Object.FindObjectOfType<SaveLoadGameSlotSelectScreen>();
			if ((Object)(object)val != (Object)null)
			{
				Plugin.Log("Screen Saving");
				val.m_SavingGameScreen.SetActive(true);
				((MonoBehaviour)CSingleton<SaveLoadGameSlotSelectScreen>.Instance).StartCoroutine(DelaySavingGame(val));
			}
			return true;
		}

		private static IEnumerator DelaySavingGame(SaveLoadGameSlotSelectScreen saveScreen)
		{
			Plugin.Log("Delay Saving");
			yield return (object)new WaitForSecondsRealtime(2f);
			saveScreen.m_SavingGameScreen.SetActive(false);
			((Component)saveScreen).gameObject.SetActive(false);
		}
	}
	internal class PlayerDataPatches
	{
		[HarmonyPatch]
		private class CreateData
		{
			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(typeof(CPlayerData), "CreateDefaultData", (Type[])null, (Type[])null);
			}

			[HarmonyPostfix]
			public static void Postfix(CPlayerData __instance)
			{
				Plugin.Log("Postfix executed on CreateDefaultData");
				CPlayerData.m_IsItemLicenseUnlocked[0] = false;
				Plugin.m_SaveManager.setIncompleteCards(GetValidTypeIdsForSanity());
			}
		}

		[HarmonyPatch]
		private class AddXp
		{
			private static int oldLevel;

			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(typeof(CPlayerData), "CPlayer_OnAddShopExp", (Type[])null, (Type[])null);
			}

			[HarmonyPrefix]
			private static void Prefix(CEventPlayer_AddShopExp evt)
			{
				oldLevel = CPlayerData.m_ShopLevel;
			}

			[HarmonyPostfix]
			private static void Postfix(CEventPlayer_AddShopExp evt)
			{
				if (oldLevel < CPlayerData.m_ShopLevel && CPlayerData.m_ShopLevel + 1 >= 2)
				{
					Plugin.Log($"Level Up: {oldLevel + 1} -> {CPlayerData.m_ShopLevel + 1}");
					Plugin.m_SessionHandler.CompleteLocationChecks(LevelMapping.startValue + CPlayerData.m_ShopLevel);
					if (Plugin.m_SessionHandler.GetSlotData().Goal == 1 && CPlayerData.m_ShopLevel + 1 >= Plugin.m_SessionHandler.GetSlotData().LevelGoal)
					{
						Plugin.m_SessionHandler.SendGoalCompletion();
						PopupTextPatches.ShowCustomText("Congrats! Your Shop Has Leveled To Your Goal!");
					}
				}
			}
		}

		[HarmonyPatch]
		private class AddLicense
		{
			private static MethodBase TargetMethod()
			{
				Type typeFromHandle = typeof(CPlayerData);
				MethodInfo method = typeFromHandle.GetMethod("SetUnlockItemLicense", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					Plugin.Log("Static method 'SetUnlockItemLicense' not found!");
				}
				return method;
			}

			private static void Prefix(int index)
			{
			}

			private static void Postfix(int index)
			{
			}
		}

		[HarmonyPatch]
		private class AddCard
		{
			private static MethodBase TargetMethod()
			{
				Type typeFromHandle = typeof(CPlayerData);
				MethodInfo method = typeFromHandle.GetMethod("AddCard", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					Plugin.Log("Static method 'AddCard' not found!");
				}
				return method;
			}

			private static void Prefix(CardData cardData, int addAmount)
			{
				//IL_003b: 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_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Invalid comparison between Unknown and I4
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Invalid comparison between Unknown and I4
				if (Plugin.m_SessionHandler.GetSlotData().CardSanity != 0)
				{
					ECollectionPackType val = (ECollectionPackType)AccessTools.Field(typeof(CardOpeningSequence), "m_CollectionPackType").GetValue(CSingleton<CardOpeningSequence>.Instance);
					if ((int)val < Plugin.m_SessionHandler.GetSlotData().CardSanity && CPlayerData.GetCardAmount(cardData) == 0 && (int)cardData.borderType <= Plugin.m_SessionHandler.GetSlotData().BorderInSanity && (!cardData.isFoil || Plugin.m_SessionHandler.GetSlotData().FoilInSanity))
					{
						Plugin.m_SessionHandler.CompleteLocationChecks(CardMapping.getId(cardData));
					}
				}
			}

			private static void Postfix(CardData cardData, int addAmount)
			{
			}
		}

		public static List<int> GetValidTypeIdsForSanity()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: 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_0062: 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_0071: 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_007c: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected I4, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Invalid comparison between Unknown and I4
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Invalid comparison between Unknown and I4
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Invalid comparison between Unknown and I4
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Invalid comparison between Unknown and I4
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Invalid comparison between Unknown and I4
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Invalid comparison between Unknown and I4
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Expected I4, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected I4, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected I4, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Expected I4, but got Unknown
			if (Plugin.m_SessionHandler.GetSlotData().CardSanity == 0)
			{
				return Enumerable.Range(1, 121).ToList();
			}
			HashSet<int> hashSet = new HashSet<int>();
			ECardExpansionType[] array = (ECardExpansionType[])(object)new ECardExpansionType[2]
			{
				default(ECardExpansionType),
				(ECardExpansionType)1
			};
			ECardExpansionType[] array2 = array;
			foreach (ECardExpansionType val in array2)
			{
				for (int j = 0; j < InventoryBase.GetShownMonsterList(val).Count; j++)
				{
					EMonsterType monsterType = InventoryBase.GetMonsterData(InventoryBase.GetShownMonsterList(val)[j]).MonsterType;
					ERarity rarity = InventoryBase.GetMonsterData(InventoryBase.GetShownMonsterList(val)[j]).Rarity;
					ERarity val2 = rarity;
					ERarity val3 = val2;
					switch (val3 - 1)
					{
					case 2:
						if ((Plugin.m_SessionHandler.GetSlotData().CardSanity >= 8 && (int)val == 1) || (Plugin.m_SessionHandler.GetSlotData().CardSanity >= 4 && (int)val == 0))
						{
							hashSet.Add((int)monsterType);
						}
						break;
					case 1:
						if ((Plugin.m_SessionHandler.GetSlotData().CardSanity >= 7 && (int)val == 1) || (Plugin.m_SessionHandler.GetSlotData().CardSanity >= 3 && (int)val == 0))
						{
							hashSet.Add((int)monsterType);
						}
						break;
					case 0:
						if ((Plugin.m_SessionHandler.GetSlotData().CardSanity >= 6 && (int)val == 1) || (Plugin.m_SessionHandler.GetSlotData().CardSanity >= 2 && (int)val == 0))
						{
							hashSet.Add((int)monsterType);
						}
						break;
					default:
						if ((Plugin.m_SessionHandler.GetSlotData().CardSanity >= 5 && (int)val == 1) || (Plugin.m_SessionHandler.GetSlotData().CardSanity >= 1 && (int)val == 0))
						{
							hashSet.Add((int)monsterType);
						}
						break;
					}
				}
			}
			return hashSet.ToList();
		}
	}
	public class PopupTextPatches
	{
		[HarmonyPatch]
		public class ShowText
		{
			private static MethodBase TargetMethod()
			{
				Type typeFromHandle = typeof(NotEnoughResourceTextPopup);
				MethodInfo method = typeFromHandle.GetMethod("ShowText", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					Plugin.Log("Static method 'ShowText' not found!");
				}
				return method;
			}

			private static void Prefix(ENotEnoughResourceText notEnoughResourceText)
			{
				currentText = ((object)(ENotEnoughResourceText)(ref notEnoughResourceText)).ToString();
			}
		}

		private static string currentText;

		public static void ShowCustomText(string notEnoughResourceText)
		{
			if (currentText == notEnoughResourceText)
			{
				return;
			}
			CSingleton<NotEnoughResourceTextPopup>.Instance.m_ResetTimer = 0f;
			currentText = notEnoughResourceText;
			for (int i = 0; i < CSingleton<NotEnoughResourceTextPopup>.Instance.m_ShowTextGameObjectList.Count; i++)
			{
				if (!CSingleton<NotEnoughResourceTextPopup>.Instance.m_ShowTextGameObjectList[i].activeSelf)
				{
					((TMP_Text)CSingleton<NotEnoughResourceTextPopup>.Instance.m_ShowTextList[i]).text = notEnoughResourceText;
					CSingleton<NotEnoughResourceTextPopup>.Instance.m_ShowTextGameObjectList[i].gameObject.SetActive(true);
					break;
				}
			}
		}
	}
	public class RestockItemPanelUIPatches
	{
		[HarmonyPatch(typeof(RestockItemPanelUI), "Init")]
		public class Init
		{
			[HarmonyPrefix]
			private static void Prefix(RestockItemPanelUI __instance, RestockItemScreen restockItemScreen, ref int index)
			{
			}

			[HarmonyPostfix]
			private static void Postfix(RestockItemPanelUI __instance, RestockItemScreen restockItemScreen, int index)
			{
				List<EItemType> list = new List<EItemType>();
				List<int> list2 = new List<int>();
				int[] array = LicenseMapping.pg1_ids;
				switch (restockItemScreen.m_PageIndex)
				{
				case 0:
					list = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ShownItemType;
					list2 = Plugin.m_SessionHandler.GetSlotData().pg1IndexMapping;
					array = LicenseMapping.pg1_ids;
					break;
				case 1:
					list = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ShownAccessoryItemType;
					list2 = Plugin.m_SessionHandler.GetSlotData().pg2IndexMapping;
					array = LicenseMapping.pg2_ids;
					break;
				case 2:
					list = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ShownFigurineItemType;
					list2 = Plugin.m_SessionHandler.GetSlotData().pg3IndexMapping;
					array = LicenseMapping.pg3_ids;
					break;
				}
				if (restockItemScreen is RestockItemBoardGameScreen)
				{
					list = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ShownBoardGameItemType;
					list2 = Plugin.m_SessionHandler.GetSlotData().ttIndexMapping;
					array = LicenseMapping.tt_ids;
					if (index == -1)
					{
						return;
					}
				}
				else if (restockItemScreen.m_SortedRestockDataIndexList.IndexOf(index) == -1)
				{
					return;
				}
				RestockData restockData = InventoryBase.GetRestockData(array[list2.IndexOf(index)]);
				__instance.m_LevelRequired = restockData.licenseShopLevelRequired;
				((TMP_Text)__instance.m_LicensePriceText).text = GameInstance.GetPriceString(0f, false, true, false, "F2");
				if (index == Plugin.m_SessionHandler.GetSlotData().pg1IndexMapping[0])
				{
					__instance.m_LevelRequired = 0;
				}
				if (index == Plugin.m_SessionHandler.GetSlotData().pg2IndexMapping[0])
				{
					__instance.m_LevelRequired = 0;
				}
				if (index == Plugin.m_SessionHandler.GetSlotData().pg3IndexMapping[0])
				{
					__instance.m_LevelRequired = 0;
				}
				(int, string, int, int, EItemType) valueOrEmpty = LicenseMapping.getValueOrEmpty(index);
				if (valueOrEmpty.Item4 == -1)
				{
					Plugin.Log($"Failed to find index: {index}");
				}
				else
				{
					runLicenseBtnLogic(__instance, Plugin.m_SessionHandler.hasItem(valueOrEmpty.Item1), index);
				}
			}
		}

		[HarmonyPatch(typeof(RestockItemPanelUI), "OnPressPurchaseButton")]
		public class OnClick
		{
			private static bool Prefix(RestockItemPanelUI __instance)
			{
				if (Plugin.m_SessionHandler.hasItem(LicenseMapping.getValueOrEmpty(__instance.m_Index).itemid))
				{
					return true;
				}
				PopupTextPatches.ShowCustomText("License Unowned");
				return false;
			}
		}

		[HarmonyPatch(typeof(RestockItemScreen), "Init")]
		public class InitScreen
		{
			[HarmonyPrefix]
			public static void Prefix(RestockItemScreen __instance)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				CPlayerData.m_RestockSortingType = (ERestockSortingType)0;
			}
		}

		[HarmonyPatch(typeof(RestockItemScreen), "OnPressChangePageButton")]
		public class OnPressChangePageButton
		{
			[HarmonyPrefix]
			public static void Prefix(RestockItemScreen __instance)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				__instance.m_CurrentSortingMethod = (ERestockSortingType)0;
			}
		}

		[HarmonyPatch(typeof(RestockItemScreen), "EvaluateSorting")]
		public class Sorting
		{
			[HarmonyPrefix]
			public static void Prefix(RestockItemScreen __instance)
			{
				switch (__instance.m_PageIndex)
				{
				case 0:
					__instance.m_CurrentRestockDataIndexList.Clear();
					__instance.m_CurrentRestockDataIndexList.AddRange(Plugin.m_SessionHandler.GetSlotData().pg1IndexMapping);
					break;
				case 1:
					__instance.m_CurrentRestockDataIndexList.Clear();
					__instance.m_CurrentRestockDataIndexList.AddRange(Plugin.m_SessionHandler.GetSlotData().pg2IndexMapping);
					break;
				case 2:
					__instance.m_CurrentRestockDataIndexList.Clear();
					__instance.m_CurrentRestockDataIndexList.AddRange(Plugin.m_SessionHandler.GetSlotData().pg3IndexMapping);
					break;
				}
				Plugin.Log("new");
				Plugin.Log(string.Join(", ", __instance.m_CurrentRestockDataIndexList));
			}
		}

		public static void runLicenseBtnLogic(RestockItemPanelUI __instance, bool hasItem, int index)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected I4, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected I4, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log($"Item Data: {index} : {__instance.m_LevelRequired}");
			if (hasItem && CPlayerData.m_ShopLevel + 1 >= __instance.m_LevelRequired)
			{
				((UIElementBase)__instance).m_UIGrp.SetActive(true);
				__instance.m_LicenseUIGrp.SetActive(false);
				__instance.m_LockPurchaseBtn.gameObject.SetActive(false);
				EItemType type = InventoryBase.GetRestockData(index).itemType;
				IEnumerable<KeyValuePair<int, (int, string, int, int, EItemType)>> source = from i in LicenseMapping.GetKeyValueFromType(type)
					where i.Value.count > CPlayerData.m_StockSoldList[(int)type]
					select i;
				if (source.Any())
				{
					RectTransform val = ((IEnumerable<RectTransform>)((UIElementBase)__instance).m_UIGrp.GetComponentsInChildren<RectTransform>(true)).FirstOrDefault((Func<RectTransform, bool>)((RectTransform rt) => ((Object)rt).name == "UnitPriceText"));
					if ((Object)(object)val != (Object)null)
					{
						Localize component = ((Component)val).GetComponent<Localize>();
						if ((Object)(object)component != (Object)null)
						{
							component.SetTerm("Sold Check Progress");
						}
					}
					((TMP_Text)__instance.m_UnitPriceText).text = $"{CPlayerData.m_StockSoldList[(int)type]}/{source.OrderBy<KeyValuePair<int, (int, string, int, int, EItemType)>, int>((KeyValuePair<int, (int itemid, string name, int count, int locid, EItemType)> x) => x.Value.count).FirstOrDefault().Value.Item3}";
					((Graphic)__instance.m_UnitPriceText).color = Color.blue;
					return;
				}
				RectTransform val2 = ((IEnumerable<RectTransform>)((UIElementBase)__instance).m_UIGrp.GetComponentsInChildren<RectTransform>(true)).FirstOrDefault((Func<RectTransform, bool>)((RectTransform rt) => ((Object)rt).name == "UnitPriceText"));
				if ((Object)(object)val2 != (Object)null)
				{
					Localize component2 = ((Component)val2).GetComponent<Localize>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.SetTerm("Checks Completed. Total Sold:");
					}
				}
				((TMP_Text)__instance.m_UnitPriceText).text = $"{CPlayerData.m_StockSoldList[(int)type]}";
				((Graphic)__instance.m_UnitPriceText).color = Color.green;
			}
			else if (hasItem)
			{
				((UIElementBase)__instance).m_UIGrp.SetActive(false);
				__instance.m_LicenseUIGrp.SetActive(true);
				__instance.m_LockPurchaseBtn.gameObject.SetActive(true);
				((TMP_Text)__instance.m_LevelRequirementText).text = $"Level {__instance.m_LevelRequired} Required. License Found";
				((Component)__instance.m_LevelRequirementText).gameObject.SetActive(true);
			}
			else if (CPlayerData.m_ShopLevel + 1 >= __instance.m_LevelRequired)
			{
				((UIElementBase)__instance).m_UIGrp.SetActive(false);
				__instance.m_LockPurchaseBtn.gameObject.SetActive(true);
				__instance.m_LicenseUIGrp.SetActive(true);
				((Component)__instance.m_LevelRequirementText).gameObject.SetActive(true);
				((TMP_Text)__instance.m_LevelRequirementText).text = "Level Reached, License Locked by AP";
			}
			else
			{
				((UIElementBase)__instance).m_UIGrp.SetActive(false);
				__instance.m_LicenseUIGrp.SetActive(true);
				__instance.m_LockPurchaseBtn.gameObject.SetActive(true);
				((TMP_Text)__instance.m_LevelRequirementText).text = $"Level {__instance.m_LevelRequired} Required. License Locked by AP";
				((Component)__instance.m_LevelRequirementText).gameObject.SetActive(true);
			}
		}
	}
	public class SaveLoadPatches
	{
		[HarmonyPatch]
		public class SavePatch
		{
			private static MethodBase TargetMethod()
			{
				Type typeFromHandle = typeof(CSaveLoad);
				MethodInfo method = typeFromHandle.GetMethod("Save", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					Plugin.Log("Static method 'Save' not found!");
				}
				return method;
			}

			[HarmonyPrefix]
			private static bool SavePrefix(int saveSlotIndex, bool skipJSONSave = false)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				Plugin.m_SaveManager.Save(saveSlotIndex);
				CEventManager.QueueEvent((CEvent)new CEventPlayer_OnSaveStatusUpdated(true, false));
				return false;
			}
		}

		[HarmonyPatch]
		public class LoadPatch
		{
			private static MethodBase TargetMethod()
			{
				Type typeFromHandle = typeof(CSaveLoad);
				MethodInfo method = typeFromHandle.GetMethod("Load", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					Plugin.Log("Static method 'Load' not found!");
				}
				return method;
			}

			[HarmonyPrefix]
			private static bool LoadPrefix(ref bool __result, int slotIndex)
			{
				Plugin.Log("Loading AP save data");
				if (!Plugin.m_SaveManager.Load())
				{
					Plugin.Log("Cannot load Saves for AP Client");
					__result = false;
				}
				__result = true;
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(RestockItemBoardGameScreen))]
	[HarmonyPatch("EvaluateRestockItemPanelUI")]
	public class TableTopPatches
	{
		[HarmonyPrefix]
		private static bool Prefix(RestockItemBoardGameScreen __instance, int pageIndex)
		{
			((RestockItemScreen)__instance).m_CurrentRestockDataIndexList.Clear();
			((RestockItemScreen)__instance).m_CurrentRestockDataIndexList.AddRange(Plugin.m_SessionHandler.GetSlotData().ttIndexMapping);
			((RestockItemScreen)__instance).m_CurrentRestockDataIndexList.AddRange(new <>z__ReadOnlyArray<int>(new int[3] { -1, -1, -1 }));
			for (int i = 0; i < ((RestockItemScreen)__instance).m_CurrentRestockDataIndexList.Count && i < ((RestockItemScreen)__instance).m_RestockItemPanelUIList.Count; i++)
			{
				((RestockItemScreen)__instance).m_RestockItemPanelUIList[i].Init((RestockItemScreen)(object)__instance, ((RestockItemScreen)__instance).m_CurrentRestockDataIndexList[i]);
				((UIElementBase)((RestockItemScreen)__instance).m_RestockItemPanelUIList[i]).SetActive(true);
				((GenericSliderScreen)__instance).m_ScrollEndPosParent = ((Component)((RestockItemScreen)__instance).m_RestockItemPanelUIList[i]).gameObject;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(TitleScreen))]
	public class TitleScreenPatches
	{
		[HarmonyPatch("OpenLoadGameSlotScreen")]
		[HarmonyPrefix]
		private static bool LoadPrefix(TitleScreen __instance)
		{
			FieldInfo field = typeof(TitleScreen).GetField("m_IsOpeningLevel", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				return false;
			}
			if (!(bool)field.GetValue(__instance))
			{
				field.SetValue(__instance, true);
				CSingleton<CGameManager>.Instance.m_CurrentSaveLoadSlotSelectedIndex = 3;
				CSingleton<CGameManager>.Instance.m_IsManualSaveLoad = true;
				CSingleton<CGameManager>.Instance.LoadMainLevelAsync("Start", 3);
				ControllerScreenUIExtManager.OnCloseScreen(__instance.m_ControllerScreenUIExtension);
				return true;
			}
			return true;
		}

		[HarmonyPatch("OnPressStartGame")]
		[HarmonyPrefix]
		private static bool NewGamePrefix(TitleScreen __instance)
		{
			FieldInfo field = typeof(TitleScreen).GetField("m_IsOpeningLevel", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				return false;
			}
			if (!(bool)field.GetValue(__instance))
			{
				bool flag = true;
				CSingleton<CGameManager>.Instance.LoadMainLevelAsync("Start", -1);
				ControllerScreenUIExtManager.OnCloseScreen(__instance.m_ControllerScreenUIExtension);
			}
			return false;
		}
	}
	public class TutorialPatches
	{
		[HarmonyPatch(typeof(ShopRenamer))]
		public class ShopRenamerPatches
		{
			[HarmonyPatch("OnPressConfirmShopName")]
			[HarmonyPostfix]
			private static void PostFix(ShopRenamer __instance)
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Expected O, but got Unknown
				CSingleton<TutorialManager>.Instance.m_TutorialTargetIndicator.SetActive(false);
				((Component)CSingleton<TutorialManager>.Instance).gameObject.SetActive(false);
				CPlayerData.m_TutorialIndex = 16;
				CPlayerData.m_HasFinishedTutorial = true;
				CPlayerData.m_TutorialDataList.Clear();
				Plugin.onSceneLoadLogic();
				CEventManager.QueueEvent((CEvent)new CEventPlayer_SetCoin((float)Settings.Instance.StartingMoney.Value));
			}
		}
	}
}
namespace ApClient.mapping
{
	public class CardMapping
	{
		public static int ghostProgressive = 522715351;

		public static int getId(CardData cardData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0039: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected I4, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected I4, but got Unknown
			if ((int)cardData.expansionType > 1 || (int)cardData.monsterType >= 122)
			{
				return -1;
			}
			Plugin.Log(string.Format("{0} : {1}", string.Format("{0} {1} {2} {3}", cardData.monsterType, cardData.borderType, cardData.isFoil ? "Foil" : "NonFoil", cardData.expansionType), 0x1F290000 | (cardData.expansionType << 12) | (cardData.borderType << 8) | ((cardData.isFoil ? 1 : 0) << 7) | cardData.monsterType));
			return 0x1F290000 | (cardData.expansionType << 12) | (cardData.borderType << 8) | ((cardData.isFoil ? 1 : 0) << 7) | cardData.monsterType;
		}
	}
	public class EmployeeMapping
	{
		public static Dictionary<int, (int itemid, string name, int locid)> mapping = new Dictionary<int, (int, string, int)>
		{
			{
				0,
				(522715318, "Zachery", 522715505)
			},
			{
				1,
				(522715319, "Terence", 522715506)
			},
			{
				2,
				(522715320, "Dennis", 522715507)
			},
			{
				3,
				(522715321, "Clark", 522715508)
			},
			{
				4,
				(522715322, "Angus", 522715509)
			},
			{
				5,
				(522715323, "Benji", 522715510)
			},
			{
				6,
				(522715324, "Lauren", 522715511)
			},
			{
				7,
				(522715325, "Axel", 522715512)
			}
		};

		public static KeyValuePair<int, (int itemid, string name, int locid)> getKeyValue(int itemid)
		{
			KeyValuePair<int, (int, string, int)> result = mapping.FirstOrDefault((KeyValuePair<int, (int itemid, string name, int locid)> pair) => pair.Value.itemid == itemid);
			KeyValuePair<int, (int, string, int)> keyValuePair = new KeyValuePair<int, (int, string, int)>(-1, (-1, "", -1));
			if (result.Equals(default(KeyValuePair<int, (int, string, int)>)))
			{
				result = keyValuePair;
			}
			return result;
		}

		public static (int itemid, string name, int locid) getValueOrEmpty(int key)
		{
			return mapping.GetValueOrDefault(key, (-1, "", -1));
		}
	}
	public class ExpansionMapping
	{
		public static int locstartval = 522715513;

		public static int progressiveA = 522715328;

		public static int progressiveB = 522715329;

		public static int warehouseKey = 522715381;
	}
	public class FurnatureMapping
	{
		public static int[] reorder = new int[22]
		{
			0, 5, 17, 4, 11, 18, 1, 6, 12, 2,
			10, 13, 8, 14, 20, 3, 12, 19, 7, 15,
			21, 9
		};

		public static Dictionary<int, (int itemid, string name, int count)> mapping = new Dictionary<int, (int, string, int)>
		{
			{
				0,
				(-1, "Small Cabinet", 1)
			},
			{
				1,
				(522715205, "Small Metal Rack", 1)
			},
			{
				2,
				(522715214, "Play Table", 1)
			},
			{
				3,
				(522715211, "Small Personal Shelf", 1)
			},
			{
				4,
				(522715206, "Single Sided Shelf", 1)
			},
			{
				5,
				(522715209, "Card Table", 1)
			},
			{
				6,
				(522715213, "Small Warehouse Shelf", 1)
			},
			{
				7,
				(522715210, "Small Card Display", 1)
			},
			{
				8,
				(522715212, "Auto Scent M100", 1)
			},
			{
				9,
				(522715215, "Workbench", 1)
			},
			{
				10,
				(522715216, "Trash Bin", 1)
			},
			{
				11,
				(522715207, "Double Sided Shelf", 1)
			},
			{
				12,
				(522715213, "Big Warehouse Shelf", 2)
			},
			{
				13,
				(522715217, "Checkout Counter", 1)
			},
			{
				14,
				(522715212, "Auto Scent G500", 2)
			},
			{
				15,
				(522715210, "Card Display Table", 2)
			},
			{
				16,
				(522715211, "Big Personal Shelf", 2)
			},
			{
				17,
				(522715209, "Vintage Card Table", 2)
			},
			{
				18,
				(522715208, "Wide Shelf", 1)
			},
			{
				19,
				(522715211, "Huge Personal Shelf", 3)
			},
			{
				20,
				(522715212, "Auto Scent T100", 3)
			},
			{
				21,
				(522715210, "Big Card Display", 3)
			}
		};

		public static KeyValuePair<int, (int itemid, string name, int count)> getKeyValue(int itemid, int count = 1)
		{
			KeyValuePair<int, (int, string, int)> result = mapping.FirstOrDefault((KeyValuePair<int, (int itemid, string name, int count)> pair) => pair.Value.itemid == itemid && count == pair.Value.count);
			KeyValuePair<int, (int, string, int)> keyValuePair = new KeyValuePair<int, (int, string, int)>(-1, (-1, "Unknown", 0));
			if (result.Equals(default(KeyValuePair<int, (int, string, int)>)))
			{
				result = keyValuePair;
			}
			return result;
		}

		public static (int itemid, string name, int count) getValueOrEmpty(int key)
		{
			return mapping.GetValueOrDefault(key, (-1, "", 0));
		}
	}
	public class LevelMapping
	{
		public static int startValue = 522715556;
	}
	public class LicenseMapping
	{
		public static SortedDictionary<int, (int itemid, string name, int count, int locid, EItemType type)> mapping = new SortedDictionary<int, (int, string, int, int, EItemType)>
		{
			{
				0,
				(522715137, "Basic Card Pack (32)", 32, 522715376, (EItemType)0)
			},
			{
				1,
				(522715352, "Basic Card Pack (64)", 32, 522715376, (EItemType)0)
			},
			{
				2,
				(522715353, "Progressive Basic Card Pack", 8, 522715377, (EItemType)1)
			},
			{
				3,
				(522715354, "Progressive Basic Card Pack", 8, 522715377, (EItemType)1)
			},
			{
				4,
				(522715138, "Progressive Rare Card Pack", 32, 522715378, (EItemType)2)
			},
			{
				5,
				(522715355, "Progressive Rare Card Pack", 32, 522715378, (EItemType)2)
			},
			{
				6,
				(522715356, "Progressive Rare Card Pack", 8, 522715379, (EItemType)3)
			},
			{
				7,
				(522715357, "Progressive Rare Card Pack", 8, 522715379, (EItemType)3)
			},
			{
				8,
				(522715139, "Progressive Epic Card Pack", 32, 522715380, (EItemType)4)
			},
			{
				9,
				(522715358, "Progressive Epic Card Pack", 32, 522715380, (EItemType)4)
			},
			{
				10,
				(522715359, "Progressive Epic Card Pack", 8, 522715381, (EItemType)5)
			},
			{
				11,
				(522715360, "Progressive Epic Card Pack", 8, 522715381, (EItemType)5)
			},
			{
				12,
				(522715140, "Progressive Legendary Card Pack", 32, 522715382, (EItemType)6)
			},
			{
				13,
				(522715361, "Progressive Legendary Card Pack", 32, 522715382, (EItemType)6)
			},
			{
				14,
				(522715362, "Progressive Legendary Card Pack", 8, 522715383, (EItemType)7)
			},
			{
				15,
				(522715363, "Progressive Legendary Card Pack", 8, 522715383, (EItemType)7)
			},
			{
				67,
				(522715141, "Fire Battle Deck", 9, 522715392, (EItemType)55)
			},
			{
				68,
				(522715142, "Earth Battle Deck", 9, 522715393, (EItemType)56)
			},
			{
				69,
				(522715143, "Water Battle Deck", 9, 522715394, (EItemType)57)
			},
			{
				70,
				(522715144, "Wind Battle Deck", 9, 522715395, (EItemType)58)
			},
			{
				24,
				(522715145, "Progressive Basic Destiny Pack", 32, 522715384, (EItemType)8)
			},
			{
				25,
				(522715364, "Progressive Basic Destiny Pack", 32, 522715384, (EItemType)8)
			},
			{
				26,
				(522715365, "Progressive Basic Destiny Pack", 8, 522715385, (EItemType)9)
			},
			{
				27,
				(522715366, "Progressive Basic Destiny Pack", 8, 522715385, (EItemType)9)
			},
			{
				28,
				(522715146, "Progressive Rare Destiny Pack", 32, 522715386, (EItemType)10)
			},
			{
				29,
				(522715367, "Progressive Rare Destiny Pack", 32, 522715386, (EItemType)10)
			},
			{
				30,
				(522715368, "Progressive Rare Destiny Pack", 8, 522715387, (EItemType)11)
			},
			{
				31,
				(522715369, "Progressive Rare Destiny Pack", 8, 522715387, (EItemType)11)
			},
			{
				32,
				(522715147, "Progressive Epic Destiny Pack", 32, 522715388, (EItemType)12)
			},
			{
				33,
				(522715370, "Progressive Epic Destiny Pack", 32, 522715388, (EItemType)12)
			},
			{
				34,
				(522715371, "Progressive Epic Destiny Pack", 8, 522715389, (EItemType)13)
			},
			{
				35,
				(522715372, "Progressive Epic Destiny Pack", 8, 522715389, (EItemType)13)
			},
			{
				36,
				(522715148, "Progressive Legendary Destiny Pack", 32, 522715390, (EItemType)14)
			},
			{
				37,
				(522715373, "Progressive Legendary Destiny Pack", 32, 522715390, (EItemType)14)
			},
			{
				38,
				(522715374, "Progressive Legendary Destiny Pack", 8, 522715391, (EItemType)15)
			},
			{
				39,
				(522715375, "Progressive Legendary Destiny Pack", 8, 522715391, (EItemType)15)
			},
			{
				71,
				(522715149, "Fire Destiny Deck", 9, 522715396, (EItemType)59)
			},
			{
				72,
				(522715150, "Earth Destiny Deck", 9, 522715397, (EItemType)60)
			},
			{
				73,
				(522715151, "Water Destiny Deck", 9, 522715398, (EItemType)61)
			},
			{
				74,
				(522715152, "Wind Destiny Deck", 9, 522715399, (EItemType)62)
			},
			{
				40,
				(522715153, "Cleanser (8)", 8, 522715400, (EItemType)23)
			},
			{
				41,
				(522715376, "Progressive Cleanser", 8, 522715400, (EItemType)23)
			},
			{
				75,
				(522715154, "Card Sleeves (Clear)", 32, 522715401, (EItemType)63)
			},
			{
				76,
				(522715155, "Card Sleeves (Tetramon)", 32, 522715402, (EItemType)64)
			},
			{
				43,
				(522715156, "D20 Dice Red (16)", 8, 522715403, (EItemType)29)
			},
			{
				44,
				(522715157, "D20 Dice Blue (16)", 8, 522715404, (EItemType)30)
			},
			{
				45,
				(522715158, "D20 Dice Black (16)", 8, 522715405, (EItemType)31)
			},
			{
				46,
				(522715159, "D20 Dice White (16)", 8, 522715406, (EItemType)32)
			},
			{
				77,
				(522715160, "Card Sleeves (Fire)", 32, 522715407, (EItemType)65)
			},
			{
				78,
				(522715161, "Card Sleeves (Earth)", 32, 522715408, (EItemType)66)
			},
			{
				79,
				(522715162, "Card Sleeves (Water)", 32, 522715409, (EItemType)67)
			},
			{
				80,
				(522715163, "Card Sleeves (Wind)", 32, 522715410, (EItemType)68)
			},
			{
				16,
				(522715164, "Progressive Deck Box Red", 8, 522715411, (EItemType)24)
			},
			{
				17,
				(522715377, "Progressive Deck Box Red", 8, 522715411, (EItemType)24)
			},
			{
				18,
				(522715165, "Progressive Deck Box Green", 8, 522715412, (EItemType)25)
			},
			{
				19,
				(522715378, "Progressive Deck Box Green", 8, 522715412, (EItemType)25)
			},
			{
				20,
				(522715166, "Progressive Deck Box Blue", 8, 522715413, (EItemType)26)
			},
			{
				21,
				(522715379, "Progressive Deck Box Blue", 8, 522715413, (EItemType)26)
			},
			{
				22,
				(522715167, "Progressive Deck Box Yellow", 8, 522715414, (EItemType)27)
			},
			{
				23,
				(522715380, "Progressive Deck Box Yellow", 8, 522715414, (EItemType)27)
			},
			{
				42,
				(522715168, "Collection Book ", 4, 522715415, (EItemType)28)
			},
			{
				66,
				(522715169, "Premium Collection Book", 4, 522715416, (EItemType)54)
			},
			{
				83,
				(522715170, "Playmat (Drilceros)", 8, 522715417, (EItemType)71)
			},
			{
				81,
				(522715171, "Playmat (Clamigo)", 8, 522715418, (EItemType)69)
			},
			{
				87,
				(522715172, "Playmat (Wispo)", 8, 522715419, (EItemType)75)
			},
			{
				95,
				(522715173, "Playmat (Lunight)", 8, 522715420, (EItemType)83)
			},
			{
				90,
				(522715174, "Playmat (Kyrone)", 8, 522715421, (EItemType)78)
			},
			{
				82,
				(522715175, "Playmat (Duel)", 8, 522715422, (EItemType)70)
			},
			{
				86,
				(522715176, "Playmat (Dracunix)", 8, 522715423, (EItemType)74)
			},
			{
				85,
				(522715177, "Playmat (The Four Dragons)", 8, 522715424, (EItemType)73)
			},
			{
				84,
				(522715178, "Playmat (Drakon)", 8, 522715425, (EItemType)72)
			},
			{
				88,
				(522715179, "Playmat (GigatronX Evo)", 8, 522715426, (EItemType)76)
			},
			{
				91,
				(522715180, "Playmat (Fire)", 8, 522715427, (EItemType)79)
			},
			{
				92,
				(522715181, "Playmat (Earth)