using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AddWatermark;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using Cysharp.Threading.Tasks;
using HarmonyLib;
using LBoL.Base;
using LBoL.Base.Extensions;
using LBoL.ConfigData;
using LBoL.Core;
using LBoL.Core.Battle;
using LBoL.Core.Battle.BattleActions;
using LBoL.Core.Battle.Interactions;
using LBoL.Core.Cards;
using LBoL.Core.Intentions;
using LBoL.Core.Randoms;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Cards;
using LBoL.EntityLib.Cards.Neutral.White;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.StatusEffects.Basic;
using LBoL.EntityLib.StatusEffects.Cirno;
using LBoL.EntityLib.StatusEffects.Enemy;
using LBoL.EntityLib.StatusEffects.ExtraTurn;
using LBoL.EntityLib.StatusEffects.Neutral.TwoColor;
using LBoL.EntityLib.StatusEffects.Others;
using LBoL.EntityLib.StatusEffects.Sakuya;
using LBoL.Presentation;
using LBoL.Presentation.UI.Widgets;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using TMPro;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using YoumuCharacterMod.BattleActions;
using YoumuCharacterMod.Cards;
using YoumuCharacterMod.Cards.Template;
using YoumuCharacterMod.DefaultConfig;
using YoumuCharacterMod.GunName;
using YoumuCharacterMod.Illustrator;
using YoumuCharacterMod.ImageLoader;
using YoumuCharacterMod.Localization;
using YoumuCharacterMod.Patches;
using YoumuCharacterMod.StatusEffects;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("LBoL.Base")]
[assembly: IgnoresAccessChecksTo("LBoL.ConfigData")]
[assembly: IgnoresAccessChecksTo("LBoL.Core")]
[assembly: IgnoresAccessChecksTo("LBoL.EntityLib")]
[assembly: IgnoresAccessChecksTo("LBoL.Presentation")]
[assembly: IgnoresAccessChecksTo("Untitled.ConfigDataBuilder.Base")]
[assembly: AssemblyCompany("YoumuCharacterMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d7cb6584d9c26006cb896d7bddf0f1148555744e")]
[assembly: AssemblyProduct("YoumuCharacterMod")]
[assembly: AssemblyTitle("YoumuCharacterMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace YoumuCharacterMod
{
	[BepInPlugin("rmrfmaxx.lbol.YoumuCharacterMod", "Youmu Character Mod", "0.5.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		public static bool modelIsFlipped = true;

		public static List<ManaColor> offColors = new List<ManaColor>
		{
			(ManaColor)2,
			(ManaColor)3,
			(ManaColor)4,
			(ManaColor)6
		};

		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static TemplateSequenceTable sequenceTable = new TemplateSequenceTable(0);

		public static string PlayerColor = "#00b789";

		internal static IResourceSource embeddedSource = (IResourceSource)new EmbeddedSource(Assembly.GetExecutingAssembly());

		internal static DirectorySource directorySource = new DirectorySource("rmrfmaxx.lbol.YoumuCharacterMod", "");

		private void Awake()
		{
			log = ((BaseUnityPlugin)this).Logger;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			EntityManager.RegisterSelf();
			harmony.PatchAll();
			if (Chainloader.PluginInfos.ContainsKey("neo.lbol.tools.watermark"))
			{
				WatermarkWrapper.ActivateWatermark();
			}
		}

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PInfo
	{
		public const string GUID = "rmrfmaxx.lbol.YoumuCharacterMod";

		public const string Name = "Youmu Character Mod";

		public const string version = "0.5.2";

		public static readonly Harmony harmony = new Harmony("rmrfmaxx.lbol.YoumuCharacterMod");
	}
	public class YoumuLoadouts
	{
		public static string UltimateSkillA = "YoumuUltW";

		public static string UltimateSkillB = "YoumuUltG";

		public static string ExhibitA = "YoumuExhibitW";

		public static string ExhibitB = "YoumuExhibitG";

		public static List<string> DeckA = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YoumuAttackW", "YoumuAttackW", "YoumuBlockG", "YoumuBlockG", "YoumuBlockG", "YoumuInsightfulSword" };

		public static List<string> DeckB = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YoumuAttackG", "YoumuAttackG", "YoumuBlockW", "YoumuBlockW", "YoumuBlockW", "YoumuAsuraSword" };
	}
	public sealed class YoumuPlayerDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(YoumuPlayerDef))]
		public sealed class YoumuMod : PlayerUnit
		{
		}

		public static string playerName = "Youmu";

		public static string modName = "YoumuMod";

		public static DirectorySource YoumuDir = new DirectorySource("rmrfmaxx.lbol.YoumuCharacterMod", "");

		public UniTask<Sprite>? LoadSpellPortraitAsync { get; private set; }

		public override IdContainer GetId()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(modName);
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)YoumuLocalization.PlayerUnitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override PlayerImages LoadPlayerImages()
		{
			return YoumuImageLoader.LoadPlayerImages(playerName);
		}

		public override PlayerUnitConfig MakeConfig()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			int? num = 0;
			string playerColor = BepinexPlugin.PlayerColor;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 2;
			((ManaGroup)(ref val)).White = 2;
			return new PlayerUnitConfig("Youmu", 6, 0, num, "", playerColor, true, 77, val, 50, 0, YoumuLoadouts.UltimateSkillA, YoumuLoadouts.UltimateSkillB, YoumuLoadouts.ExhibitA, YoumuLoadouts.ExhibitB, (IReadOnlyList<string>)YoumuLoadouts.DeckA, (IReadOnlyList<string>)YoumuLoadouts.DeckB, 2, 2);
		}
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace YoumuCharacterMod.YoumuUlt
{
	public sealed class YoumuFlashOfTheNetherworldUltDef : YoumuUltTemplate
	{
	}
	[EntityLogic(typeof(YoumuFlashOfTheNetherworldUltDef))]
	public sealed class YoumuFlashOfTheNetherworldUlt : UltimateSkill
	{
		public YoumuFlashOfTheNetherworldUlt()
		{
			((UltimateSkill)this).TargetType = (TargetType)2;
			((UltimateSkill)this).GunName = YoumuGunName.FlashOfTheNetherworldSe;
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			yield break;
		}
	}
	public sealed class YoumuUltGDef : YoumuUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 12, 3, 1, (Keyword)256, (IReadOnlyList<string>)new List<string> { "LockedOn" }, (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(YoumuUltGDef))]
	public sealed class YoumuUltG : UltimateSkill
	{
		public YoumuUltG()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = YoumuGunName.UltimateSkillG;
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			EnemyUnit enemy = selector.GetEnemy(((UltimateSkill)this).Battle);
			yield return (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)this).Owner, (Unit)(object)enemy, ((UltimateSkill)this).Damage, ((UltimateSkill)this).GunName, (GunType)0);
			yield return (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)this).Owner, (Unit)(object)enemy, ((UltimateSkill)this).Damage, YoumuGunName.UltimateSkillGBurst, (GunType)0);
			yield return (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)this).Owner, (Unit)(object)enemy, ((UltimateSkill)this).Damage, YoumuGunName.UltimateSkillGBurst, (GunType)0);
			if (((Unit)enemy).IsAlive)
			{
				yield return (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>((Unit)(object)enemy, (int?)((UltimateSkill)this).Value1, (int?)0, (int?)0, (int?)0, 0.2f, true);
			}
		}
	}
	public class YoumuUltTemplate : UltimateSkillTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(YoumuDefaultConfig.GetDefaultID((EntityDefinition)(object)this));
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)YoumuLocalization.UltimateSkillsBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return YoumuImageLoader.LoadUltLoader((UltimateSkillTemplate)(object)this);
		}

		public override UltimateSkillConfig MakeConfig()
		{
			return YoumuDefaultConfig.DefaultUltConfig();
		}
	}
	public sealed class YoumuUltWDef : YoumuUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 30, 2, 0, (Keyword)256, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string> { "YoumuSlashOfPresent" });
		}
	}
	[EntityLogic(typeof(YoumuUltWDef))]
	public sealed class YoumuUltW : UltimateSkill
	{
		public YoumuUltW()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = YoumuGunName.UltimateSkillW;
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			EnemyUnit enemy = selector.GetEnemy(((UltimateSkill)this).Battle);
			yield return (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)this).Owner, (Unit)(object)enemy, ((UltimateSkill)this).Damage, ((UltimateSkill)this).GunName, (GunType)0);
			if (!((UltimateSkill)this).Battle.BattleShouldEnd)
			{
				for (int i = 0; i < ((UltimateSkill)this).Value1; i++)
				{
					yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YoumuSlashOfPresent>() });
				}
			}
		}
	}
}
namespace YoumuCharacterMod.StatusEffects
{
	public sealed class YoumuAgelessObsessionSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuAgelessObsessionSeDef))]
	public sealed class YoumuAgelessObsessionSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			foreach (EnemyUnit allAliveEnemy in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				((StatusEffect)this).HandleOwnerEvent<StatusEffectApplyEventArgs>(((Unit)allAliveEnemy).StatusEffectAdding, (GameEventHandler<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdding);
			}
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(((StatusEffect)this).Battle.EnemySpawned, (GameEventHandler<UnitEventArgs>)OnEnemySpawned);
		}

		private void OnEnemySpawned(UnitEventArgs args)
		{
			((StatusEffect)this).HandleOwnerEvent<StatusEffectApplyEventArgs>(args.Unit.StatusEffectAdding, (GameEventHandler<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdding);
		}

		private void OnEnemyStatusEffectAdding(StatusEffectApplyEventArgs args)
		{
			if (args.Effect is LockedOn)
			{
				((StatusEffect)this).NotifyActivating();
				StatusEffect effect = args.Effect;
				effect.Level *= ((StatusEffect)this).Level + 1;
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
		}
	}
	public sealed class YoumuAscensionToBuddhahoodSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(YoumuAscensionToBuddhahoodSeDef))]
	public sealed class YoumuAscensionToBuddhahoodSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsing, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsing);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnTurnEnded);
			((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(((Unit)((StatusEffect)this).Battle.Player).StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnOwnerStatusEffectAdded);
		}

		private IEnumerable<BattleAction> OnOwnerStatusEffectAdded(StatusEffectApplyEventArgs args)
		{
			if (args.Effect is YoumuAscensionToBuddhahoodSe)
			{
				((StatusEffect)this).Count = ((StatusEffect)this).Count + args.Level.Value;
			}
			yield break;
		}

		private IEnumerable<BattleAction> OnTurnEnded(UnitEventArgs args)
		{
			((StatusEffect)this).Count = ((StatusEffect)this).Level;
			yield break;
		}

		private IEnumerable<BattleAction> OnCardUsing(CardUsingEventArgs args)
		{
			if (!args.Card.IsCopy && args.Card.CanBeDuplicated && ((StatusEffect)this).Count > 0)
			{
				<>n__0();
				args.Card.IsEcho = true;
				int count = ((StatusEffect)this).Count;
				((StatusEffect)this).Count = count - 1;
			}
			yield break;
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuBizarenessSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuBizarenessSeDef))]
	public sealed class YoumuBizarenessSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			foreach (EnemyUnit allAliveEnemy in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(((Unit)allAliveEnemy).StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdded);
			}
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(((StatusEffect)this).Battle.EnemySpawned, (GameEventHandler<UnitEventArgs>)OnEnemySpawned);
		}

		private void OnEnemySpawned(UnitEventArgs args)
		{
			((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(args.Unit.StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdded);
		}

		private IEnumerable<BattleAction> OnEnemyStatusEffectAdded(StatusEffectApplyEventArgs args)
		{
			if (args.Effect is LockedOn)
			{
				<>n__0();
				yield return (BattleAction)(object)new ApplyStatusEffectAction<Poison>(args.Unit, (int?)((StatusEffect)this).Level, (int?)null, (int?)null, (int?)null, 0f, true);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuBloodOfAsuraSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuBloodOfAsuraSeDef))]
	public sealed class YoumuBloodOfAsuraSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if ((int)args.Card.CardType == 1)
			{
				<>n__0();
				yield return (BattleAction)(object)new ApplyStatusEffectAction<Firepower>(((StatusEffect)this).Owner, (int?)((StatusEffect)this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuDivineSeveringSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(YoumuDivineSeveringSeDef))]
	public sealed class YoumuDivineSeveringSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnsheatheEventArgs>(CustomGameEventPatch.Unsheathed, (EventSequencedReactor<UnsheatheEventArgs>)OnUnsheathe);
			((StatusEffect)this).HandleOwnerEvent<DamageDealingEventArgs>(unit.DamageDealing, (GameEventHandler<DamageDealingEventArgs>)OnDamageDealing);
		}

		private void OnDamageDealing(DamageDealingEventArgs args)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			GameEntity actionSource = ((GameEventArgs)args).ActionSource;
			Card val = (Card)(object)((actionSource is Card) ? actionSource : null);
			if (val != null && YoumuCard.IsSlashCard(val) && (int)val.CardType == 1)
			{
				DamageInfo damageInfo = args.DamageInfo;
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).IncreaseBy(((StatusEffect)this).Count);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
		}

		private IEnumerable<BattleAction> OnUnsheathe(UnsheatheEventArgs args)
		{
			((StatusEffect)this).Count = ((StatusEffect)this).Count + ((StatusEffect)this).Level;
			yield break;
		}
	}
	public sealed class YoumuDrawNextTurnSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuDrawNextTurnSeDef))]
	public sealed class YoumuDrawNextTurnSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnTurnStarted);
		}

		private IEnumerable<BattleAction> OnTurnStarted(UnitEventArgs args)
		{
			<>n__0();
			yield return (BattleAction)new DrawManyCardAction(((StatusEffect)this).Level);
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuDualWielderGreenSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			val.RelativeEffects = new List<string> { "YoumuUnsheatheSe" };
			return val;
		}
	}
	[EntityLogic(typeof(YoumuDualWielderGreenSeDef))]
	public sealed class YoumuDualWielderGreenSe : StatusEffect
	{
		public ManaGroup Green { get; set; }

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<ManaEventArgs>(((StatusEffect)this).Battle.ManaConsumed, (EventSequencedReactor<ManaEventArgs>)OnManaConsumed);
		}

		private IEnumerable<BattleAction> OnManaConsumed(ManaEventArgs args)
		{
			YoumuDualWielderGreenSe youmuDualWielderGreenSe = this;
			int count = ((StatusEffect)this).Count;
			ManaGroup value = args.Value;
			((StatusEffect)youmuDualWielderGreenSe).Count = count + ((ManaGroup)(ref value)).Green;
			YoumuDualWielderGreenSe youmuDualWielderGreenSe2 = this;
			int count2 = ((StatusEffect)this).Count;
			value = args.Value;
			((StatusEffect)youmuDualWielderGreenSe2).Count = count2 + ((ManaGroup)(ref value)).Philosophy;
			var (div, item) = MathExtensions.DivRem(((StatusEffect)this).Count, ((StatusEffect)this).Limit);
			((StatusEffect)this).Count = item;
			if (div != 0)
			{
				<>n__0();
				for (int i = 0; i < div * ((StatusEffect)this).Level; i++)
				{
					yield return (BattleAction)(object)new UnsheatheAction();
				}
			}
		}

		public IEnumerable<BattleAction> TakeEffect()
		{
			<>n__0();
			for (int i = 0; i < ((StatusEffect)this).Level; i++)
			{
				yield return (BattleAction)(object)new UnsheatheAction();
			}
		}

		public YoumuDualWielderGreenSe()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 1;
			Green = val;
			((StatusEffect)this)..ctor();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuDualWielderWhiteSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			val.RelativeEffects = new List<string> { "LockedOn" };
			return val;
		}
	}
	[EntityLogic(typeof(YoumuDualWielderWhiteSeDef))]
	public sealed class YoumuDualWielderWhiteSe : StatusEffect
	{
		public ManaGroup White { get; set; }

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<ManaEventArgs>(((StatusEffect)this).Battle.ManaConsumed, (EventSequencedReactor<ManaEventArgs>)OnManaConsumed);
		}

		private IEnumerable<BattleAction> OnManaConsumed(ManaEventArgs args)
		{
			YoumuDualWielderWhiteSe youmuDualWielderWhiteSe = this;
			int count = ((StatusEffect)this).Count;
			ManaGroup value = args.Value;
			((StatusEffect)youmuDualWielderWhiteSe).Count = count + ((ManaGroup)(ref value)).White;
			YoumuDualWielderWhiteSe youmuDualWielderWhiteSe2 = this;
			int count2 = ((StatusEffect)this).Count;
			value = args.Value;
			((StatusEffect)youmuDualWielderWhiteSe2).Count = count2 + ((ManaGroup)(ref value)).Philosophy;
			var (div, item) = MathExtensions.DivRem(((StatusEffect)this).Count, ((StatusEffect)this).Limit);
			((StatusEffect)this).Count = item;
			if (div == 0)
			{
				yield break;
			}
			<>n__0();
			foreach (EnemyUnit unit in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				yield return (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>((Unit)(object)unit, (int?)(((StatusEffect)this).Level * div), (int?)0, (int?)0, (int?)0, 0.2f, true);
			}
		}

		public IEnumerable<BattleAction> TakeEffect()
		{
			<>n__0();
			foreach (EnemyUnit unit in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				yield return (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>((Unit)(object)unit, (int?)((StatusEffect)this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
			}
		}

		public YoumuDualWielderWhiteSe()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).White = 1;
			White = val;
			((StatusEffect)this)..ctor();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuFlashOfTheNetherworldSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(YoumuFlashOfTheNetherworldSeDef))]
	public sealed class YoumuFlashOfTheNetherworldSe : StatusEffect
	{
		public int Threshold { get; set; } = 5;


		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnTurnEnded);
		}

		private IEnumerable<BattleAction> OnTurnEnded(UnitEventArgs args)
		{
			if (((Unit)((StatusEffect)this).Battle.Player).IsExtraTurn)
			{
				<>n__0();
				_ = YoumuGunName.FlashOfTheNetherworldSe;
				if (((StatusEffect)this).Count >= Threshold)
				{
					yield return (BattleAction)(object)PerformAction.Spell((Unit)(object)((StatusEffect)this).Battle.Player, "YoumuFlashOfTheNetherworldUlt");
				}
				Guns guns = new Guns(YoumuGunName.FlashOfTheNetherworldSe, ((StatusEffect)this).Count, false);
				foreach (GunPair gunPair in guns.GunPairs)
				{
					yield return (BattleAction)new DamageAction((Unit)(object)((StatusEffect)this).Battle.Player, (IEnumerable<Unit>)((StatusEffect)this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)((StatusEffect)this).Level, false), gunPair.GunName, (GunType)0);
				}
			}
			((StatusEffect)this).Count = 0;
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if (((Unit)((StatusEffect)this).Battle.Player).IsExtraTurn)
			{
				((StatusEffect)this).Count = ((StatusEffect)this).Battle.TurnCardUsageHistory.Count;
			}
			yield break;
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuGreatEnlightenmentSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuGreatEnlightenmentSeDef))]
	public sealed class YoumuGreatEnlightenmentSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnTurnStarted);
		}

		private IEnumerable<BattleAction> OnTurnStarted(UnitEventArgs args)
		{
			<>n__0();
			for (int i = 0; i < ((StatusEffect)this).Level; i++)
			{
				yield return (BattleAction)(object)new UnsheatheAction();
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuHakugyokurouSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(YoumuHakugyokurouSeDef))]
	public sealed class YoumuHakugyokurouSe : StatusEffect
	{
		public int Threshold { get; } = 10;


		public int TotalDamage => ((StatusEffect)this).Level;

		public ManaGroup Mana
		{
			get
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup result = default(ManaGroup);
				((ManaGroup)(ref result)).Philosophy = ((StatusEffect)this).Level / 50;
				return result;
			}
		}

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnTurnStarted);
		}

		private IEnumerable<BattleAction> OnTurnStarted(UnitEventArgs args)
		{
			<>n__0();
			yield return (BattleAction)new GainManaAction(Mana);
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if ((int)args.Card.CardType == 1)
			{
				<>n__0();
				((StatusEffect)this).Count = ((StatusEffect)this).Count + 1;
				if (((StatusEffect)this).Count >= Threshold)
				{
					((StatusEffect)this).Count = 0;
					yield return (BattleAction)new DamageAction((Unit)(object)((StatusEffect)this).Battle.Player, (IEnumerable<Unit>)((StatusEffect)this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)TotalDamage, false), YoumuGunName.Hakugyokurou, (GunType)0);
				}
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuInfiniteKalpasSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuInfiniteKalpasSeDef))]
	public sealed class YoumuInfiniteKalpasSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnTurnStarted);
		}

		private IEnumerable<BattleAction> OnTurnStarted(UnitEventArgs args)
		{
			<>n__0();
			if (!((StatusEffect)this).Battle.BattleShouldEnd)
			{
				<>n__0();
			}
			yield break;
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuInnerEyeSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuInnerEyeSeDef))]
	public sealed class YoumuInnerEyeSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if ((int)args.Card.CardType == 1)
			{
				<>n__0();
				yield return (BattleAction)(object)new ApplyStatusEffectAction<YoumuRiposteSe>((Unit)(object)((StatusEffect)this).Battle.Player, (int?)((StatusEffect)this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuRiposteSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuRiposteSeDef))]
	public sealed class YoumuRiposteSe : StatusEffect
	{
		public string Gun { get; set; } = YoumuGunName.RiposteSe;


		private int totalDamageReduction { get; set; } = 0;


		private Queue<ReflectDamage> ReflectDamages { get; set; } = new Queue<ReflectDamage>();


		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DamageEventArgs>(((Unit)((StatusEffect)this).Battle.Player).DamageTaking, (GameEventHandler<DamageEventArgs>)OnPlayerDamageTaking);
			((StatusEffect)this).ReactOwnerEvent<DamageEventArgs>(((Unit)((StatusEffect)this).Battle.Player).DamageReceived, (EventSequencedReactor<DamageEventArgs>)OnPlayerDamageReceived);
		}

		private void OnPlayerDamageTaking(DamageEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			DamageInfo damageInfo = args.DamageInfo;
			int num = MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage);
			if (num >= 1 && (int)((DamageInfo)(ref damageInfo)).DamageType == 2)
			{
				((StatusEffect)this).NotifyActivating();
				int num2 = Math.Min(num, ((StatusEffect)this).Level);
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).ReduceActualDamageBy(num2);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				totalDamageReduction += num2;
				if (args.Source != ((StatusEffect)this).Owner && args.Source.IsAlive)
				{
					ReflectDamages.Enqueue(new ReflectDamage(args.Source, num2));
				}
			}
		}

		private IEnumerable<BattleAction> OnPlayerDamageReceived(DamageEventArgs args)
		{
			while (ReflectDamages.Count > 0)
			{
				ReflectDamage reflectDamage = ReflectDamages.Dequeue();
				if (reflectDamage.Target.IsAlive)
				{
					yield return (BattleAction)new DamageAction((Unit)(object)((StatusEffect)this).Battle.Player, reflectDamage.Target, DamageInfo.Reaction((float)reflectDamage.Damage, false), YoumuGunName.RiposteSe, (GunType)0);
				}
			}
			((StatusEffect)this).Level = Math.Max(((StatusEffect)this).Level - totalDamageReduction, 0);
			totalDamageReduction = 0;
			if (((StatusEffect)this).Level <= 0)
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
			}
		}
	}
	public sealed class YoumuSilentNirvanaSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuSilentNirvanaSeDef))]
	public sealed class YoumuSilentNirvanaSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			foreach (EnemyUnit allAliveEnemy in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(((Unit)allAliveEnemy).StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdded);
			}
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(((StatusEffect)this).Battle.EnemySpawned, (GameEventHandler<UnitEventArgs>)OnEnemySpawned);
		}

		private void OnEnemySpawned(UnitEventArgs args)
		{
			((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(args.Unit.StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdded);
		}

		private IEnumerable<BattleAction> OnEnemyStatusEffectAdded(StatusEffectApplyEventArgs args)
		{
			if ((int)args.Effect.Type == 1)
			{
				<>n__0();
				yield return (BattleAction)new CastBlockShieldAction((Unit)(object)((StatusEffect)this).Battle.Player, (Unit)(object)((StatusEffect)this).Battle.Player, ((StatusEffect)this).Level, 0, (BlockShieldType)2, true);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuSpiritMediumBindSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuSpiritMediumBindSeDef))]
	public sealed class YoumuSpiritMediumBindSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardEventArgs>(((StatusEffect)this).Battle.CardExiled, (EventSequencedReactor<CardEventArgs>)OnCardExiled);
		}

		private IEnumerable<BattleAction> OnCardExiled(CardEventArgs args)
		{
			<>n__0();
			int damage = ((StatusEffect)this).Level;
			yield return (BattleAction)new DamageAction(((StatusEffect)this).Owner, (IEnumerable<Unit>)((StatusEffect)this).Battle.AllAliveEnemies, DamageInfo.Reaction((float)damage, false), YoumuGunName.SpiritMediumBindSe, (GunType)0);
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuUnendingWinterSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuUnendingWinterSeDef))]
	public sealed class YoumuUnendingWinterSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatisticalDamageEventArgs>(((Unit)((StatusEffect)this).Battle.Player).StatisticalTotalDamageDealt, (EventSequencedReactor<StatisticalDamageEventArgs>)OnStatisticalDamageDealt);
		}

		private IEnumerable<BattleAction> OnStatisticalDamageDealt(StatisticalDamageEventArgs args)
		{
			if (((StatusEffect)this).Battle.BattleShouldEnd)
			{
				yield break;
			}
			bool activated = false;
			foreach (KeyValuePair<Unit, IReadOnlyList<DamageEventArgs>> item in args.ArgsTable)
			{
				item.Deconstruct(out var unit, out var readOnlyList);
				Unit unit2 = unit;
				IReadOnlyList<DamageEventArgs> readOnlyList2 = readOnlyList;
				if (unit2.IsAlive)
				{
					int num = readOnlyList2.Count(delegate(DamageEventArgs damageAgs)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						//IL_0007: Unknown result type (might be due to invalid IL or missing references)
						//IL_000a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0010: Invalid comparison between Unknown and I4
						DamageInfo damageInfo = damageAgs.DamageInfo;
						return (int)((DamageInfo)(ref damageInfo)).DamageType == 2 && ((DamageInfo)(ref damageInfo)).Amount > 0f;
					});
					if (num > 0)
					{
						if (!activated)
						{
							((StatusEffect)this).NotifyActivating();
							activated = true;
						}
						for (int i = 0; i < ((StatusEffect)this).Level; i++)
						{
							if (((StatusEffect)this).Battle.BattleShouldEnd)
							{
								break;
							}
							yield return (BattleAction)(object)new ApplyStatusEffectAction<Cold>(unit2, (int?)null, (int?)null, (int?)null, (int?)null, 0f, true);
						}
					}
				}
				unit = null;
				readOnlyList = null;
			}
		}
	}
	public sealed class YoumuWatchtowerSwordSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuWatchtowerSwordSeDef))]
	public sealed class YoumuWatchtowerSwordSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatisticalDamageEventArgs>(((Unit)((StatusEffect)this).Battle.Player).StatisticalTotalDamageDealt, (EventSequencedReactor<StatisticalDamageEventArgs>)OnStatisticalDamageDealt);
		}

		private IEnumerable<BattleAction> OnStatisticalDamageDealt(StatisticalDamageEventArgs args)
		{
			if (((StatusEffect)this).Battle.BattleShouldEnd)
			{
				yield break;
			}
			bool activated = false;
			foreach (KeyValuePair<Unit, IReadOnlyList<DamageEventArgs>> item in args.ArgsTable)
			{
				item.Deconstruct(out var unit, out var readOnlyList);
				Unit unit2 = unit;
				IReadOnlyList<DamageEventArgs> readOnlyList2 = readOnlyList;
				if (unit2.IsAlive)
				{
					int num = readOnlyList2.Count(delegate(DamageEventArgs damageAgs)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						//IL_0007: Unknown result type (might be due to invalid IL or missing references)
						//IL_000a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0010: Invalid comparison between Unknown and I4
						DamageInfo damageInfo = damageAgs.DamageInfo;
						return (int)((DamageInfo)(ref damageInfo)).DamageType == 2 && ((DamageInfo)(ref damageInfo)).Amount > 0f;
					});
					if (num > 0)
					{
						if (!activated)
						{
							((StatusEffect)this).NotifyActivating();
							activated = true;
						}
						yield return (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>(unit2, (int?)(((StatusEffect)this).Level * num), (int?)null, (int?)null, (int?)null, 0f, true);
					}
				}
				unit = null;
				readOnlyList = null;
			}
		}
	}
	public sealed class YoumuWheelOfPainSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuWheelOfPainSeDef))]
	public sealed class YoumuWheelOfPainSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnTurnStarted);
		}

		private IEnumerable<BattleAction> OnTurnStarted(UnitEventArgs args)
		{
			<>n__0();
			foreach (EnemyUnit unit in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				yield return (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>((Unit)(object)unit, (int?)((StatusEffect)this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuWickedSoulSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.Order = 20;
			return val;
		}
	}
	[EntityLogic(typeof(YoumuWickedSoulSeDef))]
	public sealed class YoumuWickedSoulSe : StatusEffect
	{
		public int DamageRate { get; set; } = 2;


		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DamageDealingEventArgs>(unit.DamageDealing, (GameEventHandler<DamageDealingEventArgs>)OnDamageDealing);
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private void OnDamageDealing(DamageDealingEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			DamageInfo damageInfo = args.DamageInfo;
			if ((int)((DamageInfo)(ref damageInfo)).DamageType == 2)
			{
				GameEntity actionSource = ((GameEventArgs)args).ActionSource;
				Card val = (Card)(object)((actionSource is Card) ? actionSource : null);
				if (val != null && (int)val.CardType == 1)
				{
					damageInfo = args.DamageInfo;
					args.DamageInfo = ((DamageInfo)(ref damageInfo)).MultiplyBy(DamageRate);
					((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				}
			}
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if ((int)args.Card.CardType == 1)
			{
				int level = ((StatusEffect)this).Level;
				((StatusEffect)this).Level = level - 1;
				if (((StatusEffect)this).Level <= 0)
				{
					yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
				}
			}
		}

		public BattleAction TakeEffect()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			int level = ((StatusEffect)this).Level;
			((StatusEffect)this).Level = level - 1;
			return (BattleAction)((((StatusEffect)this).Level > 0) ? ((RemoveStatusEffectAction)null) : new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f));
		}
	}
	public class YoumuStatusEffectTemplate : StatusEffectTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(YoumuDefaultConfig.GetDefaultID((EntityDefinition)(object)this));
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)YoumuLocalization.StatusEffectsBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return YoumuImageLoader.LoadStatusEffectLoader((StatusEffectTemplate)(object)this);
		}

		public override StatusEffectConfig MakeConfig()
		{
			return DefaultStatusEffectConfig();
		}

		public static StatusEffectConfig DefaultStatusEffectConfig()
		{
			return YoumuDefaultConfig.DefaultStatusEffectConfig();
		}
	}
	public sealed class YoumuYuyukoFriendSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuYuyukoFriendSeDef))]
	public sealed class YoumuYuyukoFriendSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsing, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsing);
		}

		private IEnumerable<BattleAction> OnCardUsing(CardUsingEventArgs args)
		{
			if ((int)args.Card.CardType == 1)
			{
				<>n__0();
				args.PlayTwice = true;
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
			yield break;
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
}
namespace YoumuCharacterMod.StatusEffects.KeywordsWorkaround
{
	public sealed class YoumuUnsheatheSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuUnsheatheSeDef))]
	public sealed class YoumuUnsheatheSe : StatusEffect
	{
		public ManaGroup Mana;

		public YoumuUnsheatheSe()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup mana = default(ManaGroup);
			((ManaGroup)(ref mana)).Any = 1;
			Mana = mana;
			((StatusEffect)this)..ctor();
		}
	}
	public sealed class YoumuYuyukoDeathSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuYuyukoDeathSeDef))]
	public sealed class YoumuYuyukoDeathSe : StatusEffect
	{
	}
}
namespace YoumuCharacterMod.Patches
{
	[HarmonyPatch]
	internal class CardWidgetPatch
	{
		[HarmonyPatch(typeof(CardWidget), "SetProperties")]
		private static void Postfix(CardWidget __instance)
		{
			if (__instance._card is YoumuCard youmuCard && youmuCard.HasDisplayField)
			{
				__instance.baseLoyaltyObj.SetActive(true);
				((TMP_Text)__instance.baseLoyalty).text = youmuCard.DisplayField.ToString();
			}
		}
	}
	[HarmonyPatch]
	internal class CustomGameEventPatch
	{
		public static GameEvent<UnsheatheEventArgs> Unsheathing { get; set; }

		public static GameEvent<UnsheatheEventArgs> Unsheathed { get; set; }

		[HarmonyPatch(typeof(GameRunController), "EnterBattle")]
		private static bool Prefix(GameRunController __instance)
		{
			Unsheathing = new GameEvent<UnsheatheEventArgs>();
			Unsheathed = new GameEvent<UnsheatheEventArgs>();
			return true;
		}
	}
}
namespace YoumuCharacterMod.model
{
	public sealed class YoumuPlayerModel : UnitModelTemplate
	{
		public string model_name = "Youmu";

		public override IdContainer GetId()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return ((EntityDefinition)new YoumuPlayerDef()).UniqueId;
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)YoumuLocalization.UnitModelBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override ModelOption LoadModelOptions()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new ModelOption(ResourcesHelper.LoadSpineUnitAsync(model_name));
		}

		public override UniTask<Sprite> LoadSpellSprite()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ResourcesHelper.LoadSpellPortraitAsync(model_name);
		}

		public override UnitModelConfig MakeConfig()
		{
			UnitModelConfig val = ObjectExtensions.Copy<UnitModelConfig>(UnitModelConfig.FromName(model_name));
			val.Flip = true;
			return val;
		}
	}
}
namespace YoumuCharacterMod.Localization
{
	public sealed class YoumuLocalization
	{
		public static string Cards = "Cards";

		public static string Exhibits = "Exhibits";

		public static string PlayerUnit = "PlayerUnit";

		public static string UnitModel = "UnitModel";

		public static string UltimateSkills = "UltimateSkills";

		public static string StatusEffects = "StatusEffects";

		public static BatchLocalization CardsBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(CardTemplate), Cards, (Locale)0, false);

		public static BatchLocalization ExhibitsBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(ExhibitTemplate), Exhibits, (Locale)0, false);

		public static BatchLocalization PlayerUnitBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(PlayerUnitTemplate), PlayerUnit, (Locale)0, false);

		public static BatchLocalization UnitModelBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(UnitModelTemplate), UnitModel, (Locale)0, false);

		public static BatchLocalization UltimateSkillsBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(UltimateSkillTemplate), UltimateSkills, (Locale)0, false);

		public static BatchLocalization StatusEffectsBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(StatusEffectTemplate), StatusEffects, (Locale)0, false);
	}
}
namespace YoumuCharacterMod.ImageLoader
{
	public sealed class YoumuImageLoader
	{
		public static PlayerImages LoadPlayerImages(string name)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			PlayerImages val = new PlayerImages();
			val.AutoLoad(name, (Func<string, Sprite>)((string s) => ResourceLoader.LoadSprite(s, (IResourceSource)(object)YoumuPlayerDef.YoumuDir, 100, 1, (FilterMode)1, true, (Rect?)null, (Vector2?)null)), (Func<string, UniTask<Sprite>>)((string s) => ResourceLoader.LoadSpriteAsync(s, YoumuPlayerDef.YoumuDir, 100, (GraphicsFormat)4, 1, (FilterMode)1, (SpriteMeshType)1, (Rect?)null, (Vector2?)null, "file://")), (UseSame)2, ".png", "");
			return val;
		}

		public static CardImages LoadCardImages(CardTemplate cardTemplate)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			CardImages val = new CardImages(BepinexPlugin.embeddedSource);
			val.AutoLoad(cardTemplate, ".png", "", false);
			return val;
		}

		public static ExhibitSprites LoadExhibitSprite(ExhibitTemplate exhibit)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			ExhibitSprites val = new ExhibitSprites();
			val.main = ResourceLoader.LoadSprite(IdContainer.op_Implicit(((EntityDefinition)exhibit).GetId()) + ".png", BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null);
			return val;
		}

		public static Sprite LoadUltLoader(UltimateSkillTemplate ult)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return LoadSprite(((EntityDefinition)ult).GetId());
		}

		public static Sprite LoadStatusEffectLoader(StatusEffectTemplate status)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return LoadSprite(((EntityDefinition)status).GetId());
		}

		private static Sprite LoadSprite(IdContainer ID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ResourceLoader.LoadSprite(IdContainer.op_Implicit(ID) + ".png", BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null);
		}
	}
}
namespace YoumuCharacterMod.Illustrator
{
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct YoumuIllustrator
	{
		public static string YoumuAttackG = "涼貓";

		public static string YoumuAttackW = "藤森しき@お仕事募集中";

		public static string AsuraSword = "@Ruu_poppo_";

		public static string SwordOfBinding = "テンドウカオル";

		public static string CounterSignalling = "@bo_cota";

		public static string ScatteredFlowers = "wani_Dile";

		public static string SpringWind = "@1R0HASU";

		public static string PhosphoricSlash = "@Rinka_private";

		public static string ClosedEyeSlash = "TOP-Exerou";

		public static string SlashOfPresent = "流月_Tsuki";

		public static string SlashOfKarmicWind = "muginosa";

		public static string SlashOfMeditation = "miy@＊お仕事募集中";

		public static string LotusPostureSlash = "テンドウカオル";

		public static string SatelliteSlash = "@ainy120";

		public static string CrescentMoonSlash = "@suzukannn";

		public static string SevenHakus = "@sakipee36";

		public static string StrangeBird = "@superego51";

		public static string YoumuBlockG = "seeker";

		public static string YoumuBlockW = "GuasBin";

		public static string HesitationSign = "";

		public static string SpiritMediumBind = "@ZyUwfc";

		public static string PhantomFormation = "ゆうじん";

		public static string SilentNirvana = "개혀";

		public static string SingleThought = "@Rinka_private";

		public static string BuddhahoodOfFlora = "mutugi";

		public static string GhostSlash = "Blanc";

		public static string HeavenlyHalo = "伊代";

		public static string InsightfulSword = "@jan_husaren";

		public static string TwoHundredYojana = "@ruju_amn";

		public static string QuickDraw = "@Rinka_private";

		public static string GreatEnlightenment = "Gaff";

		public static string SwordAura = "rouge";

		public static string CircularVicissitude = "亜羽瀬ひの＠お仕事募集中";

		public static string ClearingMind = "ke-ta";

		public static string BulletCuttingSpirit = "ゆうじん";

		public static string InnerEye = "れふそん";

		public static string ThreeKons = "@sakipee36";

		public static string DyingDeva = "山梦";

		public static string KarmicPunishment = "cheeseroll8443";

		public static string KarmaGust = "@kamabokopic";

		public static string ReflectionSlash = "@zounose";

		public static string ReinforcementOfTheArmy = "";

		public static string HalfBodyDistillation = "かににゃん";

		public static string FlashOfTheNetherworld = "テンドウカオル";

		public static string WatchtowerSword = "";

		public static string InfiniteKalpas = "";

		public static string PreachingAvici = "ちきんたまご";

		public static string ClearingTheSixSenses = "久蒼穹";

		public static string SlashDraw = "tomgoku2";

		public static string BloodOfAsura = "eikou no kassai";

		public static string UnendingWinter = "krmt090815";

		public static string YuyukoFriend = "icejiangyusky";

		public static string YoumuDefenseX = "";

		public static string NetherMeditation = "鬼菌";

		public static string TenKingsRetribution = "愚頭";

		public static string SlashOfDeparture = "@zounose";

		public static string DivineSevering = "eps3rd";

		public static string WickedSoul = "@koza__mom0";

		public static string LivingAndDead = "@Rinka_private";

		public static string NextToNone = "ファルケン@";

		public static string Bizareness = "maccha (mochancc)";

		public static string WheelOfPain = "kelou";

		public static string AgelessObsession = "@TheHeavenpit";

		public static string Inclemency = "Kanta";

		public static string MatsuyoiReflecting = "hidukihumi";

		public static string MeikyoShisui = "taj!ma";

		public static string HesitationCuttingSword = "@Redd__009";

		public static string Embercleave = "あけひこ（柏原緋彦";

		public static string DualWielder = "Tyo";

		public static string Hakugyokurou = "YuYu_Loveb";

		public static string TurningAngelCut = "MuginoSa";

		public static string WaterfowlDance = "yamanakaume";

		public static string AppearingAndDisappearing = "涼貓";

		public static string TransmigrationSlash = "@asakuramaru";

		public static string AscensionToBuddhahood = "葉鶏(ばとり)";

		public static string ConventionalTruth = "れい";

		public static string PretaSword = "わんこソラ";
	}
}
namespace YoumuCharacterMod.GunName
{
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct YoumuGunName
	{
		private static IReadOnlyList<GunConfig> gunConfig = GunConfig.AllConfig();

		public static string YoumuAttackG = GunFromId(805);

		public static string YoumuAttackW = GunFromId(801);

		public static string AsuraSword = GunFromId(6162);

		public static string AsuraSwordBurst = GunFromId(851);

		public static string SwordOfBinding = GunFromId(25020);

		public static string PhosphoricSlash = GunFromId(4152);

		public static string ClosedEyeSlash = GunFromId(6160);

		public static string SlashOfPresent = GunFromId(520);

		public static string InsightfulSword = GunFromId(821);

		public static string GhostSlash = GunFromId(6190);

		public static string SlashOfKarmicWind = GunFromId(22020);

		public static string SlashOfKarmicWindBurst = GunFromId(851);

		public static string SlashOfMeditation = GunFromId(512);

		public static string LotusPostureSlash = GunFromId(6180);

		public static string SatelliteSlash = GunFromId(7000);

		public static string CrescentMoonSlash = GunFromId(13190);

		public static string ReflectionSlash = GunFromId(25020);

		public static string SlashOfDeparture = GunFromId(4131);

		public static string SlashDraw = GunFromId(21100);

		public static string WaterfowlDance = GunFromId(6300);

		public static string TransmigrationSlash = GunFromId(4535);

		public static string PretaSword = GunFromId(6002);

		public static string DyingDeva = GunFromId(865);

		public static string Hakugyokurou = GunFromId(11120);

		public static string RiposteSe = GunFromId(4034);

		public static string SpiritMediumBindSe = GunFromId(863);

		public static string FlashOfTheNetherworldSe = GunFromId(4536);

		public static string UltimateSkillG = GunFromId(521);

		public static string UltimateSkillGBurst = GunFromId(851);

		public static string UltimateSkillW = GunFromId(521);

		public static string GunFromId(int id)
		{
			string text = "";
			try
			{
				return (from config in gunConfig
					where config.Id == id
					select config.Name).ToList()[0];
			}
			catch
			{
				Debug.Log((object)("id: " + id + " doesn't exist. Check whether the ID is correct."));
				return "Instant";
			}
		}
	}
}
namespace YoumuCharacterMod.Exhibits
{
	public sealed class YoumuExhibitGDef : YoumuExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//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)
			ExhibitConfig val = DefaultExhibitConfig();
			val.Value1 = 1;
			val.Value2 = 5;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Green = 1;
			val.Mana = value;
			val.BaseManaColor = (ManaColor)5;
			val.RelativeEffects = new List<string> { "LockedOn" };
			return val;
		}
	}
	[EntityLogic(typeof(YoumuExhibitGDef))]
	public sealed class YoumuExhibitG : ShiningExhibit
	{
		protected override void OnEnterBattle()
		{
			foreach (EnemyUnit allAliveEnemy in ((Exhibit)this).Battle.AllAliveEnemies)
			{
				((Exhibit)this).HandleBattleEvent<StatusEffectEventArgs>(((Unit)allAliveEnemy).StatusEffectRemoving, (GameEventHandler<StatusEffectEventArgs>)OnStatusEffectRemoving);
			}
			((Exhibit)this).HandleBattleEvent<UnitEventArgs>(((Exhibit)this).Battle.EnemySpawned, (GameEventHandler<UnitEventArgs>)OnEnemySpawned);
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnEnding, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnEnding);
			((Exhibit)this).ReactBattleEvent<GameEventArgs>(((Exhibit)this).Battle.AllEnemyTurnEnding, (EventSequencedReactor<GameEventArgs>)OnEnemyTurnEnding);
			((Exhibit)this).ReactBattleEvent<GameEventArgs>(((Exhibit)this).Battle.BattleStarted, (EventSequencedReactor<GameEventArgs>)OnBattleStarted);
		}

		private IEnumerable<BattleAction> OnPlayerTurnEnding(UnitEventArgs args)
		{
			foreach (EnemyUnit enemyUnit in ((Exhibit)this).Battle.AllAliveEnemies)
			{
				LockedOn lockedOn = ((Unit)enemyUnit).GetStatusEffect<LockedOn>();
				if (lockedOn != null && ((StatusEffect)lockedOn).Level <= ((Exhibit)this).Value2)
				{
					((StatusEffect)((Unit)enemyUnit).GetStatusEffect<LockedOn>()).IsAutoDecreasing = false;
					((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				}
			}
			yield break;
		}

		private IEnumerable<BattleAction> OnEnemyTurnEnding(GameEventArgs args)
		{
			foreach (EnemyUnit enemyUnit in ((Exhibit)this).Battle.AllAliveEnemies)
			{
				LockedOn lockedOn = ((Unit)enemyUnit).GetStatusEffect<LockedOn>();
				if (lockedOn != null && ((StatusEffect)lockedOn).Level <= ((Exhibit)this).Value2)
				{
					((StatusEffect)((Unit)enemyUnit).GetStatusEffect<LockedOn>()).IsAutoDecreasing = false;
					args.AddModifier((GameEntity)(object)this);
				}
			}
			yield break;
		}

		private void OnEnemySpawned(UnitEventArgs args)
		{
			((Exhibit)this).HandleBattleEvent<StatusEffectEventArgs>(args.Unit.StatusEffectRemoving, (GameEventHandler<StatusEffectEventArgs>)OnStatusEffectRemoving);
		}

		private void OnStatusEffectRemoving(StatusEffectEventArgs args)
		{
			if (args.Effect is LockedOn && !((Exhibit)this).Battle.BattleShouldEnd && args.Unit.IsAlive && args.Unit.HasStatusEffect<LockedOn>())
			{
				((GameEventArgs)args).CanCancel = true;
				((GameEventArgs)args).CancelBy((GameEntity)(object)this);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				int level = ((StatusEffect)args.Unit.GetStatusEffect<LockedOn>()).Level;
				((StatusEffect)args.Unit.GetStatusEffect<LockedOn>()).Level = ((level >= ((Exhibit)this).Value2 * 2) ? ((int)Math.Floor((double)((StatusEffect)args.Unit.GetStatusEffect<LockedOn>()).Level / 2.0)) : ((((StatusEffect)args.Unit.GetStatusEffect<LockedOn>()).Level < ((Exhibit)this).Value2) ? level : ((Exhibit)this).Value2));
				((Exhibit)this).NotifyActivating();
			}
		}

		private IEnumerable<BattleAction> OnBattleStarted(GameEventArgs args)
		{
			foreach (EnemyUnit enemyUnit in ((Exhibit)this).Battle.AllAliveEnemies)
			{
				yield return (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>((Unit)(object)enemyUnit, (int?)((Exhibit)this).Value1, (int?)0, (int?)null, (int?)null, 0f, true);
			}
		}
	}
	public class YoumuExhibitTemplate : ExhibitTemplate
	{
		protected string OwnerName = YoumuPlayerDef.playerName;

		public override IdContainer GetId()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(YoumuDefaultConfig.GetDefaultID((EntityDefinition)(object)this));
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)YoumuLocalization.ExhibitsBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override ExhibitSprites LoadSprite()
		{
			return YoumuImageLoader.LoadExhibitSprite((ExhibitTemplate)(object)this);
		}

		public override ExhibitConfig MakeConfig()
		{
			return DefaultExhibitConfig();
		}

		public ExhibitConfig DefaultExhibitConfig()
		{
			return YoumuDefaultConfig.DefaultExhibitConfig();
		}
	}
	public sealed class YoumuExhibitWDef : YoumuExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig val = DefaultExhibitConfig();
			val.Value1 = 1;
			val.Value2 = 10;
			val.HasCounter = true;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).White = 1;
			val.Mana = value;
			val.BaseManaColor = (ManaColor)1;
			val.RelativeCards = new List<string> { "YoumuSlashOfPresent" };
			val.RelativeEffects = new List<string> { "YoumuUnsheatheSe" };
			return val;
		}
	}
	[EntityLogic(typeof(YoumuExhibitWDef))]
	public sealed class YoumuExhibitW : ShiningExhibit
	{
		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnStarted);
			((Exhibit)this).ReactBattleEvent<CardUsingEventArgs>(((Exhibit)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private IEnumerable<BattleAction> OnPlayerTurnStarted(UnitEventArgs args)
		{
			if (((Unit)((Exhibit)this).Battle.Player).TurnCounter == 1)
			{
				<>n__0();
				yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YoumuSlashOfPresent>() });
			}
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if ((int)args.Card.CardType == 1 && !((Exhibit)this).Battle.BattleShouldEnd)
			{
				int counter = ((Exhibit)this).Counter;
				((Exhibit)this).Counter = counter + 1;
				if (((Exhibit)this).Counter >= ((Exhibit)this).Value2)
				{
					yield return (BattleAction)(object)new UnsheatheAction();
					((Exhibit)this).Counter = 0;
				}
			}
		}

		protected override void OnLeaveBattle()
		{
			((Exhibit)this).Counter = 0;
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
}
namespace YoumuCharacterMod.DefaultConfig
{
	public sealed class YoumuDefaultConfig
	{
		private static readonly string OwnerName = YoumuPlayerDef.playerName;

		public static string GetDefaultID(EntityDefinition entity)
		{
			string name = ((object)entity).GetType().Name;
			return name.Remove(name.Length - 3);
		}

		public static CardConfig CardDefaultConfig()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			return new CardConfig(0, "", 10, true, new string[0][], "", "", 0, false, true, true, false, true, (Rarity)0, (CardType)0, (TargetType?)null, (IReadOnlyList<ManaColor>)new List<ManaColor>(), false, default(ManaGroup), (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (ManaGroup?)null, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)0, (Keyword)0, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (string)null, "", "", false, (string)null, (IReadOnlyList<string>)new List<string>());
		}

		public static ExhibitConfig DefaultExhibitConfig()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			return new ExhibitConfig(0, "", 10, false, false, false, false, (AppearanceType)3, OwnerName, (ExhibitLosableType)1, (Rarity)3, (int?)null, (int?)null, (int?)null, (ManaGroup?)default(ManaGroup), (ManaColor?)null, (ManaColor?)(ManaColor)1, 1, false, (int?)null, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}

		public static StatusEffectConfig DefaultStatusEffectConfig()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			return new StatusEffectConfig(0, "", 10, (StatusEffectType)0, false, true, (int?)null, true, (StackType?)(StackType)0, false, (StackType?)(StackType)0, (DurationDecreaseTiming)0, false, (StackType?)(StackType)3, (StackType?)(StackType)3, false, (Keyword)0, (IReadOnlyList<string>)new List<string>(), "Default", "Default", "Default");
		}

		public static UltimateSkillConfig DefaultUltConfig()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 0, 0, 0, (Keyword)256, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}
	}
}
namespace YoumuCharacterMod.Cards
{
	public sealed class YoumuBizarenessDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor>
			{
				(ManaColor)3,
				(ManaColor)5
			};
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 1;
			((ManaGroup)(ref cost)).Black = 1;
			((ManaGroup)(ref cost)).Green = 1;
			val.Cost = cost;
			val.Rarity = (Rarity)1;
			val.Owner = OwnerName;
			val.Type = (CardType)4;
			val.TargetType = (TargetType)0;
			val.Value1 = 2;
			val.UpgradedValue1 = 3;
			val.Keywords = (Keyword)0;
			val.RelativeEffects = new List<string> { "LockedOn", "Poison" };
			val.UpgradedRelativeEffects = new List<string> { "LockedOn", "Poison" };
			val.Illustrator = YoumuIllustrator.Bizareness;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuBizarenessDef))]
	public sealed class YoumuBizareness : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			yield return ((Card)this).BuffAction<YoumuBizarenessSe>(((Card)this).Value1, 0, 0, 0, 0.2f);
		}
	}
	public sealed class YoumuInclemencyDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 4;
			((ManaGroup)(ref val2)).Black = 1;
			val.Cost = val2;
			val.Rarity = (Rarity)2;
			val.Owner = OwnerName;
			val.Type = (CardType)3;
			val.TargetType = (TargetType)0;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 0;
			val.Mana = val2;
			val.Value1 = 1;
			val.UpgradedValue1 = 3;
			val.Keywords = (Keyword)65536;
			val.UpgradedKeywords = (Keyword)65536;
			val.Illustrator = YoumuIllustrator.Inclemency;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuInclemencyDef))]
	public sealed class YoumuInclemency : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			yield return (BattleAction)new DrawManyCardAction(((Card)this).Value1);
			List<Card> cardsInHand = ((Card)this).Battle.HandZone.Where((Card hand) => hand != this).ToList();
			foreach (Card card in cardsInHand)
			{
				card.SetTurnCost(((Card)this).Mana);
			}
			yield return ((Card)this).BuffAction<CantDrawThisTurn>(0, 0, 0, 0, 0.2f);
		}
	}
	public sealed class YoumuNextToNoneDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Black = 1;
			val.Cost = val2;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 0;
			val.UpgradedCost = val2;
			val.Rarity = (Rarity)1;
			val.Owner = OwnerName;
			val.Type = (CardType)3;
			val.TargetType = (TargetType)1;
			val.Value1 = 1;
			val.Keywords = (Keyword)2162688;
			val.UpgradedKeywords = (Keyword)2162688;
			val.RelativeKeyword = (Keyword)1536;
			val.UpgradedRelativeKeyword = (Keyword)1536;
			val.RelativeCards = new List<string> { "YoumuSlashOfPresent" };
			val.UpgradedRelativeCards = new List<string> { "YoumuSlashOfPresent" };
			val.RelativeEffects = new List<string> { "Graze", "Invincible", "GuangxueMicai", "YoumuUnsheatheSe" };
			val.UpgradedRelativeEffects = new List<string> { "Graze", "Invincible", "GuangxueMicai", "YoumuUnsheatheSe" };
			val.Illustrator = YoumuIllustrator.NextToNone;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuNextToNoneDef))]
	public sealed class YoumuNextToNone : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			EnemyUnit selectedEnemy = selector.SelectedEnemy;
			int enemyBlock = ((Unit)selectedEnemy).Block;
			int enemyShield = ((Unit)selectedEnemy).Shield;
			yield return (BattleAction)new LoseBlockShieldAction((Unit)(object)selectedEnemy, enemyBlock, enemyShield, false);
			if (((Unit)selectedEnemy).HasStatusEffect<Graze>())
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)((Unit)selectedEnemy).GetStatusEffect<Graze>(), true, 0.1f);
			}
			if (((Unit)selectedEnemy).HasStatusEffect<GuangxueMicai>())
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)((Unit)selectedEnemy).GetStatusEffect<GuangxueMicai>(), true, 0.1f);
			}
			if (((Unit)selectedEnemy).HasStatusEffect<Invincible>())
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)((Unit)selectedEnemy).GetStatusEffect<Invincible>(), true, 0.1f);
			}
			if (((Unit)selectedEnemy).HasStatusEffect<InvincibleEternal>())
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)((Unit)selectedEnemy).GetStatusEffect<InvincibleEternal>(), true, 0.1f);
			}
			yield return (BattleAction)(object)new UnsheatheAction();
		}
	}
	public sealed class YoumuYuyukoFriendDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_002f: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor>
			{
				(ManaColor)5,
				(ManaColor)1,
				(ManaColor)3
			};
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).White = 1;
			((ManaGroup)(ref val2)).Black = 1;
			((ManaGroup)(ref val2)).Green = 1;
			val.Cost = val2;
			val.Rarity = (Rarity)2;
			val.Owner = OwnerName;
			val.Type = (CardType)5;
			val.TargetType = (TargetType)0;
			val.Loyalty = 4;
			val.UpgradedLoyalty = 5;
			val.PassiveCost = 2;
			val.UpgradedPassiveCost = 2;
			val.ActiveCost = -3;
			val.UpgradedActiveCost = -3;
			val.UltimateCost = -9;
			val.UpgradedUltimateCost = -9;
			val.Value1 = 8;
			val.UpgradedValue1 = 10;
			val.Value2 = 3;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Green = 1;
			((ManaGroup)(ref val2)).Black = 1;
			val.Mana = val2;
			val.Keywords = (Keyword)0;
			val.RelativeEffects = new List<string>();
			val.RelativeCards = new List<string>();
			val.UpgradedRelativeCards = new List<string>();
			val.RelativeEffects = new List<string> { "Weak", "Vulnerable", "YoumuYuyukoDeathSe" };
			val.UpgradedRelativeEffects = new List<string> { "Weak", "Vulnerable", "YoumuYuyukoDeathSe" };
			val.Illustrator = YoumuIllustrator.YuyukoFriend;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuYuyukoFriendDef))]
	public sealed class YoumuYuyukoFriend : YoumuCard
	{
		public override IEnumerable<BattleAction> OnTurnStartedInHand()
		{
			return ((Card)this).GetPassiveActions();
		}

		public override IEnumerable<BattleAction> GetPassiveActions()
		{
			if (!((Card)this).Summoned || ((Card)this).Battle.BattleShouldEnd)
			{
				yield break;
			}
			<>n__0();
			((Card)this).Loyalty = ((Card)this).Loyalty + ((Card)this).PassiveCost;
			for (int i = 0; i < ((Card)this).Battle.FriendPassiveTimes; i++)
			{
				if (((Card)this).Battle.BattleShouldEnd)
				{
					break;
				}
				yield return (BattleAction)new GainManaAction(((Card)this).Mana);
			}
		}

		public override IEnumerable<BattleAction> SummonActions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			foreach (EnemyUnit unit in ((Card)this).Battle.AllAliveEnemies)
			{
				yield return (BattleAction)new ApplyStatusEffectAction(typeof(YuyukoDeath), (Unit)(object)unit, (int?)((Card)this).Value1, (int?)null, (int?)null, (int?)null, 0.2f, true);
			}
			foreach (BattleAction item in <>n__1(selector, consumingMana, precondition))
			{
				yield return item;
			}
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (precondition == null || (int)((MiniSelectCardInteraction)precondition).SelectedCard.FriendToken == 1)
			{
				((Card)this).Loyalty = ((Card)this).Loyalty + ((Card)this).ActiveCost;
				foreach (EnemyUnit unit in ((Card)this).Battle.AllAliveEnemies)
				{
					yield return ((Card)this).DebuffAction<Weak>((Unit)(object)unit, 0, ((Card)this).Value2, 0, 0, true, 0.2f);
					yield return ((Card)this).DebuffAction<Vulnerable>((Unit)(object)unit, 0, ((Card)this).Value2, 0, 0, true, 0.2f);
				}
				yield return (BattleAction)(object)((Card)this).SkillAnime;
			}
			else
			{
				((Card)this).Loyalty = ((Card)this).Loyalty + ((Card)this).UltimateCost;
				((Card)this).UltimateUsed = true;
				yield return ((Card)this).BuffAction<YoumuYuyukoFriendSe>(1, 0, 0, 0, 0.2f);
				yield return (BattleAction)(object)((Card)this).SkillAnime;
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Card)this).NotifyActivating();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__1(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return ((Card)this).SummonActions(selector, consumingMana, precondition);
		}
	}
	public sealed class YoumuMeikyoShisuiDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 1;
			((ManaGroup)(ref cost)).Colorless = 1;
			val.Cost = cost;
			val.Rarity = (Rarity)1;
			val.Owner = OwnerName;
			val.Type = (CardType)2;
			val.TargetType = (TargetType)4;
			val.Block = 10;
			val.UpgradedBlock = 13;
			val.Value1 = 1;
			val.UpgradedValue1 = 2;
			val.Keywords = (Keyword)0;
			val.UpgradedKeywords = (Keyword)0;
			val.RelativeEffects = new List<string> { "YoumuRiposteSe" };
			val.UpgradedRelativeEffects = new List<string> { "YoumuRiposteSe" };
			val.Illustrator = YoumuIllustrator.MeikyoShisui;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuMeikyoShisuiDef))]
	public sealed class YoumuMeikyoShisui : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			BattleController battle = ((Card)this).Battle;
			YoumuMeikyoShisui youmuMeikyoShisui = this;
			BlockInfo val = <>n__0();
			int riposteAmount = battle.CalculateBlockShield((GameEntity)(object)youmuMeikyoShisui, (float)((BlockInfo)(ref val)).Block, 0f, (BlockShieldType)1).Item1;
			if (riposteAmount > 0)
			{
				yield return ((Card)this).BuffAction<YoumuRiposteSe>(riposteAmount, 0, 0, 0, 0.2f);
			}
			if (((Card)this).Value1 > 0)
			{
				yield return (BattleAction)new DrawManyCardAction(((Card)this).Value1);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private BlockInfo <>n__0()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((Card)this).Block;
		}
	}
	public sealed class YoumuSpiritMediumBindDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 3;
			((ManaGroup)(ref cost)).Colorless = 1;
			val.Cost = cost;
			val.Rarity = (Rarity)2;
			val.Owner = OwnerName;
			val.Type = (CardType)4;
			val.TargetType = (TargetType)0;
			val.Value1 = 7;
			val.UpgradedValue1 = 9;
			val.Keywords = (Keyword)0;
			val.RelativeEffects = new List<string>();
			val.Illustrator = YoumuIllustrator.SpiritMediumBind;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuSpiritMediumBindDef))]
	public sealed class YoumuSpiritMediumBind : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!((Card)this).Battle.BattleShouldEnd)
			{
				yield return ((Card)this).BuffAction<YoumuSpiritMediumBindSe>(((Card)this).Value1, 0, 0, 0, 0.2f);
			}
		}
	}
	public sealed class YoumuAsuraSwordDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.GunName = YoumuGunName.AsuraSword;
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Green = 2;
			val.Cost = cost;
			val.Rarity = (Rarity)0;
			val.Owner = OwnerName;
			val.Type = (CardType)1;
			val.TargetType = (TargetType)1;
			val.Damage = 6;
			val.Value1 = 2;
			val.UpgradedValue1 = 3;
			val.Keywords = (Keyword)0;
			val.RelativeEffects = new List<string> { "LockedOn" };
			val.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			val.Illustrator = YoumuIllustrator.AsuraSword;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuAsuraSwordDef))]
	public sealed class YoumuAsuraSword : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).CardGuns = new Guns(((Card)this).GunName, ((Card)this).Value1, false);
			foreach (GunPair gunPair in ((Card)this).CardGuns.GunPairs)
			{
				yield return ((Card)this).AttackAction(selector, gunPair);
			}
			EnemyUnit selectedEnemy = selector.SelectedEnemy;
			if (((Unit)selector.SelectedEnemy).IsAlive)
			{
				yield return ((Card)this).DebuffAction<LockedOn>((Unit)(object)selectedEnemy, ((Card)this).Value1, 0, 0, 0, true, 0.2f);
			}
		}
	}
	public sealed class YoumuPretaSwordDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.GunName = YoumuGunName.PretaSword;
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 1;
			val.Cost = cost;
			val.Rarity = (Rarity)0;
			val.Owner = OwnerName;
			val.Type = (CardType)1;
			val.TargetType = (TargetType)1;
			val.Damage = 6;
			val.UpgradedDamage = 9;
			val.Value1 = 1;
			val.Value2 = 1;
			val.UpgradedKeywords = (Keyword)256;
			val.RelativeEffects = new List<string> { "Weak" };
			val.UpgradedRelativeEffects = new List<string> { "Weak" };
			val.Illustrator = YoumuIllustrator.PretaSword;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuPretaSwordDef))]
	public sealed class YoumuPretaSword : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			yield return ((Card)this).AttackAction(selector, ((Card)this).GunName);
			EnemyUnit selectedEnemy = selector.SelectedEnemy;
			if (((Unit)selectedEnemy).IsAlive)
			{
				yield return ((Card)this).DebuffAction<Weak>((Unit)(object)selectedEnemy, 0, ((Card)this).Value1, 0, 0, true, 0.2f);
			}
		}
	}
	public sealed class YoumuScatteredFlowersDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 2;
			((ManaGroup)(ref cost)).Green = 1;
			val.Cost = cost;
			val.Rarity = (Rarity)0;
			val.Owner = OwnerName;
			val.Type = (CardType)2;
			val.TargetType = (TargetType)4;
			val.Block = 18;
			val.UpgradedBlock = 24;
			val.Value1 = 1;
			val.UpgradedValue1 = 2;
			val.Value2 = 1;
			val.RelativeKeyword = (Keyword)512;
			val.UpgradedRelativeKeyword = (Keyword)512;
			val.RelativeEffects = new List<string> { "LockedOn" };
			val.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			val.Keywords = (Keyword)0;
			val.Illustrator = YoumuIllustrator.ScatteredFlowers;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuScatteredFlowersDef))]
	public sealed class YoumuScatteredFlowers : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			yield return ((Card)this).DefenseAction(true);
			foreach (EnemyUnit enemyUnit in ((Card)this).Battle.AllAliveEnemies)
			{
				yield return ((Card)this).DebuffAction<LockedOn>((Unit)(object)enemyUnit, ((Card)this).Value1, 0, 0, 0, true, 0.2f);
			}
		}
	}
	public sealed class YoumuSpringWindDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 1;
			((ManaGroup)(ref val2)).Green = 1;
			val.Cost = val2;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 1;
			val.UpgradedCost = val2;
			val.Rarity = (Rarity)0;
			val.Owner = OwnerName;
			val.Type = (CardType)3;
			val.TargetType = (TargetType)2;
			val.Value1 = 1;
			val.Value2 = 3;
			val.Keywords = (Keyword)0;
			val.RelativeEffects = new List<string> { "LockedOn" };
			val.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			val.Illustrator = YoumuIllustrator.SpringWind;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuSpringWindDef))]
	public sealed class YoumuSpringWind : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			yield return (BattleAction)new DrawManyCardAction(((Card)this).Value2);
			foreach (BattleAction item in ((Card)this).DebuffAction<LockedOn>((IEnumerable<Unit>)((Card)this).Battle.AllAliveEnemies, ((Card)this).Value1, 0, 0, 0, true, 0.2f))
			{
				yield return item;
			}
		}
	}
	public sealed class YoumuStrangeBirdDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 1;
			((ManaGroup)(ref cost)).Green = 1;
			val.Cost = cost;
			val.Rarity = (Rarity)0;
			val.Owner = OwnerName;
			val.Type = (CardType)3;
			val.TargetType = (TargetType)5;
			val.Value1 = 1;
			val.UpgradedValue1 = 2;
			val.Value2 = 6;
			val.UpgradedValue2 = 8;
			val.RelativeKeyword = (Keyword)512;
			val.UpgradedRelativeKeyword = (Keyword)512;
			val.Keywords = (Keyword)0;
			val.RelativeEffects = new List<string> { "Graze", "Weak" };
			val.UpgradedRelativeEffects = new List<string> { "Graze", "Weak" };
			val.Illustrator = YoumuIllustrator.StrangeBird;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuStrangeBirdDef))]
	public sealed class YoumuStrangeBird : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			yield return ((Card)this).BuffAction<Graze>(((Card)this).Value1, 0, 0, 0, 0.2f);
			yield return ((Card)this).BuffAction<NextTurnGainBlock>(((Card)this).Value2, 0, 0, 0, 0.2f);
		}
	}
	public sealed class YoumuTransmigrationSlashDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.GunName = YoumuGunName.TransmigrationSlash;
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 2;
			((ManaGroup)(ref cost)).Green = 1;
			val.Cost = cost;
			val.Rarity = (Rarity)0;
			val.Owner = OwnerName;
			val.Type = (CardType)1;
			val.TargetType = (TargetType)2;
			val.Damage = 8;
			val.UpgradedDamage = 10;
			val.Value1 = 2;
			val.UpgradedValue1 = 3;
			val.Value2 = 2;
			val.Keywords = (Keyword)524288;
			val.UpgradedKeywords = (Keyword)524288;
			val.RelativeEffects = new List<string> { "LockedOn" };
			val.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			val.Illustrator = YoumuIllustrator.TransmigrationSlash;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuTransmigrationSlashDef))]
	public sealed class YoumuTransmigrationSlash : YoumuCard
	{
		public override bool IsSlash { get; set; } = true;


		public DamageInfo ExiledDamage => CalculateDamage(((Card)this).Value2);

		private DamageInfo CalculateDamage(int amount)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return DamageInfo.Attack((float)amount, ((Card)this).IsAccuracy);
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).CardGuns = new Guns(((Card)this).GunName, ((Card)this).Value2, false);
			foreach (GunPair gunPair in ((Card)this).CardGuns.GunPairs)
			{
				yield return ((Card)this).AttackAction(selector, gunPair);
			}
			foreach (BattleAction item in ((Card)this).DebuffAction<LockedOn>((IEnumerable<Unit>)((Card)this).Battle.AllAliveEnemies, ((Card)this).Value1, 0, 0, 0, true, 0.2f))
			{
				yield return item;
			}
		}

		public override IEnumerable<BattleAction> OnExile(CardZone srcZone)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (((Card)this).Battle.BattleShouldEnd)
			{
				yield break;
			}
			foreach (BattleAction item in ((Card)this).DebuffAction<LockedOn>((IEnumerable<Unit>)((Card)this).Battle.AllAliveEnemies, ((Card)this).Value1, 0, 0, 0, true, 0.2f))
			{
				yield return item;
			}
		}
	}
	public sealed class YoumuAttackGDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0033: 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)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.GunName = YoumuGunName.YoumuAttackG;
			val.IsPooled = false;
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 1;
			((ManaGroup)(ref val2)).Green = 1;
			val.Cost = val2;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 2;
			val.UpgradedCost = val2;
			val.Rarity = (Rarity)0;
			val.Owner = OwnerName;
			val.Type = (CardType)1;
			val.TargetType = (TargetType)1;
			val.Damage = 10;
			val.UpgradedDamage = 14;
			val.Keywords = (Keyword)2;
			val.UpgradedKeywords = (Keyword)2;
			val.Illustrator = YoumuIllustrator.YoumuAttackG;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuAttackGDef))]
	public sealed class YoumuAttackG : YoumuCard
	{
	}
	public sealed class YoumuBlockGDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0027: 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)
			//IL_0049: 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)
			CardConfig val = CardDefaultConfig();
			val.IsPooled = false;
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 1;
			((ManaGroup)(ref val2)).Green = 1;
			val.Cost = val2;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 2;
			val.UpgradedCost = val2;
			val.Rarity = (Rarity)0;
			val.Owner = OwnerName;
			val.Type = (CardType)2;
			val.TargetType = (TargetType)4;
			val.Block = 10;
			val.UpgradedBlock = 13;
			val.Keywords = (Keyword)2;
			val.UpgradedKeywords = (Keyword)2;
			val.RelativeKeyword = (Keyword)512;
			val.UpgradedRelativeKeyword = (Keyword)512;
			val.Illustrator = YoumuIllustrator.YoumuBlockG;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuBlockGDef))]
	public sealed class YoumuBlockG : YoumuCard
	{
	}
	public sealed class YoumuAgelessObsessionDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Green = 3;
			val.Cost = val2;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Green = 2;
			val.UpgradedCost = val2;
			val.Rarity = (Rarity)2;
			val.Owner = OwnerName;
			val.Type = (CardType)4;
			val.TargetType = (TargetType)0;
			val.Value1 = 2;
			val.UpgradedValue1 = 3;
			val.Value2 = 1;
			val.Keywords = (Keyword)0;
			val.RelativeEffects = new List<string> { "LockedOn" };
			val.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			val.Illustrator = YoumuIllustrator.AgelessObsession;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuAgelessObsessionDef))]
	public sealed class YoumuAgelessObsession : YoumuCard
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			foreach (BattleAction item in ((Card)this).DebuffAction<LockedOn>((IEnumerable<Unit>)((Card)this).Battle.AllAliveEnemies, ((Card)this).Value1, 0, 0, 0, true, 0.2f))
			{
				yield return item;
			}
			if (!((Card)this).Battle.BattleShouldEnd)
			{
				yield return ((Card)this).BuffAction<YoumuAgelessObsessionSe>(((Card)this).Value2, 0, 0, 0, 0.2f);
			}
		}
	}
	public sealed class YoumuClosedEyeSlashDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			CardConfig val = CardDefaultConfig();
			val.GunName = YoumuGunName.ClosedEyeSlash;
			val.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 2;
			((ManaGroup)(ref cost)).Green = 1;
			val.Cost = cost;
			val.Rarity = (Rarity)2;
			val.Owner = OwnerName;
			val.Type = (CardType)1;
			val.TargetType = (TargetType)1;
			val.Damage = 12;
			val.UpgradedDamage = 15;
			val.Keywords = (Keyword)0;
			val.UpgradedKeywords = (Keyword)256;
			val.RelativeEffects = new List<string> { "YoumuRiposteSe" };
			val.UpgradedRelativeEffects = new List<string> { "YoumuRiposteSe" };
			val.Illustrator = YoumuIllustrator.ClosedEyeSlash;
			val.Index = CardIndexGenerator.GetUniqueIndex(val);
			return val;
		}
	}
	[EntityLogic(typeof(YoumuClosedEyeSlashDef))]
	public sealed class YoumuClosedEyeSlash : You