using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using DiskCardGame;
using HarmonyLib;
using InscryptionAPI.Encounters;
using InscryptionAPI.Regions;
using OLD_SA.Tribes;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("OldSa_Battle")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OldSa_Battle")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a79770a7-eb75-4467-a2c4-5ab71b61dbe0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace OLD_SA.Patches
{
	[HarmonyPatch(typeof(RegionData), "GetBlueprintForNode")]
	public static class EncounterDifficultyPatch
	{
		[HarmonyPostfix]
		public static void Postfix(CardBattleNodeData nodeData, ref EncounterBlueprintData __result, RegionData __instance)
		{
			if ((Object)(object)__result == (Object)null || nodeData == null || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			int difficulty = nodeData.difficulty;
			int difficultyModifier = RunState.Run.DifficultyModifier;
			if (!((Object)__result).name.StartsWith("OLD_SA_BATTLE") || (difficulty >= __result.minDifficulty && difficulty <= __result.maxDifficulty))
			{
				return;
			}
			List<EncounterBlueprintData> list = new List<EncounterBlueprintData>();
			foreach (EncounterBlueprintData encounter in __instance.encounters)
			{
				if (!((Object)(object)encounter == (Object)null))
				{
					if (!((Object)encounter).name.StartsWith("OLD_SA_BATTLE"))
					{
						list.Add(encounter);
					}
					else if (encounter.PrerequisitesMet() && difficulty >= encounter.minDifficulty && difficulty <= encounter.maxDifficulty)
					{
						list.Add(encounter);
					}
				}
			}
			if (list.Count != 0)
			{
				__result = list[SeededRandom.Range(0, list.Count, SaveManager.SaveFile.GetCurrentRandomSeed())];
			}
		}
	}
}
namespace OLD_SA.Battle
{
	public static class BattleAPI
	{
		private const int EASY_MIN = 1;

		private const int EASY_MAX = 3;

		private const int LOW_MIN = 4;

		private const int LOW_MAX = 8;

		private const int MEDIUM_MIN = 9;

		private const int MEDIUM_MAX = 12;

		private const int HIGH_MIN = 13;

		private const int HIGH_MAX = 20;

		public static EncounterBlueprintData WolfPack;

		public static EncounterBlueprintData SwarmCrisis;

		public static EncounterBlueprintData BoneCrisis;

		public static EncounterBlueprintData Attack;

		public static EncounterBlueprintData HoovedPack;

		public static EncounterBlueprintData Magic;

		public static EncounterBlueprintData Cat;

		public static EncounterBlueprintData Snake;

		public static EncounterBlueprintData Bird;

		public static EncounterBlueprintData Mosquito;

		public static EncounterBlueprintData Crab;

		private static CardBlueprint Card(string cardName, int minDifficulty = 1, int maxDifficulty = 20)
		{
			return EncounterManager.NewCardBlueprint(cardName, 0, false, 0, (string)null, minDifficulty, maxDifficulty);
		}

		public static void Init()
		{
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Expected I4, but got Unknown
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Expected I4, but got Unknown
			//IL_0650: Unknown result type (might be due to invalid IL or missing references)
			//IL_0656: Expected I4, but got Unknown
			//IL_093d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0943: Expected I4, but got Unknown
			try
			{
				WolfPack = EncounterManager.New("OLD_SA_BATTLE_WOLF_PACK", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(WolfPack, new List<CardBlueprint>[5]
				{
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[4]
					{
						Card("OLD_SA_WARG"),
						Card("Rabbit", 1, 3),
						Card("WolfCub", 4, 12),
						Card("Wolf", 13)
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("WolfCub", 1, 8),
						Card("Wolf", 9)
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[3]
					{
						Card("Mole", 4, 8),
						Card("WolfCub", 9, 12),
						Card("Wolf", 13)
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("OLD_SA_WARG", 4),
						Card("WolfCub", 13)
					}),
					EncounterManager.CreateTurn(Card("Alpha", 13))
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(WolfPack, (Tribe[])(object)new Tribe[1] { (Tribe)3 });
				SwarmCrisis = EncounterManager.New("OLD_SA_BATTLE_SWARM_CRISIS", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(SwarmCrisis, new List<CardBlueprint>[5]
				{
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[3]
					{
						Card("OLD_SA_WHORLTOOTH_WORM"),
						Card("Bee", 4, 8),
						Card("AntQueen", 9)
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("Bee", 1, 8),
						Card("Ant", 9)
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("Bee", 9, 12),
						Card("OLD_SA_WASP", 13)
					}),
					EncounterManager.CreateTurn(Card("OLD_SA_WHORLTOOTH_WORM", 13)),
					EncounterManager.CreateTurn(Card("Mole", 4))
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(SwarmCrisis, (Tribe[])(object)new Tribe[1] { (Tribe)6 });
				BoneCrisis = EncounterManager.New("OLD_SA_BATTLE_BONE_CRISIS", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(BoneCrisis, new List<CardBlueprint>[6]
				{
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("OLD_SA_GULPER_EEL", 9),
						Card("OLD_SA_ARMORED_CATFISH")
					}),
					EncounterManager.CreateTurn("OLD_SA_BONEGULL"),
					EncounterManager.CreateTurn((CardBlueprint)null),
					EncounterManager.CreateTurn("Mole"),
					EncounterManager.CreateTurn("OLD_SA_BONEGULL"),
					EncounterManager.CreateTurn(Card("DireWolfCub", 13))
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(BoneCrisis, (Tribe[])(object)new Tribe[1] { (Tribe)2 });
				Attack = EncounterManager.New("OLD_SA_BATTLE_ATTACK", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(Attack, new List<CardBlueprint>[6]
				{
					EncounterManager.CreateTurn(new string[2] { "Mantis", "OLD_SA_MANTIS_SHRIMP" }),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("Mole", 1, 12),
						Card("Porcupine", 13)
					}),
					EncounterManager.CreateTurn("Mantis"),
					EncounterManager.CreateTurn(Card("OLD_SA_STAG_BEETLE", 9)),
					EncounterManager.CreateTurn((CardBlueprint)null),
					EncounterManager.CreateTurn(Card("OLD_SA_MANTIS_SHRIMP", 13))
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(Attack, (Tribe[])(object)new Tribe[1] { (Tribe)(int)TribesAPI.Crustacean });
				HoovedPack = EncounterManager.New("OLD_SA_BATTLE_HoovedPack", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(HoovedPack, new List<CardBlueprint>[6]
				{
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("Mole", 4),
						Card("OLD_SA_ANTELOPE")
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[3]
					{
						Card("ElkCub", 1, 8),
						Card("Elk", 9, 12),
						Card("Bull", 13)
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("ElkCub", 4, 8),
						Card("OLD_SA_ANTELOPE", 9)
					}),
					EncounterManager.CreateTurn(Card("Bull", 13)),
					EncounterManager.CreateTurn(Card("Pronghorn", 13)),
					EncounterManager.CreateTurn(Card("Elk", 13))
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(HoovedPack, (Tribe[])(object)new Tribe[1] { (Tribe)4 });
				Magic = EncounterManager.New("OLD_SA_BATTLE_MAGIC", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(Magic, new List<CardBlueprint>[5]
				{
					EncounterManager.CreateTurn(new string[2] { "OLD_SA_PUPPET_SAD", "OLD_SA_PUPPETEER_FEAR" }),
					EncounterManager.CreateTurn(new string[2] { "Alpha", "OLD_SA_PUPPETEER_HAPPY" }),
					EncounterManager.CreateTurn("OLD_SA_PUPPET_SAD"),
					EncounterManager.CreateTurn("OLD_SA_PUPPETEER_FEAR"),
					EncounterManager.CreateTurn("Mole")
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(Magic, (Tribe[])(object)new Tribe[1] { (Tribe)(int)TribesAPI.Magic });
				Cat = EncounterManager.New("OLD_SA_BATTLE_CAT", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(Cat, new List<CardBlueprint>[5]
				{
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("OLD_SA_LYNX"),
						Card("OLD_SA_BLACK_PANTHER", 9)
					}),
					EncounterManager.CreateTurn("Mole"),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("OLD_SA_LYNX"),
						Card("OLD_SA_BLACK_PANTHER", 9)
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("OLD_SA_BLACK_PANTHER", 4, 12),
						Card("OLD_SA_LION", 13)
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("OLD_SA_LYNX", 4, 12),
						Card("OLD_SA_BLACK_PANTHER", 13)
					})
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(Cat, (Tribe[])(object)new Tribe[1] { (Tribe)(int)TribesAPI.Feline });
				Snake = EncounterManager.New("OLD_SA_BATTLE_SNAKE", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(Snake, new List<CardBlueprint>[5]
				{
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[3]
					{
						Card("OLD_SA_DART_FROG"),
						Card("Skink", 4, 8),
						Card("OLD_SA_INK_ADDER", 9)
					}),
					EncounterManager.CreateTurn("Skink"),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("Mole", 4, 8),
						Card("OLD_SA_INK_ADDER", 9)
					}),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("Skink", 9, 12),
						Card("OLD_SA_INK_ADDER", 13)
					}),
					EncounterManager.CreateTurn(Card("OLD_SA_TRICERATOPS", 13))
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(Snake, (Tribe[])(object)new Tribe[1] { (Tribe)5 });
				Bird = EncounterManager.New("OLD_SA_BATTLE_BIRD", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(Bird, new List<CardBlueprint>[5]
				{
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[3]
					{
						Card("Raven"),
						Card("Porcupine", 9, 12),
						Card("RavenEgg", 13)
					}),
					EncounterManager.CreateTurn("Sparrow"),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("RavenEgg", 9, 12),
						Card("OLD_SA_HUNTER_DOVE", 13)
					}),
					EncounterManager.CreateTurn(Card("MoleMan", 13)),
					EncounterManager.CreateTurn(Card("Kingfisher", 9, 12))
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(Bird, (Tribe[])(object)new Tribe[1] { (Tribe)2 });
				Mosquito = EncounterManager.New("OLD_SA_BATTLE_MOSQUITO", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(Mosquito, new List<CardBlueprint>[1] { EncounterManager.CreateTurn("OLD_SA_MOSQUITO_DUKE") });
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(Mosquito, (Tribe[])(object)new Tribe[1] { (Tribe)6 });
				Crab = EncounterManager.New("OLD_SA_BATTLE_CRAB", true);
				EncounterExtensions.AddTurns<EncounterBlueprintData>(Crab, new List<CardBlueprint>[5]
				{
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("OLD_SA_CRAB"),
						Card("OLD_SA_LOBSTER", 4, 8)
					}),
					EncounterManager.CreateTurn(Card("OLD_SA_HERMIT_CRAB", 4, 8)),
					EncounterManager.CreateTurn((CardBlueprint[])(object)new CardBlueprint[2]
					{
						Card("Mole", 4),
						Card("Kingfisher", 9)
					}),
					EncounterManager.CreateTurn(Card("OLD_SA_LOBSTER", 9)),
					EncounterManager.CreateTurn(Card("OLD_SA_CRAB", 13))
				});
				EncounterExtensions.AddDominantTribes<EncounterBlueprintData>(Crab, (Tribe[])(object)new Tribe[1] { (Tribe)(int)TribesAPI.Crustacean });
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(WolfPack, 1, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(SwarmCrisis, 1, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(BoneCrisis, 6, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(Attack, 6, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(HoovedPack, 1, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(Magic, 9, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(Cat, 1, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(Snake, 4, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(Bird, 1, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(Mosquito, 8, 20);
				EncounterExtensions.SetDifficulty<EncounterBlueprintData>(Crab, 1, 20);
				RegionManager.ModifyRegionsList += AddEncountersToRegions;
				RegionManager.SyncRegionList();
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[OLD_SA] BattleAPI 初始化失败：\n" + ex));
			}
		}

		private static List<RegionData> AddEncountersToRegions(List<RegionData> regions)
		{
			if (regions == null)
			{
				return regions;
			}
			RegionData val = regions.Find((RegionData x) => (Object)(object)x != (Object)null && ((Object)x).name == "Forest");
			if ((Object)(object)val != (Object)null)
			{
				if (val.encounters == null)
				{
					val.encounters = new List<EncounterBlueprintData>();
				}
				if (!val.encounters.Contains(WolfPack))
				{
					val.encounters.Add(WolfPack);
				}
				if (!val.encounters.Contains(Magic))
				{
					val.encounters.Add(Magic);
				}
				if (!val.encounters.Contains(Cat))
				{
					val.encounters.Add(Cat);
				}
				if (!val.encounters.Contains(Mosquito))
				{
					val.encounters.Add(Mosquito);
				}
			}
			RegionData val2 = regions.Find((RegionData x) => (Object)(object)x != (Object)null && ((Object)x).name == "Wetlands");
			if ((Object)(object)val2 != (Object)null)
			{
				if (val2.encounters == null)
				{
					val2.encounters = new List<EncounterBlueprintData>();
				}
				if (!val2.encounters.Contains(SwarmCrisis))
				{
					val2.encounters.Add(SwarmCrisis);
				}
				if (!val2.encounters.Contains(BoneCrisis))
				{
					val2.encounters.Add(BoneCrisis);
				}
				if (!val2.encounters.Contains(Attack))
				{
					val2.encounters.Add(Attack);
				}
				if (!val2.encounters.Contains(Mosquito))
				{
					val2.encounters.Add(Mosquito);
				}
				if (!val2.encounters.Contains(Crab))
				{
					val2.encounters.Add(Crab);
				}
			}
			RegionData val3 = regions.Find((RegionData x) => (Object)(object)x != (Object)null && ((Object)x).name == "alpine");
			if ((Object)(object)val3 != (Object)null)
			{
				if (val3.encounters == null)
				{
					val3.encounters = new List<EncounterBlueprintData>();
				}
				if (!val3.encounters.Contains(HoovedPack))
				{
					val3.encounters.Add(HoovedPack);
				}
				if (!val3.encounters.Contains(Snake))
				{
					val3.encounters.Add(Snake);
				}
				if (!val3.encounters.Contains(Bird))
				{
					val3.encounters.Add(Bird);
				}
				if (!val3.encounters.Contains(Mosquito))
				{
					val3.encounters.Add(Mosquito);
				}
			}
			return regions;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("OLD_SA.Battle", "OLD SA Battle", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static Plugin Instance;

		private void Awake()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			Instance = this;
			BattleAPI.Init();
			Harmony val = new Harmony("OLD_SA.Battle");
			val.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"OLD SA Battle loaded.");
		}
	}
}

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.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using DiskCardGame;
using HarmonyLib;
using InscryptionAPI.Ascension;
using InscryptionAPI.Helpers;
using InscryptionAPI.Slots;
using OLD_SA.Dialogue;
using OLD_SA.Random;
using OLD_SA.RedirectStrike;
using OldSa_Challenge;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("OldSa_Challenge")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OldSa_Challenge")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7bddb5c6-b65b-44d7-8bf7-754e15af94f3")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace OLD_SA.Combat
{
	[HarmonyPatch(typeof(CombatPhaseManager), "DealOverkillDamage")]
	public static class EnemyOverkillHandDamagePatch
	{
		public static bool Prefix(int damage, CardSlot attackingSlot, CardSlot opposingSlot, ref IEnumerator __result)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (damage <= 0)
			{
				return true;
			}
			if ((Object)(object)attackingSlot == (Object)null || (Object)(object)attackingSlot.Card == (Object)null)
			{
				return true;
			}
			if (attackingSlot.IsPlayerSlot)
			{
				return true;
			}
			if ((Object)(object)opposingSlot == (Object)null || !opposingSlot.IsPlayerSlot)
			{
				return true;
			}
			if (attackingSlot.Card.HasAbility(RedirectStrikeAPI.ability.Id))
			{
				return true;
			}
			bool flag = false;
			try
			{
				flag = AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.OverkillPunishmentChallengeType);
			}
			catch
			{
				flag = false;
			}
			if (!flag)
			{
				return true;
			}
			ChallengeActivationUI.TryShowActivation(ChallengeRegistry.OverkillPunishmentChallengeType);
			__result = EnemyOverkillHandResolver.Resolve(damage, attackingSlot.Card);
			return false;
		}
	}
	public static class EnemyOverkillHandResolver
	{
		public static IEnumerator Resolve(int damage, PlayableCard attacker)
		{
			PlayerHand hand = Singleton<PlayerHand>.Instance;
			if ((Object)(object)hand == (Object)null || hand.CardsInHand.Count == 0)
			{
				yield break;
			}
			PlayableCard card = hand.CardsInHand[0];
			if (!((Object)(object)card == (Object)null))
			{
				if ((Object)(object)Singleton<ViewManager>.Instance != (Object)null && (Object)(object)Singleton<BoardManager>.Instance != (Object)null)
				{
					Singleton<ViewManager>.Instance.SwitchToView(Singleton<BoardManager>.Instance.DefaultView, false, false);
					yield return (object)new WaitForSeconds(0.3f);
				}
				PlayableCard dialogueCard = card;
				yield return HandDamageResolver.Deal(card, damage, attacker);
				yield return SigilDialogueAPI.ShowFirstTime("EnemyOverkillHandDamage", "Surprised? My overkill damage can reach your hand now. Be careful with your first card.", dialogueCard);
			}
		}
	}
	[HarmonyPatch(typeof(PlayableCard), "Die")]
	public static class HandDeathSlotWrapper
	{
		private static FieldInfo slotField = typeof(PlayableCard).GetField("slot", BindingFlags.Instance | BindingFlags.NonPublic);

		public static void Prefix(PlayableCard __instance, ref CardSlot __state)
		{
			__state = null;
			if ((Object)(object)__instance == (Object)null || slotField == null)
			{
				return;
			}
			PlayerHand instance = Singleton<PlayerHand>.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.CardsInHand.Contains(__instance))
			{
				BoardManager instance2 = Singleton<BoardManager>.Instance;
				if (!((Object)(object)instance2 == (Object)null) && instance2.PlayerSlotsCopy.Count != 0)
				{
					__state = null;
					slotField.SetValue(__instance, instance2.PlayerSlotsCopy[0]);
				}
			}
		}

		public static void Postfix(PlayableCard __instance, CardSlot __state)
		{
			if (!((Object)(object)__instance == (Object)null) && !(slotField == null))
			{
				PlayerHand instance = Singleton<PlayerHand>.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.CardsInHand.Contains(__instance))
				{
					slotField.SetValue(__instance, null);
				}
			}
		}
	}
	public static class HandDamageResolver
	{
		public static IEnumerator Deal(PlayableCard card, int damage, PlayableCard attacker)
		{
			if ((Object)(object)card == (Object)null)
			{
				yield break;
			}
			PlayableCardStatus status = card.Status;
			status.damageTaken += damage;
			if (card.TriggerHandler.RespondsToTrigger((Trigger)8, new object[1] { attacker }))
			{
				yield return card.TriggerHandler.OnTrigger((Trigger)8, new object[1] { attacker });
			}
			if (card.Health > 0)
			{
				if ((Object)(object)((Card)card).Anim != (Object)null)
				{
					((Card)card).Anim.PlayHitAnimation();
				}
				yield break;
			}
			card.Dead = true;
			if ((Object)(object)((Card)card).Anim != (Object)null)
			{
				((Card)card).Anim.PlayDeathAnimation(true);
				yield return (object)new WaitForSeconds(1f);
			}
			BoardManager board = Singleton<BoardManager>.Instance;
			if ((Object)(object)Singleton<ResourcesManager>.Instance != (Object)null && (Object)(object)board != (Object)null && board.PlayerSlotsCopy.Count > 0)
			{
				yield return Singleton<ResourcesManager>.Instance.AddBones(1, board.PlayerSlotsCopy[0]);
			}
			if (card.TriggerHandler.RespondsToTrigger((Trigger)12, new object[2] { false, attacker }))
			{
				yield return card.TriggerHandler.OnTrigger((Trigger)12, new object[2] { false, attacker });
			}
			if ((Object)(object)Singleton<GlobalTriggerHandler>.Instance != (Object)null)
			{
				yield return Singleton<GlobalTriggerHandler>.Instance.TriggerAll((Trigger)11, false, new object[4]
				{
					card,
					board.PlayerSlotsCopy[0],
					true,
					attacker
				});
			}
			PlayerHand hand = Singleton<PlayerHand>.Instance;
			if ((Object)(object)hand != (Object)null)
			{
				hand.CardsInHand.Remove(card);
			}
			Object.Destroy((Object)(object)((Component)card).gameObject);
		}
	}
}
namespace OldSa_Challenge
{
	[HarmonyPatch(typeof(AscensionSaveData), "NewRun")]
	public static class BadThingsChallengePatch
	{
		private const string BrokenPeltName = "OLD_SA_BROKEN_PELT";

		[HarmonyPrefix]
		private static void Prefix(List<CardInfo> starterDeck)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!SaveFile.IsAscension || starterDeck == null || starterDeck.Count == 0)
			{
				return;
			}
			int numChallengesOfTypeActive = AscensionSaveData.Data.GetNumChallengesOfTypeActive(ChallengeRegistry.BadThingsChallengeType);
			if (numChallengesOfTypeActive <= 0)
			{
				return;
			}
			CardInfo cardByName = CardLoader.GetCardByName("OLD_SA_BROKEN_PELT");
			List<CardInfo> list = starterDeck.Where((CardInfo card) => (Object)(object)card != (Object)null && !card.HasTrait((Trait)13) && ((Object)card).name != "OLD_SA_BROKEN_PELT").ToList();
			if (list.Count == 0)
			{
				return;
			}
			int num = Math.Min(numChallengesOfTypeActive, list.Count);
			for (int num2 = 0; num2 < num; num2++)
			{
				int index = Random.Range(0, list.Count);
				CardInfo val = list[index];
				if (!((Object)(object)val == (Object)null))
				{
					int num3 = starterDeck.IndexOf(val);
					if (num3 >= 0)
					{
						starterDeck[num3] = cardByName;
						list.RemoveAt(index);
					}
				}
			}
			if (numChallengesOfTypeActive <= num)
			{
			}
		}
	}
	[HarmonyPatch(typeof(GainConsumablesSequencer), "ReplenishConsumables")]
	public static class BrokenBackpackPatch
	{
		private static readonly FieldInfo BackpackField = AccessTools.Field(typeof(GainConsumablesSequencer), "backpack");

		private static readonly MethodInfo FullConsumablesSequenceMethod = AccessTools.Method(typeof(GainConsumablesSequencer), "FullConsumablesSequence", (Type[])null, (Type[])null);

		private static readonly MethodInfo TutorialGainConsumablesMethod = AccessTools.Method(typeof(GainConsumablesSequencer), "TutorialGainConsumables", (Type[])null, (Type[])null);

		private static readonly MethodInfo RegularGainConsumablesMethod = AccessTools.Method(typeof(GainConsumablesSequencer), "RegularGainConsumables", (Type[])null, (Type[])null);

		[HarmonyPrefix]
		public static bool Prefix(GainConsumablesSequencer __instance, GainConsumablesNodeData nodeData, ref IEnumerator __result)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ChallengeRegistry.BrokenBagChallenge == (Object)null || AscensionSaveData.Data == null || !AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.BrokenBagChallengeType))
			{
				return true;
			}
			__result = ReplenishConsumablesWithDialogue(__instance, nodeData);
			return false;
		}

		private static IEnumerator ReplenishConsumablesWithDialogue(GainConsumablesSequencer instance, GainConsumablesNodeData nodeData)
		{
			Singleton<ViewManager>.Instance.SwitchToView((View)1, false, true);
			yield return (object)new WaitForEndOfFrame();
			Singleton<ExplorableAreaManager>.Instance.SetHandLightRange(17f, 0.25f);
			Singleton<ExplorableAreaManager>.Instance.SetHangingLightRange(7f, 0.25f);
			GameObject backpack = GetBackpack(instance);
			if ((Object)(object)backpack != (Object)null)
			{
				backpack.SetActive(true);
			}
			yield return (object)new WaitForSeconds(0.25f);
			if ((Object)(object)Singleton<GameFlowManager>.Instance != (Object)null)
			{
				yield return (object)new WaitUntil((Func<bool>)(() => !Singleton<GameFlowManager>.Instance.Transitioning));
			}
			ChallengeActivationUI.TryShowActivation(ChallengeRegistry.BrokenBagChallengeType);
			yield return ChallengeDialogueManager.ShowFirstTime("Broken Bag", "Not much for you to choose from this time.");
			if (RunState.Run.consumables.Count == RunState.Run.MaxConsumables)
			{
				yield return InvokeCoroutine(FullConsumablesSequenceMethod, instance);
			}
			else if (!ProgressionData.LearnedMechanic((MechanicsConcept)33))
			{
				yield return InvokeCoroutine(TutorialGainConsumablesMethod, instance);
				ProgressionData.SetMechanicLearned((MechanicsConcept)33);
			}
			else
			{
				yield return InvokeCoroutine(RegularGainConsumablesMethod, instance, nodeData);
				ProgressionData.SetMechanicLearned((MechanicsConcept)34);
			}
			Singleton<ExplorableAreaManager>.Instance.ResetHandLightRange(0.25f);
			Singleton<ExplorableAreaManager>.Instance.ResetHangingLightRange(0.25f);
			if ((Object)(object)backpack != (Object)null)
			{
				Animator animator = backpack.GetComponentInChildren<Animator>();
				if ((Object)(object)animator != (Object)null)
				{
					animator.SetTrigger("exit");
				}
				CustomCoroutine.WaitThenExecute(0.25f, (Action)delegate
				{
					backpack.SetActive(false);
				}, false);
			}
			if ((Object)(object)Singleton<GameFlowManager>.Instance != (Object)null)
			{
				Singleton<GameFlowManager>.Instance.TransitionToGameState((GameState)1, (NodeData)null);
			}
		}

		private static GameObject GetBackpack(GainConsumablesSequencer instance)
		{
			if ((Object)(object)instance == (Object)null || BackpackField == null)
			{
				return null;
			}
			object? value = BackpackField.GetValue(instance);
			return (GameObject)((value is GameObject) ? value : null);
		}

		private static IEnumerator InvokeCoroutine(MethodInfo method, object instance, params object[] parameters)
		{
			if (method == null)
			{
				yield break;
			}
			object result = method.Invoke(instance, parameters);
			if (result is IEnumerator sequence)
			{
				while (sequence.MoveNext())
				{
					yield return sequence.Current;
				}
			}
		}
	}
	public static class BrokenBagPatch
	{
		private static readonly HashSet<string> ForbiddenConsumables = new HashSet<string> { "Hourglass", "Scissors", "CuckooClock", "PocketWatch" };

		public static void Apply(Harmony harmony)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(GainConsumablesSequencer), "GenerateItemChoices", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find GainConsumablesSequencer.GenerateItemChoices.");
			}
			else
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(BrokenBagPatch), "GenerateItemChoices_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ItemsUtil), "GetRandomUnlockedConsumable", (Type[])null, (Type[])null);
			if (methodInfo2 == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find ItemsUtil.GetRandomUnlockedConsumable.");
			}
			else
			{
				harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(BrokenBagPatch), "GetRandomUnlockedConsumable_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			PatchBuyPeltsStateMachine(harmony);
			MethodInfo methodInfo3 = AccessTools.Method(typeof(BuyPeltsSequencer), "OnPurchaseKnifePressed", (Type[])null, (Type[])null);
			if (methodInfo3 == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find BuyPeltsSequencer.OnPurchaseKnifePressed.");
			}
			else
			{
				harmony.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(BrokenBagPatch), "OnPurchaseKnifePressed_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static bool GenerateItemChoices_Prefix(GainConsumablesNodeData nodeData, int randomSeed, ref List<ConsumableItemData> __result)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			if (!IsBrokenBagActive())
			{
				return true;
			}
			List<ConsumableItemData> list = new List<ConsumableItemData>(ItemsUtil.GetUnlockedConsumablesForRegion(RunState.CurrentMapRegion));
			List<ConsumableItemData> list2 = new List<ConsumableItemData>();
			if (StoryEventsData.EventCompleted((StoryEvent)15) && !StoryEventsData.EventCompleted((StoryEvent)30) && ((int)RunState.Run.eyeState == 0 || (int)RunState.Run.eyeState == 3) && !RunState.Run.consumables.Contains("SpecialDagger"))
			{
				list2.Add(ItemsUtil.GetConsumableByName("SpecialDagger"));
			}
			while (list2.Count < 3)
			{
				if (list.Count == 0)
				{
					ConsumableItemData consumableByName = ItemsUtil.GetConsumableByName("SquirrelBottle");
					list2.Add(consumableByName);
					continue;
				}
				int num = ((RunState.Run != null) ? (RunState.Run.consumables.Count * 1000) : 0);
				int num2 = randomSeed + num;
				int powerLevelRoll = SeededRandom.Range(1, 6, num2++);
				List<ConsumableItemData> list3 = list.FindAll((ConsumableItemData x) => (Object)(object)x != (Object)null && x.powerLevel <= powerLevelRoll && !IsForbidden(((Object)x).name));
				if (list3.Count == 0)
				{
					randomSeed++;
					continue;
				}
				int index = SeededRandom.Range(0, list3.Count, num2++);
				ConsumableItemData val = list3[index];
				list.Remove(val);
				if ((Object)(object)val != (Object)null)
				{
					list2.Add(val);
				}
				randomSeed += 2;
			}
			if (RunState.Run.regionTier > 0 && StoryEventsData.EventCompleted((StoryEvent)5) && !StoryEventsData.EventCompleted((StoryEvent)80) && !RunState.Run.consumables.Contains("GooBottle") && RunState.Run.consumables.Count == 2 && !SaveFile.IsAscension)
			{
				list2[1] = ItemsUtil.GetConsumableByName("GooBottle");
			}
			for (int num3 = 0; num3 < list2.Count; num3++)
			{
				ConsumableItemData val2 = list2[num3];
				if (!((Object)(object)val2 == (Object)null) && IsForbidden(((Object)val2).name))
				{
					Plugin.Log.LogError((object)("[OldSa Challenge] Forbidden consumable reached bag result: " + ((Object)val2).name));
					ConsumableItemData replacementConsumable = GetReplacementConsumable(randomSeed + num3);
					if ((Object)(object)replacementConsumable != (Object)null)
					{
						list2[num3] = replacementConsumable;
					}
				}
			}
			__result = list2;
			return false;
		}

		private static bool GetRandomUnlockedConsumable_Prefix(int randomSeed, ref ConsumableItemData __result)
		{
			//IL_00a0: 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)
			if (!IsBrokenBagActive())
			{
				return true;
			}
			List<ConsumableItemData> list = new List<ConsumableItemData>(ItemsUtil.GetUnlockedConsumables());
			list.RemoveAll((ConsumableItemData item) => (Object)(object)item == (Object)null || item.notRandomlyGiven || IsForbidden(((Object)item).name));
			if (list.Count == 0)
			{
				ConsumableItemData consumableByName = ItemsUtil.GetConsumableByName("SquirrelBottle");
				if ((Object)(object)consumableByName != (Object)null)
				{
					ChallengeActivationUI.TryShowActivation(ChallengeRegistry.BrokenBagChallengeType);
					__result = consumableByName;
					return false;
				}
				return true;
			}
			int index = SeededRandom.Range(0, list.Count, randomSeed);
			ConsumableItemData val = list[index];
			ChallengeActivationUI.TryShowActivation(ChallengeRegistry.BrokenBagChallengeType);
			__result = val;
			return false;
		}

		private static ConsumableItemData GetReplacementConsumable(int randomSeed)
		{
			List<ConsumableItemData> list = new List<ConsumableItemData>(ItemsUtil.GetUnlockedConsumablesForRegion(RunState.CurrentMapRegion));
			list.RemoveAll((ConsumableItemData item) => (Object)(object)item == (Object)null || item.notRandomlyGiven || IsForbidden(((Object)item).name));
			if (list.Count == 0)
			{
				return ItemsUtil.GetConsumableByName("SquirrelBottle");
			}
			int index = SeededRandom.Range(0, list.Count, randomSeed);
			return list[index];
		}

		private static bool IsForbidden(string itemName)
		{
			return !string.IsNullOrEmpty(itemName) && ForbiddenConsumables.Contains(itemName);
		}

		private static bool IsBrokenBagActive()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (AscensionSaveData.Data == null)
			{
				return false;
			}
			return AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.BrokenBagChallengeType);
		}

		private static void PatchBuyPeltsStateMachine(Harmony harmony)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			Type type = typeof(BuyPeltsSequencer).GetNestedTypes(BindingFlags.NonPublic).FirstOrDefault((Type type2) => type2.Name.StartsWith("<BuyPelts>d__", StringComparison.Ordinal));
			if (type == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find BuyPelts state machine.");
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(type, "MoveNext", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find MoveNext() in BuyPelts state machine.");
			}
			else
			{
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(BrokenBagPatch), "BuyPelts_MoveNext_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static IEnumerable<CodeInstruction> BuyPelts_MoveNext_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(GameObject), "SetActive", (Type[])null, (Type[])null);
			MethodInfo target = AccessTools.Method(typeof(GenericMainInputInteractable), "SetEnabled", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(BrokenBagPatch), "ShouldShowKnife", (Type[])null, (Type[])null);
			MethodInfo methodInfo3 = AccessTools.Method(typeof(BrokenBagPatch), "ShouldEnableKnife", (Type[])null, (Type[])null);
			MethodInfo methodInfo4 = AccessTools.Method(typeof(BrokenBagPatch), "ShowHunterActivation", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find GameObject.SetActive.");
			}
			if (methodInfo2 == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find ShouldShowKnife.");
			}
			if (methodInfo3 == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find ShouldEnableKnife.");
			}
			if (methodInfo4 == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find ShowHunterActivation.");
			}
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (IsLdcI4One(list[i].opcode) && CallsMethod(list[i + 1], methodInfo))
				{
					list.Insert(i, new CodeInstruction(OpCodes.Call, (object)methodInfo4));
					i++;
					list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo2);
					flag = true;
					flag3 = true;
					break;
				}
			}
			for (int j = 0; j < list.Count - 1; j++)
			{
				if (IsLdcI4One(list[j].opcode) && CallsMethod(list[j + 1], target))
				{
					list[j] = new CodeInstruction(OpCodes.Call, (object)methodInfo3);
					flag2 = true;
					break;
				}
			}
			if (!flag)
			{
				Plugin.Log.LogWarning((object)"[OldSa Challenge] Could not patch hunter knife GameObject.SetActive.");
			}
			if (!flag2)
			{
				Plugin.Log.LogWarning((object)"[OldSa Challenge] Could not patch hunter knife SetEnabled.");
			}
			if (!flag3)
			{
				Plugin.Log.LogWarning((object)"[OldSa Challenge] Could not patch hunter activation display.");
			}
			return list;
		}

		private static void ShowHunterActivation()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (IsBrokenBagActive())
			{
				ChallengeActivationUI.TryShowActivation(ChallengeRegistry.BrokenBagChallengeType);
			}
		}

		private static bool IsLdcI4One(OpCode opcode)
		{
			return opcode == OpCodes.Ldc_I4_1;
		}

		private static bool CallsMethod(CodeInstruction instruction, MethodInfo target)
		{
			if (instruction == null || target == null)
			{
				return false;
			}
			if (instruction.opcode != OpCodes.Call && instruction.opcode != OpCodes.Callvirt)
			{
				return false;
			}
			if (!(instruction.operand is MethodInfo methodInfo))
			{
				return false;
			}
			return methodInfo == target;
		}

		private static bool ShouldShowKnife()
		{
			if (IsBrokenBagActive())
			{
				return false;
			}
			return true;
		}

		private static bool ShouldEnableKnife()
		{
			if (IsBrokenBagActive())
			{
				return false;
			}
			return true;
		}

		private static bool OnPurchaseKnifePressed_Prefix()
		{
			if (!IsBrokenBagActive())
			{
				return true;
			}
			return false;
		}
	}
	public static class BrokenStartPatch
	{
		[HarmonyPatch(typeof(AscensionSaveData), "NewRun", new Type[] { typeof(List<CardInfo>) })]
		private static class NewRunPatch
		{
			[HarmonyPrefix]
			private static void Prefix(AscensionSaveData __instance)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				remainingReplacements = 0;
				if (__instance != null && SaveFile.IsAscension)
				{
					int numChallengesOfTypeActive = __instance.GetNumChallengesOfTypeActive(ChallengeRegistry.BrokenStartChallengeType);
					if (numChallengesOfTypeActive > 0)
					{
						remainingReplacements = numChallengesOfTypeActive;
					}
				}
			}

			[HarmonyPostfix]
			private static void Postfix()
			{
				if (remainingReplacements > 0)
				{
				}
				remainingReplacements = 0;
			}
		}

		[HarmonyPatch(typeof(CardLoader), "GetCardByName", new Type[] { typeof(string) })]
		private static class GetCardByNamePatch
		{
			[HarmonyPrefix]
			private static bool Prefix(ref string name)
			{
				if (remainingReplacements <= 0)
				{
					return true;
				}
				if (name != "PeltHare")
				{
					return true;
				}
				name = "OLD_SA_BROKEN_PELT";
				remainingReplacements--;
				return true;
			}
		}

		private const string BrokenPeltName = "OLD_SA_BROKEN_PELT";

		private static int remainingReplacements;
	}
	public static class ChallengeIncompatibilities
	{
		public static void RegisterAll()
		{
			RegisterMutual(ChallengeRegistry.ElephantModeChallenge, (AscensionChallenge)13);
			RegisterMutual(ChallengeRegistry.BadThingsChallenge, ChallengeRegistry.DizzyStartersChallenge);
			RegisterMutual(ChallengeRegistry.BadThingsChallenge, (AscensionChallenge)9);
		}

		private static void RegisterMutual(AscensionChallengeInfo customChallenge, AscensionChallenge vanillaChallenge)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected I4, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected I4, but got Unknown
			if (!((Object)(object)customChallenge == (Object)null))
			{
				ChallengeManager.GetFullChallenge(customChallenge).SetIncompatibleChallengeGetterStatic((AscensionChallenge[])(object)new AscensionChallenge[1] { (AscensionChallenge)(int)vanillaChallenge });
				ChallengeManager.GetFullChallenge(vanillaChallenge).SetIncompatibleChallengeGetterStatic((AscensionChallenge[])(object)new AscensionChallenge[1] { (AscensionChallenge)(int)customChallenge.challengeType });
			}
		}

		private static void RegisterMutual(AscensionChallengeInfo first, AscensionChallengeInfo second)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected I4, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected I4, but got Unknown
			if (!((Object)(object)first == (Object)null) && !((Object)(object)second == (Object)null))
			{
				ChallengeManager.GetFullChallenge(first).SetIncompatibleChallengeGetterStatic((AscensionChallenge[])(object)new AscensionChallenge[1] { (AscensionChallenge)(int)second.challengeType });
				ChallengeManager.GetFullChallenge(second).SetIncompatibleChallengeGetterStatic((AscensionChallenge[])(object)new AscensionChallenge[1] { (AscensionChallenge)(int)first.challengeType });
			}
		}
	}
	public static class ChallengeDialogueAPI
	{
		public static IEnumerator ShowFirstTime(string challengeName, string dialogue)
		{
			if (!string.IsNullOrEmpty(challengeName) && !string.IsNullOrEmpty(dialogue) && !ChallengeDialogueSaveData.HasTriggered(challengeName))
			{
				ChallengeDialogueSaveData.AddTriggered(challengeName);
				OLD_SA_SaveManager.Save();
				TextDisplayer textDisplayer = Singleton<TextDisplayer>.Instance;
				if (!((Object)(object)textDisplayer == (Object)null))
				{
					yield return textDisplayer.ShowUntilInput(dialogue, -2.5f, 0.5f, (Emotion)0, (LetterAnimation)0, (Speaker)0, (string[])null, true);
				}
			}
		}
	}
	public static class ChallengeDialogueConfig
	{
		public const string NoGrowthDialogue = "NoGrowthChallenge";

		public const string NoWoodcarverDialogue = "NoWoodcarverChallenge";

		public const string DizzyStartersDialogue = "DizzyStartersChallenge";

		public const string DoubleTrialDialogue = "DoubleTrialChallenge";

		public const string BrokenStartDialogue = "BrokenStartChallenge";

		public const string BadThingsDialogue = "BadThingsChallenge";

		public const string ElephantModeDialogue = "ElephantModeChallenge";

		public const string BrokenBagDialogue = "BrokenBagChallenge";

		public const string NeverStarvationDialogue = "NeverStarvationChallenge";
	}
	public static class ChallengeDialogueManager
	{
		public static IEnumerator ShowFirstTime(string challengeName, string dialogue)
		{
			if (string.IsNullOrEmpty(challengeName) || string.IsNullOrEmpty(dialogue) || ChallengeDialogueSaveData.HasTriggered(challengeName))
			{
				yield break;
			}
			ChallengeDialogueSaveData.AddTriggered(challengeName);
			OLD_SA_SaveManager.Save();
			if ((Object)(object)Singleton<ViewManager>.Instance != (Object)null)
			{
				Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)1;
			}
			if ((Object)(object)Singleton<PlayerHand>.Instance != (Object)null)
			{
				Singleton<PlayerHand>.Instance.PlayingLocked = true;
			}
			try
			{
				if ((Object)(object)Singleton<TextDisplayer>.Instance != (Object)null)
				{
					yield return Singleton<TextDisplayer>.Instance.ShowUntilInput(dialogue, -2.5f, 0.5f, (Emotion)0, (LetterAnimation)0, (Speaker)0, (string[])null, true);
				}
			}
			finally
			{
				if ((Object)(object)Singleton<PlayerHand>.Instance != (Object)null)
				{
					Singleton<PlayerHand>.Instance.PlayingLocked = false;
				}
				if ((Object)(object)Singleton<ViewManager>.Instance != (Object)null)
				{
					Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)0;
				}
			}
		}
	}
	public static class ChallengeDialogueSaveData
	{
		private static readonly HashSet<string> TriggeredChallenges = new HashSet<string>();

		public static bool HasTriggered(string challengeName)
		{
			if (string.IsNullOrEmpty(challengeName))
			{
				return false;
			}
			return TriggeredChallenges.Contains(challengeName);
		}

		public static void AddTriggered(string challengeName)
		{
			if (!string.IsNullOrEmpty(challengeName))
			{
				TriggeredChallenges.Add(challengeName);
			}
		}

		public static List<string> GetSaveList()
		{
			return new List<string>(TriggeredChallenges);
		}

		public static void LoadFromList(List<string> list)
		{
			TriggeredChallenges.Clear();
			if (list == null)
			{
				return;
			}
			foreach (string item in list)
			{
				if (!string.IsNullOrEmpty(item))
				{
					TriggeredChallenges.Add(item);
				}
			}
		}
	}
	public static class ChallengeRegistry
	{
		public static AscensionChallengeInfo NoGrowthChallenge;

		public const string NoGrowthName = "No Growth";

		public const string NoGrowthDescription = "Fledgling sigils no longer evolve. They only grant +1 Power and +1 Health.";

		public static AscensionChallengeInfo NoWoodcarverChallenge;

		public const string NoWoodcarverName = "No Woodcarver";

		public const string NoWoodcarverDescription = "You will no longer encounter Woodcarver choice nodes.";

		public static AscensionChallengeInfo DizzyStartersChallenge;

		public const string DizzyStartersName = "Dizzy Starters";

		public const string DizzyStartersDescription = "All creatures in your starting deck gain the Random sigil.";

		public static AscensionChallengeInfo DoubleTrialChallenge;

		public const string DoubleTrialName = "Double Trial";

		public const string DoubleTrialDescription = "All Totem battles in this run have bases with the Double Strike sigil.";

		public static AscensionChallengeInfo BrokenStartChallenge;

		public const string BrokenStartName = "Broken Start";

		public const string BrokenStartDescription = "One of your starting pelts is replaced with a Broken Pelt.";

		public static AscensionChallengeInfo BadThingsChallenge;

		public const string BadThingsName = "Bad Things";

		public const string BadThingsDescription = "One of your starting creatures is replaced with a Broken Pelt.";

		public static AscensionChallengeInfo ElephantModeChallenge;

		public const string ElephantModeName = "Elephant Bosses";

		public const string ElephantModeDescription = "On the second turn, the Boss will fill the board with Elephants.";

		public static AscensionChallengeInfo BrokenBagChallenge;

		public const string BrokenBagName = "Broken Bag";

		public const string BrokenBagDescription = "You will not encounter the Hourglass, Skinning Knife, Scissors, or CuckooClock.";

		public static AscensionChallengeInfo NeverStarvationChallenge;

		public const string NeverStarvationName = "Never Starvation";

		public const string NeverStarvationDescription = "You will never encounter starvation, even when there are no cards left to draw.";

		public static AscensionChallengeInfo WaterForestChallenge;

		public const string WaterForestName = "Water Forest";

		public const string WaterForestDescription = "Turn one of your spaces into a Submerge Slot.";

		public static AscensionChallengeInfo HallucinationSlotChallenge;

		public const string HallucinationSlotName = "Hallucination Forest";

		public const string HallucinationSlotDescription = "Turn one of your spaces into a Hallucination Slot.";

		public static AscensionChallengeInfo StartledSlotChallenge;

		public const string StartledSlotName = "Startled Forest";

		public const string StartledSlotDescription = "Turn one of your spaces into a Startled Slot.";

		public static AscensionChallengeInfo OverkillPunishmentChallenge;

		public const string OverkillPunishmentName = "Overkill Punishment";

		public const string OverkillPunishmentDescription = "Leshy's overkill damage also affects your hand.";

		public static AscensionChallenge NoGrowthChallengeType => (AscensionChallenge)(((Object)(object)NoGrowthChallenge != (Object)null) ? ((int)NoGrowthChallenge.challengeType) : 0);

		public static AscensionChallenge NoWoodcarverChallengeType => (AscensionChallenge)(((Object)(object)NoWoodcarverChallenge != (Object)null) ? ((int)NoWoodcarverChallenge.challengeType) : 0);

		public static AscensionChallenge DizzyStartersChallengeType => (AscensionChallenge)(((Object)(object)DizzyStartersChallenge != (Object)null) ? ((int)DizzyStartersChallenge.challengeType) : 0);

		public static AscensionChallenge DoubleTrialChallengeType => (AscensionChallenge)(((Object)(object)DoubleTrialChallenge != (Object)null) ? ((int)DoubleTrialChallenge.challengeType) : 0);

		public static AscensionChallenge BrokenStartChallengeType => (AscensionChallenge)(((Object)(object)BrokenStartChallenge != (Object)null) ? ((int)BrokenStartChallenge.challengeType) : 0);

		public static AscensionChallenge BadThingsChallengeType => (AscensionChallenge)(((Object)(object)BadThingsChallenge != (Object)null) ? ((int)BadThingsChallenge.challengeType) : 0);

		public static AscensionChallenge ElephantModeChallengeType => (AscensionChallenge)(((Object)(object)ElephantModeChallenge != (Object)null) ? ((int)ElephantModeChallenge.challengeType) : 0);

		public static AscensionChallenge BrokenBagChallengeType => (AscensionChallenge)(((Object)(object)BrokenBagChallenge != (Object)null) ? ((int)BrokenBagChallenge.challengeType) : 0);

		public static AscensionChallenge NeverStarvationChallengeType => (AscensionChallenge)(((Object)(object)NeverStarvationChallenge != (Object)null) ? ((int)NeverStarvationChallenge.challengeType) : 0);

		public static AscensionChallenge WaterForestChallengeType => (AscensionChallenge)(((Object)(object)WaterForestChallenge != (Object)null) ? ((int)WaterForestChallenge.challengeType) : 0);

		public static AscensionChallenge HallucinationSlotChallengeType => (AscensionChallenge)(((Object)(object)HallucinationSlotChallenge != (Object)null) ? ((int)HallucinationSlotChallenge.challengeType) : 0);

		public static AscensionChallenge StartledSlotChallengeType => (AscensionChallenge)(((Object)(object)StartledSlotChallenge != (Object)null) ? ((int)StartledSlotChallenge.challengeType) : 0);

		public static AscensionChallenge OverkillPunishmentChallengeType => (AscensionChallenge)(((Object)(object)OverkillPunishmentChallenge != (Object)null) ? ((int)OverkillPunishmentChallenge.challengeType) : 0);

		public static void Register()
		{
			NoGrowthChallenge = FullChallenge.op_Implicit(ChallengeManager.Add("OLD_SA.Challenge", "No Growth", "Fledgling sigils no longer evolve. They only grant +1 Power and +1 Health.", 15, TextureHelper.GetImageAsTexture("NoGrowth.png", (FilterMode)0), TextureHelper.GetImageAsTexture("NoGrowth_Activated.png", (FilterMode)0), 0, false));
			NoWoodcarverChallenge = FullChallenge.op_Implicit(ChallengeManager.Add("OLD_SA.Challenge", "No Woodcarver", "You will no longer encounter Woodcarver choice nodes.", 15, TextureHelper.GetImageAsTexture("NoWoodcarver.png", (FilterMode)0), TextureHelper.GetImageAsTexture("NoWoodcarver_Activated.png", (FilterMode)0), 0, false));
			DizzyStartersChallenge = FullChallenge.op_Implicit(ChallengeManager.Add("OLD_SA.Challenge", "Dizzy Starters", "All creatures in your starting deck gain the Random sigil.", 0, TextureHelper.GetImageAsTexture("DizzyStarters.png", (FilterMode)0), TextureHelper.GetImageAsTexture("DizzyStarters_Activated.png", (FilterMode)0), 0, false));
			DoubleTrialChallenge = FullChallenge.op_Implicit(ChallengeManager.Add("OLD_SA.Challenge", "Double Trial", "All Totem battles in this run have bases with the Double Strike sigil.", 100, TextureHelper.GetImageAsTexture("DoubleTrial.png", (FilterMode)0), TextureHelper.GetImageAsTexture("DoubleTrial_Activated.png", (FilterMode)0), 0, false));
			BrokenStartChallenge = FullChallenge.op_Implicit(ChallengeManager.AddSpecific("OLD_SA.Challenge", "Broken Start", "One of your starting pelts is replaced with a Broken Pelt.", 15, TextureHelper.GetImageAsTexture("BrokenStart.png", (FilterMode)0), TextureHelper.GetImageAsTexture("BrokenStart_Activated.png", (FilterMode)0), (Type)null, 0, (List<object>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, 2));
			BadThingsChallenge = FullChallenge.op_Implicit(ChallengeManager.AddSpecific("OLD_SA.Challenge", "Bad Things", "One of your starting creatures is replaced with a Broken Pelt.", 20, TextureHelper.GetImageAsTexture("BadThings.png", (FilterMode)0), TextureHelper.GetImageAsTexture("BadThings_Activated.png", (FilterMode)0), (Type)null, 0, (List<object>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, 3));
			ElephantModeChallenge = FullChallenge.op_Implicit(ChallengeManager.AddSpecific("OLD_SA.Challenge", "Elephant Bosses", "On the second turn, the Boss will fill the board with Elephants.", 50, TextureHelper.GetImageAsTexture("ElephantMode.png", (FilterMode)0), TextureHelper.GetImageAsTexture("ElephantMode_Activated.png", (FilterMode)0), (Type)null, 0, (List<object>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, 1));
			BrokenBagChallenge = FullChallenge.op_Implicit(ChallengeManager.AddSpecific("OLD_SA.Challenge", "Broken Bag", "You will not encounter the Hourglass, Skinning Knife, Scissors, or CuckooClock.", 50, TextureHelper.GetImageAsTexture("BrokenBag.png", (FilterMode)0), TextureHelper.GetImageAsTexture("BrokenBag_Activated.png", (FilterMode)0), (Type)null, 0, (List<object>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, 1));
			NeverStarvationChallenge = FullChallenge.op_Implicit(ChallengeManager.AddSpecific("OLD_SA.Challenge", "Never Starvation", "You will never encounter starvation, even when there are no cards left to draw.", -15, TextureHelper.GetImageAsTexture("NeverStarvation.png", (FilterMode)0), TextureHelper.GetImageAsTexture("NeverStarvation_Activated.png", (FilterMode)0), (Type)null, 0, (List<object>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, 1));
			WaterForestChallenge = FullChallenge.op_Implicit(ChallengeManager.AddSpecific("OLD_SA.Challenge", "Water Forest", "Turn one of your spaces into a Submerge Slot.", 25, TextureHelper.GetImageAsTexture("WaterForest.png", (FilterMode)0), TextureHelper.GetImageAsTexture("WaterForest_Activated.png", (FilterMode)0), (Type)null, 0, (List<object>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, 1));
			HallucinationSlotChallenge = FullChallenge.op_Implicit(ChallengeManager.AddSpecific("OLD_SA.Challenge", "Hallucination Forest", "Turn one of your spaces into a Hallucination Slot.", 25, TextureHelper.GetImageAsTexture("HallucinationSlot.png", (FilterMode)0), TextureHelper.GetImageAsTexture("HallucinationSlot_Activated.png", (FilterMode)0), (Type)null, 0, (List<object>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, 1));
			StartledSlotChallenge = FullChallenge.op_Implicit(ChallengeManager.AddSpecific("OLD_SA.Challenge", "Startled Forest", "Turn one of your spaces into a Startled Slot.", 20, TextureHelper.GetImageAsTexture("StartledSlot.png", (FilterMode)0), TextureHelper.GetImageAsTexture("StartledSlot_Activated.png", (FilterMode)0), (Type)null, 0, (List<object>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, 1));
			OverkillPunishmentChallenge = FullChallenge.op_Implicit(ChallengeManager.AddSpecific("OLD_SA.Challenge", "Overkill Punishment", "Leshy's overkill damage also affects your hand.", 50, TextureHelper.GetImageAsTexture("OverkillPunishment.png", (FilterMode)0), TextureHelper.GetImageAsTexture("OverkillPunishment_Activated.png", (FilterMode)0), (Type)null, 0, (List<object>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, (Func<FullChallenge[], IEnumerable<AscensionChallenge>>)null, 1));
			ChallengeIncompatibilities.RegisterAll();
		}
	}
	[HarmonyPatch]
	public static class ChallengeIntroDialoguePatch
	{
		internal static bool InRunIntro;

		internal static bool IntroDeckShown;

		[HarmonyPatch(typeof(RunIntroSequencer), "RunIntroSequence")]
		[HarmonyPrefix]
		private static void RunIntroPrefix()
		{
			InRunIntro = true;
			IntroDeckShown = false;
		}

		[HarmonyPatch(typeof(RunIntroSequencer), "RunIntroSequence")]
		[HarmonyPostfix]
		private static void RunIntroPostfix(ref IEnumerator __result)
		{
			if (__result == null)
			{
				InRunIntro = false;
			}
			else
			{
				__result = WrapRunIntro(__result);
			}
		}

		private static IEnumerator WrapRunIntro(IEnumerator original)
		{
			while (original.MoveNext())
			{
				yield return original.Current;
			}
			InRunIntro = false;
		}

		[HarmonyPatch(typeof(DeckReviewSequencer), "SetDeckReviewShown", new Type[]
		{
			typeof(bool),
			typeof(Transform),
			typeof(Vector3),
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPostfix]
		private static void SetDeckReviewShownPostfix(DeckReviewSequencer __instance, bool shown)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (shown && InRunIntro && SaveFile.IsAscension && !IntroDeckShown)
			{
				IntroDeckShown = true;
				bool flag = IsChallengeActive(ChallengeRegistry.BadThingsChallengeType);
				bool flag2 = IsChallengeActive(ChallengeRegistry.BrokenStartChallengeType);
				bool flag3 = IsChallengeActive(ChallengeRegistry.DizzyStartersChallengeType);
				if ((flag || flag2 || flag3) && !((Object)(object)__instance == (Object)null))
				{
					((MonoBehaviour)__instance).StartCoroutine(ShowIntroDialogues(flag, flag2, flag3));
				}
			}
		}

		private static bool IsChallengeActive(AscensionChallenge challenge)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (AscensionSaveData.Data == null)
			{
				return false;
			}
			return AscensionSaveData.Data.ChallengeIsActive(challenge);
		}

		private static IEnumerator ShowIntroDialogues(bool badThings, bool brokenStart, bool dizzyStarters)
		{
			yield return (object)new WaitForSeconds(0.3f);
			if (badThings)
			{
				ChallengeActivationUI.TryShowActivation(ChallengeRegistry.BadThingsChallengeType);
				yield return ChallengeDialogueManager.ShowFirstTime("Bad Things", "Your creature has left you.I kept this for you.");
			}
			if (brokenStart)
			{
				ChallengeActivationUI.TryShowActivation(ChallengeRegistry.BrokenStartChallengeType);
				yield return ChallengeDialogueManager.ShowFirstTime("Broken Start", "Sorry,I don't have anything better.Good luck.");
			}
			if (dizzyStarters)
			{
				ChallengeActivationUI.TryShowActivation(ChallengeRegistry.DizzyStartersChallengeType);
				yield return ChallengeDialogueManager.ShowFirstTime("Dizzy Starters", "They have all lost their sense of direction.");
			}
		}
	}
	[HarmonyPatch(typeof(AscensionSaveData), "NewRun")]
	public static class DizzyStartersPatch
	{
		[HarmonyPostfix]
		public static void Postfix(AscensionSaveData __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_00c0: Expected O, but got Unknown
			if (!__instance.ChallengeIsActive(ChallengeRegistry.DizzyStartersChallengeType) || __instance.currentRun == null || __instance.currentRun.playerDeck == null)
			{
				return;
			}
			Ability randomAbility = RandomAPI.RandomAbility;
			if ((int)randomAbility == 0)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Dizzy Starters: Random ability is invalid.");
				return;
			}
			foreach (CardInfo card in ((CardCollectionInfo)__instance.currentRun.playerDeck).Cards)
			{
				if (!((Object)(object)card == (Object)null) && !card.HasTrait((Trait)13) && !card.HasAbility(randomAbility))
				{
					CardModificationInfo val = new CardModificationInfo(randomAbility);
					__instance.currentRun.playerDeck.ModifyCard(card, val);
				}
			}
		}
	}
	[HarmonyPatch(typeof(TotemsUtil), "AssignAbilityToBottom")]
	public static class DoubleTrialPatch
	{
		[HarmonyPostfix]
		public static void Postfix(TotemBottomData bottom)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)bottom == (Object)null) && bottom.effectParams != null)
			{
				AscensionSaveData data = AscensionSaveData.Data;
				if (data != null && data.ChallengeIsActive(ChallengeRegistry.DoubleTrialChallengeType))
				{
					bottom.effectParams.ability = (Ability)100;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Part1Opponent), "AssembleTotem")]
	public static class DoubleTrialTotemPatch
	{
		[HarmonyPrefix]
		public static void Prefix(Part1Opponent __instance, TotemItemData totemData)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)ChallengeRegistry.DoubleTrialChallenge == (Object)null) && AscensionSaveData.Data != null && AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.DoubleTrialChallenge.challengeType))
			{
				ChallengeActivationUI.TryShowActivation(ChallengeRegistry.DoubleTrialChallengeType);
			}
		}
	}
	[HarmonyPatch]
	public static class ElephantGrizzlyPhasePatch
	{
		private static MethodBase TargetMethod()
		{
			MethodInfo method = typeof(Part1BossOpponent).GetMethod("HasGrizzlyGlitchPhase", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method == null)
			{
				Plugin.Log.LogError((object)"[OLD SA Elephant] HasGrizzlyGlitchPhase NOT FOUND!");
				return null;
			}
			return method;
		}

		[HarmonyPostfix]
		private static void HasGrizzlyGlitchPhasePostfix(ref bool __result)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (AscensionSaveData.Data != null && AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.ElephantModeChallengeType))
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch]
	public static class ElephantBearGlitchPatch
	{
		private static MethodBase TargetMethod()
		{
			MethodInfo method = typeof(Tutorial4BattleSequencer).GetMethod("BearGlitchSequence", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (method == null)
			{
				Plugin.Log.LogError((object)"[OLD SA Elephant] BearGlitchSequence NOT FOUND!");
				return null;
			}
			return method;
		}

		[HarmonyPrefix]
		private static bool BearGlitchSequencePrefix(ref IEnumerator __result)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (AscensionSaveData.Data == null)
			{
				Plugin.Log.LogWarning((object)"[OLD SA Elephant] AscensionSaveData.Data == null.");
				return true;
			}
			if (!AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.ElephantModeChallengeType))
			{
				return true;
			}
			__result = ElephantGlitchSequence();
			return false;
		}

		private static IEnumerator ElephantGlitchSequence()
		{
			ChallengeActivationUI.TryShowActivation(ChallengeRegistry.ElephantModeChallengeType);
			CardInfo elephantInfo = CardLoader.GetCardByName("OLD_SA_Elephant");
			if ((Object)(object)elephantInfo == (Object)null)
			{
				Plugin.Log.LogError((object)"[OLD SA Elephant] OLD_SA_Elephant NOT FOUND!");
				yield break;
			}
			((ScreenEffect)Singleton<UIManager>.Instance.Effects.GetEffect<ScreenGlitchEffect>()).SetIntensity(1f, 1f);
			Singleton<CameraEffects>.Instance.Shake(0.1f, 1f);
			AudioController.Instance.PlaySound2D("broken_hum", (MixerGroup)0, 1f, 0f, (Pitch)null, (Repetition)null, (Randomization)null, (Distortion)null, false);
			foreach (CardSlot slot in Singleton<BoardManager>.Instance.OpponentSlotsCopy)
			{
				if (!Singleton<TurnManager>.Instance.Opponent.QueuedSlots.Contains(slot))
				{
					yield return Singleton<TurnManager>.Instance.Opponent.QueueCard(elephantInfo, slot, false, false, false);
				}
				if ((Object)(object)slot.Card == (Object)null)
				{
					yield return Singleton<BoardManager>.Instance.CreateCardInSlot(elephantInfo, slot, 0f, true);
				}
				if ((Object)(object)slot.Card != (Object)null)
				{
					GiveCardReachAndRedColor(slot.Card);
				}
			}
			foreach (PlayableCard playableCard in Singleton<TurnManager>.Instance.Opponent.Queue)
			{
				if ((Object)(object)playableCard != (Object)null && (Object)(object)((Card)playableCard).Info != (Object)null && ((Object)((Card)playableCard).Info).name == "OLD_SA_Elephant")
				{
					GiveCardReachAndRedColor(playableCard);
				}
			}
			yield return (object)new WaitForSeconds(0.5f);
		}

		private static void GiveCardReachAndRedColor(PlayableCard card)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)card == (Object)null))
			{
				CardModificationInfo val = new CardModificationInfo((Ability)23);
				val.fromTotem = true;
				if ((Object)(object)((Card)card).StatsLayer != (Object)null)
				{
					((Card)card).StatsLayer.SetEmissionColor(GameColors.Instance.glowRed);
				}
				card.AddTemporaryMod(val);
			}
		}
	}
	[HarmonyPatch(typeof(PlayableCard), "GetOpposingSlots")]
	public static class HallucinationPatch
	{
		private static int randomCounter;

		[HarmonyPostfix]
		public static void Postfix(PlayableCard __instance, ref List<CardSlot> __result)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.Slot == (Object)null || __result == null || !HasHallucinationSlot(__instance.Slot))
			{
				return;
			}
			List<CardSlot> list = (__instance.OpponentCard ? Singleton<BoardManager>.Instance.PlayerSlotsCopy : Singleton<BoardManager>.Instance.OpponentSlotsCopy);
			if (list == null || list.Count == 0)
			{
				return;
			}
			int count = __result.Count;
			if (count > 0)
			{
				List<CardSlot> list2 = new List<CardSlot>();
				for (int i = 0; i < count; i++)
				{
					int seed = GetSeed(__instance, i);
					float num = SeededRandom.Value(seed);
					int num2 = Mathf.FloorToInt(num * (float)list.Count);
					num2 = Mathf.Clamp(num2, 0, list.Count - 1);
					list2.Add(list[num2]);
				}
				__result = list2;
			}
		}

		private static bool HasHallucinationSlot(CardSlot slot)
		{
			if ((Object)(object)slot == (Object)null)
			{
				return false;
			}
			return (Object)(object)((Component)slot).GetComponent<HallucinationSlot>() != (Object)null;
		}

		private static int GetSeed(PlayableCard card, int index)
		{
			int currentRandomSeed = SaveManager.SaveFile.GetCurrentRandomSeed();
			int index2 = card.Slot.Index;
			int num = randomCounter++;
			currentRandomSeed = currentRandomSeed * 31 + index2;
			currentRandomSeed = currentRandomSeed * 31 + index;
			return currentRandomSeed * 31 + num;
		}
	}
	public class HallucinationSlot : SlotModificationBehaviour
	{
		public static ModificationType SlotType;

		private static bool initialized;

		public static void Add_HallucinationSlot()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!initialized)
			{
				initialized = true;
				SlotType = SlotModificationExtensions.SetRulebook(SlotModificationManager.New("OLD_SA.Challenge", "HallucinationSlot", typeof(HallucinationSlot), TextureHelper.GetImageAsTexture("hallucination_slot.png", (FilterMode)0)), "Hallucination Slot", "Creatures on this space attack random targets.", TextureHelper.GetImageAsTexture("hallucination_rulebook.png", (FilterMode)0), (ModificationMetaCategory[])(object)new ModificationMetaCategory[1]);
			}
		}
	}
	public static class NeverHungryPatch
	{
		public static void Apply(Harmony harmony)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			Type type = typeof(CardDrawPiles).GetNestedTypes(BindingFlags.NonPublic).FirstOrDefault((Type type3) => type3.Name.StartsWith("<ExhaustedSequence>d__", StringComparison.Ordinal));
			if (type == null)
			{
				Plugin.Log.LogError((object)"[OldSa Challenge] Could not find the compiler-generated state machine for CardDrawPiles.ExhaustedSequence.");
				Type[] nestedTypes = typeof(CardDrawPiles).GetNestedTypes(BindingFlags.NonPublic);
				Type[] array = nestedTypes;
				foreach (Type type2 in array)
				{
				}
			}
			else
			{
				MethodInfo methodInfo = AccessTools.Method(type, "MoveNext", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Plugin.Log.LogError((object)"[OldSa Challenge] Could not find MoveNext() in ExhaustedSequence state machine.");
				}
				else
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(NeverHungryPatch), "ExhaustedSequence_MoveNext_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static bool IsNeverHungryActive()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.NeverStarvationChallengeType);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[OldSa Challenge] Failed to check NeverHungry challenge: " + ex));
				return false;
			}
		}

		private static bool ExhaustedSequence_MoveNext_Prefix()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!IsNeverHungryActive())
			{
				return true;
			}
			ChallengeActivationUI.TryShowActivation(ChallengeRegistry.NeverStarvationChallengeType);
			return false;
		}
	}
	[HarmonyPatch(typeof(Evolve), "OnUpkeep")]
	public static class NoGrowthPatch
	{
		private static readonly FieldRef<Evolve, int> NumTurnsInPlay = AccessTools.FieldRefAccess<Evolve, int>("numTurnsInPlay");

		private static readonly MethodInfo PreSuccessfulTriggerSequenceMethod = AccessTools.Method(typeof(AbilityBehaviour), "PreSuccessfulTriggerSequence", (Type[])null, (Type[])null);

		private static readonly PropertyInfo CardProperty = AccessTools.Property(typeof(AbilityBehaviour), "Card");

		private static readonly HashSet<Evolve> ProcessedEvolves = new HashSet<Evolve>();

		[HarmonyPrefix]
		public static bool Prefix(Evolve __instance, bool playerUpkeep, ref IEnumerator __result)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			if ((Object)(object)ChallengeRegistry.NoGrowthChallenge == (Object)null || AscensionSaveData.Data == null || !AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.NoGrowthChallenge.challengeType))
			{
				return true;
			}
			PlayableCard card = GetCard(__instance);
			if ((Object)(object)card == (Object)null || card.Dead)
			{
				return true;
			}
			if (card.OpponentCard)
			{
				return true;
			}
			if (ProcessedEvolves.Contains(__instance))
			{
				__result = EmptySequence();
				return false;
			}
			__result = NoGrowthOnUpkeep(__instance, card, playerUpkeep);
			return false;
		}

		private static IEnumerator EmptySequence()
		{
			yield break;
		}

		private static PlayableCard GetCard(Evolve evolve)
		{
			if ((Object)(object)evolve == (Object)null || CardProperty == null)
			{
				return null;
			}
			object? value = CardProperty.GetValue(evolve, null);
			return (PlayableCard)((value is PlayableCard) ? value : null);
		}

		private static IEnumerator NoGrowthOnUpkeep(Evolve evolve, PlayableCard card, bool playerUpkeep)
		{
			if ((Object)(object)evolve == (Object)null || (Object)(object)card == (Object)null || card.Dead || card.OpponentCard == playerUpkeep)
			{
				yield break;
			}
			int turnsToEvolve = ((!((Object)(object)((Card)card).Info != (Object)null) || ((Card)card).Info.evolveParams == null) ? 1 : ((Card)card).Info.evolveParams.turnsToEvolve);
			int numTurnsInPlay = NumTurnsInPlay.Invoke(evolve);
			numTurnsInPlay++;
			NumTurnsInPlay.Invoke(evolve) = numTurnsInPlay;
			int remaining = Mathf.Max(1, turnsToEvolve - numTurnsInPlay);
			((Card)card).RenderInfo.OverrideAbilityIcon((Ability)5, ResourceBank.Get<Texture>("Art/Cards/AbilityIcons/ability_evolve_" + remaining));
			((Card)card).RenderCard();
			if (numTurnsInPlay >= turnsToEvolve)
			{
				ChallengeActivationUI.TryShowActivation(ChallengeRegistry.NoGrowthChallenge.challengeType);
				ProcessedEvolves.Add(evolve);
				yield return InvokePreSuccessfulTriggerSequence(evolve);
				if (!((Object)(object)card == (Object)null) && !card.Dead)
				{
					Singleton<ViewManager>.Instance.SwitchToView((View)4, false, false);
					yield return (object)new WaitForSeconds(0.15f);
					((Card)card).Anim.PlayTransformAnimation();
					yield return (object)new WaitForSeconds(0.15f);
					CardModificationInfo growth = new CardModificationInfo
					{
						attackAdjustment = 1,
						healthAdjustment = 1,
						singletonId = "OLD_SA_NoGrowth_StatIncrease"
					};
					card.AddTemporaryMod(growth);
					HideEvolve(card);
					card.OnStatsChanged();
					((Card)card).RenderCard();
					card.UpdateFaceUpOnBoardEffects();
					yield return ChallengeDialogueManager.ShowFirstTime("No Growth", "They were meant to evolve... but only an echo answered.");
				}
			}
		}

		private static void HideEvolve(PlayableCard card)
		{
			if (!((Object)(object)card == (Object)null) && card.Status != null)
			{
				if (card.Status.hiddenAbilities == null)
				{
					card.Status.hiddenAbilities = new List<Ability>();
				}
				if (!card.Status.hiddenAbilities.Contains((Ability)5))
				{
					card.Status.hiddenAbilities.Add((Ability)5);
				}
				((Card)card).RenderInfo.OverrideAbilityIcon((Ability)5, (Texture)null);
				((Card)card).RenderCard();
			}
		}

		private static IEnumerator InvokePreSuccessfulTriggerSequence(Evolve evolve)
		{
			if ((Object)(object)evolve == (Object)null || PreSuccessfulTriggerSequenceMethod == null)
			{
				yield break;
			}
			object result = PreSuccessfulTriggerSequenceMethod.Invoke(evolve, null);
			if (result is IEnumerator sequence)
			{
				while (sequence.MoveNext())
				{
					yield return sequence.Current;
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameMap), "ShowMapSequence")]
	public static class NoWoodcarverDialoguePatch
	{
		private static readonly MethodInfo UnrollingSequenceMethod = AccessTools.Method(typeof(GameMap), "UnrollingSequence", (Type[])null, (Type[])null);

		[HarmonyPrefix]
		public static bool Prefix(GameMap __instance, float unrollSpeed, ref IEnumerator __result)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			if ((Object)(object)ChallengeRegistry.NoWoodcarverChallenge == (Object)null || AscensionSaveData.Data == null || !AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.NoWoodcarverChallenge.challengeType))
			{
				return true;
			}
			__result = ShowMapSequenceWithDialogue(__instance, unrollSpeed);
			return false;
		}

		private static IEnumerator ShowMapSequenceWithDialogue(GameMap map, float unrollSpeed)
		{
			SetFullyUnrolled(map, value: false);
			IEnumerator sequence = InvokeUnrollingSequence(map, unrollSpeed);
			if (sequence != null)
			{
				while (sequence.MoveNext())
				{
					yield return sequence.Current;
				}
			}
			((AnimatedGameMapMarker)PlayerMarker.Instance).Show();
			SetFullyUnrolled(map, value: true);
			yield return ChallengeDialogueManager.ShowFirstTime("No Woodcarver", "Sorry,she doesn't have enough wood.");
		}

		private static IEnumerator InvokeUnrollingSequence(GameMap map, float unrollSpeed)
		{
			if ((Object)(object)map == (Object)null || UnrollingSequenceMethod == null)
			{
				yield break;
			}
			object result = UnrollingSequenceMethod.Invoke(map, new object[1] { unrollSpeed });
			if (result is IEnumerator sequence)
			{
				while (sequence.MoveNext())
				{
					yield return sequence.Current;
				}
			}
		}

		private static void SetFullyUnrolled(GameMap map, bool value)
		{
			if (!((Object)(object)map == (Object)null))
			{
				PropertyInfo propertyInfo = AccessTools.Property(typeof(GameMap), "FullyUnrolled");
				if (!(propertyInfo == null))
				{
					propertyInfo.SetValue(map, value, null);
				}
			}
		}
	}
	[HarmonyPatch(typeof(MapGenerator), "GenerateMap")]
	public static class NoWoodcarverMapGeneratePatch
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (SaveFile.IsAscension && !((Object)(object)ChallengeRegistry.NoWoodcarverChallenge == (Object)null) && AscensionSaveData.Data != null && AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.NoWoodcarverChallenge.challengeType))
			{
				ChallengeActivationUI.TryShowActivation(ChallengeRegistry.NoWoodcarverChallenge.challengeType);
			}
		}
	}
	[HarmonyPatch(typeof(MapGenerator), "ChooseSpecialNodeFromPossibilities")]
	public static class NoWoodcarverPatch
	{
		[HarmonyPrefix]
		public static void Prefix(List<NodeData> possibilities)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (possibilities != null && !((Object)(object)ChallengeRegistry.NoWoodcarverChallenge == (Object)null) && SaveFile.IsAscension && AscensionSaveData.Data.ChallengeIsActive(ChallengeRegistry.NoWoodcarverChallenge.challengeType))
			{
				possibilities.RemoveAll((NodeData node) => node is BuildTotemNodeData);
			}
		}
	}
	public static class OpeningHandSlotPatch
	{
		[HarmonyPatch(typeof(CardDrawPiles3D), "DrawOpeningHand")]
		public static class DrawOpeningHandPatch
		{
			private static IEnumerator Postfix(IEnumerator result)
			{
				yield return result;
				yield return (object)new WaitForSeconds(0.5f);
				yield return SlotChallengePatch.GenerateChallengeSlots();
			}
		}
	}
	[BepInPlugin("OLD_SA.Challenge", "OLD SA Challenge", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "OLD_SA.Challenge";

		public const string PluginName = "OLD SA Challenge";

		public const string PluginVersion = "1.0.0";

		internal static ManualLogSource Log;

		private void Awake()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			ChallengeRegistry.Register();
			Harmony val = new Harmony("OLD_SA.Challenge");
			NeverHungryPatch.Apply(val);
			BrokenBagPatch.Apply(val);
			val.PatchAll();
			WaterForestSlot.Add_WaterForestSlot();
			StartledSlot.Add_StartledSlot();
			HallucinationSlot.Add_HallucinationSlot();
		}

		public static Texture2D LoadTexture(string name)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("OldSa_Challenge.Resources." + name);
			if (stream == null)
			{
				Log.LogError((object)("[OldSa Challenge] Missing texture: " + name));
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array);
			((Object)val).name = name;
			return val;
		}
	}
	[HarmonyPatch(typeof(PlayableCard), "GetPassiveAttackBuffs")]
	public static class StartledPatch
	{
		[HarmonyPostfix]
		public static void Postfix(PlayableCard __instance, ref int __result)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.Slot == (Object)null) && HasStartledSlot(__instance.Slot))
			{
				__result--;
			}
		}

		private static bool HasStartledSlot(CardSlot slot)
		{
			if ((Object)(object)slot == (Object)null)
			{
				return false;
			}
			return (Object)(object)((Component)slot).GetComponent<StartledSlot>() != (Object)null;
		}
	}
	public class StartledSlot : SlotModificationBehaviour
	{
		public static ModificationType SlotType;

		public static void Add_StartledSlot()
		{
			//IL_0020: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			SlotType = SlotModificationExtensions.SetRulebook(SlotModificationManager.New("OLD_SA.Challenge", "StartledSlot", typeof(StartledSlot), TextureHelper.GetImageAsTexture("startled_slot.png", (FilterMode)0)), "Startled Slot", "Creatures on this space lose 1 attack.", TextureHelper.GetImageAsTexture("startled_rulebook.png", (FilterMode)0), (ModificationMetaCategory[])(object)new ModificationMetaCategory[1]);
		}
	}
	public static class SlotChallengePatch
	{
		public static List<CardSlot> ModifiedSlots = new List<CardSlot>();

		public static IEnumerator GenerateChallengeSlots()
		{
			if (!SaveFile.IsAscension)
			{
				yield break;
			}
			BoardManager3D board = Singleton<BoardManager3D>.Instance;
			if (!((Object)(object)board == (Object)null))
			{
				ModifiedSlots.Clear();
				List<CardSlot> availableSlots = ((BoardManager)board).PlayerSlotsCopy.ToList();
				Random slotRandom = new Random(SaveManager.SaveFile.GetCurrentRandomSeed() + 777);
				int waterForestCount = AscensionSaveData.Data.GetNumChallengesOfTypeActive(ChallengeRegistry.WaterForestChallengeType);
				if (waterForestCount > 0)
				{
					ChallengeActivationUI.TryShowActivation(ChallengeRegistry.WaterForestChallengeType);
					yield return ApplySlot(availableSlots, waterForestCount, WaterForestSlot.SlotType, slotRandom);
				}
				int hallucinationCount = AscensionSaveData.Data.GetNumChallengesOfTypeActive(ChallengeRegistry.HallucinationSlotChallengeType);
				if (hallucinationCount > 0)
				{
					ChallengeActivationUI.TryShowActivation(ChallengeRegistry.HallucinationSlotChallengeType);
					yield return ApplySlot(availableSlots, hallucinationCount, HallucinationSlot.SlotType, slotRandom);
				}
				int startledCount = AscensionSaveData.Data.GetNumChallengesOfTypeActive(ChallengeRegistry.StartledSlotChallengeType);
				if (startledCount > 0)
				{
					ChallengeActivationUI.TryShowActivation(ChallengeRegistry.StartledSlotChallengeType);
					yield return ApplySlot(availableSlots, startledCount, StartledSlot.SlotType, slotRandom);
				}
			}
		}

		private static IEnumerator ApplySlot(List<CardSlot> availableSlots, int count, ModificationType slotType, Random random)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (availableSlots == null || availableSlots.Count == 0 || count <= 0)
			{
				yield break;
			}
			List<CardSlot> selectedSlots = availableSlots.OrderBy((CardSlot x) => random.Next()).Take(count).ToList();
			foreach (CardSlot slot in selectedSlots)
			{
				((HighlightedInteractable)slot).SetShown(false, false);
			}
			yield return (object)new WaitForSeconds(0.45f);
			foreach (CardSlot slot2 in selectedSlots)
			{
				yield return SlotModificationExtensions.SetSlotModification(slot2, slotType);
				if (!ModifiedSlots.Contains(slot2))
				{
					ModifiedSlots.Add(slot2);
				}
				availableSlots.Remove(slot2);
			}
			foreach (CardSlot slot3 in selectedSlots)
			{
				((HighlightedInteractable)slot3).SetShown(true, false);
				yield return (object)new WaitForSeconds(0.05f);
			}
		}
	}
	public class WaterForestSlot : SlotModificationBehaviour
	{
		public static ModificationType SlotType;

		private const string WATER_FOREST_ID = "oldsa_water_forest_submerge";

		private readonly CardModificationInfo waterMod = new CardModificationInfo
		{
			abilities = new List<Ability> { (Ability)13 },
			singletonId = "oldsa_water_forest_submerge",
			nonCopyable = true,
			RemoveOnUpkeep = false
		};

		private static bool initialized;

		public override bool RespondsToOtherCardAssignedToSlot(PlayableCard otherCard)
		{
			return (Object)(object)otherCard != (Object)null && (Object)(object)((SlotModificationBehaviour)this).Slot.Card == (Object)(object)otherCard && !HasWaterForestMod(otherCard);
		}

		public override IEnumerator OnOtherCardAssignedToSlot(PlayableCard otherCard)
		{
			if (!((Object)(object)otherCard == (Object)null) && !HasWaterForestMod(otherCard) && !otherCard.HasAbility((Ability)13) && !otherCard.HasAbility((Ability)89))
			{
				otherCard.Status.hiddenAbilities.Add((Ability)13);
				otherCard.AddTemporaryMod(waterMod);
				otherCard.OnStatsChanged();
			}
			yield break;
		}

		private bool HasWaterForestMod(PlayableCard card)
		{
			if ((Object)(object)card == (Object)null)
			{
				return false;
			}
			foreach (CardModificationInfo temporaryMod in card.TemporaryMods)
			{
				if (temporaryMod.singletonId == "oldsa_water_forest_submerge")
				{
					return true;
				}
			}
			return false;
		}

		public static void Add_WaterForestSlot()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!initialized)
			{
				initialized = true;
				ModificationType slotType = SlotModificationExtensions.SetRulebook(SlotModificationManager.New("OLD_SA.Challenge", "WaterForestSlot", typeof(WaterForestSlot), TextureHelper.GetImageAsTexture("water_forest_slot.png", (FilterMode)0)), "Submerge Slot", "Creatures that enter this space gain the Submerge sigil for this battle.", TextureHelper.GetImageAsTexture("water_forest_rulebook.png", (FilterMode)0), (ModificationMetaCategory[])(object)new ModificationMetaCategory[1]);
				SlotType = slotType;
			}
		}
	}
}