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

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 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 void Register()
	{
		Plugin.Log.LogInfo((object)"[OldSa Challenge] Registering challenges...");
		NoGrowthChallenge = FullChallenge.op_Implicit(ChallengeManager.Add("OLD_SA.Challenge", "No Growth", "Fledgling sigils no longer evolve. They only grant +1 Power and +1 Health.", 30, TextureHelper.GetImageAsTexture("NoGrowth.png", (FilterMode)0), TextureHelper.GetImageAsTexture("NoGrowth_Activated.png", (FilterMode)0), 0, false));
		Plugin.Log.LogInfo((object)("[OldSa Challenge] Registered: No Growth | ID: " + ((object)Unsafe.As<AscensionChallenge, AscensionChallenge>(ref NoGrowthChallenge.challengeType)/*cast due to .constrained prefix*/).ToString()));
		NoWoodcarverChallenge = FullChallenge.op_Implicit(ChallengeManager.Add("OLD_SA.Challenge", "No Woodcarver", "You will no longer encounter Woodcarver choice nodes.", 30, TextureHelper.GetImageAsTexture("NoWoodcarver.png", (FilterMode)0), TextureHelper.GetImageAsTexture("NoWoodcarver_Activated.png", (FilterMode)0), 0, false));
		Plugin.Log.LogInfo((object)("[OldSa Challenge] Registered: No Woodcarver | ID: " + ((object)Unsafe.As<AscensionChallenge, AscensionChallenge>(ref NoWoodcarverChallenge.challengeType)/*cast due to .constrained prefix*/).ToString()));
		DizzyStartersChallenge = FullChallenge.op_Implicit(ChallengeManager.Add("OLD_SA.Challenge", "Dizzy Starters", "All creatures in your starting deck gain the Random sigil.", 30, TextureHelper.GetImageAsTexture("DizzyStarters.png", (FilterMode)0), TextureHelper.GetImageAsTexture("DizzyStarters_Activated.png", (FilterMode)0), 0, false));
		Plugin.Log.LogInfo((object)("[OldSa Challenge] Registered: Dizzy Starters | ID: " + ((object)Unsafe.As<AscensionChallenge, AscensionChallenge>(ref DizzyStartersChallenge.challengeType)/*cast due to .constrained prefix*/).ToString()));
		Plugin.Log.LogInfo((object)"[OldSa Challenge] All challenges registered.");
	}
}
[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);
				Plugin.Log.LogInfo((object)("[OldSa Challenge] Dizzy Starters: Added Random to " + ((Object)card).name));
			}
		}
	}
}
[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)
		{
			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();
			}
		}
	}

	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(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);
		}
	}
}
[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_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		Log.LogInfo((object)"[OldSa Challenge] Plugin loaded.");
		Harmony val = new Harmony("OLD_SA.Challenge");
		val.PatchAll();
		Log.LogInfo((object)"[OldSa Challenge] Harmony patches applied.");
		ChallengeRegistry.Register();
		Log.LogInfo((object)"[OldSa Challenge] Initialization complete.");
	}

	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)("[World Rules] 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;
	}
}

using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using InscryptionAPI.Ascension;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("OLD_SA_Decks")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OLD_SA_Decks")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("006f57b1-dcb0-4c34-9083-035a71c7be95")]
[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")]
public static class StarterDeck
{
	public static void Init()
	{
		StarterDeckManager.New("com.oldsa.hive", "Hive Will", "OLD_SA_HiveDeck.png", new string[3] { "Beehive", "OLD_SA_BEE_WORKER", "OLD_SA_BEE_QUEEN" }, 0);
		StarterDeckManager.New("com.oldsa.poison", "Poison", "OLD_SA_Poison.png", new string[3] { "Skink", "OLD_SA_DART_FROG", "Adder" }, 0);
		StarterDeckManager.New("com.oldsa.strafe", "Strafe", "OLD_SA_Strafe.png", new string[3] { "ElkCub", "OLD_SA_ANTELOPE", "Bull" }, 0);
		StarterDeckManager.New("com.oldsa.cat", "Cat", "OLD_SA_Cat.png", new string[3] { "Cat", "OLD_SA_LYNX", "Wolf" }, 0);
	}
}
namespace OLD_SA.Decks;

[BepInPlugin("OLD_SA.Decks", "OLD SA Decks", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	private void Awake()
	{
		StarterDeck.Init();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"OLD SA Decks Loaded");
	}
}

using System;
using System.Collections;
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.Card;
using OLD_SA.Dialogue;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("OLD_SA_Evolution")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OLD_SA_Evolution")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5b768fcb-7685-41db-8b51-6ca3e88435e4")]
[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.Evolution;

public static class EvolutionAPI
{
	public static Dictionary<string, string> Evolutions = new Dictionary<string, string>();

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

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

	public static HashSet<string> TriggeredEvolutionDialogues = new HashSet<string>();

	public static void AddEvolution(string from, string to, int turns, string dialogue = null)
	{
		Evolutions[from] = to;
		Turns[from] = turns;
		if (!string.IsNullOrEmpty(dialogue))
		{
			EvolutionDialogues[from] = dialogue;
		}
	}

	public static bool ShouldTriggerEvolutionDialogue(string cardName)
	{
		if (TriggeredEvolutionDialogues.Contains(cardName))
		{
			return false;
		}
		TriggeredEvolutionDialogues.Add(cardName);
		OLD_SA_SaveManager.Save();
		return true;
	}

	public static List<string> GetTriggeredDialogues()
	{
		return new List<string>(TriggeredEvolutionDialogues);
	}

	public static void LoadTriggeredDialogues(List<string> data)
	{
		TriggeredEvolutionDialogues.Clear();
		if (data == null)
		{
			return;
		}
		foreach (string datum in data)
		{
			if (!string.IsNullOrEmpty(datum))
			{
				TriggeredEvolutionDialogues.Add(datum);
			}
		}
	}

	public static void ClearTriggeredDialogues()
	{
		TriggeredEvolutionDialogues.Clear();
	}
}
public class EvolutionData
{
	public string target;

	public int turns;

	public string dialogue;
}
[HarmonyPatch(typeof(PlayableCard))]
public static class EvolutionDialoguePatch
{
	private static Dictionary<PlayableCard, string> BeforeEvolution = new Dictionary<PlayableCard, string>();

	[HarmonyPatch("TransformIntoCard")]
	[HarmonyPrefix]
	public static void Prefix(PlayableCard __instance)
	{
		if (!((Object)(object)__instance == (Object)null) && !((Object)(object)((Card)__instance).Info == (Object)null))
		{
			BeforeEvolution[__instance] = ((Object)((Card)__instance).Info).name;
		}
	}

	[HarmonyPatch("TransformIntoCard")]
	[HarmonyPostfix]
	public static IEnumerator Postfix(IEnumerator result, PlayableCard __instance, CardInfo evolvedInfo)
	{
		while (result.MoveNext())
		{
			yield return result.Current;
		}
		if (!((Object)(object)__instance == (Object)null) && !((Object)(object)evolvedInfo == (Object)null) && BeforeEvolution.ContainsKey(__instance))
		{
			string oldName = BeforeEvolution[__instance];
			BeforeEvolution.Remove(__instance);
			if (EvolutionAPI.EvolutionDialogues.ContainsKey(oldName) && EvolutionAPI.ShouldTriggerEvolutionDialogue(oldName))
			{
				string dialogue = EvolutionAPI.EvolutionDialogues[oldName];
				yield return ShowEvolutionDialogue(dialogue);
			}
		}
	}

	private static IEnumerator ShowEvolutionDialogue(string dialogue)
	{
		yield return (object)new WaitForEndOfFrame();
		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);
		}
	}
}
public static class EvolutionManager
{
	public static void RegisterAll()
	{
		foreach (CardInfo item in CardManager.AllCardsCopy)
		{
			string evolveFrom = CardExtensions.GetExtendedProperty(item, "OLD_SA_EvolveFrom");
			if (string.IsNullOrEmpty(evolveFrom))
			{
				continue;
			}
			CardInfo val = CardManager.AllCardsCopy.Find((CardInfo x) => ((Object)x).name == evolveFrom);
			if (!((Object)(object)val == (Object)null))
			{
				int num = 1;
				string extendedProperty = CardExtensions.GetExtendedProperty(item, "OLD_SA_EvolveTurns");
				if (int.TryParse(extendedProperty, out var result))
				{
					num = result;
				}
				if (val.evolveParams == null || (Object)(object)val.evolveParams.evolution != (Object)(object)item)
				{
					CardExtensions.SetEvolve(val, item, num, (IEnumerable<CardModificationInfo>)null);
				}
				if (val.evolveParams != null)
				{
					val.evolveParams.turnsToEvolve = num;
				}
				string extendedProperty2 = CardExtensions.GetExtendedProperty(item, "OLD_SA_EvolveDialogue");
				EvolutionAPI.AddEvolution(((Object)val).name, ((Object)item).name, num, extendedProperty2);
			}
		}
	}
}
[BepInPlugin("OLD_SA.Evolution", "OLD SA Evolution", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	private void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		Harmony val = new Harmony("OLD_SA.Evolution");
		val.PatchAll();
		SceneManager.sceneLoaded += OnSceneLoaded;
		((MonoBehaviour)this).StartCoroutine(InitialRegister());
		Debug.Log((object)"OLD SA Evolution Loaded");
	}

	private IEnumerator InitialRegister()
	{
		yield return (object)new WaitUntil((Func<bool>)(() => CardManager.AllCardsCopy != null && CardManager.AllCardsCopy.Count > 0));
		yield return (object)new WaitForSeconds(1f);
		EvolutionManager.RegisterAll();
	}

	private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		((MonoBehaviour)this).StartCoroutine(DelayedSceneRegister());
	}

	private IEnumerator DelayedSceneRegister()
	{
		yield return (object)new WaitForSeconds(1f);
		EvolutionManager.RegisterAll();
	}
}

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.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using DiskCardGame;
using HarmonyLib;
using OLD_SA.CardTraits;
using OLD_SA.Evolution;
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("OLD_SA_Sigil")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OLD_SA_Sigil")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("59150cfa-2a48-413c-bd72-7da85784e761")]
[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.Dialogue;

public static class DialogueColorAPI
{
	public static Color? CurrentColor;
}
public static class OLD_SA_SaveManager
{
	[Serializable]
	private class DialogueSaveData
	{
		public List<string> SigilDialogues = new List<string>();

		public List<string> EvolutionDialogues = new List<string>();

		public List<string> TraitDialogues = new List<string>();
	}

	private static string PathFile => Path.Combine(Application.persistentDataPath, "OLD_SA_Save.json");

	public static void Save()
	{
		DialogueSaveData dialogueSaveData = new DialogueSaveData();
		dialogueSaveData.SigilDialogues = SigilDialogueSaveData.GetSaveList();
		dialogueSaveData.EvolutionDialogues = EvolutionAPI.GetTriggeredDialogues();
		dialogueSaveData.TraitDialogues = CardTraitDialogueSaveData.GetSaveList();
		string contents = JsonUtility.ToJson((object)dialogueSaveData, true);
		try
		{
			File.WriteAllText(PathFile, contents);
			Debug.Log((object)"OLD SA Save Complete");
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("OLD SA Save Failed: " + ex.Message));
		}
	}

	public static void Load()
	{
		if (!File.Exists(PathFile))
		{
			Debug.Log((object)"OLD SA Save Not Found");
			return;
		}
		try
		{
			string text = File.ReadAllText(PathFile);
			DialogueSaveData dialogueSaveData = JsonUtility.FromJson<DialogueSaveData>(text);
			if (dialogueSaveData != null)
			{
				SigilDialogueSaveData.LoadFromList(dialogueSaveData.SigilDialogues);
				EvolutionAPI.LoadTriggeredDialogues(dialogueSaveData.EvolutionDialogues);
				CardTraitDialogueSaveData.LoadFromList(dialogueSaveData.TraitDialogues);
				Debug.Log((object)"OLD SA Load Complete");
			}
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("OLD SA Load Failed: " + ex.Message));
		}
	}
}
[BepInPlugin("OLD_SA.Dialogue", "OLD SA Dialogue", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	private void Awake()
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		OLD_SA_SaveManager.Load();
		Harmony val = new Harmony("OLD_SA.Dialogue");
		val.PatchAll();
		Debug.Log((object)"OLD SA Dialogue Loaded");
	}
}
public static class SigilDialogueAPI
{
	public static bool ShowingDialogue;

	public static IEnumerator ShowFirstTime(string sigilID, string dialogue)
	{
		return ShowFirstTime(sigilID, dialogue, null);
	}

	public static IEnumerator ShowFirstTime(string sigilID, string dialogue, PlayableCard triggerCard = null)
	{
		if (SigilDialogueSaveData.HasTriggered(sigilID))
		{
			yield break;
		}
		SigilDialogueSaveData.AddTriggered(sigilID);
		OLD_SA_SaveManager.Save();
		DialogueColorAPI.CurrentColor = null;
		if ((Object)(object)triggerCard != (Object)null && (Object)(object)((Card)triggerCard).Info != (Object)null)
		{
			string cardName = ((Object)((Card)triggerCard).Info).name;
			if (cardName == "OLD_SA_WIND_PTEROSAUR")
			{
				DialogueColorAPI.CurrentColor = Color.cyan;
			}
			if (cardName == "OLD_SA_BEE_QUEEN")
			{
				DialogueColorAPI.CurrentColor = Color.yellow;
			}
		}
		ShowingDialogue = true;
		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;
			}
			DialogueColorAPI.CurrentColor = null;
			ShowingDialogue = false;
		}
	}
}
public static class SigilDialogueSaveData
{
	private static HashSet<string> Triggered = new HashSet<string>();

	public static int Count => Triggered.Count;

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

	public static void AddTriggered(string id)
	{
		if (!string.IsNullOrEmpty(id) && !Triggered.Contains(id))
		{
			Triggered.Add(id);
		}
	}

	public static void Remove(string id)
	{
		if (!string.IsNullOrEmpty(id))
		{
			Triggered.Remove(id);
		}
	}

	public static void Clear()
	{
		Triggered.Clear();
	}

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

	public static void LoadFromList(List<string> data)
	{
		Triggered.Clear();
		if (data == null)
		{
			return;
		}
		foreach (string datum in data)
		{
			if (!string.IsNullOrEmpty(datum))
			{
				Triggered.Add(datum);
			}
		}
	}
}
[HarmonyPatch]
public static class SigilDialogueSavePatch
{
	[HarmonyPatch(typeof(SaveFile), "Initialize")]
	[HarmonyPostfix]
	public static void InitializePostfix()
	{
		OLD_SA_SaveManager.Load();
		Debug.Log((object)"OLD SA Dialogue Save Loaded");
	}

	[HarmonyPatch(typeof(SaveManager), "SaveToFile")]
	[HarmonyPostfix]
	public static void SaveToFilePostfix(bool saveActiveScene)
	{
		OLD_SA_SaveManager.Save();
		Debug.Log((object)"OLD SA Dialogue Save Saved");
	}
}
[HarmonyPatch(typeof(TextDisplayer), "ShowMessage")]
public static class TextDisplayerColorPatch
{
	[HarmonyPostfix]
	public static void Postfix(TextDisplayer __instance)
	{
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		if (!DialogueColorAPI.CurrentColor.HasValue)
		{
			return;
		}
		FieldInfo fieldInfo = AccessTools.Field(typeof(TextDisplayer), "textMesh");
		if (fieldInfo == null)
		{
			return;
		}
		object value = fieldInfo.GetValue(__instance);
		if (value != null)
		{
			PropertyInfo property = value.GetType().GetProperty("color");
			if (property != null && property.CanWrite)
			{
				property.SetValue(value, DialogueColorAPI.CurrentColor.Value);
			}
		}
	}
}

using System;
using System.Collections;
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.Card;
using OLD_SA.Dialogue;
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_CardTraits")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OldSa_CardTraits")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4ebfbc44-c273-4a7d-92ed-5b86f52380fa")]
[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.CardTraits;

public static class CardTrait
{
	public const string Featherless = "OLD_SA_Featherless";

	public const string Jackal = "OLD_SA_Jackal";

	public const string WeakHatchling = "OLD_SA_WeakHatchling";

	public const string Infinite = "OLD_SA_Infinite";
}
public static class CardTraitAPI
{
	public static HashSet<string> TriggeredTraitDialogues = new HashSet<string>();

	public static bool ShouldTriggerDialogue(string dialogueID)
	{
		if (string.IsNullOrEmpty(dialogueID))
		{
			return false;
		}
		if (TriggeredTraitDialogues.Contains(dialogueID))
		{
			return false;
		}
		TriggeredTraitDialogues.Add(dialogueID);
		OLD_SA_SaveManager.Save();
		return true;
	}

	public static List<string> GetTriggeredDialogues()
	{
		return new List<string>(TriggeredTraitDialogues);
	}

	public static void LoadTriggeredDialogues(List<string> data)
	{
		TriggeredTraitDialogues.Clear();
		if (data == null)
		{
			return;
		}
		foreach (string datum in data)
		{
			if (!string.IsNullOrEmpty(datum))
			{
				TriggeredTraitDialogues.Add(datum);
			}
		}
	}

	public static void ClearTriggeredDialogues()
	{
		TriggeredTraitDialogues.Clear();
	}
}
public static class CardTraitConditionAPI
{
	private static Dictionary<string, string> RequiredAdjacent = new Dictionary<string, string>();

	public static void RegisterAdjacentRequirement(string trait, string cardName)
	{
		RequiredAdjacent[trait] = cardName;
	}

	public static bool CheckAdjacentRequirement(PlayableCard card, string trait)
	{
		if (!RequiredAdjacent.ContainsKey(trait))
		{
			return true;
		}
		string text = RequiredAdjacent[trait];
		foreach (CardSlot adjacentSlot in Singleton<BoardManager>.Instance.GetAdjacentSlots(card.Slot))
		{
			if ((Object)(object)adjacentSlot.Card != (Object)null && ((Object)((Card)adjacentSlot.Card).Info).name == text)
			{
				return true;
			}
		}
		return false;
	}
}
public static class CardTraitDialogueManager
{
	public static IEnumerator TryTrigger(PlayableCard card)
	{
		if (!((Object)(object)card == (Object)null) && !((Object)(object)((Card)card).Info == (Object)null))
		{
			string dialogueID = CardExtensions.GetExtendedProperty(((Card)card).Info, "OLD_SA_TraitDialogueID");
			string dialogue = CardExtensions.GetExtendedProperty(((Card)card).Info, "OLD_SA_TraitDialogue");
			yield return TryTrigger(dialogueID, dialogue);
		}
	}

	public static IEnumerator TryTrigger(string dialogueID, string dialogue)
	{
		if (!string.IsNullOrEmpty(dialogueID) && !string.IsNullOrEmpty(dialogue) && !CardTraitDialogueSaveData.HasTriggered(dialogueID))
		{
			yield return Singleton<TextDisplayer>.Instance.ShowUntilInput(dialogue, -0.65f, 0.4f, (Emotion)0, (LetterAnimation)0, (Speaker)0, (string[])null, true);
			CardTraitDialogueSaveData.AddTriggered(dialogueID);
		}
	}
}
public static class CardTraitDialogueQueue
{
	private static string id;

	private static string text;

	public static void Add(string dialogueID, string dialogue)
	{
		if (!string.IsNullOrEmpty(dialogueID) && !string.IsNullOrEmpty(dialogue))
		{
			id = dialogueID;
			text = dialogue;
		}
	}

	public static bool HasDialogue()
	{
		return !string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(text);
	}

	public static IEnumerator Play()
	{
		if (HasDialogue())
		{
			string currentID = id;
			string currentText = text;
			id = null;
			text = null;
			yield return Singleton<TextDisplayer>.Instance.ShowUntilInput(currentText, -0.65f, 0.4f, (Emotion)0, (LetterAnimation)0, (Speaker)0, (string[])null, true);
			CardTraitDialogueSaveData.AddTriggered(currentID);
		}
	}
}
public class CardTraitDialogueRunner : MonoBehaviour
{
	private static CardTraitDialogueRunner instance;

	private bool playing;

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

	public void Queue(string dialogueID, string dialogue)
	{
		CardTraitDialogueQueue.Add(dialogueID, dialogue);
	}

	private void Update()
	{
		if (!playing && CardTraitDialogueQueue.HasDialogue())
		{
			((MonoBehaviour)this).StartCoroutine(PlayQueue());
		}
	}

	private IEnumerator PlayQueue()
	{
		playing = true;
		yield return CardTraitDialogueQueue.Play();
		playing = false;
	}
}
public static class CardTraitDialogueSaveData
{
	private static HashSet<string> Triggered = new HashSet<string>();

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

	public static void AddTriggered(string id)
	{
		if (!string.IsNullOrEmpty(id) && !Triggered.Contains(id))
		{
			Triggered.Add(id);
		}
	}

	public static void Remove(string id)
	{
		if (!string.IsNullOrEmpty(id))
		{
			Triggered.Remove(id);
		}
	}

	public static void Clear()
	{
		Triggered.Clear();
	}

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

	public static void LoadFromList(List<string> data)
	{
		Triggered.Clear();
		if (data == null)
		{
			return;
		}
		foreach (string datum in data)
		{
			if (!string.IsNullOrEmpty(datum))
			{
				Triggered.Add(datum);
			}
		}
	}
}
[HarmonyPatch(typeof(PlayableCard), "AddTemporaryMod")]
public static class CardTraitFlyingPatch
{
	[HarmonyPrefix]
	public static bool Prefix(PlayableCard __instance, CardModificationInfo mod)
	{
		if ((Object)(object)__instance == (Object)null || (Object)(object)((Card)__instance).Info == (Object)null || mod == null || mod.abilities == null)
		{
			return true;
		}
		if (!mod.abilities.Contains((Ability)19))
		{
			return true;
		}
		if (mod.singletonId == "wind_blessing_flying")
		{
			return true;
		}
		if (!CardTraitHelper.HasTrait(__instance, "OLD_SA_Featherless"))
		{
			return true;
		}
		((MonoBehaviour)__instance).StartCoroutine(CardTraitDialogueManager.TryTrigger(__instance));
		mod.abilities.Remove((Ability)19);
		if (mod.abilities.Count == 0 && mod.attackAdjustment == 0 && mod.healthAdjustment == 0 && (mod.negateAbilities == null || mod.negateAbilities.Count == 0))
		{
			return false;
		}
		return true;
	}
}
public static class CardTraitHelper
{
	public static bool HasTrait(PlayableCard card, string trait)
	{
		if ((Object)(object)card == (Object)null || (Object)(object)((Card)card).Info == (Object)null)
		{
			return false;
		}
		if (CardExtensions.GetExtendedProperty(((Card)card).Info, trait) == "true")
		{
			return true;
		}
		foreach (CardModificationInfo mod in ((Card)card).Info.Mods)
		{
			if (mod.singletonId == trait)
			{
				return true;
			}
		}
		foreach (CardModificationInfo temporaryMod in card.TemporaryMods)
		{
			if (temporaryMod.singletonId == trait)
			{
				return true;
			}
		}
		return false;
	}
}
[HarmonyPatch(typeof(DeckInfo), "ModifyCard")]
public static class FeatherlessDeckModifyPatch
{
	[HarmonyPrefix]
	public static bool Prefix(CardInfo card, CardModificationInfo mod)
	{
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Invalid comparison between Unknown and I4
		if ((Object)(object)card == (Object)null || mod == null || mod.abilities == null)
		{
			return true;
		}
		if (!mod.abilities.Contains((Ability)19))
		{
			return true;
		}
		if (CardExtensions.GetExtendedProperty(card, "OLD_SA_Featherless") != "true")
		{
			return true;
		}
		mod.abilities.Remove((Ability)19);
		string extendedProperty = CardExtensions.GetExtendedProperty(card, "OLD_SA_TraitDialogueID");
		string extendedProperty2 = CardExtensions.GetExtendedProperty(card, "OLD_SA_TraitDialogue");
		CardTraitDialogueQueue.Add(extendedProperty, extendedProperty2);
		if (mod.abilities.Count == 0 && mod.attackAdjustment == 0 && mod.healthAdjustment == 0 && (mod.negateAbilities == null || mod.negateAbilities.Count == 0) && (mod.addGemCost == null || mod.addGemCost.Count == 0) && (mod.specialAbilities == null || mod.specialAbilities.Count == 0) && (int)mod.statIcon == 0)
		{
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(RandomAbility), "ChooseAbility")]
public static class FeatherlessRandomAbilityPatch
{
	[HarmonyPostfix]
	public static void Postfix(RandomAbility __instance, ref Ability __result)
	{
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Expected I4, but got Unknown
		if ((Object)(object)__instance == (Object)null)
		{
			return;
		}
		PlayableCard card = Traverse.Create((object)__instance).Field("Card").GetValue<PlayableCard>();
		if (!((Object)(object)card == (Object)null) && !((Object)(object)((Card)card).Info == (Object)null) && CardTraitHelper.HasTrait(card, "OLD_SA_Featherless") && (int)__result == 19)
		{
			List<Ability> learnedAbilities = AbilitiesUtil.GetLearnedAbilities(false, 0, 5, (AbilityMetaCategory)1);
			learnedAbilities.Remove((Ability)19);
			learnedAbilities.RemoveAll((Ability x) => card.HasAbility(x));
			if (learnedAbilities.Count > 0)
			{
				__result = (Ability)(int)learnedAbilities[SeededRandom.Range(0, learnedAbilities.Count, SaveManager.SaveFile.GetCurrentRandomSeed())];
			}
			else
			{
				__result = (Ability)15;
			}
		}
	}
}
[HarmonyPatch(typeof(PlayableCard), "AddTemporaryMod")]
public static class InfinitePermanentStatsPatch
{
	[HarmonyPrefix]
	public static bool Prefix(PlayableCard __instance, CardModificationInfo mod)
	{
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Expected O, but got Unknown
		if ((Object)(object)__instance == (Object)null || (Object)(object)((Card)__instance).Info == (Object)null || mod == null)
		{
			return true;
		}
		if (!CardTraitHelper.HasTrait(__instance, "OLD_SA_Infinite"))
		{
			return true;
		}
		int num = ((mod.attackAdjustment > 0) ? mod.attackAdjustment : 0);
		int num2 = ((mod.healthAdjustment > 0) ? mod.healthAdjustment : 0);
		if (num == 0 && num2 == 0)
		{
			return true;
		}
		CardModificationInfo val = new CardModificationInfo();
		val.attackAdjustment = num;
		val.healthAdjustment = num2;
		((Card)__instance).Info.Mods.Add(val);
		mod.attackAdjustment -= num;
		mod.healthAdjustment -= num2;
		if (mod.attackAdjustment != 0 || mod.healthAdjustment != 0 || mod.bloodCostAdjustment != 0 || mod.bonesCostAdjustment != 0 || mod.energyCostAdjustment != 0 || mod.gemify || mod.fromOverclock || (mod.abilities != null && mod.abilities.Count > 0) || (mod.negateAbilities != null && mod.negateAbilities.Count > 0))
		{
			return true;
		}
		return false;
	}
}
public static class JackalFusionManager
{
	public static void ReplaceDeckCards(CardInfo jackal, CardInfo wolf, CardInfo result)
	{
		if (RunState.Run == null)
		{
			return;
		}
		DeckInfo playerDeck = RunState.Run.playerDeck;
		if (playerDeck == null)
		{
			return;
		}
		if ((Object)(object)jackal != (Object)null)
		{
			((CardCollectionInfo)playerDeck).RemoveCardByName(((Object)jackal).name);
		}
		if ((Object)(object)wolf != (Object)null)
		{
			((CardCollectionInfo)playerDeck).RemoveCardByName(((Object)wolf).name);
		}
		if ((Object)(object)result != (Object)null)
		{
			((CardCollectionInfo)playerDeck).AddCard(result);
		}
		foreach (CardInfo card in ((CardCollectionInfo)playerDeck).Cards)
		{
		}
	}
}
public static class JackalTraitAPI
{
	public const string Trait = "OLD_SA_Jackal";

	public const string ConditionCard = "OLD_SA_TraitConditionCard";

	public const string TransformCard = "OLD_SA_TraitTransformCard";

	public const string DialogueID = "OLD_SA_TraitDialogueID";

	public const string Dialogue = "OLD_SA_TraitDialogue";

	public static string GetConditionCard(PlayableCard card)
	{
		if (!CardTraitHelper.HasTrait(card, "OLD_SA_Jackal"))
		{
			return null;
		}
		return CardExtensions.GetExtendedProperty(((Card)card).Info, "OLD_SA_TraitConditionCard");
	}

	public static string GetTransformCard(PlayableCard card)
	{
		if (!CardTraitHelper.HasTrait(card, "OLD_SA_Jackal"))
		{
			return null;
		}
		return CardExtensions.GetExtendedProperty(((Card)card).Info, "OLD_SA_TraitTransformCard");
	}

	public static string GetDialogueID(PlayableCard card)
	{
		if (!CardTraitHelper.HasTrait(card, "OLD_SA_Jackal"))
		{
			return null;
		}
		return CardExtensions.GetExtendedProperty(((Card)card).Info, "OLD_SA_TraitDialogueID");
	}

	public static string GetDialogue(PlayableCard card)
	{
		if (!CardTraitHelper.HasTrait(card, "OLD_SA_Jackal"))
		{
			return null;
		}
		return CardExtensions.GetExtendedProperty(((Card)card).Info, "OLD_SA_TraitDialogue");
	}
}
public static class JackalTraitPatch
{
	private static bool transforming;

	public static IEnumerator CheckJackalFusion()
	{
		if (transforming || (Object)(object)Singleton<BoardManager>.Instance == (Object)null)
		{
			yield break;
		}
		foreach (CardSlot slot in Singleton<BoardManager>.Instance.GetSlots(true))
		{
			if ((Object)(object)slot.Card == (Object)null)
			{
				continue;
			}
			PlayableCard jackal = slot.Card;
			if (CardTraitHelper.HasTrait(jackal, "OLD_SA_Jackal"))
			{
				PlayableCard wolf = FindWolf(jackal);
				if ((Object)(object)wolf != (Object)null)
				{
					yield return Fusion(jackal, wolf);
					yield break;
				}
			}
		}
	}

	private static PlayableCard FindWolf(PlayableCard jackal)
	{
		foreach (CardSlot adjacentSlot in Singleton<BoardManager>.Instance.GetAdjacentSlots(jackal.Slot))
		{
			if ((Object)(object)adjacentSlot.Card == (Object)null || !(((Object)((Card)adjacentSlot.Card).Info).name == JackalTraitAPI.GetConditionCard(jackal)))
			{
				continue;
			}
			return adjacentSlot.Card;
		}
		return null;
	}

	private static IEnumerator Fusion(PlayableCard jackal, PlayableCard wolf)
	{
		transforming = true;
		CardInfo result = CardLoader.GetCardByName(JackalTraitAPI.GetTransformCard(jackal));
		if ((Object)(object)result == (Object)null)
		{
			transforming = false;
			yield break;
		}
		CardSlot spawnSlot = jackal.Slot;
		CardInfo jackalInfo = ((Card)jackal).Info;
		CardInfo wolfInfo = ((Card)wolf).Info;
		yield return CardTraitDialogueManager.TryTrigger(jackal);
		if ((Object)(object)jackal != (Object)null)
		{
			((Card)jackal).Anim.ExitBoard(0.5f, Vector3.zero);
		}
		if ((Object)(object)wolf != (Object)null)
		{
			((Card)wolf).Anim.ExitBoard(0.5f, Vector3.zero);
		}
		yield return (object)new WaitForSeconds(0.6f);
		if ((Object)(object)jackal != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)jackal).gameObject);
		}
		if ((Object)(object)wolf != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)wolf).gameObject);
		}
		yield return (object)new WaitForSeconds(0.2f);
		yield return Singleton<BoardManager>.Instance.CreateCardInSlot(result, spawnSlot, 0.1f, true);
		JackalFusionManager.ReplaceDeckCards(jackalInfo, wolfInfo, result);
		transforming = false;
	}
}
[HarmonyPatch(typeof(BoardManager), "AssignCardToSlot")]
public static class JackalFusionTriggerPatch
{
	public static IEnumerator Postfix(IEnumerator __result)
	{
		while (__result.MoveNext())
		{
			yield return __result.Current;
		}
		yield return (object)new WaitForSeconds(0.05f);
		if (HasJackalOnBoard())
		{
			yield return JackalTraitPatch.CheckJackalFusion();
		}
	}

	private static bool HasJackalOnBoard()
	{
		if ((Object)(object)Singleton<BoardManager>.Instance == (Object)null)
		{
			return false;
		}
		foreach (CardSlot slot in Singleton<BoardManager>.Instance.GetSlots(true))
		{
			if ((Object)(object)slot.Card == (Object)null || !CardTraitHelper.HasTrait(slot.Card, "OLD_SA_Jackal"))
			{
				continue;
			}
			return true;
		}
		return false;
	}
}
[BepInPlugin("OLD_SA.CardTraits", "OLD SA CardTraits", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	private void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		Harmony val = new Harmony("OLD_SA.CardTraits");
		val.PatchAll();
		_ = CardTraitDialogueRunner.Instance;
		((BaseUnityPlugin)this).Logger.LogInfo((object)"OLD SA CardTraits Loaded");
	}
}
[HarmonyPatch(typeof(Evolve), "OnUpkeep")]
public static class WeakHatchlingPatch
{
	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);

	[HarmonyPrefix]
	public static bool Prefix(Evolve __instance, bool playerUpkeep, ref IEnumerator __result)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return true;
		}
		PlayableCard card = GetCard(__instance);
		if ((Object)(object)card == (Object)null || !CardTraitHelper.HasTrait(card, "OLD_SA_WeakHatchling"))
		{
			return true;
		}
		__result = WeakHatchlingOnUpkeep(__instance, card, playerUpkeep);
		return false;
	}

	private static PlayableCard GetCard(Evolve evolve)
	{
		if ((Object)(object)evolve == (Object)null)
		{
			return null;
		}
		PropertyInfo propertyInfo = AccessTools.Property(typeof(AbilityBehaviour), "Card");
		if (propertyInfo == null)
		{
			return null;
		}
		object? value = propertyInfo.GetValue(evolve, null);
		return (PlayableCard)((value is PlayableCard) ? value : null);
	}

	private static IEnumerator WeakHatchlingOnUpkeep(Evolve evolve, PlayableCard card, bool playerUpkeep)
	{
		if (!((Object)(object)evolve == (Object)null) && !((Object)(object)card == (Object)null) && !card.Dead && card.OpponentCard != playerUpkeep)
		{
			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)
			{
				yield return InvokePreSuccessfulTriggerSequence(evolve);
				CardModificationInfo growth = new CardModificationInfo
				{
					attackAdjustment = 1,
					healthAdjustment = 1,
					singletonId = "OLD_SA_WeakHatchling_Growth"
				};
				card.AddTemporaryMod(growth);
				RemoveEvolve(card);
				((Card)card).RenderCard();
				card.OnStatsChanged();
				card.UpdateFaceUpOnBoardEffects();
				yield return CardTraitDialogueManager.TryTrigger(card);
			}
		}
	}

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

	private static void RemoveEvolve(PlayableCard card)
	{
		if ((Object)(object)card == (Object)null)
		{
			return;
		}
		if ((Object)(object)card.TriggerHandler != (Object)null)
		{
			card.TriggerHandler.RemoveAbility((Ability)5);
		}
		while (true)
		{
			CardModificationInfo val = null;
			foreach (CardModificationInfo temporaryMod in card.TemporaryMods)
			{
				if (temporaryMod == null || temporaryMod.abilities == null || !temporaryMod.abilities.Contains((Ability)5))
				{
					continue;
				}
				val = temporaryMod;
				break;
			}
			if (val == null)
			{
				break;
			}
			card.RemoveTemporaryMod(val, true);
		}
	}
}