using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using CustomSideDeck.Info;
using DiskCardGame;
using GBC;
using HarmonyLib;
using InscryptionAPI.Ascension;
using InscryptionAPI.Card;
using InscryptionAPI.Guid;
using InscryptionAPI.Helpers;
using InscryptionAPI.Helpers.Extensions;
using InscryptionAPI.Nodes;
using InscryptionAPI.Saves;
using Microsoft.CodeAnalysis;
using Pixelplacement;
using UnityEngine;

[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.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("CustomSideDeck")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Placeholder description")]
[assembly: AssemblyFileVersion("2.3.2.0")]
[assembly: AssemblyInformationalVersion("2.3.2")]
[assembly: AssemblyProduct("CustomSideDeck")]
[assembly: AssemblyTitle("CustomSideDeck")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.3.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ExampleMod
{
	public class ExampleSequencer : CustomNodeSequencer, ICustomNodeSequencer
	{
		public SelectCardFromDeckSlot selectionSlot = Singleton<SpecialNodeHandler>.Instance.cardStatBoostSequencer.selectionSlot;

		public override bool ShouldNotReturnToMapOnEnd(CustomSpecialNodeData exampleNode)
		{
			return true;
		}

		public override IEnumerator DoCustomSequence(CustomSpecialNodeData exampleNode)
		{
			Singleton<ViewManager>.Instance.SwitchToView((View)1, false, true);
			yield return (object)new WaitForSeconds(0.5f);
			Singleton<ViewManager>.Instance.SwitchToView((View)38, false, true);
			Singleton<TableRuleBook>.Instance.SetOnBoard(true);
			Singleton<InteractionCursor>.Instance.SetEnabled(true);
			((InteractableBase)selectionSlot).ClearDelegates();
			Component[] componentsInChildren = ((Component)selectionSlot).GetComponentsInChildren<Component>();
			foreach (Component child in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)child) && ((object)child).ToString().Contains("FireAnim"))
				{
					Object.Destroy((Object)(object)child.gameObject);
				}
			}
			if (((HighlightedInteractable)selectionSlot).specificRenderers.Count > 1)
			{
				((HighlightedInteractable)selectionSlot).specificRenderers.RemoveAt(1);
			}
			((HighlightedInteractable)selectionSlot).specificRenderers[0].material.mainTexture = (Texture)(object)TextureHelper.GetImageAsTexture("slot_example_sequence.png", (FilterMode)0);
			SelectCardFromDeckSlot selectCardFromDeckSlot = selectionSlot;
			((MainInputInteractable)selectCardFromDeckSlot).CursorSelectStarted = (Action<MainInputInteractable>)Delegate.Combine(((MainInputInteractable)selectCardFromDeckSlot).CursorSelectStarted, (Action<MainInputInteractable>)delegate(MainInputInteractable slot)
			{
				OnSlotSelected(slot);
			});
			yield return (object)new WaitForSeconds(0.3f);
			((Component)Singleton<ExplorableAreaManager>.Instance.HangingLight).gameObject.SetActive(false);
			((Component)Singleton<ExplorableAreaManager>.Instance.HandLight).gameObject.SetActive(false);
			yield return Singleton<TextDisplayer>.Instance.ShowUntilInput("There is nothing here yet...", -0.65f, 0.5f, (Emotion)1, (LetterAnimation)0, (Speaker)0, (string[])null, true);
			yield return Singleton<TextDisplayer>.Instance.ShowUntilInput("Pity.", -0.45f, 0.5f, (Emotion)2, (LetterAnimation)0, (Speaker)1, (string[])null, true);
			((Component)selectionSlot).gameObject.SetActive(true);
			selectionSlot.RevealAndEnable();
			yield return (object)new WaitForSeconds(0.3f);
			((Component)Singleton<ExplorableAreaManager>.Instance.HangingLight).gameObject.SetActive(true);
			((Component)Singleton<ExplorableAreaManager>.Instance.HandLight).gameObject.SetActive(true);
			yield return (object)new WaitForSeconds(0.5f);
			yield return Singleton<TextDisplayer>.Instance.ShowUntilInput("Oh..?", -0.45f, 0.5f, (Emotion)5, (LetterAnimation)0, (Speaker)1, (string[])null, true);
		}

		private void OnSlotSelected(MainInputInteractable slot)
		{
			List<CardInfo> validCards = GetValidCards();
			((InteractableBase)selectionSlot).SetEnabled(false);
			((HighlightedInteractable)selectionSlot).ShowState((State)1, false, 0.15f);
			if (validCards == null)
			{
				((MonoBehaviour)this).StartCoroutine(ApplyCardCostSequence(validCards: false));
			}
			else if (validCards != null)
			{
				((SelectCardFromDeckSlot)((slot is SelectCardFromDeckSlot) ? slot : null)).SelectFromCards(validCards, (Action)OnSlotSelectionEnded, false);
			}
		}

		private IEnumerator ApplyCardCostSequence(bool validCards)
		{
			if (!validCards)
			{
				((InteractableBase)selectionSlot).SetEnabled(false);
				selectionSlot.FlyOffCard();
				selectionSlot.Disable();
				((HighlightedInteractable)selectionSlot).SetShown(false, false);
				Singleton<SpecialNodeHandler>.Instance.cardStatBoostSequencer.selectionSlot.pile.Draw();
				Singleton<SpecialNodeHandler>.Instance.cardStatBoostSequencer.selectionSlot.pile.DestroyCardsImmediate();
				yield return (object)new WaitForSeconds(0.5f);
				if ((Object)(object)Singleton<GameFlowManager>.Instance != (Object)null)
				{
					Singleton<GameFlowManager>.Instance.TransitionToGameState((GameState)1, (NodeData)null);
				}
				yield break;
			}
			((InteractableBase)selectionSlot).SetEnabled(false);
			yield return Singleton<TextDisplayer>.Instance.ShowUntilInput("That's a fine " + ((Card)selectionSlot.Card).Info.displayedName + "...", -2.5f, 0.5f, (Emotion)0, (LetterAnimation)0, (Speaker)0, (string[])null, true);
			ScriptableObject.CreateInstance<CardInfo>();
			CardInfo modifiedCard = ((Card)selectionSlot.Card).Info;
			modifiedCard.cost = ((Card)selectionSlot.Card).Info.cost - 1;
			((Card)selectionSlot.Card).SetFaceDown(true, false);
			((Card)selectionSlot.Card).Info.cost = modifiedCard.cost;
			((Card)selectionSlot.Card).SetInfo(modifiedCard);
			((Card)selectionSlot.Card).RenderCard();
			yield return (object)new WaitForSeconds(0.6f);
			((Card)selectionSlot.Card).SetFaceDown(false, false);
			((CardCollectionInfo)RunState.Run.playerDeck).RemoveCard(((Card)selectionSlot.Card).Info);
			((CardCollectionInfo)RunState.Run.playerDeck).AddCard(modifiedCard);
			SaveManager.SaveToFile(false);
			Singleton<ViewManager>.Instance.SwitchToView((View)38, false, true);
			yield return (object)new WaitForSeconds(1.2f);
			selectionSlot.FlyOffCard();
			selectionSlot.Disable();
			((HighlightedInteractable)selectionSlot).SetShown(false, false);
			Singleton<SpecialNodeHandler>.Instance.cardStatBoostSequencer.selectionSlot.pile.Draw();
			Singleton<SpecialNodeHandler>.Instance.cardStatBoostSequencer.selectionSlot.pile.DestroyCardsImmediate();
			yield return (object)new WaitForSeconds(0.5f);
			if ((Object)(object)Singleton<GameFlowManager>.Instance != (Object)null)
			{
				Singleton<GameFlowManager>.Instance.TransitionToGameState((GameState)1, (NodeData)null);
			}
		}

		private void OnSlotSelectionEnded()
		{
			if ((Object)(object)selectionSlot.Card != (Object)null)
			{
				Debug.Log((object)"SlotSelectionEnded");
				((HighlightedInteractable)selectionSlot).SetShown(true, false);
				((HighlightedInteractable)selectionSlot).ShowState((State)2, false, 0.15f);
				Singleton<ViewManager>.Instance.SwitchToView((View)38, false, true);
				((MonoBehaviour)this).StartCoroutine(ApplyCardCostSequence(validCards: true));
			}
		}

		private List<CardInfo> GetValidCards()
		{
			List<CardInfo> list = new List<CardInfo>();
			list.Clear();
			list.AddRange(RunState.DeckList);
			list.RemoveAll((CardInfo x) => x.cost == 0);
			return list;
		}
	}
}
namespace CustomSideDeck
{
	[BepInPlugin("tvflabs.inscryption.CustomSideDeck", "CustomSideDeck", "2.3.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public class Part1CardDrawPiles_SideDeckData_Patch
		{
			public static void Postfix(ref List<CardInfo> __result, Part1CardDrawPiles __instance)
			{
				List<CardInfo> sideDeckCards = SideDeckCards;
				__result = sideDeckCards;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public class Part3CardDrawPiles_SideDeckData_Patch
		{
			public static void Postfix(ref List<CardInfo> __result, Part3CardDrawPiles __instance)
			{
				List<CardInfo> list = new List<CardInfo>();
				for (int i = 1; i < SideDeckCards.Count; i++)
				{
					object obj = SideDeckCards[i].Clone();
					CardInfo val = (CardInfo)((obj is CardInfo) ? obj : null);
					Part3CardDrawPiles.AddModsToVessel(val);
					list.Add(val);
				}
				__result = list;
			}
		}

		[HarmonyPatch(typeof(AscensionSaveData), "GetActiveChallengePoints")]
		public class AscensionSaveData_GetActiveChallengePoints_Patch
		{
			public static void Postfix(ref int __result, AscensionSaveData __instance)
			{
				if (CurrentSideDeck != null)
				{
					__result += CurrentSideDeck.challengePoints;
				}
			}
		}

		[HarmonyPatch(typeof(LoadingScreenManager), "LoadGameData")]
		public class LoadingScreenManager_LoadGameData_Patch
		{
			public static IEnumerator Postfix(IEnumerator values, LoadingScreenManager __instance)
			{
				yield return values;
				InitializeSideDecks();
			}
		}

		[HarmonyPatch(typeof(Part1CardDrawPiles), "Start")]
		public class Part1CardDrawPiles_Start_Patch
		{
			public static void Postfix(Part1CardDrawPiles __instance)
			{
				//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ae: Expected O, but got Unknown
				//IL_02c7: 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_02d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02da: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0304: Unknown result type (might be due to invalid IL or missing references)
				//IL_0320: Unknown result type (might be due to invalid IL or missing references)
				//IL_0327: Unknown result type (might be due to invalid IL or missing references)
				//IL_032e: Unknown result type (might be due to invalid IL or missing references)
				//IL_033a: Unknown result type (might be due to invalid IL or missing references)
				//IL_033f: Unknown result type (might be due to invalid IL or missing references)
				bool flag = false;
				Texture2D imageAsTexture = TextureHelper.GetImageAsTexture("CSD_squirrel_back.png", (FilterMode)0);
				if (CurrentSideDeck.cardBack != null)
				{
					if (CurrentSideDeck.cardBack == "squirrel")
					{
						imageAsTexture = TextureHelper.GetImageAsTexture("CSD_squirrel_back.png", (FilterMode)0);
						flag = true;
					}
					else if (CurrentSideDeck.cardBack == "bee")
					{
						imageAsTexture = TextureHelper.GetImageAsTexture("CSD_bee_back.png", (FilterMode)0);
						flag = true;
					}
					else if (CurrentSideDeck.cardBack == "waterborne" || CurrentSideDeck.cardBack == "aquasquirrel" || CurrentSideDeck.cardBack == "aqua" || CurrentSideDeck.cardBack == "submerge")
					{
						imageAsTexture = TextureHelper.GetImageAsTexture("CSD_aquasquirrel_back.png", (FilterMode)0);
						flag = true;
					}
					else if (CurrentSideDeck.cardBack == "blank")
					{
						imageAsTexture = TextureHelper.GetImageAsTexture("CSD_card_back_template.png", (FilterMode)0);
						flag = true;
					}
					if (!flag && !(CurrentSideDeck.cardBack == "generated") && !(CurrentSideDeck.cardBack == "gen"))
					{
						DirectoryInfo directoryInfo = new DirectoryInfo(Paths.PluginPath);
						FileInfo[] files = directoryInfo.GetFiles(CurrentSideDeck.cardBack, SearchOption.AllDirectories);
						if (files.Length != 0)
						{
							string fullName = files[0].FullName;
							if ((Object)(object)TextureHelper.GetImageAsTexture(fullName, (FilterMode)0) != (Object)null)
							{
								imageAsTexture = TextureHelper.GetImageAsTexture(fullName, (FilterMode)0);
								flag = true;
							}
						}
					}
				}
				if ((plugin.generateCardBacks.Value || (CurrentSideDeck.cardBack != null && (CurrentSideDeck.cardBack == "generated" || CurrentSideDeck.cardBack == "gen"))) && !flag)
				{
					imageAsTexture = TextureHelper.GetImageAsTexture("CSD_card_back_template.png", (FilterMode)0);
					Texture2D texture = CardLoader.GetCardByName(CurrentSideDeck.defaultCard).portraitTex.texture;
					if ((Object)(object)texture != (Object)null)
					{
						Color32[] pixels = texture.GetPixels32();
						Color32[] pixels2 = imageAsTexture.GetPixels32();
						for (int i = 0; i < pixels.Length; i++)
						{
							if (pixels[i].a > 0)
							{
								Color32 val = Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(pixels2[(i % ((Texture)texture).width + 5) * (i / ((Texture)texture).width + 49)]), Color32.op_Implicit(pixels[i]), ((float)(int)pixels[i].a - 8f) / 255f));
								imageAsTexture.SetPixel(i % ((Texture)texture).width + 5, i / ((Texture)texture).width + 49, Color32.op_Implicit(new Color32(val.r, val.g, val.b, byte.MaxValue)));
							}
						}
						imageAsTexture.Apply();
					}
				}
				Transform val2 = ((CardDrawPiles3D)__instance).SidePile.cardbackPrefab.transform.Find("BendableCard");
				GameObject gameObject = ((Component)val2.Find("Mesh")).gameObject;
				SkinnedMeshRenderer val3 = (SkinnedMeshRenderer)gameObject.GetComponentByName("SkinnedMeshRenderer");
				((Renderer)val3).materials[1].mainTexture = (Texture)(object)imageAsTexture;
			}
		}

		[HarmonyPatch(typeof(AscensionStartScreen), "ContinueGameSequence")]
		public class AscensionStartScreen_ContinueGameSequence_Patch
		{
			public static void Postfix()
			{
				InitializeSideDecks();
			}
		}

		[HarmonyPatch(typeof(DeckReviewSequencer), "OnEnterDeckView")]
		public class DeckReviewSequencer_OnEnterDeckView_Patch
		{
			public static bool Prefix(DeckReviewSequencer __instance)
			{
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Expected O, but got Unknown
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Expected O, but got Unknown
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Expected O, but got Unknown
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Expected O, but got Unknown
				//IL_0253: Unknown result type (might be due to invalid IL or missing references)
				//IL_025e: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_030c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0335: Unknown result type (might be due to invalid IL or missing references)
				//IL_035e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0387: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentSideDeck.canEditDuringRun && (CurrentSideDeck.csdType == "Configurable" || CurrentSideDeck.csdType == "Advanced"))
				{
					if ((Object)(object)mainDeckPile == (Object)null || (Object)(object)sideDeckPile == (Object)null || (Object)(object)mainDeckInteractable == (Object)null || (Object)(object)sideDeckInteractable == (Object)null)
					{
						mainDeckObject = new GameObject("MainDeck");
						GameObject val = new GameObject("SelectionInteractable");
						val.transform.parent = mainDeckObject.transform;
						Component obj = mainDeckObject.AddComponent(typeof(CardPile));
						mainDeckPile = (CardPile)(object)((obj is CardPile) ? obj : null);
						Component obj2 = val.AddComponent(typeof(GenericMainInputInteractable));
						mainDeckInteractable = (GenericMainInputInteractable)(object)((obj2 is GenericMainInputInteractable) ? obj2 : null);
						sideDeckObject = new GameObject("SideDeck");
						GameObject val2 = new GameObject("SelectionInteractable");
						val2.transform.parent = sideDeckObject.transform;
						Component obj3 = sideDeckObject.AddComponent(typeof(CardPile));
						sideDeckPile = (CardPile)(object)((obj3 is CardPile) ? obj3 : null);
						Component obj4 = val2.AddComponent(typeof(GenericMainInputInteractable));
						sideDeckInteractable = (GenericMainInputInteractable)(object)((obj4 is GenericMainInputInteractable) ? obj4 : null);
						CardPile component = GameObject.Find("PlayerDeckPile").GetComponent<CardPile>();
						CardPile component2 = GameObject.Find("SquirrelPile").GetComponent<CardPile>();
						mainDeckPile.CardBackPrefab = component.cardbackPrefab;
						sideDeckPile.CardBackPrefab = component2.cardbackPrefab;
						mainDeckPile.tapSoundEvent = component.tapSoundEvent;
						sideDeckPile.tapSoundEvent = component2.tapSoundEvent;
						mainDeckPile.shadow = component.shadow;
						sideDeckPile.shadow = component2.shadow;
						((MainInputInteractable)mainDeckInteractable).CursorSelectStarted = (Action<MainInputInteractable>)Delegate.Combine(((MainInputInteractable)mainDeckInteractable).CursorSelectStarted, (Action<MainInputInteractable>)delegate
						{
							OnMainDeckSelected(__instance);
						});
						((MainInputInteractable)sideDeckInteractable).CursorSelectStarted = (Action<MainInputInteractable>)Delegate.Combine(((MainInputInteractable)sideDeckInteractable).CursorSelectStarted, (Action<MainInputInteractable>)delegate
						{
							OnSideDeckSelected(__instance);
						});
						mainDeckInteractable.cursorType = (CursorType)4;
						sideDeckInteractable.cursorType = (CursorType)4;
						mainDeckInteractable.is2D = false;
						sideDeckInteractable.is2D = false;
						((MainInputInteractable)mainDeckInteractable).ParentInteractables.Add((MainInputInteractable)(object)mainDeckPile);
						((MainInputInteractable)sideDeckInteractable).ParentInteractables.Add((MainInputInteractable)(object)sideDeckPile);
						((InteractableBase)mainDeckInteractable).coll = (Collider)(object)val.AddComponent<BoxCollider>();
						((InteractableBase)sideDeckInteractable).coll = (Collider)(object)val2.AddComponent<BoxCollider>();
						Collider coll = ((InteractableBase)mainDeckInteractable).coll;
						((BoxCollider)((coll is BoxCollider) ? coll : null)).center = new Vector3(0f, 0.5f, 0f);
						Collider coll2 = ((InteractableBase)sideDeckInteractable).coll;
						((BoxCollider)((coll2 is BoxCollider) ? coll2 : null)).center = new Vector3(0f, 0.5f, 0f);
						Collider coll3 = ((InteractableBase)mainDeckInteractable).coll;
						((BoxCollider)((coll3 is BoxCollider) ? coll3 : null)).extents = new Vector3(0.7f, 0.5f, 1f);
						Collider coll4 = ((InteractableBase)sideDeckInteractable).coll;
						((BoxCollider)((coll4 is BoxCollider) ? coll4 : null)).extents = new Vector3(0.7f, 0.5f, 1f);
						Collider coll5 = ((InteractableBase)mainDeckInteractable).coll;
						((BoxCollider)((coll5 is BoxCollider) ? coll5 : null)).size = new Vector3(1.4f, 1f, 2f);
						Collider coll6 = ((InteractableBase)sideDeckInteractable).coll;
						((BoxCollider)((coll6 is BoxCollider) ? coll6 : null)).size = new Vector3(1.4f, 1f, 2f);
						((InteractableBase)mainDeckInteractable).SetEnabled(false);
						((InteractableBase)sideDeckInteractable).SetEnabled(false);
					}
					deckReviewState = "ChoosePile";
					entering = true;
					((MonoBehaviour)__instance).StartCoroutine(SpawnDeckPiles(__instance));
					return false;
				}
				deckReviewState = "";
				return true;
			}
		}

		[HarmonyPatch(typeof(DeckReviewSequencer), "OnExitDeckView")]
		public class DeckReviewSequencer_OnExitDeckView_Patch
		{
			public static bool Prefix(DeckReviewSequencer __instance)
			{
				if (CurrentSideDeck.canEditDuringRun && (CurrentSideDeck.csdType == "Configurable" || CurrentSideDeck.csdType == "Advanced"))
				{
					((InteractableBase)mainDeckInteractable).SetEnabled(false);
					((InteractableBase)sideDeckInteractable).SetEnabled(false);
					if (deckReviewState == "ChoosePile" && !exiting)
					{
						exiting = true;
						((MonoBehaviour)__instance).StartCoroutine(CleanUpDeckPiles(selectedMainPile: true, selectedSidePile: true, __instance));
					}
					return false;
				}
				return true;
			}
		}

		[AscensionScreenSort(/*Could not decode attribute arguments.*/)]
		public class SideDeckSelectionScreen : AscensionRunSetupScreenBase
		{
			private int numCardsToShow = 7;

			private List<SideDeckInfo> validSideDecks = new List<SideDeckInfo>();

			private GameObject selectedBorder;

			public static SideDeckSelectionScreen Instance;

			public int scrollIndex = 0;

			public override string headerText => "Select Side Deck";

			public override bool showCardDisplayer => true;

			public override bool showCardPanel => true;

			public override void InitializeScreen(GameObject partialScreen)
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = Resources.Load<GameObject>("prefabs/gbcui/pixelselectionborder");
				GameObject val2 = Object.Instantiate<GameObject>(val, ((Component)base.cards[0]).gameObject.transform);
				val2.GetComponent<SpriteRenderer>().color = GameColors.Instance.brightNearWhite;
				val2.AddComponent<PixelSnapElement>();
				selectedBorder = val2;
				Instance = this;
			}

			public override void CardClicked(PixelSelectableCard card)
			{
				if ((Object)(object)card != (Object)null && (Object)(object)((Card)card).Info != (Object)null)
				{
					CurrentSideDeck = SideDeckManager.GetSideDeckByName(CardExtensions.GetExtendedProperty(((Card)card).Info, "CSDAssociatedSideDeck"));
					ShowPage();
				}
			}

			public override void OnEnable()
			{
				((AscensionRunSetupScreenBase)this).OnEnable();
				InitializeSideDecks();
				validSideDecks.Clear();
				if (!AscensionSaveData.Data.ChallengeIsActive((AscensionChallenge)12))
				{
					validSideDecks.Add(SideDeckManager.GetSideDeckByName(CardExtensions.GetExtendedProperty(CardLoader.GetCardByName("Squirrel"), "CSDAssociatedSideDeck")));
					validSideDecks.Add(SideDeckManager.GetSideDeckByName(CardExtensions.GetExtendedProperty(CardLoader.GetCardByName("Bee"), "CSDAssociatedSideDeck")));
				}
				if (AscensionSaveData.Data.ChallengeIsActive((AscensionChallenge)12) || plugin.showAquasquirrelsWhenChallengeDisabled.Value)
				{
					validSideDecks.Add(SideDeckManager.GetSideDeckByName(CardExtensions.GetExtendedProperty(CardLoader.GetCardByName("AquaSquirrel"), "CSDAssociatedSideDeck")));
				}
				foreach (SideDeckInfo sideDecks in SideDeckManager.sideDecksList)
				{
					if (sideDecks.kayceesMod && !validSideDecks.Contains(sideDecks))
					{
						if (!AscensionSaveData.Data.ChallengeIsActive((AscensionChallenge)12) && !sideDecks.isAqua)
						{
							validSideDecks.Add(sideDecks);
						}
						if ((AscensionSaveData.Data.ChallengeIsActive((AscensionChallenge)12) || plugin.showAquasquirrelsWhenChallengeDisabled.Value) && sideDecks.isAqua)
						{
							validSideDecks.Add(sideDecks);
						}
					}
				}
				if (AscensionSaveData.Data.ChallengeIsActive((AscensionChallenge)12) && plugin.generateAquaVersions.Value)
				{
					foreach (SideDeckInfo sideDecks2 in SideDeckManager.sideDecksList)
					{
						if (validSideDecks.Contains(sideDecks2))
						{
							continue;
						}
						bool flag = false;
						if ((Object)(object)CardLoader.GetCardByName(sideDecks2.defaultCard) != (Object)null && !CardLoader.GetCardByName(sideDecks2.defaultCard).HasAbility((Ability)13))
						{
							flag = true;
						}
						if (!flag)
						{
							foreach (string card in sideDecks2.cards)
							{
								if ((Object)(object)CardLoader.GetCardByName(card) != (Object)null && !CardLoader.GetCardByName(card).HasAbility((Ability)13))
								{
									flag = true;
									break;
								}
							}
						}
						if (!flag)
						{
							foreach (string card2 in sideDecks2.cards)
							{
								if ((Object)(object)CardLoader.GetCardByName(card2) != (Object)null && !CardLoader.GetCardByName(card2).HasAbility((Ability)13))
								{
									flag = true;
									break;
								}
							}
						}
						if (flag)
						{
							validSideDecks.Add(sideDecks2);
						}
					}
				}
				CurrentSideDeck = validSideDecks[0];
				scrollIndex = 0;
				ShowPage();
				((AscensionRunSetupScreenBase)this).CardClicked(base.cards[0]);
			}

			public void ShowPage()
			{
				List<CardInfo> list = new List<CardInfo>();
				foreach (SideDeckInfo validSideDeck in validSideDecks)
				{
					CardInfo cardByName = CardLoader.GetCardByName(validSideDeck.defaultCard);
					if (AscensionSaveData.Data.ChallengeIsActive((AscensionChallenge)12) && plugin.generateAquaVersions.Value && !validSideDeck.isAqua)
					{
						string text = cardByName.DisplayedNameLocalized;
						if (char.IsUpper(text[0]))
						{
							text = ((text.Length <= 1) ? text.ToLower() : (char.ToLower(text[0]) + text.Substring(1)));
						}
						CardExtensions.SetDisplayedName(cardByName, "Aqua" + text);
						if (!cardByName.HasAbility((Ability)13))
						{
							CardExtensions.AddAbilities(cardByName, (Ability[])(object)new Ability[1] { (Ability)13 });
						}
					}
					list.Add(cardByName);
				}
				((AscensionRunSetupScreenBase)this).ShowCards(list.GetRange(scrollIndex, Math.Min(list.Count - scrollIndex, numCardsToShow)));
				selectedBorder.SetActive(false);
				foreach (PixelSelectableCard card in base.cards)
				{
					if ((Object)(object)card != (Object)null && ((Behaviour)card).enabled && (Object)(object)((Card)card).Info != (Object)null && CardExtensions.GetExtendedProperty(((Card)card).Info, "CSDAssociatedSideDeck") != null && CardExtensions.GetExtendedProperty(((Card)card).Info, "CSDAssociatedSideDeck") == CurrentSideDeck.internalName)
					{
						selectedBorder.transform.SetParent(((Component)card).transform.Find("Base/PixelSnap"), false);
						selectedBorder.SetActive(true);
						break;
					}
				}
				string text2 = "<color=#eef4c6>0</color> Challenge Points";
				if (CurrentSideDeck.challengePoints != 0)
				{
					text2 = ((CurrentSideDeck.challengePoints <= 0) ? ("<color=#eef4c6>" + CurrentSideDeck.challengePoints + "</color> Challenge Points") : ("<color=#eef4c6>+" + CurrentSideDeck.challengePoints + "</color> Challenge Points"));
				}
				SequentialPixelTextLines component = GameObjectExtensions.FindChild(((Component)this).gameObject, "Header").GetComponent<SequentialPixelTextLines>();
				component.ShowText(0.1f, new string[2]
				{
					"CURRENT SIDE DECK: " + text2,
					"Total Challenge Points: <color=#eef4c6>" + AscensionSaveData.Data.GetActiveChallengePoints() + "</color>"
				}, true);
			}

			public override void LeftButtonClicked(MainInputInteractable button)
			{
				if (scrollIndex > 0)
				{
					scrollIndex = Math.Max(0, scrollIndex - numCardsToShow);
					ShowPage();
				}
			}

			public override void RightButtonClicked(MainInputInteractable button)
			{
				if (scrollIndex < validSideDecks.Count - numCardsToShow)
				{
					scrollIndex += numCardsToShow;
					ShowPage();
				}
			}
		}

		[AscensionScreenSort(/*Could not decode attribute arguments.*/)]
		public class SideDeckConfigurationScreen : AscensionRunSetupScreenBase
		{
			private int numCardsToShow = 5;

			public static SideDeckConfigurationScreen Instance;

			public bool isAdvanced = false;

			public List<CardInfo> confCards;

			public int scrollIndex = 0;

			public override string headerText => "Configure Side Deck";

			public override bool showCardDisplayer => true;

			public override bool showCardPanel => true;

			public override void InitializeScreen(GameObject partialScreen)
			{
				Instance = this;
			}

			public override void CardClicked(PixelSelectableCard card)
			{
				if (!((Object)(object)card != (Object)null) || !((Object)(object)((Card)card).Info != (Object)null))
				{
					return;
				}
				int index = confCards.IndexOf(((Card)card).Info);
				string extendedProperty = CardExtensions.GetExtendedProperty(((Card)card).Info, "ConfIndex");
				confCards.RemoveAt(index);
				for (int i = 0; i <= CurrentSideDeck.options.Count; i++)
				{
					if (((Object)((Card)card).Info).name == CurrentSideDeck.options[i])
					{
						if (i == CurrentSideDeck.options.Count - 1)
						{
							((Card)card).SetInfo(CardExtensions.SetExtendedProperty(CardLoader.GetCardByName(CurrentSideDeck.options[0]), "ConfIndex", (object)extendedProperty));
						}
						else
						{
							((Card)card).SetInfo(CardExtensions.SetExtendedProperty(CardLoader.GetCardByName(CurrentSideDeck.options[i + 1]), "ConfIndex", (object)extendedProperty));
						}
						break;
					}
				}
				confCards.Insert(index, ((Card)card).Info);
				int num = 0;
				foreach (CardInfo confCard in confCards)
				{
					SetConfCard(((Object)confCard).name, num);
					num++;
				}
				ShowPage();
			}

			public override void OnEnable()
			{
				int num = 0;
				if (CurrentSideDeck.csdType == "Advanced")
				{
					isAdvanced = true;
					for (int i = 1; i <= CurrentSideDeck.cards.Count; i++)
					{
						if (!Utility.IsNullOrWhiteSpace(CurrentSideDeck.cards[i - 1]) && (CurrentSideDeck.cards[i - 1] == "conf" || CurrentSideDeck.cards[i - 1] == "c"))
						{
							num++;
						}
					}
				}
				else if (CurrentSideDeck.options.Count > 0)
				{
					num = CurrentSideDeck.numCards;
				}
				if (CurrentSideDeck.options.Count == 0 || num == 0)
				{
					((MainInputInteractable)base.continueButton).CursorSelectStart();
					((MainInputInteractable)base.continueButton).CursorSelectEnd();
					return;
				}
				((AscensionRunSetupScreenBase)this).OnEnable();
				confCards = new List<CardInfo>();
				if (isAdvanced)
				{
					for (int j = 1; j <= num; j++)
					{
						confCards.Add(CardLoader.GetCardByName(CurrentSideDeck.options[0]));
					}
				}
				else
				{
					for (int k = 1; k <= CurrentSideDeck.numCards; k++)
					{
						confCards.Add(CardLoader.GetCardByName(CurrentSideDeck.options[0]));
					}
				}
				int num2 = 0;
				foreach (CardInfo confCard in confCards)
				{
					SetConfCard(((Object)confCard).name, num2);
					num2++;
				}
				ShowPage();
			}

			public void ShowPage()
			{
				((AscensionRunSetupScreenBase)this).ShowCards(confCards.GetRange(scrollIndex, Math.Min(confCards.Count - scrollIndex, numCardsToShow)));
				string text = "<color=#eef4c6>0</color> Challenge Points";
				if (CurrentSideDeck.challengePoints != 0)
				{
					text = ((CurrentSideDeck.challengePoints <= 0) ? ("<color=#eef4c6>" + CurrentSideDeck.challengePoints + "</color> Challenge Points") : ("<color=#eef4c6>+" + CurrentSideDeck.challengePoints + "</color> Challenge Points"));
				}
				SequentialPixelTextLines component = GameObjectExtensions.FindChild(((Component)this).gameObject, "Header").GetComponent<SequentialPixelTextLines>();
				component.ShowText(0.1f, new string[2]
				{
					"CURRENT SIDE DECK: " + text,
					"Total Challenge Points: <color=#eef4c6>" + AscensionSaveData.Data.GetActiveChallengePoints() + "</color>"
				}, true);
			}

			public override void LeftButtonClicked(MainInputInteractable button)
			{
				if (scrollIndex > 0)
				{
					scrollIndex = Math.Max(0, scrollIndex - numCardsToShow);
					ShowPage();
				}
			}

			public override void RightButtonClicked(MainInputInteractable button)
			{
				if (scrollIndex < confCards.Count - numCardsToShow)
				{
					scrollIndex += numCardsToShow;
					ShowPage();
				}
			}
		}

		private Harmony harmony = new Harmony("tvflabs.inscryption.CustomSideDeck");

		private const string PluginGuid = "tvflabs.inscryption.CustomSideDeck";

		private const string PluginName = "CustomSideDeck";

		private const string PluginVersion = "2.3.0";

		private const string PluginPrefix = "CustomSideDeck";

		private static Plugin plugin;

		private static bool alreadyInitialized;

		private ConfigEntry<bool> generateCardBacks;

		private ConfigEntry<bool> generateAquaVersions;

		private ConfigEntry<bool> showAquasquirrelsWhenChallengeDisabled;

		private static string deckReviewState = "";

		private static CardPile mainDeckPile = null;

		private static CardPile sideDeckPile = null;

		private static GenericMainInputInteractable mainDeckInteractable = null;

		private static GenericMainInputInteractable sideDeckInteractable = null;

		private static GameObject mainDeckObject = null;

		private static GameObject sideDeckObject = null;

		private static Vector3 defaultMainPilePos = new Vector3(-1.09f, 5.0196f, 1.36f);

		private static Vector3 defaultSidePilePos = new Vector3(1.71f, 5.0199f, 1.36f);

		private static bool entering = false;

		private static bool exiting = false;

		private static List<CardInfo> sideDeckCards = new List<CardInfo>();

		public static List<CardInfo> SideDeckCards
		{
			get
			{
				List<CardInfo> list = new List<CardInfo>();
				if (CurrentSideDeck.csdType != "Advanced")
				{
					for (int i = 0; i < CurrentSideDeck.numCards; i++)
					{
						if (CurrentSideDeck.options.Count > 0)
						{
							list.Add(CardLoader.GetCardByName(GetConfCards()[i]));
						}
						else
						{
							list.Add(CardLoader.GetCardByName(CurrentSideDeck.defaultCard));
						}
					}
				}
				else
				{
					int num = 0;
					foreach (string card in CurrentSideDeck.cards)
					{
						if (card == "conf")
						{
							list.Add(CardLoader.GetCardByName(GetConfCards()[num]));
							num++;
						}
						else if (card == "def" || card == "self")
						{
							CardLoader.GetCardByName(CurrentSideDeck.defaultCard);
						}
						else
						{
							list.Add(CardLoader.GetCardByName(card));
						}
					}
				}
				if (AscensionSaveData.Data.ChallengeIsActive((AscensionChallenge)12) && !CurrentSideDeck.isAqua)
				{
					foreach (CardInfo item in list)
					{
						string text = item.DisplayedNameLocalized;
						if (char.IsUpper(text[0]))
						{
							text = ((text.Length <= 1) ? text.ToLower() : (char.ToLower(text[0]) + text.Substring(1)));
						}
						CardExtensions.SetDisplayedName(item, "Aqua" + text);
						if (!item.HasAbility((Ability)13))
						{
							CardExtensions.AddAbilities(item, (Ability[])(object)new Ability[1] { (Ability)13 });
						}
					}
				}
				return list;
			}
		}

		public static SideDeckInfo CurrentSideDeck
		{
			get
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Invalid comparison between Unknown and I4
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Invalid comparison between Unknown and I4
				if (SaveFile.IsAscension)
				{
					string value = ModdedSaveManager.SaveData.GetValue("tvflabs.inscryption.CustomSideDeck", "CurrentSideDeck");
					return (!string.IsNullOrEmpty(value)) ? SideDeckManager.GetSideDeckByName(value) : SideDeckManager.GetSideDeckByName("_Squirrel");
				}
				if (SaveManager.SaveFile.IsPart1)
				{
					CardDrawPiles instance = Singleton<CardDrawPiles>.Instance;
					if ((int)((Part1CardDrawPiles)((instance is Part1CardDrawPiles) ? instance : null)).sidePileFigurine == 1)
					{
						return SideDeckManager.GetSideDeckByName("_Bee");
					}
					CardDrawPiles instance2 = Singleton<CardDrawPiles>.Instance;
					if ((int)((Part1CardDrawPiles)((instance2 is Part1CardDrawPiles) ? instance2 : null)).sidePileFigurine == 2)
					{
						return SideDeckManager.GetSideDeckByName("_AquaSquirrel");
					}
					return SideDeckManager.GetSideDeckByName("_Squirrel");
				}
				if (SaveManager.SaveFile.IsPart3)
				{
					if (StoryEventsData.EventCompleted((StoryEvent)54))
					{
						return SideDeckManager.GetSideDeckByName("_EmptyVessel_GreenGem");
					}
					return SideDeckManager.GetSideDeckByName("_EmptyVessel");
				}
				return SideDeckManager.GetSideDeckByName("_Squirrel");
			}
			set
			{
				ModdedSaveManager.SaveData.SetValue("tvflabs.inscryption.CustomSideDeck", "CurrentSideDeck", (object)value.internalName);
			}
		}

		private void Awake()
		{
			plugin = this;
			generateCardBacks = ((BaseUnityPlugin)this).Config.Bind<bool>("CSDConfig", "GenerateDefaultCardBacks", false, "How the mod should handle side deck card backs for side decks that don't add their own custom card back. If enabled, automatically generates a unique card back based on the side deck's main card's portrait. Otherwise, the default squirrel back will be used.");
			generateAquaVersions = ((BaseUnityPlugin)this).Config.Bind<bool>("CSDConfig", "GenerateAquaVersions", false, "Whether to automatically add an Aqua version of all custom side decks. Buggy, not recommended.");
			showAquasquirrelsWhenChallengeDisabled = ((BaseUnityPlugin)this).Config.Bind<bool>("CSDConfig", "ShowAquaSideDecksWhenSquirrelFishChallengeDisabled", false, "Whether or not Aquasquirrels and custom side decks marked as `CSDIsAqua` should be shown as options even when the Squirrel Fish challenge isn't on.");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded CustomSideDeck!");
			harmony.PatchAll();
			AscensionScreenManager.RegisterScreen<SideDeckSelectionScreen>();
			AscensionScreenManager.RegisterScreen<SideDeckConfigurationScreen>();
			RegisterSideDecks();
		}

		private void RegisterSideDecks()
		{
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Squirrel"), "CSDIsSideDeck", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Squirrel"), "CSDSideDeckType", (object)"Basic");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Squirrel"), "CSDCardBack", (object)"squirrel");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Squirrel"), "CSDChallengePoints", (object)"0");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Squirrel"), "CSDAct1", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Squirrel"), "CSDKayceesMod", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Bee"), "CSDIsSideDeck", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Bee"), "CSDSideDeckType", (object)"Basic");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Bee"), "CSDCardBack", (object)"bee");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Bee"), "CSDChallengePoints", (object)"-20");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Bee"), "CSDAct1", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("Bee"), "CSDKayceesMod", (object)"true");
			CardExtensions.SetPixelPortrait(CardLoader.GetCardByName("Bee"), TextureHelper.GetImageAsSprite("pixelportrait_bee.png", (SpriteType)1, (FilterMode)0));
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("AquaSquirrel"), "CSDIsSideDeck", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("AquaSquirrel"), "CSDSideDeckType", (object)"Basic");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("AquaSquirrel"), "CSDCardBack", (object)"aquasquirrel");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("AquaSquirrel"), "CSDIsAqua", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("AquaSquirrel"), "CSDChallengePoints", (object)"0");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("AquaSquirrel"), "CSDKayceesMod", (object)"true");
			CardExtensions.SetPixelPortrait(CardLoader.GetCardByName("AquaSquirrel"), TextureHelper.GetImageAsSprite("pixelportrait_aquasquirrel.png", (SpriteType)1, (FilterMode)0));
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel"), "CSDIsSideDeck", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel"), "CSDSideDeckType", (object)"Basic");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel"), "CSDCardBack", (object)"blank");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel"), "CSDChallengePoints", (object)"5");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel"), "CSDAct3", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDIsSideDeck", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDSideDeckType", (object)"Configurable");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDNumCards", (object)"10");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDNumOptions", (object)"3");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDOption1", (object)"EmptyVessel_GreenGem");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDOption2", (object)"EmptyVessel_OrangeGem");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDOption3", (object)"EmptyVessel_BlueGem");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDCardBack", (object)"blank");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDChallengePoints", (object)"0");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDCanEditDuringRun", (object)"true");
			CardExtensions.SetExtendedProperty(CardLoader.GetCardByName("EmptyVessel_GreenGem"), "CSDAct3", (object)"true");
		}

		public static List<string> GetConfCards()
		{
			List<string> list = new List<string>();
			if (CurrentSideDeck.csdType != "Advanced")
			{
				if (CurrentSideDeck.options.Count > 0)
				{
					for (int i = 0; i < CurrentSideDeck.numCards; i++)
					{
						list.Add(ModdedSaveManager.SaveData.GetValue("tvflabs.inscryption.CustomSideDeck", $"ConfCard{i}"));
					}
				}
			}
			else
			{
				int num = 0;
				foreach (string card in CurrentSideDeck.cards)
				{
					if (card == "conf")
					{
						list.Add(ModdedSaveManager.SaveData.GetValue("tvflabs.inscryption.CustomSideDeck", $"ConfCard{num}"));
						num++;
					}
				}
			}
			return list;
		}

		public static void SetConfCard(string card, int cardNum)
		{
			ModdedSaveManager.SaveData.SetValue("tvflabs.inscryption.CustomSideDeck", $"ConfCard{cardNum}", (object)card);
		}

		private static void InitializeSideDecks()
		{
			//IL_005c: 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_00aa: Invalid comparison between Unknown and I4
			if (alreadyInitialized)
			{
				return;
			}
			if (Chainloader.PluginInfos.ContainsKey("zorro.inscryption.infiniscryption.sidedecks"))
			{
				foreach (CardInfo item in CardManager.AllCardsCopy)
				{
					if (CardExtensions.HasCardMetaCategory(item, GuidManager.GetEnumValue<CardMetaCategory>("zorro.inscryption.infiniscryption.sidedecks", "SideDeck")) && (!CardExtensions.GetExtendedPropertyAsBool(item, "CSDIsSideDeck").HasValue || !CardExtensions.GetExtendedPropertyAsBool(item, "CSDIsSideDeck").Value) && (int)item.temple == 0)
					{
						CardExtensions.SetExtendedProperty(item, "CSDIsSideDeck", (object)"true");
						CardExtensions.SetExtendedProperty(item, "CSDSideDeckType", (object)"Basic");
						if (CardExtensions.GetExtendedPropertyAsInt(item, "SideDeckValue").HasValue)
						{
							CardExtensions.SetExtendedProperty(item, "CSDChallengePoints", (object)(-CardExtensions.GetExtendedPropertyAsInt(item, "SideDeckValue")));
						}
					}
				}
			}
			foreach (CardInfo item2 in CardManager.AllCardsCopy)
			{
				if (!CardExtensions.GetExtendedPropertyAsBool(item2, "CSDIsSideDeck").HasValue || !CardExtensions.GetExtendedPropertyAsBool(item2, "CSDIsSideDeck").Value)
				{
					continue;
				}
				SideDeckInfo sideDeckInfo;
				if (CardExtensions.GetExtendedProperty(item2, "CSDSideDeckType").ToLower() == "basic")
				{
					sideDeckInfo = SideDeckManager.New(CardExtensions.GetModPrefix(item2), ((Object)item2).name, "Basic", new List<string>(), new List<string>(), ((Object)item2).name);
				}
				else if (CardExtensions.GetExtendedProperty(item2, "CSDSideDeckType").ToLower() == "setcount")
				{
					sideDeckInfo = SideDeckManager.New(CardExtensions.GetModPrefix(item2), ((Object)item2).name, "SetCount", new List<string>(), new List<string>(), ((Object)item2).name, CardExtensions.GetExtendedPropertyAsInt(item2, "CSDNumCards") ?? 10);
				}
				else if (CardExtensions.GetExtendedProperty(item2, "CSDSideDeckType").ToLower() == "configurable")
				{
					List<string> list = new List<string>();
					for (int i = 0; i < CardExtensions.GetExtendedPropertyAsInt(item2, "CSDNumOptions").GetValueOrDefault(); i++)
					{
						list.Add(CardExtensions.GetExtendedProperty(item2, $"CSDOption{i + 1}"));
					}
					sideDeckInfo = SideDeckManager.New(CardExtensions.GetModPrefix(item2), ((Object)item2).name, "Configurable", new List<string>(), list, ((Object)item2).name, CardExtensions.GetExtendedPropertyAsInt(item2, "CSDNumCards") ?? 10);
				}
				else if (CardExtensions.GetExtendedProperty(item2, "CSDSideDeckType").ToLower() == "advanced")
				{
					List<string> list2 = new List<string>();
					for (int j = 0; j < CardExtensions.GetExtendedPropertyAsInt(item2, "CSDNumOptions").GetValueOrDefault(); j++)
					{
						list2.Add(CardExtensions.GetExtendedProperty(item2, $"CSDOption{j + 1}"));
					}
					List<string> list3 = new List<string>();
					for (int k = 0; k < (CardExtensions.GetExtendedPropertyAsInt(item2, "CSDNumCards") ?? 1); k++)
					{
						list3.Add(CardExtensions.GetExtendedProperty(item2, $"CSDCard{k + 1}"));
					}
					sideDeckInfo = SideDeckManager.New(CardExtensions.GetModPrefix(item2), ((Object)item2).name, "Advanced", list3, list2, ((Object)item2).name, CardExtensions.GetExtendedPropertyAsInt(item2, "CSDNumCards") ?? 10);
				}
				else
				{
					sideDeckInfo = SideDeckManager.New(CardExtensions.GetModPrefix(item2), ((Object)item2).name, "Basic", new List<string>(), new List<string>(), ((Object)item2).name);
				}
				if (CardExtensions.GetExtendedPropertyAsBool(item2, "CSDAct1").HasValue || CardExtensions.GetExtendedPropertyAsBool(item2, "CSDAct3").HasValue || CardExtensions.GetExtendedPropertyAsBool(item2, "CSDKayceesMod").HasValue)
				{
					sideDeckInfo.act1 = CardExtensions.GetExtendedPropertyAsBool(item2, "CSDAct1").HasValue && CardExtensions.GetExtendedPropertyAsBool(item2, "CSDAct1").Value;
					sideDeckInfo.act3 = CardExtensions.GetExtendedPropertyAsBool(item2, "CSDAct3").HasValue && CardExtensions.GetExtendedPropertyAsBool(item2, "CSDAct3").Value;
					sideDeckInfo.kayceesMod = CardExtensions.GetExtendedPropertyAsBool(item2, "KayceesMod").HasValue && CardExtensions.GetExtendedPropertyAsBool(item2, "KayceesMod").Value;
				}
				sideDeckInfo.cardBack = CardExtensions.GetExtendedProperty(item2, "CSDCardBack");
				sideDeckInfo.isAqua = CardExtensions.GetExtendedPropertyAsBool(item2, "CSDIsAqua").HasValue && CardExtensions.GetExtendedPropertyAsBool(item2, "CSDIsAqua").Value;
				sideDeckInfo.challengePoints = (CardExtensions.GetExtendedPropertyAsInt(item2, "CSDChallengePoints").HasValue ? CardExtensions.GetExtendedPropertyAsInt(item2, "CSDChallengePoints").Value : 0);
				sideDeckInfo.canEditDuringRun = CardExtensions.GetExtendedPropertyAsBool(item2, "CSDCanEditDuringRun").HasValue && CardExtensions.GetExtendedPropertyAsBool(item2, "CSDCanEditDuringRun").Value;
				CardExtensions.SetExtendedProperty(item2, "CSDAssociatedSideDeck", (object)sideDeckInfo.internalName);
			}
			alreadyInitialized = true;
		}

		private static void OnMainDeckSelected(DeckReviewSequencer deckReviewSequencer)
		{
			deckReviewState = "MainDeck";
			((InteractableBase)mainDeckInteractable).SetEnabled(false);
			((InteractableBase)sideDeckInteractable).SetEnabled(false);
			((MonoBehaviour)deckReviewSequencer).StartCoroutine(CleanUpDeckPiles(selectedMainPile: true, selectedSidePile: false, deckReviewSequencer));
			Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)1;
			CustomCoroutine.WaitThenExecute(0.2f, (Action)delegate
			{
				deckReviewSequencer.ArrayDeck(((CardCollectionInfo)SaveManager.SaveFile.CurrentDeck).Cards, (Action<SelectableCard>)null, false);
			}, false);
		}

		private static void OnSideDeckSelected(DeckReviewSequencer deckReviewSequencer)
		{
			deckReviewState = "EditSideDeck";
			((MonoBehaviour)deckReviewSequencer).StartCoroutine(CleanUpDeckPiles(selectedMainPile: false, selectedSidePile: true, deckReviewSequencer));
			((InteractableBase)mainDeckInteractable).SetEnabled(false);
			((InteractableBase)sideDeckInteractable).SetEnabled(false);
			Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)1;
			sideDeckCards.Clear();
			foreach (string confCard in GetConfCards())
			{
				sideDeckCards.Add(CardLoader.GetCardByName(confCard));
			}
			CustomCoroutine.WaitThenExecute(0.2f, (Action)delegate
			{
				deckReviewSequencer.ArrayDeck(sideDeckCards, (Action<SelectableCard>)OnSideDeckCardSelected, false);
			}, false);
		}

		private static void OnSideDeckCardSelected(SelectableCard card)
		{
			string name = ((Object)((Card)card).Info).name;
			if ((Object)(object)card != (Object)null && (Object)(object)((Card)card).Info != (Object)null)
			{
				int index = sideDeckCards.IndexOf(((Card)card).Info);
				string extendedProperty = CardExtensions.GetExtendedProperty(((Card)card).Info, "ConfIndex");
				sideDeckCards.RemoveAt(index);
				for (int i = 0; i <= CurrentSideDeck.options.Count; i++)
				{
					if (((Object)((Card)card).Info).name == CurrentSideDeck.options[i])
					{
						if (i == CurrentSideDeck.options.Count - 1)
						{
							((Card)card).SetInfo(CardExtensions.SetExtendedProperty(CardLoader.GetCardByName(CurrentSideDeck.options[0]), "ConfIndex", (object)extendedProperty));
						}
						else
						{
							((Card)card).SetInfo(CardExtensions.SetExtendedProperty(CardLoader.GetCardByName(CurrentSideDeck.options[i + 1]), "ConfIndex", (object)extendedProperty));
						}
						break;
					}
				}
				sideDeckCards.Insert(index, ((Card)card).Info);
				int num = 0;
				foreach (CardInfo sideDeckCard in sideDeckCards)
				{
					SetConfCard(((Object)sideDeckCard).name, num);
					num++;
				}
				((Card)card).SetInfo(sideDeckCards[index]);
			}
			((Card)card).Anim.LightNegationEffect();
		}

		private static IEnumerator SpawnDeckPiles(DeckReviewSequencer deckReviewSequencer)
		{
			Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)1;
			((Component)mainDeckPile).transform.position = defaultMainPilePos;
			((Component)sideDeckPile).transform.position = defaultSidePilePos;
			((MonoBehaviour)deckReviewSequencer).StartCoroutine(mainDeckPile.SpawnCards(((CardCollectionInfo)SaveManager.SaveFile.CurrentDeck).Cards.Count, 0.5f));
			((MonoBehaviour)deckReviewSequencer).StartCoroutine(sideDeckPile.SpawnCards(GetNumConfCards(), 0.5f));
			yield return (object)new WaitUntil((Func<bool>)(() => !mainDeckPile.DoingCardOperation && !sideDeckPile.DoingCardOperation));
			yield return (object)new WaitForSeconds(0.5f);
			Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)0;
			((InteractableBase)mainDeckInteractable).SetEnabled(true);
			((InteractableBase)sideDeckInteractable).SetEnabled(true);
			entering = false;
		}

		private static IEnumerator CleanUpDeckPiles(bool selectedMainPile, bool selectedSidePile, DeckReviewSequencer deckReviewSequencer)
		{
			Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)1;
			Tween.Position(((Component)mainDeckPile).transform, defaultMainPilePos + Vector3.back * 3.5f, selectedMainPile ? 0.15f : 0.2f, selectedMainPile ? 0.15f : 0f, Tween.EaseLinear, (LoopType)0, (Action)null, (Action)delegate
			{
				if (!selectedMainPile)
				{
					mainDeckPile.DestroyCardsImmediate();
				}
			}, true);
			Tween.Position(((Component)sideDeckPile).transform, defaultSidePilePos + Vector3.back * 3.5f, selectedSidePile ? 0.15f : 0.2f, selectedSidePile ? 0.15f : 0f, Tween.EaseLinear, (LoopType)0, (Action)null, (Action)delegate
			{
				if (!selectedSidePile)
				{
					sideDeckPile.DestroyCardsImmediate();
				}
			}, true);
			if (selectedMainPile)
			{
				((MonoBehaviour)deckReviewSequencer).StartCoroutine(mainDeckPile.DestroyCards(0.2f));
			}
			if (selectedSidePile)
			{
				((MonoBehaviour)deckReviewSequencer).StartCoroutine(sideDeckPile.DestroyCards(0.2f));
			}
			yield return (object)new WaitUntil((Func<bool>)(() => !mainDeckPile.DoingCardOperation && !sideDeckPile.DoingCardOperation));
			Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)0;
			exiting = false;
		}

		private static int GetNumConfCards()
		{
			int num = 0;
			if (CurrentSideDeck.csdType == "Advanced")
			{
				for (int i = 1; i <= CurrentSideDeck.cards.Count; i++)
				{
					if (!Utility.IsNullOrWhiteSpace(CurrentSideDeck.cards[i - 1]) && (CurrentSideDeck.cards[i - 1] == "conf" || CurrentSideDeck.cards[i - 1] == "c"))
					{
						num++;
					}
				}
			}
			else if (CurrentSideDeck.options.Count > 0)
			{
				num = CurrentSideDeck.numCards;
			}
			return num;
		}
	}
	internal class SideDeckIcon : MainInputInteractable
	{
		public SideDeckInfo Info;

		private Plugin.SideDeckSelectionScreen ScreenParent => ((Component)this).GetComponentInParent<Plugin.SideDeckSelectionScreen>();

		public override bool CollisionIs2D => true;

		public override void OnCursorEnter()
		{
			((AscensionRunSetupScreenBase)ScreenParent).DisplayCardInfo((CardInfo)null, Localization.Translate(Info.displayName), Info.description + $"\nContains {Info.cards.Count} cards", false);
		}

		public override void OnCursorExit()
		{
			((AscensionRunSetupScreenBase)ScreenParent).ClearMessage();
		}
	}
	public static class SideDeckManager
	{
		public static List<SideDeckInfo> sideDecksList = new List<SideDeckInfo>();

		public static SideDeckInfo New(string modPrefix, string name, string csdType, List<string> cards, List<string> options, string defaultCard, int numCards = 10, string cardBack = null, string pixelCardBack = null, bool isAqua = false, int challengePoints = 0, bool canEditDuringRun = false, bool act1 = false, bool act3 = false, bool kayceesMod = true)
		{
			SideDeckInfo sideDeckInfo = new SideDeckInfo();
			sideDeckInfo.internalName = modPrefix + "_" + name;
			sideDeckInfo.numCards = numCards;
			sideDeckInfo.defaultCard = defaultCard;
			sideDeckInfo.cards = new List<string>();
			sideDeckInfo.options = new List<string>();
			sideDeckInfo.csdType = csdType;
			sideDeckInfo.isAqua = isAqua;
			sideDeckInfo.challengePoints = challengePoints;
			sideDeckInfo.canEditDuringRun = canEditDuringRun;
			sideDeckInfo.act1 = act1;
			sideDeckInfo.act3 = act3;
			sideDeckInfo.kayceesMod = kayceesMod;
			foreach (string card in cards)
			{
				sideDeckInfo.cards.Add(card);
			}
			foreach (string option in options)
			{
				sideDeckInfo.options.Add(option);
			}
			sideDecksList.Add(sideDeckInfo);
			return sideDeckInfo;
		}

		public static SideDeckInfo GetSideDeckByName(string name)
		{
			return sideDecksList.Find((SideDeckInfo sideDeck) => sideDeck.internalName == name);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "CustomSideDeck";

		public const string PLUGIN_NAME = "CustomSideDeck";

		public const string PLUGIN_VERSION = "2.3.2";
	}
}
namespace CustomSideDeck.Info
{
	public class SideDeckInfo
	{
		public string internalName;

		public string displayName;

		public string description;

		public string csdType;

		public int numCards;

		public string defaultCard;

		public List<string> cards;

		public List<string> options;

		public string cardBack;

		public string pixelCardBack;

		public bool isAqua;

		public bool act1;

		public bool act3;

		public bool kayceesMod;

		public int challengePoints;

		public bool canEditDuringRun;
	}
}