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.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+af5e675fa24d95c9f4fe0d384b73feb784288613")]
[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.4.17")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static TemplateSequenceTable sequenceTable = new TemplateSequenceTable(0);

		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.4.17";

		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;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 2;
			((ManaGroup)(ref val)).White = 2;
			return new PlayerUnitConfig("Youmu", 6, 0, num, "", "#00b789", 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 YoumuUltGDef : YoumuUltTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("YoumuUltG");
		}

		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()
		{
			throw new NotImplementedException();
		}

		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()
		{
			throw new NotImplementedException();
		}
	}
	public sealed class YoumuUltWDef : YoumuUltTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("YoumuUltW");
		}

		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 defaultStatusEffectConfig = YoumuStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[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 defaultStatusEffectConfig = YoumuStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YoumuDivineSeveringSeDef))]
	public sealed class YoumuDivineSeveringSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<GameEventArgs>(CustomGameEventPatch.Unsheathed, (EventSequencedReactor<GameEventArgs>)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(GameEventArgs 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 YoumuDualWielderSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YoumuStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "YoumuUnsheatheSe" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YoumuDualWielderSeDef))]
	public sealed class YoumuDualWielderSe : StatusEffect
	{
		private static readonly int lockOnThreshold = 5;

		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)
			{
				((StatusEffect)this).Count = ((StatusEffect)this).Count + args.Effect.Level;
				while (((StatusEffect)this).Count >= lockOnThreshold)
				{
					<>n__0();
					yield return (BattleAction)(object)new UnsheatheAllInHandAction();
					((StatusEffect)this).Count = ((StatusEffect)this).Count - lockOnThreshold;
				}
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuFlashOfTheNetherworldSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YoumuStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YoumuFlashOfTheNetherworldSeDef))]
	public sealed class YoumuFlashOfTheNetherworldSe : StatusEffect
	{
		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();
				string gunName = YoumuGunName.FlashOfTheNetherworldSe;
				for (int i = 0; i < ((StatusEffect)this).Count; i++)
				{
					if (i > 0)
					{
						gunName = "Instant";
					}
					<>n__0();
					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), 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 UnsheatheAllInHandAction();
			}
		}

		[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();
				Type[] array = CollectionsExtensions.SampleManyOrAll<Type>((IEnumerable<Type>)YoumuCard.AllEthereal, ((StatusEffect)this).Level, ((GameEntity)this).GameRun.BattleCardRng);
				for (int i = 0; i < array.Length; i++)
				{
					YoumuCard card = (YoumuCard)(object)Library.CreateCard(array[i]);
					((Card)card).IsExile = true;
					yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { card });
				}
			}
		}

		[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 (YoumuCard.IsSlashCard(args.Card))
			{
				<>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 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 GetDefaultStatusEffectConfig();
		}

		public static StatusEffectConfig GetDefaultStatusEffectConfig()
		{
			return YoumuDefaultConfig.GetDefaultStatusEffectConfig();
		}
	}
	public sealed class YoumuYuyukoFriendSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuYuyukoFriendSeDef))]
	public sealed class YoumuYuyukoFriendSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnEnding, (EventSequencedReactor<UnitEventArgs>)OnTurnEnding);
		}

		private IEnumerable<BattleAction> OnTurnEnding(UnitEventArgs args)
		{
			<>n__0();
			foreach (EnemyUnit unit in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				yield return (BattleAction)(object)new ApplyStatusEffectAction<YuyukoDeath>((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();
		}
	}
}
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<GameEventArgs> Unsheathing { get; set; }

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

		[HarmonyPatch(typeof(GameRunController), "EnterBattle")]
		private static bool Prefix(GameRunController __instance)
		{
			Unsheathing = new GameEvent<GameEventArgs>();
			Unsheathed = new GameEvent<GameEventArgs>();
			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 = YoumuIllustrationRefs.YGO;

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

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

		public static string WatchtowerSword = "";

		public static string InfiniteKalpas = YoumuIllustrationRefs.Touhou17;

		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 = "わんこソラ";
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct YoumuIllustrationRefs
	{
		public static string Adia = "Touhou Artificial Dream in Arcadia";

		public static string LOT2 = "Labyrinth of Touhou 2";

		public static string PdP = "Touhou Puppet Dance Performance";

		public static string Hisoutensoku = "Touhou Hisoutensoku";

		public static string GensoWanderer = "Touhou Gensou Wanderer";

		public static string GensoSkydrift = "Touhou Genso Skydrift";

		public static string MonsterTowerDefense = "Touhou Monster Tower Defense";

		public static string GensoShoujo = "Touhou Gensou Shoujo Taisen You";

		public static string Touhou7 = "Touhou 7";

		public static string Touhou8 = "Touhou 8";

		public static string Touhou9 = "Touhou 9";

		public static string Touhou17 = "Touhou 17";

		public static string Touhouvania = "Touhou Koumajou Densetsu II";

		public static string Mystia = "Touhou Mystia Izakaya";

		public static string YGO = "Yu-gi-oh!";
	}
}
namespace YoumuCharacterMod.GunName
{
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct YoumuGunName
	{
		private static IReadOnlyList<GunConfig> gunConfig = GunConfig.AllConfig();

		public static string YoumuAttackG = GetGunFromId(805);

		public static string YoumuAttackW = GetGunFromId(801);

		public static string AsuraSword = GetGunFromId(6162);

		public static string AsuraSwordBurst = GetGunFromId(851);

		public static string SwordOfBinding = GetGunFromId(25020);

		public static string PhosphoricSlash = GetGunFromId(4152);

		public static string ClosedEyeSlash = GetGunFromId(6160);

		public static string SlashOfPresent = GetGunFromId(520);

		public static string InsightfulSword = GetGunFromId(821);

		public static string GhostSlash = GetGunFromId(6190);

		public static string SlashOfKarmicWind = GetGunFromId(22020);

		public static string SlashOfKarmicWindBurst = GetGunFromId(851);

		public static string SlashOfMeditation = GetGunFromId(512);

		public static string LotusPostureSlash = GetGunFromId(851);

		public static string SatelliteSlash = GetGunFromId(7090);

		public static string CrescentMoonSlash = GetGunFromId(13190);

		public static string ReflectionSlash = GetGunFromId(6400);

		public static string SlashOfDeparture = GetGunFromId(4131);

		public static string SlashDraw = GetGunFromId(21100);

		public static string WaterfowlDance = GetGunFromId(6300);

		public static string TransmigrationSlash = GetGunFromId(6180);

		public static string PretaSword = GetGunFromId(6002);

		public static string DyingDeva = GetGunFromId(865);

		public static string Hakugyokurou = GetGunFromId(11120);

		public static string RiposteSe = GetGunFromId(4034);

		public static string SpiritMediumBindSe = GetGunFromId(863);

		public static string FlashOfTheNetherworldSe = GetGunFromId(4535);

		public static string UltimateSkillG = GetGunFromId(521);

		public static string UltimateSkillGBurst = GetGunFromId(851);

		public static string UltimateSkillW = GetGunFromId(521);

		public static string GetGunFromId(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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Value1 = 1;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Green = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)5;
			defaultExhibitConfig.RelativeEffects = new List<string> { "LockedOn" };
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(YoumuExhibitGDef))]
	public sealed class YoumuExhibitG : ShiningExhibit
	{
		protected override void OnEnterBattle()
		{
			foreach (EnemyUnit allAliveEnemy in ((Exhibit)this).Battle.AllAliveEnemies)
			{
				((Exhibit)this).ReactBattleEvent<StatusEffectApplyEventArgs>(((Unit)allAliveEnemy).StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdded);
			}
			((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)
			{
				if (((Unit)enemyUnit).HasStatusEffect<LockedOn>())
				{
					((StatusEffect)((Unit)enemyUnit).GetStatusEffect<LockedOn>()).IsAutoDecreasing = false;
				}
			}
			yield break;
		}

		private IEnumerable<BattleAction> OnEnemyTurnEnding(GameEventArgs args)
		{
			foreach (EnemyUnit enemyUnit in ((Exhibit)this).Battle.AllAliveEnemies)
			{
				if (((Unit)enemyUnit).HasStatusEffect<LockedOn>())
				{
					((StatusEffect)((Unit)enemyUnit).GetStatusEffect<LockedOn>()).IsAutoDecreasing = false;
				}
			}
			yield break;
		}

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

		private IEnumerable<BattleAction> OnEnemyStatusEffectAdded(StatusEffectApplyEventArgs args)
		{
			if (args.Effect is LockedOn && !((Exhibit)this).Battle.BattleShouldEnd)
			{
				args.Effect.IsAutoDecreasing = false;
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
			yield break;
		}

		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 GetDefaultExhibitConfig();
		}

		public ExhibitConfig GetDefaultExhibitConfig()
		{
			return YoumuDefaultConfig.GetDefaultExhibitConfig();
		}
	}
	public sealed class YoumuExhibitWDef : YoumuExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Value1 = 1;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).White = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)1;
			defaultExhibitConfig.RelativeCards = new List<string> { "YoumuSlashOfPresent" };
			return defaultExhibitConfig;
		}
	}
	[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);
		}

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

		[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 GetCardDefaultConfig()
		{
			//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 GetDefaultExhibitConfig()
		{
			//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 GetDefaultStatusEffectConfig()
		{
			//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");
		}
	}
}
namespace YoumuCharacterMod.Cards
{
	public sealed class YoumuBizarenessDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 4102;
			cardDefaultConfig.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;
			cardDefaultConfig.Cost = cost;
			cardDefaultConfig.Rarity = (Rarity)2;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)4;
			cardDefaultConfig.TargetType = (TargetType)0;
			cardDefaultConfig.Value1 = 1;
			cardDefaultConfig.UpgradedValue1 = 2;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.RelativeEffects = new List<string> { "LockedOn", "Poison" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "LockedOn", "Poison" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.Bizareness;
			return cardDefaultConfig;
		}
	}
	[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 YoumuLivingAndDeadDef : 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 4100;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.Cost = val;
			cardDefaultConfig.Rarity = (Rarity)1;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)3;
			cardDefaultConfig.TargetType = (TargetType)0;
			cardDefaultConfig.Value1 = 3;
			cardDefaultConfig.UpgradedValue1 = 5;
			cardDefaultConfig.Value2 = 1;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			cardDefaultConfig.Mana = val;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.RelativeKeyword = (Keyword)524288;
			cardDefaultConfig.UpgradedRelativeKeyword = (Keyword)524288;
			cardDefaultConfig.Illustrator = YoumuIllustrator.LivingAndDead;
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(YoumuLivingAndDeadDef))]
	public sealed class YoumuLivingAndDead : 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)
			Type[] allYoumuEtherealCards = CollectionsExtensions.SampleManyOrAll<Type>((IEnumerable<Type>)YoumuCard.AllEthereal, ((Card)this).Value1, ((GameEntity)this).GameRun.BattleCardRng);
			List<Card> list = new List<Card>();
			Type[] array2 = allYoumuEtherealCards;
			for (int i = 0; i < array2.Length; i++)
			{
				Card youmuEtherealCard = Library.CreateCard(array2[i]);
				list.Add(youmuEtherealCard);
			}
			if (list.Count > 0)
			{
				MiniSelectCardInteraction interaction = new MiniSelectCardInteraction((IEnumerable<Card>)list, false, false, false)
				{
					Source = (GameEntity)(object)this
				};
				yield return (BattleAction)new InteractionAction((Interaction)(object)interaction, false);
				Card selectedCard = interaction.SelectedCard;
				selectedCard.SetTurnCost(((Card)this).Mana);
				selectedCard.IsExile = true;
				yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { selectedCard });
			}
		}
	}
	public sealed class YoumuNextToNoneDef : 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 cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 4101;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)1;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)3;
			cardDefaultConfig.TargetType = (TargetType)1;
			cardDefaultConfig.Value1 = 1;
			cardDefaultConfig.Keywords = (Keyword)2162688;
			cardDefaultConfig.UpgradedKeywords = (Keyword)2162688;
			cardDefaultConfig.RelativeKeyword = (Keyword)1536;
			cardDefaultConfig.UpgradedRelativeKeyword = (Keyword)1536;
			cardDefaultConfig.RelativeCards = new List<string> { "YoumuSlashOfPresent" };
			cardDefaultConfig.UpgradedRelativeCards = new List<string> { "YoumuSlashOfPresent" };
			cardDefaultConfig.RelativeEffects = new List<string> { "Graze", "Invincible", "GuangxueMicai", "YoumuUnsheatheSe" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "Graze", "Invincible", "GuangxueMicai", "YoumuUnsheatheSe" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.NextToNone;
			return cardDefaultConfig;
		}
	}
	[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 UnsheatheAllInHandAction();
		}
	}
	public sealed class YoumuYuyukoFriendDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0043: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 4500;
			cardDefaultConfig.Colors = new List<ManaColor>
			{
				(ManaColor)5,
				(ManaColor)1,
				(ManaColor)3
			};
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).White = 1;
			((ManaGroup)(ref val)).Black = 1;
			((ManaGroup)(ref val)).Green = 1;
			cardDefaultConfig.Cost = val;
			cardDefaultConfig.Rarity = (Rarity)2;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)5;
			cardDefaultConfig.TargetType = (TargetType)0;
			cardDefaultConfig.Loyalty = 4;
			cardDefaultConfig.UpgradedLoyalty = 4;
			cardDefaultConfig.PassiveCost = 2;
			cardDefaultConfig.UpgradedPassiveCost = 2;
			cardDefaultConfig.ActiveCost = -3;
			cardDefaultConfig.UpgradedActiveCost = -3;
			cardDefaultConfig.UltimateCost = -8;
			cardDefaultConfig.UpgradedUltimateCost = -8;
			cardDefaultConfig.Value1 = 6;
			cardDefaultConfig.UpgradedValue1 = 8;
			cardDefaultConfig.Value2 = 3;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 1;
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.Mana = val;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.RelativeEffects = new List<string>();
			cardDefaultConfig.RelativeCards = new List<string>();
			cardDefaultConfig.UpgradedRelativeCards = new List<string>();
			cardDefaultConfig.RelativeEffects = new List<string> { "Weak", "Vulnerable", "YoumuYuyukoDeathSe" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "Weak", "Vulnerable", "YoumuYuyukoDeathSe" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.YuyukoFriend;
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(YoumuYuyukoFriendDef))]
	public sealed class YoumuYuyukoFriend : YoumuCard
	{
		public string Indent { get; } = "<indent=80>";


		public string PassiveCostIcon => $"<indent=0><sprite=\"Passive\" name=\"{((Card)this).PassiveCost}\">{Indent}";

		public string ActiveCostIcon => $"<indent=0><sprite=\"Active\" name=\"{((Card)this).ActiveCost}\">{Indent}";

		public string UltimateCostIcon => $"<indent=0><sprite=\"Ultimate\" name=\"{((Card)this).UltimateCost}\">{Indent}";

		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>(((Card)this).Value1, 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_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)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 4320;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 1;
			((ManaGroup)(ref cost)).Colorless = 1;
			cardDefaultConfig.Cost = cost;
			cardDefaultConfig.Rarity = (Rarity)1;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)2;
			cardDefaultConfig.TargetType = (TargetType)4;
			cardDefaultConfig.Block = 9;
			cardDefaultConfig.UpgradedBlock = 12;
			cardDefaultConfig.Value1 = 1;
			cardDefaultConfig.UpgradedValue1 = 2;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.UpgradedKeywords = (Keyword)0;
			cardDefaultConfig.RelativeEffects = new List<string> { "YoumuRiposteSe" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "YoumuRiposteSe" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.MeikyoShisui;
			return cardDefaultConfig;
		}
	}
	[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_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)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 4340;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 3;
			((ManaGroup)(ref cost)).Colorless = 1;
			cardDefaultConfig.Cost = cost;
			cardDefaultConfig.Rarity = (Rarity)2;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)4;
			cardDefaultConfig.TargetType = (TargetType)0;
			cardDefaultConfig.Value1 = 6;
			cardDefaultConfig.UpgradedValue1 = 8;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.RelativeEffects = new List<string>();
			cardDefaultConfig.Illustrator = YoumuIllustrator.SpiritMediumBind;
			return cardDefaultConfig;
		}
	}
	[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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.Index = 3006;
			cardDefaultConfig.GunName = YoumuGunName.AsuraSword;
			cardDefaultConfig.GunNameBurst = YoumuGunName.AsuraSwordBurst;
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Green = 2;
			cardDefaultConfig.Cost = cost;
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)1;
			cardDefaultConfig.TargetType = (TargetType)1;
			cardDefaultConfig.Damage = 6;
			cardDefaultConfig.Value1 = 2;
			cardDefaultConfig.UpgradedValue1 = 3;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.RelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.AsuraSword;
			return cardDefaultConfig;
		}
	}
	[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)
			yield return ((Card)this).AttackAction(selector, ((Card)this).Config.GunName);
			yield return ((Card)this).AttackAction(selector, ((Card)this).Config.GunNameBurst);
			if (((Card)this).IsUpgraded)
			{
				yield return ((Card)this).AttackAction(selector, ((Card)this).Config.GunNameBurst);
			}
			EnemyUnit selectedEnemy = selector.SelectedEnemy;
			if (((Unit)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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.GunName = YoumuGunName.PretaSword;
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 3210;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 1;
			cardDefaultConfig.Cost = cost;
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)1;
			cardDefaultConfig.TargetType = (TargetType)1;
			cardDefaultConfig.Damage = 8;
			cardDefaultConfig.UpgradedDamage = 12;
			cardDefaultConfig.Value1 = 3;
			cardDefaultConfig.Value2 = 1;
			cardDefaultConfig.Keywords = (Keyword)256;
			cardDefaultConfig.UpgradedKeywords = (Keyword)256;
			cardDefaultConfig.RelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.PretaSword;
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(YoumuPretaSwordDef))]
	public sealed class YoumuPretaSword : YoumuCard
	{
		public override bool Triggered
		{
			get
			{
				IEnumerable<EnemyUnit> allAliveEnemies = ((Card)this).Battle.AllAliveEnemies;
				bool flag = false;
				foreach (EnemyUnit item in allAliveEnemies)
				{
					if (((Unit)item).HasStatusEffect<LockedOn>() && ((StatusEffect)((Unit)item).GetStatusEffect<LockedOn>()).Level >= ((Card)this).Value1)
					{
						return true;
					}
				}
				return false;
			}
		}

		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);
			if (((Card)this).PlayInTriggered && !((Card)this).Battle.BattleShouldEnd)
			{
				yield return (BattleAction)new DrawManyCardAction(((Card)this).Value2);
			}
		}
	}
	public sealed class YoumuScatteredFlowersDef : 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)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 3230;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 2;
			((ManaGroup)(ref cost)).Green = 1;
			cardDefaultConfig.Cost = cost;
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)2;
			cardDefaultConfig.TargetType = (TargetType)4;
			cardDefaultConfig.Block = 18;
			cardDefaultConfig.UpgradedBlock = 24;
			cardDefaultConfig.Value1 = 1;
			cardDefaultConfig.UpgradedValue1 = 2;
			cardDefaultConfig.RelativeKeyword = (Keyword)512;
			cardDefaultConfig.UpgradedRelativeKeyword = (Keyword)512;
			cardDefaultConfig.RelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.Illustrator = YoumuIllustrator.ScatteredFlowers;
			return cardDefaultConfig;
		}
	}
	[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 unit in ((Card)this).Battle.AllAliveEnemies)
			{
				if (((Unit)unit).HasStatusEffect<LockedOn>())
				{
					yield return (BattleAction)new DamageAction((Unit)(object)((Card)this).Battle.Player, (Unit)(object)unit, DamageInfo.Reaction((float)((StatusEffect)((Unit)unit).GetStatusEffect<LockedOn>()).Level * (float)((Card)this).Value1, false), YoumuGunName.SpiritMediumBindSe, (GunType)0);
				}
			}
		}
	}
	public sealed class YoumuSpringWindDef : 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 cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 3221;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Green = 1;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)3;
			cardDefaultConfig.TargetType = (TargetType)2;
			cardDefaultConfig.Value1 = 2;
			cardDefaultConfig.Value2 = 3;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.RelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.SpringWind;
			return cardDefaultConfig;
		}
	}
	[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)
			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).Value2 > 0 && !((Card)this).Battle.BattleShouldEnd)
			{
				yield return (BattleAction)new DrawManyCardAction(((Card)this).Value2);
			}
		}
	}
	public sealed class YoumuStrangeBirdDef : 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_006d: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 3231;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Green = 2;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Green = 1;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)3;
			cardDefaultConfig.TargetType = (TargetType)1;
			cardDefaultConfig.Value1 = 2;
			cardDefaultConfig.Value2 = 2;
			cardDefaultConfig.UpgradedValue2 = 3;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.RelativeEffects = new List<string> { "Graze", "LockedOn" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "Graze", "LockedOn" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.StrangeBird;
			return cardDefaultConfig;
		}
	}
	[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).DebuffAction<LockedOn>((Unit)(object)selector.SelectedEnemy, ((Card)this).Value1, 0, 0, 0, true, 0.2f);
			yield return ((Card)this).BuffAction<Graze>(((Card)this).Value1, 0, 0, 0, 0.2f);
		}
	}
	public sealed class YoumuSwordOfBindingDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.GunName = YoumuGunName.SwordOfBinding;
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 3220;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 1;
			((ManaGroup)(ref cost)).Green = 1;
			cardDefaultConfig.Cost = cost;
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)1;
			cardDefaultConfig.TargetType = (TargetType)2;
			cardDefaultConfig.Damage = 12;
			cardDefaultConfig.UpgradedDamage = 14;
			cardDefaultConfig.Value1 = 2;
			cardDefaultConfig.UpgradedValue1 = 3;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.RelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.SwordOfBinding;
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(YoumuSwordOfBindingDef))]
	public sealed class YoumuSwordOfBinding : 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);
			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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.Index = 3002;
			cardDefaultConfig.GunName = YoumuGunName.YoumuAttackG;
			cardDefaultConfig.IsPooled = false;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Green = 1;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)1;
			cardDefaultConfig.TargetType = (TargetType)1;
			cardDefaultConfig.Damage = 10;
			cardDefaultConfig.UpgradedDamage = 14;
			cardDefaultConfig.Keywords = (Keyword)2;
			cardDefaultConfig.UpgradedKeywords = (Keyword)2;
			cardDefaultConfig.Illustrator = YoumuIllustrator.YoumuAttackG;
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(YoumuAttackGDef))]
	public sealed class YoumuAttackG : YoumuCard
	{
	}
	public sealed class YoumuBlockGDef : 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 cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.Index = 3003;
			cardDefaultConfig.IsPooled = false;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Green = 1;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)2;
			cardDefaultConfig.TargetType = (TargetType)4;
			cardDefaultConfig.Block = 10;
			cardDefaultConfig.UpgradedBlock = 13;
			cardDefaultConfig.Keywords = (Keyword)2;
			cardDefaultConfig.UpgradedKeywords = (Keyword)2;
			cardDefaultConfig.RelativeKeyword = (Keyword)512;
			cardDefaultConfig.UpgradedRelativeKeyword = (Keyword)512;
			cardDefaultConfig.Illustrator = YoumuIllustrator.YoumuBlockG;
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(YoumuBlockGDef))]
	public sealed class YoumuBlockG : YoumuCard
	{
	}
	public sealed class YoumuAgelessObsessionDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 4401;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 4;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 3;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)2;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)4;
			cardDefaultConfig.TargetType = (TargetType)0;
			cardDefaultConfig.Value1 = 2;
			cardDefaultConfig.UpgradedValue1 = 3;
			cardDefaultConfig.Value2 = 1;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.RelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "LockedOn" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.AgelessObsession;
			return cardDefaultConfig;
		}
	}
	[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 YoumuAscensionToBuddhahoodDef : 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 3851;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			((ManaGroup)(ref val)).Green = 3;
			cardDefaultConfig.Cost = val;
			cardDefaultConfig.Rarity = (Rarity)2;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)4;
			cardDefaultConfig.TargetType = (TargetType)0;
			cardDefaultConfig.Value1 = 1;
			cardDefaultConfig.Value2 = 1;
			cardDefaultConfig.RelativeKeyword = (Keyword)131072;
			cardDefaultConfig.UpgradedRelativeKeyword = (Keyword)131072;
			cardDefaultConfig.Keywords = (Keyword)8796093022208L;
			cardDefaultConfig.UpgradedKeywords = (Keyword)8796093022208L;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 1;
			cardDefaultConfig.Mana = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 1;
			((ManaGroup)(ref val)).Philosophy = 1;
			cardDefaultConfig.UpgradedMana = val;
			cardDefaultConfig.RelativeEffects = new List<string> { "YoumuRiposteSe" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "YoumuRiposteSe" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.AscensionToBuddhahood;
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(YoumuAscensionToBuddhahoodDef))]
	public sealed class YoumuAscensionToBuddhahood : YoumuCard
	{
		public override ManaGroup? PlentifulMana => ((Card)this).Mana;

		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<YoumuAscensionToBuddhahoodSe>(((Card)this).Value1, 0, 0, 0, 0.2f);
			}
			if (precondition == null)
			{
				yield break;
			}
			IReadOnlyList<Card> selectedCards = ((SelectHandInteraction)precondition).SelectedCards;
			if (!CollectionsExtensions.NotEmpty<Card>((IReadOnlyCollection<Card>)selectedCards))
			{
				yield break;
			}
			foreach (Card card in selectedCards)
			{
				card.IsEcho = true;
			}
		}
	}
	public sealed class YoumuClosedEyeSlashDef : YoumuCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.GunName = YoumuGunName.ClosedEyeSlash;
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Index = 3830;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)5 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 2;
			((ManaGroup)(ref cost)).Green = 1;
			cardDefaultConfig.Cost = cost;
			cardDefaultConfig.Rarity = (Rarity)2;
			cardDefaultConfig.Owner = OwnerName;
			cardDefaultConfig.Type = (CardType)1;
			cardDefaultConfig.TargetType = (TargetType)1;
			cardDefaultConfig.Damage = 12;
			cardDefaultConfig.UpgradedDamage = 15;
			cardDefaultConfig.Keywords = (Keyword)0;
			cardDefaultConfig.UpgradedKeywords = (Keyword)256;
			cardDefaultConfig.RelativeEffects = new List<string> { "YoumuRiposteSe" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "YoumuRiposteSe" };
			cardDefaultConfig.Illustrator = YoumuIllustrator.ClosedEyeSlash;
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(YoumuClosedEyeSlashDef))]
	public sealed class YoumuClosedEyeSlash : YoumuCard
	{
		public override bool IsSlash { get; set; } = true;


		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);
			DamageInfo val = <>n__0();
			DamageInfo damageInfo = DamageInfo.Attack(((DamageInfo)(ref val)).Damage, ((Card)this).IsAccuracy);
			((Card)this).Battle.CalculateDamage((GameEntity)(object)this, (Unit)(object)((Card)this).Battle.Player, (Unit)(object)selector.SelectedEnemy, damageInfo);
		}

		protected override void OnEnterBattle(BattleController battle)
		{
			((Card)this).ReactBattleEvent<DamageEventArgs>(((Unit)((Card)this).Battle.Player).DamageDealt, (EventSequencedR