using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using COTL_API.CustomTarotCard;
using COTL_API.Helpers;
using HarmonyLib;
using Lamb.UI;
using Microsoft.CodeAnalysis;
using SuperchargedTarotsUA.Tarots;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("SuperchargedTarotsUA")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+6e0adf95dc5097feb6754ea315897429ce8a42bc")]
[assembly: AssemblyProduct("SuperchargedTarotsUA")]
[assembly: AssemblyTitle("SuperchargedTarotsUA")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SuperchargedTarotsUA
{
	[BepInPlugin("InfernoDragon0.cotl.SuperchargedTarotsUA", "SuperchargedTarotsUA", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[HarmonyPatch]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "InfernoDragon0.cotl.SuperchargedTarotsUA";

		public const string PluginName = "SuperchargedTarotsUA";

		public const string PluginVer = "1.0.1";

		internal static ManualLogSource Log;

		internal static readonly Harmony Harmony = new Harmony("InfernoDragon0.cotl.SuperchargedTarotsUA");

		internal static string PluginPath;

		public static Card secondWind;

		public static Card finalStand;

		public static Card reinforcement;

		public static Card bloodForBlood;

		public static Card staticElectricity;

		public static Card duality;

		public static Card transference;

		public static Card wardingBond;

		public static Card deathContract;

		public static Card ignite;

		internal static ConfigEntry<bool> tarotSecondWindConfig;

		internal static ConfigEntry<bool> tarotFinalStandConfig;

		internal static ConfigEntry<bool> tarotReinforcementConfig;

		internal static ConfigEntry<bool> tarotBloodForBloodConfig;

		internal static ConfigEntry<bool> tarotStaticElectricityConfig;

		internal static ConfigEntry<bool> tarotDualityConfig;

		internal static ConfigEntry<bool> tarotTransferenceConfig;

		internal static ConfigEntry<bool> tarotWardingBondConfig;

		internal static ConfigEntry<bool> tarotDeathContractConfig;

		internal static ConfigEntry<bool> tarotIgniteConfig;

		internal static ConfigEntry<bool> shouldAddCardConfig;

		public static List<Card> coopCards = new List<Card>();

		public static List<Card> soloCards = new List<Card>();

		private void Awake()
		{
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			PluginPath = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			tarotSecondWindConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "Second Wind", true, "Enable this card?");
			tarotFinalStandConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "Final Stand", true, "Enable this card?");
			tarotReinforcementConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "Reinforcement", true, "Enable this card?");
			tarotBloodForBloodConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "Blood For Blood", true, "Enable this card?");
			tarotStaticElectricityConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "Static Electricity", true, "Enable this card?");
			tarotDualityConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "Duality", true, "Enable this card?");
			tarotTransferenceConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SupercargedTarotsUA", "Transference", true, "Enable this card?");
			tarotWardingBondConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "Warding Bond", true, "Enable this card?");
			tarotDeathContractConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "Death Contract", true, "Enable this card?");
			tarotIgniteConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "Ignite", true, "Enable this card?");
			shouldAddCardConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("SuperchargedTarotsUA", "EnableCoopSoloEffects", false, "Set to true if you would like effects of coop cards to apply in solo mode.");
			if (tarotSecondWindConfig.Value)
			{
				secondWind = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_SecondWind());
			}
			if (tarotFinalStandConfig.Value)
			{
				finalStand = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_FinalStand());
			}
			if (tarotReinforcementConfig.Value)
			{
				reinforcement = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_Reinforcement());
			}
			if (tarotBloodForBloodConfig.Value)
			{
				bloodForBlood = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_BloodForBlood());
			}
			if (tarotStaticElectricityConfig.Value)
			{
				staticElectricity = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_StaticElectricity());
			}
			if (tarotDualityConfig.Value)
			{
				duality = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_Duality());
			}
			if (tarotTransferenceConfig.Value)
			{
				transference = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_Transference());
			}
			if (tarotWardingBondConfig.Value)
			{
				wardingBond = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_WardingBond());
			}
			if (tarotDeathContractConfig.Value)
			{
				deathContract = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_DeathContract());
			}
			if (tarotIgniteConfig.Value)
			{
				ignite = CustomTarotCardManager.Add((CustomTarotCard)(object)new Tarot_Ignite());
			}
			coopCards.Add(staticElectricity);
			coopCards.Add(duality);
			coopCards.Add(transference);
			coopCards.Add(wardingBond);
			coopCards.Add(deathContract);
			coopCards.Add(ignite);
			soloCards.Add(secondWind);
			soloCards.Add(finalStand);
			soloCards.Add(reinforcement);
			soloCards.Add(bloodForBlood);
		}

		private void OnEnable()
		{
			Harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded SuperchargedTarotsUA!");
		}

		private void OnDisable()
		{
			Harmony.UnpatchSelf();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Unloaded SuperchargedTarotsUA!");
		}
	}
}
namespace SuperchargedTarotsUA.Tarots
{
	internal class Tarot_BloodForBlood : CustomTarotCard
	{
		public override string InternalName => "TAROT_BLOODFORBLOOD_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_bloodforblood.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Blood For Blood</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "Killing an enemy grants you half a spirit heart.";
		}
	}
	internal class Tarot_DeathContract : CustomTarotCard
	{
		public override string InternalName => "TAROT_DEATHCONTRACT_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_deathcontract.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Death Contract</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "Taking damage to red hearts transfers damage taken as blue hearts to the other player.";
		}
	}
	internal class Tarot_Duality : CustomTarotCard
	{
		public override string InternalName => "TAROT_DUALITY_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_duality.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Duality</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "Attacking an enemy heals the other player for half a heart.";
		}
	}
	internal class Tarot_FinalStand : CustomTarotCard
	{
		public override string InternalName => "TAROT_FINALSTAND_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_finalstand.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Final Stand</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "For every dead follower you own, increase weapon damage by 10%.";
		}

		public override float GetWeaponDamageMultiplerIncrease(TarotCard card)
		{
			int count = DataManager.instance.Followers_Dead.Count;
			Plugin.Log.LogInfo((object)("Granting final stand bonus using " + count + " dead followers."));
			return 1f + (float)count * 0.1f;
		}
	}
	internal class Tarot_Ignite : CustomTarotCard
	{
		public override string InternalName => "TAROT_IGNITE_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_ignite.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Ignite</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "Both players explode when pressing Attack at the same time.";
		}
	}
	internal class Tarot_Reinforcement : CustomTarotCard
	{
		public override string InternalName => "TAROT_REINFORCEMENT_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_reinforcement.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Reinforcement</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "You are immune to traps. Each time you take damage, summon a combat follower to fight for you.";
		}

		public override void ApplyInstantEffects(TarotCard card)
		{
			((Health)PlayerFarming.Instance.health).ImmuneToTraps = true;
		}
	}
	internal class Tarot_SecondWind : CustomTarotCard
	{
		public override string InternalName => "TAROT_SECONDWIND_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_secondwind.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Second Wind</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "Gain 2 Blue Hearts for each heart you currently have.";
		}

		public override void ApplyInstantEffects(TarotCard card)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			float totalSpiritHearts = ((Health)((Component)PlayerFarming.Instance).GetComponent<HealthPlayer>()).TotalSpiritHearts;
			float blackHearts = ((Health)((Component)PlayerFarming.Instance).GetComponent<HealthPlayer>()).BlackHearts;
			float blueHearts = ((Health)((Component)PlayerFarming.Instance).GetComponent<HealthPlayer>()).BlueHearts;
			float totalHP = ((Health)((Component)PlayerFarming.Instance).GetComponent<HealthPlayer>()).totalHP;
			float num = (totalSpiritHearts + blackHearts + blueHearts + totalHP) * 2f;
			HealthPlayer component = ((Component)PlayerFarming.Instance).GetComponent<HealthPlayer>();
			((Health)component).BlueHearts = ((Health)component).BlueHearts + num;
			Vector3 position = PlayerFarming.Instance.CameraBone.transform.position;
			BiomeConstants.Instance.EmitHeartPickUpVFX(position, 0f, "red", "burst_big", true);
		}
	}
	internal class Tarot_StaticElectricity : CustomTarotCard
	{
		public override string InternalName => "TAROT_STATICELECTRICITY_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_staticelectricity.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Static Electricity</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "While near each other, pressing Attack generate lightning strikes.";
		}
	}
	internal class Tarot_Transference : CustomTarotCard
	{
		public override string InternalName => "TAROT_TRANSFERENCE_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_transference.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Transference</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "Taking damage will make the other player explode in a large radius.";
		}
	}
	internal class Tarot_WardingBond : CustomTarotCard
	{
		public override string InternalName => "TAROT_WARDINGBOND_X";

		public override Sprite CustomSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/tarot_wardingbond.png"));

		public override Sprite CustomBackSprite => TextureHelper.CreateSpriteFromPath(Path.Combine(Plugin.PluginPath, "Assets/cardback.png"));

		public override string LocalisedName(int upgradeIndex)
		{
			return "<color=\"red\">Warding Bond</color>";
		}

		public override string LocalisedLore()
		{
			return "<color=\"yellow\">[Supercharged Tarots: Unholy Alliance]</color>";
		}

		public override string LocalisedDescription(int upgradeIndex)
		{
			return "While near each other, negate damage taken at a 70% chance.";
		}
	}
}
namespace SuperchargedTarotsUA.Patches
{
	[HarmonyPatch]
	internal class PerfectCastPatch
	{
		[HarmonyPatch(typeof(UITarotChoiceOverlayController), "Show")]
		[HarmonyPrefix]
		public static bool UITarotChoiceOverlayController_Show(UITarotChoiceOverlayController __instance, TarotCard card1, TarotCard card2, bool instant)
		{
			if (Chainloader.PluginInfos.ContainsKey("InfernoDragon0.cotl.SuperchargedTarots"))
			{
				if (Random.value > 0.5f)
				{
					Plugin.Log.LogInfo((object)"Let SuperchargedTarots decide the cards.");
					return true;
				}
				Plugin.Log.LogInfo((object)"We decide our own cards.");
			}
			__instance._card1 = GetCard();
			__instance._card2 = GetCard(customFirst: false);
			__instance._uiCard1.Play(__instance._card1);
			__instance._uiCard2.Play(__instance._card2);
			__instance.OnTarotCardSelected = (Action<TarotCard>)Delegate.Combine(__instance.OnTarotCardSelected, (Action<TarotCard>)delegate(TarotCard card)
			{
				Plugin.Log.LogInfo((object)("keeping " + ((object)(Card)(ref card.CardType)).ToString()));
			});
			((UIMenuBase)__instance).Show(instant);
			return false;
		}

		private static TarotCard GetCard(bool customFirst = true)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			TarotCard val = null;
			bool flag = false;
			if (customFirst)
			{
				Card val2 = Plugin.soloCards[Random.Range(0, Plugin.soloCards.Count)];
				if (CoopManager.CoopActive || Plugin.shouldAddCardConfig.Value)
				{
					if (Random.value > 0.4f)
					{
						Plugin.Log.LogInfo((object)"Giving Supercharged UA CO OP Card");
						val2 = Plugin.coopCards[Random.Range(0, Plugin.coopCards.Count)];
					}
					else
					{
						Plugin.Log.LogInfo((object)"Giving Supercharged UA SOLO Card");
					}
				}
				val = new TarotCard(val2, 0);
				Plugin.Log.LogInfo((object)("Giving Supercharged UA Card " + ((object)(Card)(ref val2)).ToString()));
			}
			if (DataManager.Instance.PlayerRunTrinketsContains(val, PlayerFarming.Instance))
			{
				Plugin.Log.LogInfo((object)"custom already taken");
				flag = true;
			}
			if (PlayerFarming.playersCount > 1 && DataManager.Instance.PlayerRunTrinketsContains(val, PlayerFarming.players[1]))
			{
				Plugin.Log.LogInfo((object)"custom already taken by other player");
				flag = true;
			}
			if (flag || val == null)
			{
				val = TarotCards.DrawRandomCard(PlayerFarming.Instance, true);
			}
			Plugin.Log.LogInfo((object)("Giving Supercharged UA Card second " + ((object)(Card)(ref val.CardType)).ToString()));
			return val;
		}

		[HarmonyPatch(typeof(Health), "HandleDamageModifierBuff")]
		[HarmonyPrefix]
		public static bool Health_HandleDamageModifierBuff(Health __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (TrinketManager.HasTrinket(Plugin.bloodForBlood))
			{
				HealthPlayer health = PlayerFarming.Instance.health;
				float totalSpiritHearts = ((Health)health).TotalSpiritHearts;
				((Health)health).TotalSpiritHearts = totalSpiritHearts + 1f;
				Plugin.Log.LogInfo((object)"Blood for Blood: Gained 1 Empty Spirit Heart");
			}
			if (TrinketManager.HasTrinket(Plugin.duality))
			{
				Plugin.Log.LogInfo((object)"Heal both players");
				((Health)PlayerFarming.Instance.health).Heal(1f);
				if (PlayerFarming.playersCount > 1)
				{
					((Health)PlayerFarming.players[1].health).Heal(1f);
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(HealthPlayer), "DealDamage")]
		[HarmonyPrefix]
		public static bool HealthPlayer_DealDamage_Prefix(HealthPlayer __instance, out float __state)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			__state = ((Health)__instance).HP;
			if (TrinketManager.HasTrinket(Plugin.deathContract))
			{
				Plugin.Log.LogInfo((object)("Death Contract: Pre Damage HP " + __state));
			}
			return true;
		}

		[HarmonyPatch(typeof(HealthPlayer), "DealDamage")]
		[HarmonyPostfix]
		public static void HealthPlayer_DealDamage(HealthPlayer __instance, ref bool __result, float __state)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			if (TrinketManager.HasTrinket(Plugin.reinforcement) && __result)
			{
				if ((Object)(object)PlayerFarming.Instance.playerRelic != (Object)null)
				{
					Plugin.Log.LogInfo((object)"Has Relic");
					VFXSequence val = EquipmentManager.GetRelicData((RelicType)42).VFXData.PlayNewSequence(((Component)PlayerFarming.Instance).transform, (Transform[])(object)new Transform[1] { ((Component)PlayerFarming.Instance).transform }, (Transform)null, true);
					val.OnImpact = (Action<VFXObject, int>)Delegate.Combine(val.OnImpact, new Action<VFXObject, int>(PlayerFarming.Instance.playerRelic.SpawnFriendlyEnemy));
				}
				else
				{
					Plugin.Log.LogInfo((object)"No Relic");
				}
			}
			if (TrinketManager.HasTrinket(Plugin.transference) && __result)
			{
				Plugin.Log.LogInfo((object)"Other player explodes.");
				if (PlayerFarming.playersCount > 1)
				{
					if ((Object)(object)PlayerFarming.players[0].health == (Object)(object)__instance)
					{
						Explosion.CreateExplosion(((Component)PlayerFarming.players[1]).transform.position, (Team)1, (Health)(object)PlayerFarming.players[1].health, 12f, 4f, -1f, false, 1f, (AttackFlags)0, false, false, true, Array.Empty<UnitObject>());
					}
					else
					{
						Explosion.CreateExplosion(((Component)PlayerFarming.players[0]).transform.position, (Team)1, (Health)(object)PlayerFarming.players[0].health, 12f, 4f, -1f, false, 1f, (AttackFlags)0, false, false, true, Array.Empty<UnitObject>());
					}
				}
				else
				{
					if (Plugin.shouldAddCardConfig.Value)
					{
						Explosion.CreateExplosion(((Component)PlayerFarming.players[0]).transform.position, (Team)1, (Health)(object)PlayerFarming.players[0].health, 4f, 2f, -1f, false, 1f, (AttackFlags)0, false, false, true, Array.Empty<UnitObject>());
					}
					Plugin.Log.LogInfo((object)"Transference: Not multiplayer");
				}
			}
			if (!TrinketManager.HasTrinket(Plugin.deathContract) || !__result)
			{
				return;
			}
			if (((Health)__instance).HP < __state)
			{
				if (PlayerFarming.playersCount > 1)
				{
					if ((Object)(object)PlayerFarming.players[0].health == (Object)(object)__instance)
					{
						HealthPlayer health = PlayerFarming.players[1].health;
						float blueHearts = ((Health)health).BlueHearts;
						((Health)health).BlueHearts = blueHearts + 1f;
						Plugin.Log.LogInfo((object)"Death Contract: Give P2 Health");
					}
					else
					{
						HealthPlayer health2 = PlayerFarming.players[0].health;
						float blueHearts = ((Health)health2).BlueHearts;
						((Health)health2).BlueHearts = blueHearts + 1f;
						Plugin.Log.LogInfo((object)"Death Contract: Give P1 Health");
					}
				}
				else
				{
					if (Plugin.shouldAddCardConfig.Value)
					{
						HealthPlayer health3 = PlayerFarming.players[0].health;
						float blueHearts = ((Health)health3).BlueHearts;
						((Health)health3).BlueHearts = blueHearts + 1f;
					}
					Plugin.Log.LogInfo((object)"Death Contract: Not multiplayer");
				}
				Plugin.Log.LogInfo((object)("Death Contract: Post Damage HP Loss " + __state));
			}
			else
			{
				Plugin.Log.LogInfo((object)("Death Contract: No HP Loss " + __state));
			}
		}

		[HarmonyPatch(typeof(TrinketManager), "CanNegateDamage")]
		[HarmonyPrefix]
		public static bool TrinketManager_CanNegateDamage(TrinketManager __instance, ref bool __result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (TrinketManager.HasTrinket(Plugin.wardingBond))
			{
				__result = true;
				Plugin.Log.LogInfo((object)"Warding Bond: Negate Damage possible");
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(Health), "ChanceToNegateDamage")]
		[HarmonyPrefix]
		public static bool Health_ChanceToNegateDamage(Health __instance, ref bool __result)
		{
			//IL_0001: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			if (TrinketManager.HasTrinket(Plugin.wardingBond))
			{
				bool flag = Random.value > 0.3f;
				if (PlayerFarming.playersCount > 1)
				{
					if ((double)Vector3.Distance(((Component)PlayerFarming.players[0]).transform.position, ((Component)PlayerFarming.players[1]).transform.position) >= 3.0)
					{
						Plugin.Log.LogInfo((object)("Warding Bond: Not near each other or single player - " + __result));
					}
					else if (flag)
					{
						__result = true;
						Plugin.Log.LogInfo((object)"Warding Bond: Near each other, negate");
					}
					else
					{
						Plugin.Log.LogInfo((object)"Warding Bond: no negate");
					}
				}
				else if (flag && Plugin.shouldAddCardConfig.Value)
				{
					__result = true;
					Plugin.Log.LogInfo((object)"Warding Bond: Negate Damage Solo");
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void PlayerWeapon_DoAttackRoutine(PlayerWeapon __instance)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if (!InputManager.Gameplay.GetAttackButtonDown((PlayerFarming)null) && !InputManager.Gameplay.GetHeavyAttackButtonDown((PlayerFarming)null))
			{
				return;
			}
			if (TrinketManager.HasTrinket(Plugin.staticElectricity))
			{
				if (PlayerFarming.playersCount <= 1 || (double)Vector3.Distance(((Component)PlayerFarming.players[0]).transform.position, ((Component)PlayerFarming.players[1]).transform.position) >= 3.0)
				{
					if (PlayerFarming.playersCount <= 1 && Plugin.shouldAddCardConfig.Value)
					{
						((StrikeAbility)new LightningStrikeAbility(1)).Play(((Component)PlayerFarming.players[0]).gameObject, (Team)2, 12f, PlayerFarming.players[0], true, (List<Health>)null, "");
					}
					Plugin.Log.LogInfo((object)"Static Electricity: Not near each other or single player");
				}
				else
				{
					Plugin.Log.LogInfo((object)"Static Electricity: creating lightning strikes");
					((StrikeAbility)new LightningStrikeAbility(1)).Play(((Component)PlayerFarming.players[0]).gameObject, (Team)2, 12f, PlayerFarming.players[0], true, (List<Health>)null, "");
					((StrikeAbility)new LightningStrikeAbility(1)).Play(((Component)PlayerFarming.players[1]).gameObject, (Team)2, 12f, PlayerFarming.players[1], true, (List<Health>)null, "");
				}
			}
			if (!TrinketManager.HasTrinket(Plugin.ignite))
			{
				return;
			}
			if (PlayerFarming.playersCount > 1)
			{
				if ((double)Mathf.Abs(PlayerFarming.players[0].playerWeapon.TimeOfAttack - PlayerFarming.players[1].playerWeapon.TimeOfAttack) < 0.2)
				{
					Explosion.CreateExplosion(((Component)PlayerFarming.players[0]).transform.position, (Team)1, (Health)(object)PlayerFarming.players[0].health, 3f, -1f, -1f, false, 1f, (AttackFlags)0, false, false, true, Array.Empty<UnitObject>());
					Explosion.CreateExplosion(((Component)PlayerFarming.players[1]).transform.position, (Team)1, (Health)(object)PlayerFarming.players[1].health, 3f, -1f, -1f, false, 1f, (AttackFlags)0, false, false, true, Array.Empty<UnitObject>());
					Plugin.Log.LogInfo((object)"Ignite: creating explosion");
				}
			}
			else
			{
				if (Plugin.shouldAddCardConfig.Value)
				{
					Explosion.CreateExplosion(((Component)PlayerFarming.players[0]).transform.position, (Team)1, (Health)(object)PlayerFarming.players[0].health, 3f, -1f, -1f, false, 1f, (AttackFlags)0, false, false, true, Array.Empty<UnitObject>());
				}
				Plugin.Log.LogInfo((object)"Ignite: not multiplayer");
			}
		}
	}
}