using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
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.Randoms;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Cards.Character.Cirno;
using LBoL.EntityLib.Cards.Character.Cirno.Friend;
using LBoL.EntityLib.Cards.Character.Koishi;
using LBoL.EntityLib.Cards.Character.Marisa;
using LBoL.EntityLib.Cards.Character.Sakuya;
using LBoL.EntityLib.Cards.Enemy;
using LBoL.EntityLib.Cards.Misfortune;
using LBoL.EntityLib.Cards.Neutral.MultiColor;
using LBoL.EntityLib.Cards.Neutral.TwoColor;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.StatusEffects.Basic;
using LBoL.EntityLib.StatusEffects.Enemy;
using LBoL.EntityLib.StatusEffects.Others;
using LBoL.EntityLib.StatusEffects.Reimu;
using LBoL.Presentation;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using ReimuUnifierMod.BattleActions;
using ReimuUnifierMod.Cards;
using ReimuUnifierMod.Cards.Template;
using ReimuUnifierMod.Config;
using ReimuUnifierMod.GunName;
using ReimuUnifierMod.ImageLoader;
using ReimuUnifierMod.Localization;
using ReimuUnifierMod.Patches;
using ReimuUnifierMod.StatusEffects;
using UnityEngine;
using UnityEngine.Experimental.Rendering;

[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 = "")]
[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("ReimuUnifierMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ReimuUnifierMod")]
[assembly: AssemblyTitle("ReimuUnifierMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace ReimuUnifierMod
{
	[BepInPlugin("Saevin.ReimuUnifierMod", "ReimuUnifier", "0.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		public static string modUniqueID = "ReimuUnifierMod";

		public static string playerName = "ReimuAlt";

		public static bool useInGameModel = true;

		public static string modelName = "Reimu";

		public static bool modelIsFlipped = false;

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

		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("Saevin.ReimuUnifierMod", "");

		private void Awake()
		{
			log = ((BaseUnityPlugin)this).Logger;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			CardIndexGenerator.PromiseClearIndexSet();
			EntityManager.RegisterSelf();
			harmony.PatchAll();
			if (Chainloader.PluginInfos.ContainsKey("neo.lbol.tools.watermark"))
			{
				WatermarkWrapper.ActivateWatermark();
			}
			Func<Sprite> func = () => ResourceLoader.LoadSprite("BossIcon.png", (IResourceSource)(object)directorySource, (Rect?)null, 1, (Vector2?)null);
		}

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

		public const string Name = "ReimuUnifier";

		public const string version = "0.0.1";

		public static readonly Harmony harmony = new Harmony("Saevin.ReimuUnifierMod");
	}
	public class ReimuUnifierLoadouts
	{
		public static string UltimateSkillA = "ReimuUnifierUltA";

		public static string UltimateSkillB = "ReimuUnifierUltB";

		public static string ExhibitA = "ReimuUnifierExhibitA";

		public static string ExhibitB = "ReimuUnifierExhibitB";

		public static List<string> DeckA = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "ReimuUnifierAttackR", "ReimuUnifierAttackR", "ReimuUnifierBlockW", "ReimuUnifierBlockW", "MarisaKirisameFriend", "CoordinatedStrike" };

		public static List<string> DeckB = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "ReimuUnifierAttackW", "ReimuUnifierAttackW", "ReimuUnifierBlockR", "ReimuUnifierBlockR", "YukariYakumoFriend", "ReinforcedBoundary" };

		public static PlayerUnitConfig playerUnitConfig;

		static ReimuUnifierLoadouts()
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			string modUniqueID = BepinexPlugin.modUniqueID;
			int? num = 0;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).White = 2;
			((ManaGroup)(ref val)).Blue = 0;
			((ManaGroup)(ref val)).Black = 0;
			((ManaGroup)(ref val)).Red = 2;
			((ManaGroup)(ref val)).Green = 0;
			((ManaGroup)(ref val)).Colorless = 0;
			((ManaGroup)(ref val)).Philosophy = 0;
			ManaGroup val2 = val;
			playerUnitConfig = new PlayerUnitConfig(modUniqueID, true, "", 0, 8, num, true, (int?)null, (ManaColor)4, (ManaColor)1, val2, "#e58c27", 80, 20, 0, UltimateSkillA, UltimateSkillB, ExhibitA, ExhibitB, (IReadOnlyList<string>)DeckA, (IReadOnlyList<string>)DeckB, 2, 1);
		}
	}
	public sealed class ReimuUnifierModDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(ReimuUnifierModDef))]
		public sealed class ReimuUnifierMod : PlayerUnit
		{
		}

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

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

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

		public override PlayerUnitConfig MakeConfig()
		{
			return ReimuUnifierLoadouts.playerUnitConfig;
		}
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace ReimuUnifierMod.ReimuUnifierUlt
{
	public sealed class ReimuUnifierUltADef : ReimuUnifierUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.RelativeCards = new List<string> { "MarisaKirisameFriend" };
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierUltADef))]
	public sealed class ReimuUnifierUltA : UltimateSkill
	{
		public ManaGroup ManaPreview => ManaGroup.Empty;

		public ReimuUnifierUltA()
		{
			((UltimateSkill)this).TargetType = (TargetType)0;
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			yield return (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)this).Owner, "ReimuUnifierUltA");
			Card MarisaToTheRescue = (Card)(object)Library.CreateCard<MarisaKirisameFriend>();
			MarisaToTheRescue.Loyalty = 9;
			MarisaToTheRescue.SetTurnCost(ManaPreview);
			yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { MarisaToTheRescue });
		}
	}
	public sealed class ReimuUnifierUltBDef : ReimuUnifierUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.RelativeEffects = new List<string> { "Invincible" };
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierUltBDef))]
	public sealed class ReimuUnifierUltB : UltimateSkill
	{
		public ReimuUnifierUltB()
		{
			((UltimateSkill)this).TargetType = (TargetType)0;
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			yield return (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)this).Owner, "ReimuUnifierUltB");
			yield return (BattleAction)(object)new ApplyStatusEffectAction<Invincible>((Unit)(object)((UltimateSkill)this).Battle.Player, (int?)0, (int?)1, (int?)null, (int?)null, 0f, true);
			if (((Unit)((UltimateSkill)this).Battle.Player).HasStatusEffect<Weak>())
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)((Unit)((UltimateSkill)this).Battle.Player).GetStatusEffect<Weak>(), true, 0.1f);
			}
			if (((Unit)((UltimateSkill)this).Battle.Player).HasStatusEffect<Vulnerable>())
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)((Unit)((UltimateSkill)this).Battle.Player).GetStatusEffect<Vulnerable>(), true, 0.1f);
			}
			if (((Unit)((UltimateSkill)this).Battle.Player).HasStatusEffect<Fragil>())
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)((Unit)((UltimateSkill)this).Battle.Player).GetStatusEffect<Fragil>(), true, 0.1f);
			}
		}
	}
	public class ReimuUnifierUltTemplate : UltimateSkillTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(ReimuUnifierDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

		public override UltimateSkillConfig MakeConfig()
		{
			throw new NotImplementedException();
		}

		public UltimateSkillConfig GetDefaulUltConfig()
		{
			return ReimuUnifierDefaultConfig.DefaultUltConfig();
		}
	}
}
namespace ReimuUnifierMod.StatusEffects
{
	public sealed class FakeCuriositySeDef : ReimuUnifierStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(FakeCuriositySeDef))]
	public sealed class FakeCuriositySe : StatusEffect
	{
	}
	public sealed class FakeSealedSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(FakeSealedSeDef))]
	public sealed class FakeSealedSe : StatusEffect
	{
	}
	public sealed class TeamUpSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(TeamUpSeDef))]
	public sealed class TeamUpSe : StatusEffect
	{
	}
	public sealed class ReimuUnifierAunnProtectionSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierAunnProtectionSeDef))]
	public sealed class ReimuUnifierAunnProtectionSe : StatusEffect
	{
		private int ActiveTimes { get; set; }

		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_004b: Unknown result type (might be due to invalid IL or missing references)
			DamageInfo damageInfo = args.DamageInfo;
			int num = MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage);
			if (num >= 1 && ActiveTimes < ((StatusEffect)this).Level)
			{
				((StatusEffect)this).NotifyActivating();
				int activeTimes = ActiveTimes + 1;
				ActiveTimes = activeTimes;
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).ReduceActualDamageBy(num);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
		}

		private IEnumerable<BattleAction> OnPlayerDamageReceived(DamageEventArgs args)
		{
			((StatusEffect)this).Level = ((StatusEffect)this).Level - ActiveTimes;
			ActiveTimes = 0;
			if (((StatusEffect)this).Level <= 0)
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
			}
		}
	}
	public sealed class ReimuUnifierAyaDominanceSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.LevelStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierAyaDominanceSeDef))]
	public sealed class ReimuUnifierAyaDominanceSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			ReimuUnifierAyaDominanceSe ReimuUnifierAyaDominanceSe = this;
			if (!((StatusEffect)ReimuUnifierAyaDominanceSe).Battle.BattleShouldEnd && ((StatusEffect)this).Battle.AllAliveEnemies.Count() > 0)
			{
				EnemyUnit target = CollectionsExtensions.SampleOrDefault<EnemyUnit>(((StatusEffect)this).Battle.EnemyGroup.Alives, ((StatusEffect)this).Battle.GameRun.BattleRng);
				yield return (BattleAction)new DamageAction((Unit)(object)((StatusEffect)this).Battle.Player, (Unit)(object)target, DamageInfo.Reaction((float)((StatusEffect)this).Level, false), "新闻", (GunType)0);
			}
		}
	}
	public sealed class ReimuUnifierBattleFeverSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierBattleFeverSeDef))]
	public sealed class ReimuUnifierBattleFeverSe : StatusEffect
	{
		private ManaGroup SePreviewMana => ManaGroup.Reds(((StatusEffect)this).Level);

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<TeamUpEventArgs>(CustomGameEventManager.TeamUpSuccess, (EventSequencedReactor<TeamUpEventArgs>)OnTeamUp);
		}

		private IEnumerable<BattleAction> OnTeamUp(TeamUpEventArgs args)
		{
			if (!((StatusEffect)this).Battle.BattleShouldEnd)
			{
				ManaGroup val = default(ManaGroup);
				((ManaGroup)(ref val)).Red = ((StatusEffect)this).Level;
				yield return (BattleAction)new GainManaAction(val);
			}
		}
	}
	public sealed class ReimuUnifierCoordinatedPursuitSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.LevelStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierCoordinatedPursuitSeDef))]
	public sealed class ReimuUnifierCoordinatedPursuitSe : StatusEffect
	{
		private ManaGroup SePreviewMana => ManaGroup.Anys(0);

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

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			ReimuUnifierCoordinatedPursuitSe ReimuUnifierCoordinatedPursuitSe = this;
			if (!((StatusEffect)ReimuUnifierCoordinatedPursuitSe).Battle.BattleShouldEnd)
			{
				Card card = args.Card;
				if ((int)card.CardType == 5 && !card.Summoning)
				{
					((StatusEffect)ReimuUnifierCoordinatedPursuitSe).NotifyActivating();
					yield return ((StatusEffect)this).BuffAction<ReimuFreeAttackSe>(((StatusEffect)this).Level, 0, 0, 0, 0.2f);
				}
			}
		}
	}
	public sealed class ReimuUnifierDanmakuCollisionSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierDanmakuCollisionSeDef))]
	public sealed class ReimuUnifierDanmakuCollisionSe : StatusEffect
	{
		public int SummonedTeammatesInHand
		{
			get
			{
				try
				{
					return ((StatusEffect)this).Battle.HandZone.Count((Card card) => (int)card.CardType == 5 && card.Summoned);
				}
				catch
				{
					return 0;
				}
			}
		}

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
		}

		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			yield return (BattleAction)new CastBlockShieldAction((Unit)(object)((StatusEffect)this).Battle.Player, ((StatusEffect)this).Level * SummonedTeammatesInHand, 0, (BlockShieldType)2, false);
		}
	}
	public sealed class ReimuUnifierDarknessOfTheCrowSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierDarknessOfTheCrowSeDef))]
	public sealed class ReimuUnifierDarknessOfTheCrowSe : StatusEffect
	{
		private string GunName => (((StatusEffect)this).Level <= 20) ? "无差别起火" : "无差别起火B";

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
			((StatusEffect)this).ReactOwnerEvent<DamageEventArgs>(((Unit)((StatusEffect)this).Battle.Player).DamageReceived, (EventSequencedReactor<DamageEventArgs>)OnPlayerDamageReceived);
		}

		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			if (!((StatusEffect)this).Battle.BattleShouldEnd && ((StatusEffect)this).Battle.EnemyGroup.Alives != null)
			{
				((StatusEffect)this).NotifyActivating();
				yield return (BattleAction)new DamageAction(((StatusEffect)this).Owner, (IEnumerable<Unit>)((StatusEffect)this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)((StatusEffect)this).Level, false), GunName, (GunType)0);
			}
		}

		private IEnumerable<BattleAction> OnPlayerDamageReceived(DamageEventArgs args)
		{
			DamageInfo damageInfo = args.DamageInfo;
			if (((DamageInfo)(ref damageInfo)).IsGrazed && !((StatusEffect)this).Battle.BattleShouldEnd && ((StatusEffect)this).Battle.EnemyGroup.Alives != null)
			{
				<>n__0();
				yield return (BattleAction)new DamageAction(((StatusEffect)this).Owner, (IEnumerable<Unit>)((StatusEffect)this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)((StatusEffect)this).Level, false), GunName, (GunType)0);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class ReimuUnifierDimensionalRiftBoundarySeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			defaultStatusEffectConfig.LevelStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierDimensionalRiftBoundarySeDef))]
	public sealed class ReimuUnifierDimensionalRiftBoundarySe : StatusEffect
	{
		private string GunName
		{
			get
			{
				if (((StatusEffect)this).Level <= 10)
				{
					return "闭目射击";
				}
				return "闭目射击B";
			}
		}

		private ManaGroup SePreviewMana => ManaGroup.Reds(((StatusEffect)this).Count);

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardEventArgs>(((StatusEffect)this).Battle.CardDrawn, (EventSequencedReactor<CardEventArgs>)OnCardDrawn);
			((StatusEffect)this).ReactOwnerEvent<CardMovingEventArgs>(((StatusEffect)this).Battle.CardMoved, (EventSequencedReactor<CardMovingEventArgs>)OnCardMoved);
		}

		private IEnumerable<BattleAction> OnCardDrawn(CardEventArgs args)
		{
			if (!((StatusEffect)this).Battle.BattleShouldEnd && ((StatusEffect)this).Battle.EnemyGroup.Alives != null)
			{
				CardType cardType = args.Card.CardType;
				if ((int)cardType == 5)
				{
					<>n__0();
					yield return (BattleAction)new DamageAction((Unit)(object)((StatusEffect)this).Battle.Player, (IEnumerable<Unit>)((StatusEffect)this).Battle.AllAliveEnemies, DamageInfo.Reaction((float)((StatusEffect)this).Level, false), GunName, (GunType)0);
				}
			}
		}

		private IEnumerable<BattleAction> OnCardMoved(CardMovingEventArgs args)
		{
			if (!((StatusEffect)this).Battle.BattleShouldEnd && ((StatusEffect)this).Battle.EnemyGroup.Alives != null && (int)args.DestinationZone == 3)
			{
				CardType cardType = args.Card.CardType;
				if ((int)cardType == 5 && args.Card.Summoned)
				{
					<>n__0();
					ManaGroup val = default(ManaGroup);
					((ManaGroup)(ref val)).Red = ((StatusEffect)this).Count;
					yield return (BattleAction)new GainManaAction(val);
				}
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class ReimuUnifierDivineForgeSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierDivineForgeSeDef))]
	public sealed class ReimuUnifierDivineForgeSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			yield return (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<YoukaiForgedNeedle>(((StatusEffect)this).Level, false), (AddCardsType)0);
		}
	}
	public sealed class ReimuUnifierDuplexBarrierDanmakuMirrorSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.LevelStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierDuplexBarrierDanmakuMirrorSeDef))]
	public sealed class ReimuUnifierDuplexBarrierDanmakuMirrorSe : StatusEffect
	{
		private ManaGroup SePreviewMana => ManaGroup.Anys(0);

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

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			ReimuUnifierDuplexBarrierDanmakuMirrorSe ReimuUnifierDuplexBarrierDanmakuMirrorSe = this;
			if (!((StatusEffect)ReimuUnifierDuplexBarrierDanmakuMirrorSe).Battle.BattleShouldEnd)
			{
				Card card = args.Card;
				if ((int)card.CardType == 5 && card.Summoning && !card.IsCopy)
				{
					((StatusEffect)ReimuUnifierDuplexBarrierDanmakuMirrorSe).NotifyActivating();
					Card Copy = card.CloneBattleCard();
					Copy.IsCopy = true;
					Copy.SetTurnCost(ManaGroup.Empty);
					Copy.SetKeyword((Keyword)524288, true);
					yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Copy });
				}
			}
		}

		private IEnumerable<BattleAction> OnTurnStarted(UnitEventArgs args)
		{
			List<Card> TeammatesInHand = ((StatusEffect)this).Battle.HandZone.Where((Card card) => (int)card.CardType == 5 && card.Summoned).ToList();
			((StatusEffect)this).NotifyActivating();
			foreach (Card card2 in TeammatesInHand)
			{
				card2.NotifyActivating();
				int loyalty = card2.Loyalty;
				card2.Loyalty = loyalty + 1;
			}
			yield break;
		}
	}
	public sealed class ReimuUnifierEmotionalBoundarySynchronizationSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierEmotionalBoundarySynchronizationSeDef))]
	public sealed class ReimuUnifierEmotionalBoundarySynchronizationSe : 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 (((StatusEffect)this).Battle.BattleShouldEnd)
			{
				yield break;
			}
			Card card = args.Card;
			if ((int)card.CardType != 5 || card.Summoning)
			{
				yield break;
			}
			<>n__0();
			List<Card> TeammatesInHand = ((StatusEffect)this).Battle.HandZone.Where((Card Hand) => (int)Hand.CardType == 5).ToList();
			foreach (Card Teammate in TeammatesInHand)
			{
				Teammate.NotifyActivating();
				Teammate.Loyalty += 1;
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class ReimuUnifierFantasySealDreamfiniteSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.IsStackable = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierFantasySealDreamfiniteSeDef))]
	public sealed class ReimuUnifierFantasySealDreamfiniteSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			for (int i = 0; i < ((StatusEffect)this).Count; i++)
			{
				EnemyUnit target = CollectionsExtensions.SampleOrDefault<EnemyUnit>(((StatusEffect)this).Battle.EnemyGroup.Alives, ((StatusEffect)this).Battle.GameRun.BattleRng);
				yield return (BattleAction)new DamageAction((Unit)(object)((StatusEffect)this).Battle.Player, (Unit)(object)target, DamageInfo.Reaction((float)((StatusEffect)this).Level, false), "退魔符乱舞", (GunType)0);
			}
		}
	}
	public sealed class ReimuUnifierFlowerViewingPartySeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			defaultStatusEffectConfig.LevelStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierFlowerViewingPartySeDef))]
	public sealed class ReimuUnifierFlowerViewingPartySe : StatusEffect
	{
		private ManaGroup SePreviewMana => ManaGroup.Colorlesses(1);

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

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

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			ReimuUnifierFlowerViewingPartySe ReimuUnifierFlowerViewingPartySe = this;
			if (((StatusEffect)ReimuUnifierFlowerViewingPartySe).Battle.BattleShouldEnd)
			{
				yield break;
			}
			Card card = args.Card;
			if ((int)card.CardType == 5 && card.Summoning)
			{
				((StatusEffect)ReimuUnifierFlowerViewingPartySe).NotifyActivating();
				yield return (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<SummerFlower>(((StatusEffect)this).Level, false), (AddCardsType)0);
				if (((StatusEffect)this).Count > 0)
				{
					yield return (BattleAction)new GainManaAction(ManaGroup.Single((ManaColor)6));
					int count = ((StatusEffect)this).Count;
					((StatusEffect)this).Count = count - 1;
				}
			}
		}
	}
	public sealed class ReimuUnifierInnateDreamCounterSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.LevelStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierInnateDreamCounterSeDef))]
	public sealed class ReimuUnifierInnateDreamCounterSe : StatusEffect
	{
	}
	public sealed class ReimuUnifierNeedleSparkSealSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = false;
			defaultStatusEffectConfig.HasDuration = false;
			defaultStatusEffectConfig.HasLevel = false;
			defaultStatusEffectConfig.IsStackable = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierNeedleSparkSealSeDef))]
	public sealed class ReimuUnifierNeedleSparkSealSe : StatusEffect
	{
	}
	public sealed class ReimuUnifierNextAttackAccurateSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierNextAttackAccurateSeDef))]
	public sealed class ReimuUnifierNextAttackAccurateSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DamageDealingEventArgs>(((Unit)((StatusEffect)this).Battle.Player).DamageDealing, (GameEventHandler<DamageDealingEventArgs>)OnDamageDealing);
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsing);
		}

		private void OnDamageDealing(DamageDealingEventArgs args)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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)
			GameEntity actionSource = ((GameEventArgs)args).ActionSource;
			Card val = (Card)(object)((actionSource is Card) ? actionSource : null);
			if (val != null && (int)val.Config.Type == 1)
			{
				DamageInfo damageInfo = args.DamageInfo;
				if (!((DamageInfo)(ref damageInfo)).IsAccuracy)
				{
					DamageInfo damageInfo2 = args.DamageInfo;
					((DamageInfo)(ref damageInfo2)).IsAccuracy = true;
					args.DamageInfo = damageInfo2;
					((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				}
			}
		}

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class ReimuUnifierNitoriLochNessSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierNitoriLochNessSeDef))]
	public sealed class ReimuUnifierNitoriLochNessSe : StatusEffect
	{
		private int SePreviewTurns => ((StatusEffect)this).Level * ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
		}

		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			if (!((StatusEffect)this).Battle.BattleShouldEnd && ((StatusEffect)this).Battle.EnemyGroup.Alives != null)
			{
				((StatusEffect)this).NotifyActivating();
				yield return (BattleAction)new DamageAction(((StatusEffect)this).Owner, (IEnumerable<Unit>)((StatusEffect)this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)((StatusEffect)this).Level * (float)((Unit)((StatusEffect)this).Battle.Player).TurnCounter, false), "溺水B", (GunType)0);
			}
		}
	}
	public sealed class ReimuUnifierOccultBallSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasLevel = false;
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierOccultBallSeDef))]
	public sealed class ReimuUnifierOccultBallSe : StatusEffect
	{
	}
	public sealed class ReimuUnifierOmnidirectionalBarrageSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierOmnidirectionalBarrageSeDef))]
	public sealed class ReimuUnifierOmnidirectionalBarrageSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<TeamUpEventArgs>(CustomGameEventManager.TeamUpSuccess, (EventSequencedReactor<TeamUpEventArgs>)OnTeamUp);
		}

		private IEnumerable<BattleAction> OnTeamUp(TeamUpEventArgs args)
		{
			if (((StatusEffect)this).Battle.BattleShouldEnd || args.TeamUpCard.GetPassiveActions() == null || args.TeamUpCard.GetPassiveActions().Count() <= 0)
			{
				yield break;
			}
			for (int i = 0; i < ((StatusEffect)this).Level; i++)
			{
				foreach (BattleAction passiveAction in args.TeamUpCard.GetPassiveActions())
				{
					yield return passiveAction;
				}
			}
		}
	}
	public sealed class ReimuUnifierOnHitTempFPSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierOnHitTempFPSeDef))]
	public sealed class ReimuUnifierOnHitTempFPSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatisticalDamageEventArgs>(((StatusEffect)this).Owner.StatisticalTotalDamageReceived, (EventSequencedReactor<StatisticalDamageEventArgs>)OnStatisticalDamageReceived);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnStatisticalDamageReceived(StatisticalDamageEventArgs args)
		{
			if (args.DamageSource != ((StatusEffect)this).Owner)
			{
				((StatusEffect)this).NotifyActivating();
				yield return ((StatusEffect)this).BuffAction<TempFirepower>(((StatusEffect)this).Level, 0, 0, 0, 0.2f);
			}
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class ReimuUnifierPCBReflectSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierPCBReflectSeDef))]
	public sealed class ReimuUnifierPCBReflectSe : StatusEffect
	{
	}
	public sealed class ReimuUnifierPerfectCherryBorderSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierPerfectCherryBorderSeDef))]
	public sealed class ReimuUnifierPerfectCherryBorderSe : StatusEffect
	{
		private int ActiveTimes { get; set; }

		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_004b: Unknown result type (might be due to invalid IL or missing references)
			DamageInfo damageInfo = args.DamageInfo;
			int num = MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage);
			if (num >= 1 && ActiveTimes < ((StatusEffect)this).Level)
			{
				((StatusEffect)this).NotifyActivating();
				int activeTimes = ActiveTimes + 1;
				ActiveTimes = activeTimes;
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).ReduceActualDamageBy(num);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				if (((Unit)((StatusEffect)this).Battle.Player).HasStatusEffect<ReimuUnifierPCBReflectSe>())
				{
					((StatusEffect)((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<ReimuUnifierPCBReflectSe>()).NotifyActivating();
					ReimuUnifierPCBReflectSe statusEffect = ((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<ReimuUnifierPCBReflectSe>();
					((StatusEffect)statusEffect).Count = ((StatusEffect)statusEffect).Count + num;
				}
			}
		}

		private IEnumerable<BattleAction> OnPlayerDamageReceived(DamageEventArgs args)
		{
			if (((Unit)((StatusEffect)this).Battle.Player).HasStatusEffect<ReimuUnifierPCBReflectSe>() && ((StatusEffect)((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<ReimuUnifierPCBReflectSe>()).Count != 0)
			{
				foreach (EnemyUnit enemy in ((StatusEffect)this).Battle.AllAliveEnemies)
				{
					yield return (BattleAction)(object)DamageAction.LoseLife((Unit)(object)enemy, ((StatusEffect)((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<ReimuUnifierPCBReflectSe>()).Count, "Instant");
				}
				((StatusEffect)((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<ReimuUnifierPCBReflectSe>()).Count = 0;
				ReimuUnifierPCBReflectSe statusEffect = ((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<ReimuUnifierPCBReflectSe>();
				((StatusEffect)statusEffect).Level = ((StatusEffect)statusEffect).Level - ActiveTimes;
				if (((StatusEffect)((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<ReimuUnifierPCBReflectSe>()).Level <= 0)
				{
					yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<ReimuUnifierPCBReflectSe>(), true, 0.1f);
				}
			}
			((StatusEffect)this).Level = ((StatusEffect)this).Level - ActiveTimes;
			ActiveTimes = 0;
			if (((StatusEffect)this).Level <= 0)
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
			}
		}
	}
	public sealed class ReimuUnifierRabbleRousingSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasLevel = false;
			defaultStatusEffectConfig.HasDuration = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierRabbleRousingSeDef))]
	public sealed class ReimuUnifierRabbleRousingSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			List<Card> PossibleCards = new List<Card>
			{
				Library.CreateCard("MarisaKirisameFriend"),
				Library.CreateCard("YukariYakumoFriend"),
				Library.CreateCard("KogasaYoukaiBlacksmithFriend")
			};
			yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { CollectionsExtensions.Sample<Card>((IEnumerable<Card>)PossibleCards, ((GameEntity)this).GameRun.BattleRng) });
			((StatusEffect)this).Duration = ((StatusEffect)this).Duration - 1;
			if (((StatusEffect)this).Duration <= 0)
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
			}
		}
	}
	public sealed class ReimuUnifierRetributiveBoundarySeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierRetributiveBoundarySeDef))]
	public sealed class ReimuUnifierRetributiveBoundarySe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatisticalDamageEventArgs>(((StatusEffect)this).Owner.StatisticalTotalDamageReceived, (EventSequencedReactor<StatisticalDamageEventArgs>)OnStatisticalDamageReceived);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnStatisticalDamageReceived(StatisticalDamageEventArgs args)
		{
			if (args.DamageSource != ((StatusEffect)this).Owner)
			{
				((StatusEffect)this).NotifyActivating();
				for (int i = 0; i < ((StatusEffect)this).Level; i++)
				{
					yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YoukaiForgedNeedle>() });
				}
			}
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class ReimuUnifierRetributiveBoundaryUpgSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierRetributiveBoundaryUpgSeDef))]
	public sealed class ReimuUnifierRetributiveBoundaryUpgSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatisticalDamageEventArgs>(((StatusEffect)this).Owner.StatisticalTotalDamageReceived, (EventSequencedReactor<StatisticalDamageEventArgs>)OnStatisticalDamageReceived);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnStatisticalDamageReceived(StatisticalDamageEventArgs args)
		{
			if (args.DamageSource != ((StatusEffect)this).Owner)
			{
				((StatusEffect)this).NotifyActivating();
				for (int i = 0; i < ((StatusEffect)this).Level; i++)
				{
					yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YoukaiForgedNeedle>(true) });
				}
			}
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class ReimuUnifierRisingSynergySeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.LevelStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierRisingSynergySeDef))]
	public sealed class ReimuUnifierRisingSynergySe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatisticalDamageEventArgs>(((StatusEffect)this).Owner.StatisticalTotalDamageDealt, (EventSequencedReactor<StatisticalDamageEventArgs>)OnStatisticalDamageDealt);
		}

		private IEnumerable<BattleAction> OnStatisticalDamageDealt(StatisticalDamageEventArgs args)
		{
			if (args.DamageSource == ((StatusEffect)this).Owner && ((GameEventArgs)args).ActionSource is Card)
			{
				Card CardDamageSource = (Card)((GameEventArgs)args).ActionSource;
				if ((int)CardDamageSource.CardType == 5)
				{
					((StatusEffect)this).NotifyActivating();
					yield return ((StatusEffect)this).BuffAction<TempFirepower>(((StatusEffect)this).Level, 0, 0, 0, 0.2f);
				}
			}
		}
	}
	public sealed class ReimuUnifierRitualofEchoingProsperitySeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierRitualofEchoingProsperitySeDef))]
	public sealed class ReimuUnifierRitualofEchoingProsperitySe : StatusEffect
	{
		public int SummonedTeammatesInHand
		{
			get
			{
				try
				{
					return ((StatusEffect)this).Battle.HandZone.Count((Card card) => (int)card.CardType == 5 && card.Summoned);
				}
				catch
				{
					return 0;
				}
			}
		}

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			if (SummonedTeammatesInHand > 0)
			{
				yield return ((StatusEffect)this).BuffAction<TempFirepower>(((StatusEffect)this).Level * SummonedTeammatesInHand, 0, 0, 0, 0.2f);
				yield return ((StatusEffect)this).BuffAction<TempSpirit>(((StatusEffect)this).Level * SummonedTeammatesInHand, 0, 0, 0, 0.2f);
			}
		}
	}
	public sealed class ReimuUnifierSubterraneanAdventureSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasLevel = false;
			defaultStatusEffectConfig.IsStackable = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierSubterraneanAdventureSeDef))]
	public sealed class ReimuUnifierSubterraneanAdventureSe : StatusEffect
	{
		public int MaxHand => 12;

		protected override void OnAdded(Unit unit)
		{
			if (((StatusEffect)this).Battle.MaxHand < 12)
			{
				((StatusEffect)this).Battle.MaxHand = MaxHand;
			}
		}
	}
	public sealed class ReimuUnifierSumirekoDoppelgangerSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasLevel = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierSumirekoDoppelgangerSeDef))]
	public sealed class ReimuUnifierSumirekoDoppelgangerSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarting, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarting);
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsing, (EventSequencedReactor<CardUsingEventArgs>)OnOwnerCardUsing);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarting(UnitEventArgs args)
		{
			if (!((StatusEffect)this).Battle.BattleShouldEnd && ((StatusEffect)this).Battle.EnemyGroup.Alives != null)
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
			}
		}

		private IEnumerable<BattleAction> OnOwnerCardUsing(CardUsingEventArgs args)
		{
			args.PlayTwice = true;
			((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			yield break;
		}
	}
	public sealed class ReimuUnifierWilyBeastStrikeSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.IsStackable = true;
			defaultStatusEffectConfig.LevelStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierWilyBeastStrikeSeDef))]
	public sealed class ReimuUnifierWilyBeastStrikeSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsing, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsing);
		}

		private IEnumerable<BattleAction> OnCardUsing(CardUsingEventArgs args)
		{
			ReimuUnifierWilyBeastStrikeSe WilyBeastStrikeSe = this;
			if (((StatusEffect)WilyBeastStrikeSe).Battle.BattleShouldEnd)
			{
				yield break;
			}
			Card card = args.Card;
			if ((int)card.CardType == 5 && card.Summoned)
			{
				((StatusEffect)WilyBeastStrikeSe).NotifyActivating();
				args.PlayTwice = true;
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				int level = ((StatusEffect)this).Level;
				((StatusEffect)this).Level = level - 1;
				if (((StatusEffect)this).Level <= 0)
				{
					yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
				}
			}
		}
	}
	public sealed class ReimuUnifierYukariArcanumSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.IsStackable = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierYukariArcanumSeDef))]
	public sealed class ReimuUnifierYukariArcanumSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			int count = ((StatusEffect)this).Count;
			((StatusEffect)this).Count = count - 1;
			if (((StatusEffect)this).Count <= 0)
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
			}
		}

		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			yield return (BattleAction)new CastBlockShieldAction((Unit)(object)((StatusEffect)this).Battle.Player, 0, ((StatusEffect)this).Level, (BlockShieldType)2, false);
			EnemyUnit target = CollectionsExtensions.SampleOrDefault<EnemyUnit>(((StatusEffect)this).Battle.EnemyGroup.Alives, ((StatusEffect)this).Battle.GameRun.BattleRng);
			yield return (BattleAction)new DamageAction((Unit)(object)((StatusEffect)this).Battle.Player, (Unit)(object)target, DamageInfo.Reaction((float)((Unit)((StatusEffect)this).Battle.Player).Shield, false), "结界猛击", (GunType)0);
		}
	}
	public sealed class ReimuUnifierYukariLifeLossSeDef : ReimuUnifierStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return ReimuUnifierStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(ReimuUnifierYukariLifeLossSeDef))]
	public sealed class ReimuUnifierYukariLifeLossSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			foreach (EnemyUnit enemy in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				yield return (BattleAction)(object)DamageAction.LoseLife((Unit)(object)enemy, ((StatusEffect)this).Level, "Instant");
			}
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public class ReimuUnifierStatusEffectTemplate : 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(ReimuUnifierDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public static StatusEffectConfig GetDefaultStatusEffectConfig()
		{
			return ReimuUnifierDefaultConfig.DefaultStatusEffectConfig();
		}
	}
}
namespace ReimuUnifierMod.Patches
{
	[HarmonyPatch]
	internal class CustomGameEventManager
	{
		public static GameEvent<TeamUpEventArgs> TeamUpSuccess { get; set; }

		[HarmonyPatch(typeof(GameRunController), "EnterBattle")]
		private static bool Prefix(GameRunController __instance)
		{
			TeamUpSuccess = new GameEvent<TeamUpEventArgs>();
			return true;
		}
	}
}
namespace ReimuUnifierMod.model
{
	public sealed class ReimuUnifierModel : UnitModelTemplate
	{
		public static bool useInGameModel = BepinexPlugin.useInGameModel;

		public static string model_name = (useInGameModel ? BepinexPlugin.modelName : "ReimuUnifierModel.png");

		public static string spellsprite_name = "ReimuUnifierStand.png";

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

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

		public override ModelOption LoadModelOptions()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			if (useInGameModel)
			{
				return new ModelOption(ResourcesHelper.LoadSpineUnitAsync(model_name));
			}
			return new ModelOption(ResourceLoader.LoadSpriteAsync(model_name, BepinexPlugin.directorySource, 565, (GraphicsFormat)4, 1, (FilterMode)1, (SpriteMeshType)1, (Rect?)null, (Vector2?)null, "file://"));
		}

		public override UniTask<Sprite> LoadSpellSprite()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (useInGameModel)
			{
				return ResourcesHelper.LoadSpellPortraitAsync(model_name);
			}
			return ResourceLoader.LoadSpriteAsync(spellsprite_name, BepinexPlugin.directorySource, 100, (GraphicsFormat)4, 1, (FilterMode)1, (SpriteMeshType)1, (Rect?)null, (Vector2?)null, "file://");
		}

		public override UnitModelConfig MakeConfig()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (useInGameModel)
			{
				UnitModelConfig val = ObjectExtensions.Copy<UnitModelConfig>(UnitModelConfig.FromName(model_name));
				val.Flip = BepinexPlugin.modelIsFlipped;
				return val;
			}
			UnitModelConfig val2 = ObjectExtensions.Copy<UnitModelConfig>(((UnitModelTemplate)this).DefaultConfig());
			val2.Flip = BepinexPlugin.modelIsFlipped;
			val2.Type = 0;
			val2.Offset = new Vector2(0f, -0.1f);
			val2.HasSpellPortrait = true;
			return val2;
		}
	}
}
namespace ReimuUnifierMod.Localization
{
	public sealed class ReimuUnifierLocalization
	{
		public static string Cards = "Cards";

		public static string Exhibits = "Exhibits";

		public static string PlayerUnit = "PlayerUnit";

		public static string EnemiesUnit = "EnemyUnit";

		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 EnemiesUnitBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(EnemyUnitTemplate), EnemiesUnit, (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);

		public static void Init()
		{
			CardsBatchLoc.DiscoverAndLoadLocFiles(Cards);
			ExhibitsBatchLoc.DiscoverAndLoadLocFiles(Exhibits);
			PlayerUnitBatchLoc.DiscoverAndLoadLocFiles(PlayerUnit);
			EnemiesUnitBatchLoc.DiscoverAndLoadLocFiles(EnemiesUnit);
			UnitModelBatchLoc.DiscoverAndLoadLocFiles(UnitModel);
			UltimateSkillsBatchLoc.DiscoverAndLoadLocFiles(UltimateSkills);
			StatusEffectsBatchLoc.DiscoverAndLoadLocFiles(StatusEffects);
		}
	}
}
namespace ReimuUnifierMod.ImageLoader
{
	public sealed class ReimuUnifierImageLoader
	{
		public static string file_extension = ".png";

		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)BepinexPlugin.directorySource, 100, 1, (FilterMode)1, true, (Rect?)null, (Vector2?)null)), (Func<string, UniTask<Sprite>>)((string s) => ResourceLoader.LoadSpriteAsync(s, BepinexPlugin.directorySource, 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, file_extension, "", 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()) + file_extension, 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());
		}

		public 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) + file_extension, BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null);
		}
	}
}
namespace ReimuUnifierMod.GunName
{
	public static class GunNameID
	{
		private static IReadOnlyList<GunConfig> gunConfig = GunConfig.AllConfig();

		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 ReimuUnifierMod.Exhibits
{
	public sealed class ReimuUnifierExhibitADef : ReimuUnifierExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.Value1 = 2;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Red = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)4;
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierExhibitADef))]
	public sealed class ReimuUnifierExhibitA : ShiningExhibit
	{
		public ManaGroup Mana2 { get; } = ManaGroup.Reds(2);


		protected override void OnEnterBattle()
		{
			((Exhibit)this).Counter = 0;
			((Exhibit)this).Active = true;
			((Exhibit)this).ReactBattleEvent<CardUsingEventArgs>(((Exhibit)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if (!((Exhibit)this).Battle.BattleShouldEnd && ((Exhibit)this).Counter != 1 && (int)args.Card.CardType == 5 && args.Card.Summoning)
			{
				<>n__0();
				yield return (BattleAction)new GainManaAction(ManaGroup.Reds(((Exhibit)this).Value1));
				((Exhibit)this).Counter = 1;
				((Exhibit)this).Blackout = true;
				((Exhibit)this).Active = false;
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
	public sealed class ReimuUnifierExhibitBDef : ReimuUnifierExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).White = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)1;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(ReimuUnifierExhibitBDef))]
	public sealed class ReimuUnifierExhibitB : ShiningExhibit
	{
		public int SummonedTeammatesInHand
		{
			get
			{
				try
				{
					return ((Exhibit)this).Battle.HandZone.Count((Card card) => (int)card.CardType == 5 && card.Summoned);
				}
				catch
				{
					return 0;
				}
			}
		}

		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnEnded);
		}

		private IEnumerable<BattleAction> OnPlayerTurnEnded(UnitEventArgs args)
		{
			if (SummonedTeammatesInHand > 0)
			{
				yield return (BattleAction)new CastBlockShieldAction((Unit)(object)((Exhibit)this).Battle.Player, SummonedTeammatesInHand, 0, (BlockShieldType)2, false);
			}
		}
	}
	public class ReimuUnifierExhibitTemplate : ExhibitTemplate
	{
		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(ReimuUnifierDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public ExhibitConfig GetDefaultExhibitConfig()
		{
			return ReimuUnifierDefaultConfig.DefaultExhibitConfig();
		}
	}
}
namespace ReimuUnifierMod.Enemies.Template
{
	public abstract class ReimuUnifierEnemyGroupTemplate : EnemyGroupTemplate
	{
		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(ReimuUnifierDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override EnemyGroupConfig MakeConfig()
		{
			return ReimuUnifierDefaultConfig.EnemyGroupDefaultConfig();
		}

		public EnemyGroupConfig GetEnemyGroupDefaultConfig()
		{
			return ReimuUnifierDefaultConfig.EnemyGroupDefaultConfig();
		}
	}
	public class ReimuUnifierEnemyUnitTemplate : EnemyUnitTemplate
	{
		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(ReimuUnifierDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override EnemyUnitConfig MakeConfig()
		{
			return ReimuUnifierDefaultConfig.EnemyUnitDefaultConfig();
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)ReimuUnifierLocalization.EnemiesUnitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Type TemplateType()
		{
			return typeof(EnemyUnitTemplate);
		}

		public EnemyUnitConfig GetEnemyUnitDefaultConfig()
		{
			return ReimuUnifierDefaultConfig.EnemyUnitDefaultConfig();
		}
	}
}
namespace ReimuUnifierMod.Config
{
	public struct CustomConfigEntry<T>
	{
		public T Value { get; set; }

		public string Section { get; set; }

		public string Key { get; set; }

		public string Description { get; set; }

		public CustomConfigEntry(T value, string section, string key, string description)
		{
			Value = value;
			Section = section;
			Key = key;
			Description = description;
		}
	}
	public sealed class ReimuUnifierDefaultConfig
	{
		private static readonly string OwnerName = BepinexPlugin.modUniqueID;

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

		public static CardConfig CardDefaultConfig()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			return new CardConfig(0, "", 10, true, new string[0][], "", "", 0, false, true, false, true, true, (Rarity)0, (CardType)0, (TargetType?)null, (IReadOnlyList<ManaColor>)new List<ManaColor>(), false, default(ManaGroup), (ManaGroup?)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, (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>(), OwnerName, "", "", false, (string)null, (IReadOnlyList<string>)new List<string>());
		}

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

		public static StatusEffectConfig DefaultStatusEffectConfig()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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>(), (string)null, "Default", "Default", "Default");
		}

		public static UltimateSkillConfig DefaultUltConfig()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 1, 0, 0, (Keyword)256, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}

		public static EnemyUnitConfig EnemyUnitDefaultConfig()
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			return new EnemyUnitConfig("", false, false, (IReadOnlyList<ManaColor>)new List<ManaColor> { (ManaColor)6 }, 10, "", "#ffff", (EnemyType)3, true, (float?)null, (int?)null, 250, (int?)10, (int?)10, (int?)10, (int?)10, (int?)1, (int?)15, (int?)1, (int?)2, (int?)250, (int?)10, (int?)10, (int?)10, (int?)10, (int?)1, (int?)15, (int?)1, (int?)2, (int?)250, (int?)10, (int?)10, (int?)10, (int?)10, (int?)1, (int?)15, (int?)1, (int?)2, new MinMax(100, 100), new MinMax(100, 100), (IReadOnlyList<string>)new List<string> { GunNameID.GetGunFromId(800) }, (IReadOnlyList<string>)new List<string> { GunNameID.GetGunFromId(800) }, (IReadOnlyList<string>)new List<string> { GunNameID.GetGunFromId(800) }, (IReadOnlyList<string>)new List<string> { GunNameID.GetGunFromId(800) });
		}

		public static EnemyGroupConfig EnemyGroupDefaultConfig()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			return new EnemyGroupConfig("", false, (IReadOnlyList<string>)new List<string>(), "", "Single", (IReadOnlyList<string>)new List<string>(), (EnemyType)3, false, 1f, true, new Vector2(-4f, 0.5f), "", "", (string)null);
		}
	}
}
namespace ReimuUnifierMod.Cards
{
	public sealed class CursedBoundaryDef : ReimuUnifierCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)1;
			cardDefaultConfig.GunName = "陷入贫困";
			cardDefaultConfig.IsXCost = true;
			cardDefaultConfig.Type = (CardType)1;
			cardDefaultConfig.TargetType = (TargetType)1;
			cardDefaultConfig.Damage = 10;
			cardDefaultConfig.UpgradedDamage = 14;
			cardDefaultConfig.Value1 = 2;
			cardDefaultConfig.UpgradedValue1 = 3;
			cardDefaultConfig.Mana = ManaGroup.Anys(1);
			cardDefaultConfig.RelativeEffects = new List<string> { "TeamUpSe" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "TeamUpSe" };
			cardDefaultConfig.RelativeKeyword = (Keyword)562949953421312L;
			cardDefaultConfig.UpgradedRelativeKeyword = (Keyword)562949953421312L;
			cardDefaultConfig.Illustrator = "";
			cardDefaultConfig.Index = CardIndexGenerator.GetUniqueIndex(cardDefaultConfig);
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(CursedBoundaryDef))]
	public sealed class CursedBoundary : ReimuUnifierCard
	{
		public override ManaGroup GetXCostFromPooled(ManaGroup pooledMana)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return pooledMana;
		}

		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)
			int ManaSpent = ((ManaGroup)(ref consumingMana)).Amount;
			bool ShionInHand = TeamUpCheck<ShionImpoverishedDeityFriend>();
			for (int i = 0; i < ManaSpent; i++)
			{
				if (!((Card)this).Battle.BattleShouldEnd)
				{
					yield return ((Card)this).LoseLifeAction(1);
					yield return ((Card)this).AttackAction(selector, ((Card)this).GunName);
				}
				if (ShionInHand)
				{
					yield return (BattleAction)new GainMoneyAction(((Card)this).Value1, (SpecialSourceType)0);
				}
			}
			if (ShionInHand)
			{
				yield return (BattleAction)(object)new TeamUpAction((Card)(object)this, TeamUpCard(typeof(ShionImpoverishedDeityFriend)));
			}
		}
	}
	public sealed class FaithlessMountainAssaultDef : ReimuUnifierCardTemplate
	{
		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.GunName = "元鬼玉B";
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)1;
			cardDefaultConfig.Type = (CardType)1;
			cardDefaultConfig.TargetType = (TargetType)2;
			cardDefaultConfig.Keywords = (Keyword)274877907200L;
			cardDefaultConfig.UpgradedKeywords = (Keyword)274877907200L;
			cardDefaultConfig.RelativeCards = new List<string> { "ConsumedByVengeanceMisfortuneToken" };
			cardDefaultConfig.UpgradedRelativeCards = new List<string> { "ConsumedByVengeanceMisfortuneToken" };
			cardDefaultConfig.Damage = 24;
			cardDefaultConfig.UpgradedDamage = 32;
			cardDefaultConfig.Illustrator = "Saevin";
			cardDefaultConfig.Index = CardIndexGenerator.GetUniqueIndex(cardDefaultConfig);
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(FaithlessMountainAssaultDef))]
	public sealed class FaithlessMountainAssault : ReimuUnifierCard
	{
		protected override void OnEnterBattle(BattleController battle)
		{
			((Card)this).ReactBattleEvent<DieEventArgs>(((Card)this).Battle.EnemyDied, (EventSequencedReactor<DieEventArgs>)OnEnemyDied);
		}

		private IEnumerable<BattleAction> OnEnemyDied(DieEventArgs args)
		{
			if (args.DieSource == this && !args.Unit.HasStatusEffect<Servant>())
			{
				yield return (BattleAction)new AddCardsToDeckAction((IEnumerable<Card>)Library.CreateCards<ConsumedByVengeanceMisfortuneToken>(1, false));
			}
		}
	}
	public sealed class ShionImpoverishedDeityFriendDef : ReimuUnifierCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)2;
			cardDefaultConfig.GunName = "陷入贫困";
			cardDefaultConfig.IsPooled = true;
			cardDefaultConfig.Type = (CardType)5;
			cardDefaultConfig.TargetType = (TargetType)0;
			cardDefaultConfig.Loyalty = 4;
			cardDefaultConfig.UpgradedLoyalty = 5;
			cardDefaultConfig.PassiveCost = 1;
			cardDefaultConfig.UpgradedPassiveCost = 1;
			cardDefaultConfig.ActiveCost = -3;
			cardDefaultConfig.UpgradedActiveCost = -3;
			cardDefaultConfig.UltimateCost = -7;
			cardDefaultConfig.UpgradedUltimateCost = -7;
			cardDefaultConfig.Damage = 10;
			cardDefaultConfig.UpgradedDamage = 13;
			cardDefaultConfig.RelativeKeyword = (Keyword)256;
			cardDefaultConfig.UpgradedRelativeKeyword = (Keyword)256;
			cardDefaultConfig.RelativeEffects = new List<string> { "Graze" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "Graze" };
			cardDefaultConfig.RelativeCards = new List<string> { "BuyPeace" };
			cardDefaultConfig.UpgradedRelativeCards = new List<string> { "BuyPeace" };
			cardDefaultConfig.Illustrator = "Saevin";
			cardDefaultConfig.Index = CardIndexGenerator.GetUniqueIndex(cardDefaultConfig);
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(ShionImpoverishedDeityFriendDef))]
	public sealed class ShionImpoverishedDeityFriend : Card
	{
		public string Indent { get; } = "<indent=80>";


		public float ActiveDamagePreview
		{
			get
			{
				//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)
				DamageInfo val = DamageInfo.Attack(15f, true);
				return ((DamageInfo)(ref val)).Amount;
			}
		}

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

		protected 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)
			yield return (BattleAction)new GainMoneyAction(15, (SpecialSourceType)0);
			foreach (BattleAction item in <>n__0(selector, consumingMana, precondition))
			{
				yield return item;
			}
		}

		public override IEnumerable<BattleAction> OnTurnEndingInHand()
		{
			return ((Card)this).GetPassiveActions();
		}

		public override IEnumerable<BattleAction> GetPassiveActions()
		{
			ShionImpoverishedDeityFriend ShionImpoverishedDeityFriend = this;
			if (!((Card)ShionImpoverishedDeityFriend).Summoned || ((Card)ShionImpoverishedDeityFriend).Battle.BattleShouldEnd)
			{
				yield break;
			}
			((Card)ShionImpoverishedDeityFriend).NotifyActivating();
			((Card)ShionImpoverishedDeityFriend).Loyalty = ((Card)ShionImpoverishedDeityFriend).Loyalty + ((Card)ShionImpoverishedDeityFriend).PassiveCost;
			int i = 0;
			while (i < ((Card)ShionImpoverishedDeityFriend).Battle.FriendPassiveTimes && !((Card)ShionImpoverishedDeityFriend).Battle.BattleShouldEnd)
			{
				yield return (BattleAction)(object)PerformAction.Sfx("FairySupport", 0f);
				yield return (BattleAction)(object)PerformAction.Effect((Unit)(object)((Card)ShionImpoverishedDeityFriend).Battle.Player, "MaidFairy", 0f, (string)null, 0f, (EffectBehavior)0, 0f);
				EnemyUnit target = CollectionsExtensions.MinBy<EnemyUnit, int>(((Card)ShionImpoverishedDeityFriend).Battle.EnemyGroup.Alives, (Func<EnemyUnit, int>)((EnemyUnit unit) => ((Unit)unit).Hp));
				yield return (BattleAction)new LoseMoneyAction(5);
				DamageInfo AccurateAttack = ((Card)this).Damage;
				((DamageInfo)(ref AccurateAttack)).IsAccuracy = true;
				yield return ((Card)this).AttackAction((Unit)(object)target, AccurateAttack, ((Card)this).GunName);
				if (((Unit)target).IsAlive)
				{
					yield return ((Card)this).AttackAction((Unit)(object)target, AccurateAttack, ((Card)this).GunName);
				}
				AccurateAttack = default(DamageInfo);
				int num = i + 1;
				i = num;
			}
		}

		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)
			ShionImpoverishedDeityFriend ShionImpoverishedDeityFriend = this;
			if (precondition == null || (int)((MiniSelectCardInteraction)precondition).SelectedCard.FriendToken == 1)
			{
				((Card)ShionImpoverishedDeityFriend).Loyalty = ((Card)ShionImpoverishedDeityFriend).Loyalty + ((Card)ShionImpoverishedDeityFriend).ActiveCost;
				int livingEnemies = ((Card)this).Battle.AllAliveEnemies.Count();
				yield return (BattleAction)new LoseMoneyAction(5 * livingEnemies);
				yield return ((Card)this).AttackAction((IEnumerable<Unit>)((Card)this).Battle.AllAliveEnemies, ((Card)this).GunName, DamageInfo.Attack(15f, true));
				yield return ((Card)this).BuffAction<Graze>(livingEnemies, 0, 0, 0, 0.2f);
				yield break;
			}
			((Card)ShionImpoverishedDeityFriend).Loyalty = ((Card)ShionImpoverishedDeityFriend).Loyalty + ((Card)ShionImpoverishedDeityFriend).UltimateCost;
			((Card)ShionImpoverishedDeityFriend).UltimateUsed = true;
			((GameEntity)this).GameRun.AddDeckCard((Card)(object)Library.CreateCard<BuyPeace>(), true, (VisualSourceData)null);
			foreach (EnemyUnit unit in ((Card)this).Battle.AllAliveEnemies)
			{
				if (!unit.Config.RealName)
				{
					yield return (BattleAction)new ForceKillAction((Unit)(object)((Card)this).Battle.Player, (Unit)(object)unit);
				}
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0(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 YoukaiShrineMaidenDef : ReimuUnifierCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Black = 1;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)1;
			cardDefaultConfig.Type = (CardType)3;
			cardDefaultConfig.TargetType = (TargetType)4;
			cardDefaultConfig.Keywords = (Keyword)65536;
			cardDefaultConfig.UpgradedKeywords = (Keyword)65536;
			cardDefaultConfig.RelativeEffects = new List<string> { "TeamUpSe" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "TeamUpSe" };
			cardDefaultConfig.RelativeKeyword = (Keyword)562949953421320L;
			cardDefaultConfig.UpgradedRelativeKeyword = (Keyword)562949953421320L;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Philosophy = 3;
			cardDefaultConfig.Mana = val;
			cardDefaultConfig.Value1 = 3;
			cardDefaultConfig.UpgradedValue1 = 5;
			cardDefaultConfig.Illustrator = "";
			cardDefaultConfig.Index = CardIndexGenerator.GetUniqueIndex(cardDefaultConfig);
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(YoukaiShrineMaidenDef))]
	public sealed class YoukaiShrineMaiden : ReimuUnifierCard
	{
		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)
			List<Type> PossibleTeamUps = new List<Type>
			{
				typeof(YukariYakumoFriend),
				typeof(YukariSageOfGensokyoFriend),
				typeof(KogasaYoukaiBlacksmithFriend),
				typeof(SuikaGourdOniFriend),
				typeof(KasenWildhornFriend),
				typeof(FourFairiesFriend),
				typeof(AunnShrineGuardianFriend),
				typeof(AyaReporterOfFantasyFriend),
				typeof(NitoriBusinessPartnerFriend),
				typeof(ShionImpoverishedDeityFriend),
				typeof(ShinmyoumaruInchlingPrincessFriend),
				typeof(YukariFriend),
				typeof(YinyangQueen),
				typeof(PatchouliFriend),
				typeof(MeilingFriend),
				typeof(MaidFriend),
				typeof(LeidiFriend),
				typeof(LarvaFriend),
				typeof(LilyFriend),
				typeof(LunaFriend),
				typeof(StarFriend),
				typeof(SunnyFriend),
				typeof(ClownpieceFriend),
				typeof(KokoroFriend)
			};
			int TeamUpAmount = MultiTeamUpCheck(PossibleTeamUps);
			yield return (BattleAction)new GainManaAction(((Card)this).Mana);
			yield return (BattleAction)new DrawManyCardAction(((Card)this).Value1);
			List<Card> randomCurseCards = new List<Card>();
			int MisfortunesToAdd = 3 - TeamUpAmount;
			for (int i = 0; i < MisfortunesToAdd; i++)
			{
				randomCurseCards.Add(((GameEntity)this).GameRun.GetRandomCurseCard(((GameEntity)this).GameRun.BattleCardRng, true));
			}
			if (randomCurseCards != null)
			{
				yield return (BattleAction)new AddCardsToDiscardAction((IEnumerable<Card>)randomCurseCards, (AddCardsType)0);
			}
			if (TeamUpAmount > 3)
			{
				yield return ((Card)this).BuffAction<AmuletForCard>(TeamUpAmount - 3, 0, 0, 0, 0.2f);
			}
			if (TeamUpAmount == 0)
			{
				yield break;
			}
			List<Card> CardsInHand = ((Card)this).Battle.HandZone.ToList();
			foreach (Card card in CardsInHand)
			{
				if (PossibleTeamUps.Contains(((object)card).GetType()) && card.Summoned)
				{
					yield return (BattleAction)(object)new TeamUpAction((Card)(object)this, card);
				}
			}
		}
	}
	public sealed class CommunicatorOrbTokenDef : ReimuUnifierCardTemplate
	{
		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.GunName = "最凶恶的巫女玉";
			cardDefaultConfig.IsPooled = false;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)1 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			cardDefaultConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			cardDefaultConfig.UpgradedCost = val;
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.Type = (CardType)1;
			cardDefaultConfig.TargetType = (TargetType)1;
			cardDefaultConfig.Keywords = (Keyword)2162688;
			cardDefaultConfig.UpgradedKeywords = (Keyword)2162688;
			cardDefaultConfig.RelativeKeyword = (Keyword)562949953422336L;
			cardDefaultConfig.UpgradedRelativeKeyword = (Keyword)562949953422336L;
			cardDefaultConfig.Damage = 2;
			cardDefaultConfig.Shield = 2;
			cardDefaultConfig.Value1 = 2;
			cardDefaultConfig.Illustrator = "Saevin";
			cardDefaultConfig.Index = CardIndexGenerator.GetUniqueIndex(cardDefaultConfig);
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(CommunicatorOrbTokenDef))]
	public sealed class CommunicatorOrbToken : ReimuUnifierCard
	{
		protected override int AdditionalShield => ((Card)this).Value1 * base.SummonedTeammatesInHand;

		protected override int AdditionalDamage => ((Card)this).Value1 * base.SummonedTeammatesInHand;

		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, (GunPair)null);
			CommunicatorOrbToken communicatorOrbToken = this;
			ShieldInfo shield = ((Card)this).Shield;
			yield return ((Card)communicatorOrbToken).DefenseAction(0, ((ShieldInfo)(ref shield)).Shield, (BlockShieldType)1, false);
		}
	}
	public sealed class ConsumedByVengeanceMisfortuneTokenDef : ReimuUnifierCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.IsPooled = false;
			cardDefaultConfig.Type = (CardType)8;
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 2;
			cardDefaultConfig.Cost = cost;
			cardDefaultConfig.Rarity = (Rarity)1;
			cardDefaultConfig.IsUpgradable = false;
			cardDefaultConfig.Keywords = (Keyword)32784;
			cardDefaultConfig.UpgradedKeywords = (Keyword)32784;
			cardDefaultConfig.Illustrator = "Saevin";
			cardDefaultConfig.Index = CardIndexGenerator.GetUniqueIndex(cardDefaultConfig);
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(ConsumedByVengeanceMisfortuneTokenDef))]
	public sealed class ConsumedByVengeanceMisfortuneToken : ReimuUnifierCard
	{
		public override bool ShuffleToBottom => true;
	}
	public sealed class MercilessRodFriendTokenDef : ReimuUnifierCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			cardDefaultConfig.Cost = default(ManaGroup);
			cardDefaultConfig.Rarity = (Rarity)0;
			cardDefaultConfig.GunName = "时间悖论";
			cardDefaultConfig.IsPooled = false;
			cardDefaultConfig.Type = (CardType)5;
			cardDefaultConfig.TargetType = (TargetType)0;
			cardDefaultConfig.Loyalty = 1;
			cardDefaultConfig.UpgradedLoyalty = 1;
			cardDefaultConfig.PassiveCost = 1;
			cardDefaultConfig.UpgradedPassiveCost = 1;
			cardDefaultConfig.UltimateCost = -5;
			cardDefaultConfig.UpgradedUltimateCost = -5;
			cardDefaultConfig.Damage = 5;
			cardDefaultConfig.UpgradedDamage = 8;
			cardDefaultConfig.Value1 = 1;
			cardDefaultConfig.UpgradedValue1 = 2;
			cardDefaultConfig.RelativeEffects = new List<string> { "Firepower" };
			cardDefaultConfig.UpgradedRelativeEffects = new List<string> { "Firepower" };
			cardDefaultConfig.Illustrator = "Saevin";
			cardDefaultConfig.Index = CardIndexGenerator.GetUniqueIndex(cardDefaultConfig);
			return cardDefaultConfig;
		}
	}
	[EntityLogic(typeof(MercilessRodFriendTokenDef))]
	public sealed class MercilessRodFriendToken : ReimuUnifierCard
	{
		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}";

		protected override void OnEnterBattle(BattleController battle)
		{
			((Card)this).ReactBattleEvent<CardUsingEventArgs>(((Card)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if (!((Card)this).Battle.BattleShouldEnd)
			{
				Card card = args.Card;
				if ((int)card.Config.Rarity == 0 && ((Card)this).Summoned)
				{
					<>n__0();
					yield return ((Card)this).BuffAction<Firepower>(((Card)this).Value1, 0, 0, 0, 0.2f);
				}
			}
		}

		public override IEnumerable<BattleAction> OnTurnEndingInHand()
		{
			return ((Card)this).GetPassiveActions();
		}

		public override IEnumerable<BattleAction> GetPassiveActions()
		{
			MercilessRodFriendToken MercilessRodFriendToken = this;
			if (!((Card)MercilessRodFriendToken).Summoned || ((Card)MercilessRodFriendToken).Battle.BattleShouldEnd)
			{
				yield break;
			}
			((Card)MercilessRodFriendToken).NotifyActivating();
			((Card)MercilessRodFriendToken).Loyalty = ((Card)MercilessRodFriendToken).Loyalty + ((Card)MercilessRodFriendToken).PassiveCost;
			int i = 0;
			while (i < ((Card)MercilessRodFriendToken).Battle.FriendPassiveTimes && !((Card)MercilessRodFriendToken).Battle.BattleShouldEnd)
			{
				yield return (BattleAction)(object)PerformAction.Sfx("FairySupport", 0f);
				((Card)MercilessRodFriendToken).CardGuns = new Guns(((Card)this).GunName, 3, true);
				foreach (GunPair gunPair in ((Card)MercilessRodFriendToken).CardGuns.GunPairs)
				{
					EnemyUnit target = CollectionsExtensions.MaxBy<EnemyUnit, int>(((Card)MercilessRodFriendToken).Battle.EnemyGroup.Alives, (Func<EnemyUnit, int>)((EnemyUnit unit) => ((Unit)unit).Hp));
					yield return ((Card)MercilessRodFriendToken).AttackAction((Unit)(object)target, ((Card)this).Damage, gunPair.GunName);
				}
				int num = i + 1;
				i = num;
			}
		}

		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)
			MercilessRodFriendToken MercilessRodFriendToken = this;
			((Card)this).Loyalty = ((Card)this).Loyalty + ((Card)this).UltimateCost;
			((Card)MercilessRodFriendToken).UltimateUsed = true;
			((Card)MercilessRodFriendToken).CardGuns = new Guns("梦想封印瞬", 8, false);
			foreach (GunPair gunPair in ((Card)MercilessRodFriendToken).CardGuns.GunPairs)
			{
				yield return ((Card)MercilessRodFriendToken).AttackAllAliveEnemyAction(gunPair);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class ShinmyoumaruInchlingPrincessFriendDef : ReimuUnifierCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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)
			CardConfig cardDefaultConfig = GetCardDefaultConfig();
			cardDefaultConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 2;
			((ManaGroup)(ref cost)).Colorless = 2;