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.Configuration;
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.Stations;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Cards;
using LBoL.EntityLib.Cards.Character.Cirno;
using LBoL.EntityLib.Cards.Character.Reimu;
using LBoL.EntityLib.Cards.Enemy;
using LBoL.EntityLib.Cards.Neutral.NoColor;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.StatusEffects.Basic;
using LBoL.EntityLib.StatusEffects.Cirno;
using LBoL.EntityLib.StatusEffects.Enemy;
using LBoL.EntityLib.StatusEffects.ExtraTurn;
using LBoL.Presentation;
using LBoL.Presentation.UI;
using LBoL.Presentation.UI.Widgets;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.CustomHandlers;
using LBoLEntitySideloader.CustomKeywords;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using TMPro;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.UI;
using YuukaMod.Assets;
using YuukaMod.BattleActions;
using YuukaMod.Cards;
using YuukaMod.Cards.Template;
using YuukaMod.Config;
using YuukaMod.Enemies;
using YuukaMod.Enemies.Template;
using YuukaMod.GunName;
using YuukaMod.ImageLoader;
using YuukaMod.Keywords;
using YuukaMod.Localization;
using YuukaMod.Logic;
using YuukaMod.Patches;
using YuukaMod.Source.Keywords;
using YuukaMod.StatusEffects;

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

		public static string playerName = "Yuuka";

		public static bool useInGameModel = false;

		public static string modelName = "Youmu";

		public static bool modelIsFlipped = true;

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

		public static ConfigEntry<bool> enableAct1Boss;

		public static CustomConfigEntry<bool> enableAct1BossEntry = new CustomConfigEntry<bool>(value: true, "EnableAct1Boss", "EnableAct1Boss", "Toggle the Act 1 boss. Default: On");

		public static ConfigEntry<int> gardenJadeboxReplacementChance;

		public static CustomConfigEntry<int> gardenJadeboxReplacementChanceEntry = new CustomConfigEntry<int>(100, "Jadeboxes", "GardenOfDreamsReplacementChance", "Chance (0-100) that the 'Garden of All Dreams' Jadebox replaces non-tool Uncommon and Rare card rewards. Default: 100 (always).");

		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("Vengyre.LBoL.Character.Yuuka", "");

		internal static BatchLocalization jadeboxLoc = new BatchLocalization((IResourceSource)(object)directorySource, typeof(JadeBoxTemplate), "Jadeboxes", (Locale)0, false);

		private void Awake()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			log = ((BaseUnityPlugin)this).Logger;
			enableAct1Boss = ((BaseUnityPlugin)this).Config.Bind<bool>(enableAct1BossEntry.Section, enableAct1BossEntry.Key, enableAct1BossEntry.Value, enableAct1BossEntry.Description);
			gardenJadeboxReplacementChance = ((BaseUnityPlugin)this).Config.Bind<int>(gardenJadeboxReplacementChanceEntry.Section, gardenJadeboxReplacementChanceEntry.Key, gardenJadeboxReplacementChanceEntry.Value, new ConfigDescription(gardenJadeboxReplacementChanceEntry.Description, (AcceptableValueBase)null, Array.Empty<object>()));
			ModAssetManager.LoadAssets();
			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);
			if (enableAct1Boss.Value)
			{
				EnemyUnitTemplate.AddBossNodeIcon(modUniqueID, func, (Assembly)null);
				log.LogInfo((object)"Yuuka boss enabled!");
			}
			YuukaCharacterArrangedHandle.RegisterHandlers();
			YuukaSecondCardTracker.RegisterHandlers();
		}

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PInfo
	{
		public const string GUID = "Vengyre.LBoL.Character.Yuuka";

		public const string Name = "YuukaMod";

		public const string version = "0.6.3";

		public static readonly Harmony harmony = new Harmony("Vengyre.LBoL.Character.Yuuka");
	}
	public static class YuukaGardenArchitectConfig
	{
		public static int Option1FlowerToBonus = 3;

		public static int Option1GrowBonus = 2;

		public static int Option2FlowerBonus = 10;

		public static int Option3BloomToBonus = 3;

		public static int Option3FirepowerBonus = 1;
	}
	public static class YuukaSeasonsConfig
	{
		public static int BloomValue = 4;

		public static int GrowValue = 1;

		public static int SummerFlowerValue = 9;

		public static int FervorValue = 25;

		public static int BarrierValue = 5;
	}
	public class YuukaLoadouts
	{
		public static string UltimateSkillA = "YuukaUltA";

		public static string UltimateSkillB = "YuukaUltB";

		public static string ExhibitA = "YuukaExhibitA";

		public static string ExhibitB = "YuukaExhibitB";

		public static List<string> DeckA = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YuukaCharacterBaseAttackG", "YuukaCharacterBaseAttackG", "YuukaCharacterBaseBlockR", "YuukaCharacterBaseBlockR", "YuukaCharacterBloomingField", "YuukaCharacterRosepetalRuin" };

		public static List<string> DeckB = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YuukaCharacterBaseAttackR", "YuukaCharacterBaseAttackR", "YuukaCharacterBaseBlockG", "YuukaCharacterBaseBlockG", "YuukaCharacterSunbeamBurst", "YuukaCharacterRadiantGlare" };

		public static PlayerUnitConfig playerUnitConfig;

		static YuukaLoadouts()
		{
			//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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			string modUniqueID = BepinexPlugin.modUniqueID;
			int? num = 0;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).White = 0;
			((ManaGroup)(ref val)).Blue = 0;
			((ManaGroup)(ref val)).Black = 0;
			((ManaGroup)(ref val)).Red = 2;
			((ManaGroup)(ref val)).Green = 2;
			((ManaGroup)(ref val)).Colorless = 0;
			((ManaGroup)(ref val)).Philosophy = 0;
			ManaGroup val2 = val;
			string ultimateSkillA = UltimateSkillA;
			string ultimateSkillB = UltimateSkillB;
			string exhibitA = ExhibitA;
			string exhibitB = ExhibitB;
			IReadOnlyList<string> deckA = DeckA;
			IReadOnlyList<string> deckB = DeckB;
			playerUnitConfig = new PlayerUnitConfig(modUniqueID, true, "", 0, 8, num, true, (int?)null, (ManaColor)5, (ManaColor)4, val2, "#e58c27", 80, 70, 0, ultimateSkillA, ultimateSkillB, exhibitA, exhibitB, deckA, deckB, 2, 3);
		}
	}
	public sealed class YuukaModDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(YuukaModDef))]
		public sealed class YuukaMod : PlayerUnit
		{
			protected override void OnEnterGameRun(GameRunController gameRun)
			{
				CardConfig.FromId("PatchouliGreenAttack").IsPooled = false;
			}
		}

		[HarmonyPatch(typeof(UiManager), "LeaveGameRun")]
		private class UiManager_LeaveGameRun_Patch
		{
			private static void Postfix(UiManager __instance)
			{
				CardConfig.FromId("PatchouliGreenAttack").IsPooled = true;
			}
		}

		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)YuukaLocalization.PlayerUnitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

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

		public override PlayerUnitConfig MakeConfig()
		{
			return YuukaLoadouts.playerUnitConfig;
		}

		public override EikiSummonInfo AssociateEikiSummon()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new EikiSummonInfo(typeof(global::YuukaMod.Enemies.YuukaMod), (string)null);
		}
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace YuukaMod.YuukaUlt
{
	public class YuukaUltTemplate : 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(YuukaDefaultConfig.GetDefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public UltimateSkillConfig GetDefaulUltConfig()
		{
			return YuukaDefaultConfig.GetDefaultUltConfig();
		}
	}
	public sealed class YuukaCharacterUltFillerPrototypeMasterSparkDef : YuukaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 30;
			defaulUltConfig.RelativeCards = new List<string> { "RManaCard" };
			defaulUltConfig.Value1 = 1;
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(YuukaCharacterUltFillerPrototypeMasterSparkDef))]
	public sealed class YuukaCharacterUltFillerPrototypeMasterSpark : UltimateSkill
	{
		public YuukaCharacterUltFillerPrototypeMasterSpark()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(12170);
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			EnemyUnit enemy = selector.GetEnemy(((UltimateSkill)this).Battle);
			yield return (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)this).Owner, (Unit)(object)enemy, ((UltimateSkill)this).Damage, ((UltimateSkill)this).GunName, (GunType)0);
			yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { (Card)Library.CreateCard<RManaCard>() });
		}
	}
	public sealed class YuukaUltADef : YuukaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 15;
			defaulUltConfig.Value1 = 3;
			defaulUltConfig.RelativeEffects = new List<string> { "Graze" };
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(YuukaUltADef))]
	public sealed class YuukaUltA : UltimateSkill
	{
		public YuukaUltA()
		{
			((UltimateSkill)this).TargetType = (TargetType)2;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(25100);
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			yield return (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)this).Battle.Player, "YuukaUltA");
			yield return (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)this).Owner, (IEnumerable<Unit>)selector.GetUnits(((UltimateSkill)this).Battle), ((UltimateSkill)this).Damage, ((UltimateSkill)this).GunName, (GunType)0);
			yield return (BattleAction)(object)new ApplyStatusEffectAction<Graze>((Unit)(object)((UltimateSkill)this).Owner, (int?)((UltimateSkill)this).Value1, (int?)0, (int?)0, (int?)0, 0.2f, true);
		}
	}
	public sealed class YuukaUltBDef : YuukaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 30;
			defaulUltConfig.RelativeCards = new List<string> { "RManaCard" };
			defaulUltConfig.Value1 = 1;
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(YuukaUltBDef))]
	public sealed class YuukaUltB : UltimateSkill
	{
		public YuukaUltB()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(23061);
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			EnemyUnit enemy = selector.GetEnemy(((UltimateSkill)this).Battle);
			yield return (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)this).Battle.Player, "YuukaUltB");
			yield return (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)this).Owner, (Unit)(object)enemy, ((UltimateSkill)this).Damage, ((UltimateSkill)this).GunName, (GunType)0);
			yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { (Card)Library.CreateCard<RManaCard>() });
		}
	}
}
namespace YuukaMod.StatusEffects
{
	public sealed class YuukaArrangedKeywordDef : YuukaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YuukaArrangedKeywordDef))]
	public sealed class YuukaArrangedKeyword : StatusEffect
	{
	}
	public sealed class YuukaArrangeKeywordDef : YuukaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YuukaArrangeKeywordDef))]
	public sealed class YuukaArrangeKeyword : StatusEffect
	{
	}
	public sealed class YuukaFlourishKeywordDef : YuukaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YuukaFlourishKeywordDef))]
	public sealed class YuukaFlourishKeyword : StatusEffect
	{
	}
	public sealed class YuukaThirdTurnKeywordDef : YuukaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YuukaThirdTurnKeywordDef))]
	public sealed class YuukaThirdTurnKeyword : StatusEffect
	{
	}
	public class YuukaStatusEffectTemplate : 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(YuukaDefaultConfig.GetDefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public static StatusEffectConfig GetDefaultStatusEffectConfig()
		{
			return YuukaDefaultConfig.GetDefaultStatusEffectConfig();
		}
	}
	public sealed class YuukaBloomSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaBloomSeDef))]
	public sealed class YuukaBloomSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarting, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarting);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarting(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			if (((StatusEffect)this).Level < 5)
			{
				if (((StatusEffect)this).Level <= 0)
				{
					yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
					yield break;
				}
				yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBlossomSmall>() });
				((StatusEffect)this).Level = ((StatusEffect)this).Level - 1;
				if (args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>() != null)
				{
					YuukaShedBloomShieldBornSe pv3 = args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>();
					yield return (BattleAction)new CastBlockShieldAction(args.Unit, args.Unit, 0, ((StatusEffect)pv3).Level, (BlockShieldType)2, true);
				}
			}
			else if (((StatusEffect)this).Level < 15)
			{
				yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBlossomMedium>() });
				((StatusEffect)this).Level = ((StatusEffect)this).Level - 2;
				if (args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>() != null)
				{
					YuukaShedBloomShieldBornSe pv2 = args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>();
					yield return (BattleAction)new CastBlockShieldAction(args.Unit, args.Unit, 0, ((StatusEffect)pv2).Level * 2, (BlockShieldType)2, true);
				}
			}
			else
			{
				yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBlossomLarge>() });
				((StatusEffect)this).Level = ((StatusEffect)this).Level - 3;
				if (args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>() != null)
				{
					YuukaShedBloomShieldBornSe pv = args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>();
					yield return (BattleAction)new CastBlockShieldAction(args.Unit, args.Unit, 0, ((StatusEffect)pv).Level * 3, (BlockShieldType)2, true);
				}
			}
			if (((StatusEffect)this).Level <= 0)
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
			}
		}
	}
	public sealed class YuukaBossSleepingTerrorSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaBossSleepingTerrorSeDef))]
	public sealed class YuukaBossSleepingTerrorSe : StatusEffect
	{
		private int _internalCount;

		private bool _hasTriggered = false;

		public string HasTriggered
		{
			get
			{
				if (_hasTriggered)
				{
					return "Has already triggered this turn.";
				}
				return "Can trigger once per turn.";
			}
		}

		protected override void OnAdded(Unit unit)
		{
			_internalCount = ((StatusEffect)this).Limit;
			((StatusEffect)this).Count = _internalCount;
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(unit.TurnStarting, (GameEventHandler<UnitEventArgs>)OnTurnStarting);
			((StatusEffect)this).ReactOwnerEvent<DamageEventArgs>(unit.DamageReceived, (EventSequencedReactor<DamageEventArgs>)OnDamageReceived);
		}

		public void OnTurnStarting(UnitEventArgs args)
		{
			_internalCount = ((StatusEffect)this).Limit;
			((StatusEffect)this).Count = _internalCount;
			_hasTriggered = false;
		}

		private IEnumerable<BattleAction> OnDamageReceived(DamageEventArgs args)
		{
			DamageInfo damageInfo = args.DamageInfo;
			int num = MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage) - _internalCount;
			if (num > 0 && !_hasTriggered)
			{
				yield return (BattleAction)(object)new ApplyStatusEffectAction<Firepower>(((StatusEffect)this).Owner, (int?)((StatusEffect)this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
				_hasTriggered = true;
				((StatusEffect)this).NotifyActivating();
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
			YuukaBossSleepingTerrorSe yuukaBossSleepingTerrorSe = this;
			int internalCount = _internalCount;
			damageInfo = args.DamageInfo;
			yuukaBossSleepingTerrorSe._internalCount = internalCount - MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage);
			((StatusEffect)this).Count = Math.Max(_internalCount, 0);
		}
	}
	public sealed class YuukaBouquetBindingSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasLevel = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaBouquetBindingSeDef))]
	public sealed class YuukaBouquetBindingSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardsEventArgs>(((StatusEffect)this).Battle.CardsAddedToDiscard, (EventSequencedReactor<CardsEventArgs>)OnCardsAddedToDiscard);
			((StatusEffect)this).ReactOwnerEvent<CardsEventArgs>(((StatusEffect)this).Battle.CardsAddedToHand, (EventSequencedReactor<CardsEventArgs>)OnCardsAddedToHand);
			((StatusEffect)this).ReactOwnerEvent<CardsAddingToDrawZoneEventArgs>(((StatusEffect)this).Battle.CardsAddedToDrawZone, (EventSequencedReactor<CardsAddingToDrawZoneEventArgs>)OnCardsAddedToDrawZone);
		}

		private IEnumerable<BattleAction> OnCardsAddedToHand(CardsEventArgs args)
		{
			List<Card> list = args.Cards.Where((Card card) => card is SummerFlower).ToList();
			if (list.Count == 0)
			{
				yield break;
			}
			foreach (Card card2 in list)
			{
				yield return (BattleAction)new ExileCardAction(card2);
				yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBouquetCharm>() });
			}
		}

		private IEnumerable<BattleAction> OnCardsAddedToDiscard(CardsEventArgs args)
		{
			List<Card> list = args.Cards.Where((Card card) => card is SummerFlower).ToList();
			if (list.Count == 0)
			{
				yield break;
			}
			foreach (Card card2 in list)
			{
				yield return (BattleAction)new ExileCardAction(card2);
				yield return (BattleAction)new AddCardsToDiscardAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBouquetCharm>() });
			}
		}

		private IEnumerable<BattleAction> OnCardsAddedToDrawZone(CardsAddingToDrawZoneEventArgs args)
		{
			List<Card> list = args.Cards.Where((Card card) => card is SummerFlower).ToList();
			if (list.Count == 0)
			{
				yield break;
			}
			foreach (Card card2 in list)
			{
				yield return (BattleAction)new ExileCardAction(card2);
				yield return (BattleAction)new AddCardsToDrawZoneAction((IEnumerable<Card>)Library.CreateCards<YuukaCharacterTokenBouquetCharm>(1, false), (DrawZoneTarget)2, (AddCardsType)0);
			}
		}
	}
	public sealed class YuukaDawnsPromiseSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaDawnsPromiseSeDef))]
	public sealed class YuukaDawnsPromiseSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarting, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarting);
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			ManaGroup consumingMana = args.ConsumingMana;
			if (((ManaGroup)(ref consumingMana)).Amount >= 3)
			{
				YuukaDawnsPromiseSe yuukaDawnsPromiseSe = this;
				consumingMana = args.ConsumingMana;
				yield return ((StatusEffect)yuukaDawnsPromiseSe).BuffAction<YuukaDawnsPromiseSe>(((ManaGroup)(ref consumingMana)).Amount, 0, 0, 0, 0.2f);
			}
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarting(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			bool is_upgraded = ((StatusEffect)this).Count == 4;
			YuukaCharacterDawnsFury attack = Library.CreateCard<YuukaCharacterDawnsFury>(is_upgraded);
			((Card)attack).DeltaDamage = ((Card)attack).DeltaDamage + (((StatusEffect)this).Level - ((Card)attack).ConfigDamage);
			yield return (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { attack });
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class YuukaDazzlingFlareSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			defaultStatusEffectConfig.HasLevel = false;
			defaultStatusEffectConfig.HasDuration = true;
			defaultStatusEffectConfig.DurationStackType = (StackType)0;
			defaultStatusEffectConfig.DurationDecreaseTiming = (DurationDecreaseTiming)3;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaDazzlingFlareSeDef))]
	public sealed class YuukaDazzlingFlareSe : StatusEffect
	{
		public override bool ShouldPreventCardUsage(Card card)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			return (int)card.CardType == 1;
		}
	}
	public sealed class YuukaDrawNextTurnSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 15;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaDrawNextTurnSeDef))]
	public sealed class YuukaDrawNextTurnSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnTurnStarted);
		}

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YuukaDrawReductionNextTurnSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaDrawReductionNextTurnSeDef))]
	public sealed class YuukaDrawReductionNextTurnSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
			BattleController battle = ((StatusEffect)this).Battle;
			battle.DrawCardCount -= ((StatusEffect)this).Level;
		}

		protected override void OnRemoved(Unit unit)
		{
			BattleController battle = ((StatusEffect)this).Battle;
			battle.DrawCardCount += ((StatusEffect)this).Level;
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class YuukaFervorInTwoTurnsSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 12;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaFervorInTwoTurnsSeDef))]
	public sealed class YuukaFervorInTwoTurnsSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			yield return ((StatusEffect)this).BuffAction<YuukaFervorNextTurnSe>(((StatusEffect)this).Level, 0, 0, 0, 0.2f);
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class YuukaFervorNextTurnSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 11;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaFervorNextTurnSeDef))]
	public sealed class YuukaFervorNextTurnSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			yield return ((StatusEffect)this).BuffAction<YuukaFervorSe>(((StatusEffect)this).Level, 0, 0, 0, 0.2f);
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class YuukaFervorSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaFervorSeDef))]
	public sealed class YuukaFervorSe : StatusEffect
	{
		private float AttackRatio => ((float)((StatusEffect)this).Level + 100f) / 100f;

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

		private void OnDamageDealing(DamageDealingEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			DamageInfo damageInfo = args.DamageInfo;
			if ((int)((DamageInfo)(ref damageInfo)).DamageType == 2)
			{
				damageInfo = args.DamageInfo;
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).MultiplyBy(AttackRatio);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				if ((int)((GameEventArgs)args).Cause != 20)
				{
					((StatusEffect)this).NotifyActivating();
				}
			}
		}

		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class YuukaFloweringResonanceSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaFloweringResonanceSeDef))]
	public sealed class YuukaFloweringResonanceSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
			((StatusEffect)this).ReactOwnerEvent<BlockShieldEventArgs>(((Unit)((StatusEffect)this).Battle.Player).BlockShieldGained, (EventSequencedReactor<BlockShieldEventArgs>)OnBlockShieldGained);
		}

		private IEnumerable<BattleAction> OnBlockShieldGained(BlockShieldEventArgs args)
		{
			if (args.Block > 0f)
			{
				yield return ((StatusEffect)this).BuffAction<NextTurnGainBlock>((int)(args.Block * (float)((StatusEffect)this).Level), 0, 0, 0, 0.2f);
			}
			if (args.Shield > 0f)
			{
				yield return ((StatusEffect)this).BuffAction<NextTurnGainBlock>((int)(args.Shield * (float)((StatusEffect)this).Level), 0, 0, 0, 0.2f);
			}
		}

		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class YuukaFlowersBirdsWindAndMoonSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaFlowersBirdsWindAndMoonSeDef))]
	public sealed class YuukaFlowersBirdsWindAndMoonSe : StatusEffect
	{
		public ManaGroup Mana { get; private set; }

		protected override void OnAdded(Unit unit)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
			ManaGroup mana = default(ManaGroup);
			((ManaGroup)(ref mana)).Any = ((StatusEffect)this).Level;
			Mana = mana;
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if (args.Card.HasKeyword((Keyword)4398046511104L) || ((Enum)args.Card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L))
			{
				((StatusEffect)this).NotifyActivating();
				if (args.Card is ReimuSakura)
				{
					args.Card.DecreaseBaseCost(Mana);
				}
				yield return (BattleAction)(object)new IncreasePlayCountAction(args.Card, ((StatusEffect)this).Level);
			}
			if (args.Card is SummerFlower)
			{
				((StatusEffect)this).NotifyActivating();
				yield return ((StatusEffect)this).BuffAction<SummerFlowerSe>(args.Card.Value1 * ((StatusEffect)this).Level, 0, 0, 0, 0.2f);
			}
		}
	}
	public sealed class YuukaFrostNocturneSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaFrostNocturneSeDef))]
	public sealed class YuukaFrostNocturneSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(((Unit)((StatusEffect)this).Battle.Player).StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)StatusEffectAdded);
		}

		private IEnumerable<BattleAction> StatusEffectAdded(StatusEffectApplyEventArgs args)
		{
			if (args.Effect is YuukaBloomSe)
			{
				int level = args.Level.GetValueOrDefault();
				yield return ((StatusEffect)this).BuffAction<FrostArmor>(((StatusEffect)this).Level * level, 0, 0, 0, 0.2f);
			}
		}
	}
	public sealed class YuukaGardenArchitectChoice1SeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaGardenArchitectChoice1SeDef))]
	public sealed class YuukaGardenArchitectChoice1Se : StatusEffect
	{
		public ManaGroup Mana;

		public int FlowerReq => YuukaGardenArchitectConfig.Option1FlowerToBonus;

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardsEventArgs>(((StatusEffect)this).Battle.CardsAddedToDiscard, (EventSequencedReactor<CardsEventArgs>)OnCardsAddedToDiscard);
			((StatusEffect)this).ReactOwnerEvent<CardsEventArgs>(((StatusEffect)this).Battle.CardsAddedToHand, (EventSequencedReactor<CardsEventArgs>)OnCardsAddedToHand);
			((StatusEffect)this).ReactOwnerEvent<CardsAddingToDrawZoneEventArgs>(((StatusEffect)this).Battle.CardsAddedToDrawZone, (EventSequencedReactor<CardsAddingToDrawZoneEventArgs>)OnCardsAddedToDrawZone);
		}

		private IEnumerable<BattleAction> OnCardsAddedToHand(CardsEventArgs args)
		{
			List<Card> list = args.Cards.Where((Card card) => card is SummerFlower).ToList();
			if (list.Count == 0)
			{
				yield break;
			}
			foreach (Card card2 in list)
			{
				if (((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<YuukaBouquetBindingSe>() == null)
				{
					yield return (BattleAction)new ExileCardAction(card2);
				}
				if (((StatusEffect)this).Count == 1)
				{
					new List<Card>();
					List<Card> list2 = (from card in ((StatusEffect)this).Battle.HandZone.Concat(((StatusEffect)this).Battle.DrawZoneToShow).Concat(((StatusEffect)this).Battle.DiscardZone)
						where card.HasKeyword((Keyword)4398046511104L) || ((Enum)card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L)
						select card).ToList();
					foreach (Card card3 in list2)
					{
						if (card2 is ReimuSakura)
						{
							card2.DecreaseBaseCost(Mana * ((StatusEffect)this).Level);
						}
						yield return (BattleAction)(object)new IncreasePlayCountAction(card3, ((StatusEffect)this).Level);
					}
					((StatusEffect)this).Count = YuukaGardenArchitectConfig.Option1FlowerToBonus;
					((StatusEffect)this).NotifyActivating();
				}
				else
				{
					((StatusEffect)this).Count = ((StatusEffect)this).Count - 1;
				}
			}
		}

		private IEnumerable<BattleAction> OnCardsAddedToDiscard(CardsEventArgs args)
		{
			List<Card> list = args.Cards.Where((Card card) => card is SummerFlower).ToList();
			if (list.Count == 0)
			{
				yield break;
			}
			foreach (Card card2 in list)
			{
				if (((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<YuukaBouquetBindingSe>() == null)
				{
					yield return (BattleAction)new ExileCardAction(card2);
				}
				if (((StatusEffect)this).Count == 1)
				{
					new List<Card>();
					List<Card> list2 = (from card in ((StatusEffect)this).Battle.HandZone.Concat(((StatusEffect)this).Battle.DrawZoneToShow).Concat(((StatusEffect)this).Battle.DiscardZone)
						where card.HasKeyword((Keyword)4398046511104L) || ((Enum)card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L)
						select card).ToList();
					foreach (Card card3 in list2)
					{
						if (card2 is ReimuSakura)
						{
							card2.DecreaseBaseCost(Mana * ((StatusEffect)this).Level);
						}
						yield return (BattleAction)(object)new IncreasePlayCountAction(card3, ((StatusEffect)this).Level);
					}
					((StatusEffect)this).Count = YuukaGardenArchitectConfig.Option1FlowerToBonus;
					((StatusEffect)this).NotifyActivating();
				}
				else
				{
					((StatusEffect)this).Count = ((StatusEffect)this).Count - 1;
				}
			}
		}

		private IEnumerable<BattleAction> OnCardsAddedToDrawZone(CardsAddingToDrawZoneEventArgs args)
		{
			List<Card> list = args.Cards.Where((Card card) => card is SummerFlower).ToList();
			if (list.Count == 0)
			{
				yield break;
			}
			foreach (Card card2 in list)
			{
				if (((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<YuukaBouquetBindingSe>() == null)
				{
					yield return (BattleAction)new ExileCardAction(card2);
				}
				if (((StatusEffect)this).Count == 1)
				{
					new List<Card>();
					List<Card> list2 = (from card in ((StatusEffect)this).Battle.HandZone.Concat(((StatusEffect)this).Battle.DrawZoneToShow).Concat(((StatusEffect)this).Battle.DiscardZone)
						where card.HasKeyword((Keyword)4398046511104L) || ((Enum)card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L)
						select card).ToList();
					foreach (Card card3 in list2)
					{
						if (card2 is ReimuSakura)
						{
							card2.DecreaseBaseCost(Mana * ((StatusEffect)this).Level);
						}
						yield return (BattleAction)(object)new IncreasePlayCountAction(card3, ((StatusEffect)this).Level);
					}
					((StatusEffect)this).Count = YuukaGardenArchitectConfig.Option1FlowerToBonus;
					((StatusEffect)this).NotifyActivating();
				}
				else
				{
					((StatusEffect)this).Count = ((StatusEffect)this).Count - 1;
				}
			}
		}

		public YuukaGardenArchitectChoice1Se()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//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)
			ManaGroup mana = default(ManaGroup);
			((ManaGroup)(ref mana)).Any = YuukaSeasonsConfig.GrowValue;
			Mana = mana;
			((StatusEffect)this)..ctor();
		}
	}
	public sealed class YuukaGardenArchitectChoice2SeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaGardenArchitectChoice2SeDef))]
	public sealed class YuukaGardenArchitectChoice2Se : 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 (args.Card.HasKeyword((Keyword)4398046511104L) || ((Enum)args.Card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L))
			{
				yield return ((StatusEffect)this).BuffAction<SummerFlowerSe>(((StatusEffect)this).Level, 0, 0, 0, 0.2f);
			}
		}
	}
	public sealed class YuukaGardenArchitectChoice3SeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaGardenArchitectChoice3SeDef))]
	public sealed class YuukaGardenArchitectChoice3Se : StatusEffect
	{
		public int BloomReq => YuukaGardenArchitectConfig.Option3BloomToBonus;

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(((Unit)((StatusEffect)this).Battle.Player).StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)StatusEffectAdded);
		}

		private IEnumerable<BattleAction> StatusEffectAdded(StatusEffectApplyEventArgs args)
		{
			if (!(args.Effect is YuukaBloomSe))
			{
				yield break;
			}
			int bloom = args.Level.GetValueOrDefault();
			if (bloom >= ((StatusEffect)this).Count)
			{
				while (bloom >= ((StatusEffect)this).Count)
				{
					bloom -= ((StatusEffect)this).Count;
					yield return ((StatusEffect)this).BuffAction<Firepower>(YuukaGardenArchitectConfig.Option3FirepowerBonus * ((StatusEffect)this).Level, 0, 0, 0, 0.2f);
					((StatusEffect)this).Count = YuukaGardenArchitectConfig.Option3BloomToBonus;
				}
				if (bloom > 0)
				{
					((StatusEffect)this).Count = ((StatusEffect)this).Count - bloom;
				}
			}
			else
			{
				((StatusEffect)this).Count = ((StatusEffect)this).Count - bloom;
			}
		}
	}
	public sealed class YuukaGardenOfEndlessSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 40;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaGardenOfEndlessSeDef))]
	public sealed class YuukaGardenOfEndlessSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnTurnStarted);
		}

		private IEnumerable<BattleAction> OnTurnStarted(UnitEventArgs args)
		{
			<>n__0();
			yield return (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<SummerFlower>(((StatusEffect)this).Level, false), (AddCardsType)0);
			int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
			if (turnCounter % 3 == 0)
			{
				yield return (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<SummerFlower>(turnCounter / 3, false), (AddCardsType)0);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YuukaNightSkyDanceSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaNightSkyDanceSeDef))]
	public sealed class YuukaNightSkyDanceSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<DamageEventArgs>(((Unit)((StatusEffect)this).Battle.Player).DamageReceived, (EventSequencedReactor<DamageEventArgs>)OnPlayerDamageReceived);
		}

		private IEnumerable<BattleAction> OnPlayerDamageReceived(DamageEventArgs args)
		{
			DamageInfo damageInfo = args.DamageInfo;
			if (((DamageInfo)(ref damageInfo)).IsGrazed)
			{
				<>n__0();
				yield return (BattleAction)(object)new ApplyStatusEffectAction<YuukaFervorNextTurnSe>(((StatusEffect)this).Owner, (int?)((StatusEffect)this).Level, (int?)null, (int?)null, (int?)null, 0f, true);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YuukaPerfectCompositionSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaPerfectCompositionSeDef))]
	public sealed class YuukaPerfectCompositionSe : StatusEffect
	{
		private string Header => ((GameEntity)this).LocalizeProperty("Header", false, true);

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

		private IEnumerable<BattleAction> OnOwnerTurnEnding(UnitEventArgs args)
		{
			if (((StatusEffect)this).Battle.BattleShouldEnd)
			{
				yield break;
			}
			List<Card> list = (from card in ((StatusEffect)this).Battle.HandZone.Concat(((StatusEffect)this).Battle.DrawZoneToShow).Concat(((StatusEffect)this).Battle.DiscardZone)
				select (card)).ToList();
			if (CollectionsExtensions.Empty<Card>((IReadOnlyCollection<Card>)list))
			{
				yield break;
			}
			SelectHandInteraction interaction = new SelectHandInteraction(0, ((StatusEffect)this).Level, (IEnumerable<Card>)list);
			((Interaction)interaction).Description = Header;
			yield return (BattleAction)new InteractionAction((Interaction)(object)interaction, false);
			IReadOnlyList<Card> cards = interaction.SelectedCards;
			if (cards.Count <= 0)
			{
				yield break;
			}
			foreach (Card card2 in cards)
			{
				KeywordManager.AddCustomKeyword(card2, YuukaKeywords.YuukaArrangedKW);
				yield return (BattleAction)new MoveCardToDrawZoneAction(card2, (DrawZoneTarget)0);
			}
		}
	}
	public sealed class YuukaPerfectSlumbersSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 100;
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaPerfectSlumbersSeDef))]
	public sealed class YuukaPerfectSlumbersSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			bool sleep = true;
			if (args.Unit.GetStatusEffect<SuperExtraTurn>() != null)
			{
				SuperExtraTurn SET = ((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<SuperExtraTurn>();
				if (SET.IsInExtraTurnByThis)
				{
					sleep = false;
				}
			}
			if (!sleep)
			{
				yield break;
			}
			yield return (BattleAction)new RequestEndPlayerTurnAction();
			if (((StatusEffect)this).Level <= 0)
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
				yield break;
			}
			((StatusEffect)this).Level = ((StatusEffect)this).Level - 1;
			if (((StatusEffect)this).Level <= 0)
			{
				yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
			}
		}
	}
	public sealed class YuukaPhotosynthesisSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaPhotosynthesisSeDef))]
	public sealed class YuukaPhotosynthesisSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			ManaGroup consumingMana = args.ConsumingMana;
			if (((ManaGroup)(ref consumingMana)).Amount >= 3)
			{
				yield return ((StatusEffect)this).BuffAction<YuukaBloomSe>(((StatusEffect)this).Level, 0, 0, 0, 0.2f);
			}
		}
	}
	public sealed class YuukaShedBloomShieldBornSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaShedBloomShieldBornSeDef))]
	public sealed class YuukaShedBloomShieldBornSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
		}
	}
	public sealed class YuukaSolarCoronationSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaSolarCoronationSeDef))]
	public sealed class YuukaSolarCoronationSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
			if (turnCounter % 3 == 0)
			{
				yield return ((StatusEffect)this).BuffAction<YuukaFervorSe>(((StatusEffect)this).Level, 0, 0, 0, 0.2f);
				((StatusEffect)this).Level = ((StatusEffect)this).Level + 50;
				((StatusEffect)this).NotifyActivating();
			}
		}
	}
	public sealed class YuukaSplittingSovereignSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaSplittingSovereignSeDef))]
	public sealed class YuukaSplittingSovereignSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsing, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsing);
		}

		private IEnumerable<BattleAction> OnCardUsing(CardUsingEventArgs args)
		{
			if ((int)args.Card.CardType == 1 || (int)args.Card.CardType == 2 || (int)args.Card.CardType == 4)
			{
				<>n__0();
				args.PlayTwice = true;
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				int num = ((StatusEffect)this).Level - 1;
				((StatusEffect)this).Level = num;
				if (((StatusEffect)this).Level <= 0)
				{
					yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
				}
			}
		}

		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YuukaSplittingSovereignUnlimitedSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasLevel = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaSplittingSovereignUnlimitedSeDef))]
	public sealed class YuukaSplittingSovereignUnlimitedSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsing, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsing);
		}

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

		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YuukaSpringsAccordSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 15;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaSpringsAccordSeDef))]
	public sealed class YuukaSpringsAccordSe : StatusEffect
	{
		public ManaGroup Mana
		{
			get
			{
				//IL_0003: 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)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup result = default(ManaGroup);
				((ManaGroup)(ref result)).Philosophy = ((StatusEffect)this).Level;
				return result;
			}
		}

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

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			if (BloomUtility.CheckBloomLevel(((StatusEffect)this).Battle, ((StatusEffect)this).Level))
			{
				((StatusEffect)this).NotifyActivating();
				yield return (BattleAction)new GainManaAction(Mana);
				yield return (BattleAction)new DrawManyCardAction(((StatusEffect)this).Level);
				YuukaBloomSe statusEffect = ((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<YuukaBloomSe>();
				((StatusEffect)statusEffect).Level = ((StatusEffect)statusEffect).Level - ((StatusEffect)this).Level;
				if (((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<YuukaShedBloomShieldBornSe>() != null)
				{
					YuukaShedBloomShieldBornSe pv = ((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<YuukaShedBloomShieldBornSe>();
					yield return (BattleAction)new CastBlockShieldAction((Unit)(object)((StatusEffect)this).Battle.Player, 0, ((StatusEffect)pv).Level * ((StatusEffect)this).Level, (BlockShieldType)2, true);
				}
				if (((StatusEffect)statusEffect).Level == 0)
				{
					yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)statusEffect, true, 0.1f);
				}
			}
		}
	}
	public sealed class YuukaSunlitAfternoonTeaSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasLevel = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaSunlitAfternoonTeaSeDef))]
	public sealed class YuukaSunlitAfternoonTeaSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(((StatusEffect)this).Owner.StatusEffectAdding, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnStatusEffectAdding);
		}

		private IEnumerable<BattleAction> OnStatusEffectAdding(StatusEffectApplyEventArgs args)
		{
			if (args.Effect is Fragil || args.Effect is Weak || args.Effect is Vulnerable)
			{
				((GameEventArgs)args).CancelBy((GameEntity)(object)this);
				<>n__0();
			}
			yield break;
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YuukaTempFpNextTurnSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 11;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaTempFpNextTurnSeDef))]
	public sealed class YuukaTempFpNextTurnSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			yield return ((StatusEffect)this).BuffAction<TempFirepower>(((StatusEffect)this).Level, 0, 0, 0, 0.2f);
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class YuukaTyrantOfTheGardenSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaTyrantOfTheGardenSeDef))]
	public sealed class YuukaTyrantOfTheGardenSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<GameEventArgs>(((StatusEffect)this).Battle.BattleEnding, (EventSequencedReactor<GameEventArgs>)OnBattleEnding);
			GameRunController gameRun = ((GameEntity)this).GameRun;
			gameRun.EnemyVulnerableExtraPercentage += ((StatusEffect)this).Level;
		}

		public override bool Stack(StatusEffect other)
		{
			GameRunController gameRun = ((GameEntity)this).GameRun;
			gameRun.EnemyVulnerableExtraPercentage += other.Level;
			return ((StatusEffect)this).Stack(other);
		}

		private IEnumerable<BattleAction> OnBattleEnding(GameEventArgs args)
		{
			GameRunController gameRun = ((GameEntity)this).GameRun;
			gameRun.EnemyVulnerableExtraPercentage -= ((StatusEffect)this).Level;
			yield break;
		}
	}
	public sealed class YuukaVulnerableNextTurnSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaVulnerableNextTurnSeDef))]
	public sealed class YuukaVulnerableNextTurnSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			((StatusEffect)this).NotifyActivating();
			foreach (BattleAction item in ((StatusEffect)this).DebuffAction<Vulnerable>((IEnumerable<Unit>)((StatusEffect)this).Battle.AllAliveEnemies, 0, ((StatusEffect)this).Level, 0, 0, true, 0.2f))
			{
				yield return item;
			}
			yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
		}
	}
	public sealed class YuukaWheelOfSeasonsSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaWheelOfSeasonsSeDef))]
	public sealed class YuukaWheelOfSeasonsSe : StatusEffect
	{
		public string S1a
		{
			get
			{
				int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
				if (turnCounter % 3 == 1)
				{
					return "<b>";
				}
				return "";
			}
		}

		public string S2a
		{
			get
			{
				int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
				if (turnCounter % 3 == 2)
				{
					return "<b>";
				}
				return "";
			}
		}

		public string S3a
		{
			get
			{
				int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
				if (turnCounter % 3 == 0)
				{
					return "<b>";
				}
				return "";
			}
		}

		public string S1b
		{
			get
			{
				int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
				if (turnCounter % 3 == 1)
				{
					return ((GameEntity)this).LocalizeProperty("Header", false, true);
				}
				return "";
			}
		}

		public string S2b
		{
			get
			{
				int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
				if (turnCounter % 3 == 2)
				{
					return ((GameEntity)this).LocalizeProperty("Header", false, true);
				}
				return "";
			}
		}

		public string S3b
		{
			get
			{
				int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
				if (turnCounter % 3 == 0)
				{
					return ((GameEntity)this).LocalizeProperty("Header", false, true);
				}
				return "";
			}
		}

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

		private IEnumerable<BattleAction> OnOwnerTurnEnding(UnitEventArgs args)
		{
			int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = ((StatusEffect)this).Level;
			ManaGroup Mana = val;
			if (turnCounter % 3 == 1)
			{
				yield return ((StatusEffect)this).BuffAction<YuukaBloomSe>(((StatusEffect)this).Level * YuukaSeasonsConfig.BloomValue, 0, 0, 0, 0.2f);
			}
			else if (turnCounter % 3 == 2)
			{
				new List<Card>();
				List<Card> list = (from card in ((StatusEffect)this).Battle.HandZone.Concat(((StatusEffect)this).Battle.DrawZoneToShow).Concat(((StatusEffect)this).Battle.DiscardZone)
					where card.HasKeyword((Keyword)4398046511104L) || ((Enum)card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L)
					select card).ToList();
				foreach (Card card2 in list)
				{
					if (card2 is ReimuSakura)
					{
						card2.DecreaseBaseCost(Mana);
					}
					yield return (BattleAction)(object)new IncreasePlayCountAction(card2, ((StatusEffect)this).Level * YuukaSeasonsConfig.GrowValue);
				}
				yield return ((StatusEffect)this).BuffAction<SummerFlowerSe>(((StatusEffect)this).Level * YuukaSeasonsConfig.SummerFlowerValue, 0, 0, 0, 0.2f);
			}
			else
			{
				if (args.Unit.GetStatusEffect<YuukaFervorSe>() != null)
				{
					YuukaFervorSe FervorSe = ((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<YuukaFervorSe>();
					int FervorCount = ((StatusEffect)FervorSe).Level / YuukaSeasonsConfig.FervorValue;
					yield return (BattleAction)new CastBlockShieldAction(args.Unit, args.Unit, 0, ((StatusEffect)this).Level * FervorCount * YuukaSeasonsConfig.BarrierValue, (BlockShieldType)2, true);
				}
				yield return ((StatusEffect)this).BuffAction<YuukaWheelOfSeasonsSe>(1, 0, 0, 0, 0.2f);
			}
		}
	}
	public sealed class YuukaWovenContingencySeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaWovenContingencySeDef))]
	public sealed class YuukaWovenContingencySe : StatusEffect
	{
		public string ExtraRule
		{
			get
			{
				int turnCounter = ((Unit)((StatusEffect)this).Battle.Player).TurnCounter;
				if (((StatusEffect)this).Level == 6)
				{
					return " <b>past the first</b>";
				}
				return "";
			}
		}

		private string Header => ((GameEntity)this).LocalizeProperty("Header", false, true);

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

		private IEnumerable<BattleAction> OnOwnerTurnEnding(UnitEventArgs args)
		{
			if (((StatusEffect)this).Battle.BattleShouldEnd)
			{
				yield break;
			}
			List<Card> list = ((StatusEffect)this).Battle.HandZone.Where((Card hand) => !hand.IsTempRetain && !hand.IsRetain && !hand.Summoned && !hand.IsEthereal).ToList();
			if (CollectionsExtensions.Empty<Card>((IReadOnlyCollection<Card>)list))
			{
				yield break;
			}
			SelectHandInteraction interaction = new SelectHandInteraction(0, 5, (IEnumerable<Card>)list);
			((Interaction)interaction).Description = Header;
			yield return (BattleAction)new InteractionAction((Interaction)(object)interaction, false);
			int selectedCardCount = interaction.SelectedCards.Count();
			foreach (Card card in interaction.SelectedCards)
			{
				if (!card.IsRetain && !card.Summoned)
				{
					card.IsTempRetain = true;
				}
			}
			if (((StatusEffect)this).Level == 5 && selectedCardCount > 0)
			{
				yield return ((StatusEffect)this).BuffAction<YuukaDrawReductionNextTurnSe>(selectedCardCount, 0, 0, 0, 0.2f);
			}
			else if (((StatusEffect)this).Level == 6 && selectedCardCount > 1)
			{
				yield return ((StatusEffect)this).BuffAction<YuukaDrawReductionNextTurnSe>(selectedCardCount - 1, 0, 0, 0, 0.2f);
			}
		}
	}
}
namespace YuukaMod.Patches
{
	[HarmonyPatch(typeof(AudioManager), "PlayBossBgm")]
	internal class AudioManager_PlayBossBgm_Patch_Yuuka
	{
		private static bool Prefix(AudioManager __instance)
		{
			GameMaster instance = Singleton<GameMaster>.Instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameRunController currentGameRun = instance.CurrentGameRun;
				obj = ((currentGameRun != null) ? currentGameRun.CurrentStation : null);
			}
			Station val = (Station)obj;
			BossStation val2 = (BossStation)(object)((val is BossStation) ? val : null);
			if (val2 != null)
			{
				EnemyGroup enemyGroup = ((BattleStation)val2).EnemyGroup;
				if (((enemyGroup != null) ? enemyGroup.Id : null) == "YuukaMod")
				{
					BepinexPlugin.log.LogInfo((object)"Playing Yuuka Boss BGM: YuukaBossBgm");
					AudioManager.PlayInLayer1("YuukaBossBgm");
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal class CustomGameEventManager
	{
		public static GameEvent<IncreasePlayCountEventArgs> PreIncreasePlayCountEvent { get; set; }

		public static GameEvent<IncreasePlayCountEventArgs> PostIncreasePlayCountEvent { get; set; }

		[HarmonyPatch(typeof(GameRunController), "EnterBattle")]
		private static bool Prefix(GameRunController __instance)
		{
			PreIncreasePlayCountEvent = new GameEvent<IncreasePlayCountEventArgs>();
			PostIncreasePlayCountEvent = new GameEvent<IncreasePlayCountEventArgs>();
			return true;
		}
	}
	[HarmonyPatch]
	internal class CardWidget_GrowCountDisplay_Patch
	{
		private const string GrowCountGoName = "GrowCountTracker";

		[HarmonyPatch(typeof(CardWidget), "SetProperties")]
		[HarmonyPostfix]
		private static void SetProperties_Postfix(CardWidget __instance)
		{
			UpdateGrowCountDisplay(__instance);
		}

		[HarmonyPatch(typeof(CardWidget), "LazySetCard")]
		[HarmonyPostfix]
		private static void LazySetCard_Postfix(CardWidget __instance)
		{
			UpdateGrowCountDisplay(__instance);
		}

		private static void UpdateGrowCountDisplay(CardWidget __instance)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.Card == null)
			{
				return;
			}
			Card card = __instance.Card;
			bool flag = card.Battle != null;
			bool flag2 = card.HasKeyword((Keyword)4398046511104L) || ((Enum)card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L);
			bool flag3 = flag && flag2;
			Transform val = ((Component)__instance).transform.Find("GrowCountTracker");
			GameObject val2 = (((Object)(object)val != (Object)null) ? ((Component)val).gameObject : null);
			if (flag3)
			{
				if ((Object)(object)ModAssetManager.GrowIcon == (Object)null)
				{
					BepinexPlugin.log.LogError((object)"GrowIcon not loaded!");
					return;
				}
				if ((Object)(object)val2 == (Object)null)
				{
					GameObject baseLoyaltyObj = __instance.baseLoyaltyObj;
					if ((Object)(object)baseLoyaltyObj == (Object)null)
					{
						BepinexPlugin.log.LogError((object)"baseLoyaltyObj is null, cannot clone for GrowCount display.");
						return;
					}
					val2 = Object.Instantiate<GameObject>(baseLoyaltyObj, baseLoyaltyObj.transform.parent, false);
					((Object)val2).name = "GrowCountTracker";
					val2.transform.localPosition = baseLoyaltyObj.transform.localPosition + new Vector3(0f, 90f, 0f);
				}
				Image component = val2.GetComponent<Image>();
				Transform obj = val2.transform.Find("BaseLoyaltyText");
				TextMeshProUGUI val3 = ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null);
				if ((Object)(object)component == (Object)null || (Object)(object)val3 == (Object)null)
				{
					ManualLogSource log = BepinexPlugin.log;
					GameObject baseLoyaltyObj2 = __instance.baseLoyaltyObj;
					log.LogError((object)("GrowCountTracker is missing Image or TextMeshProUGUI component(s). Cloned from: " + ((baseLoyaltyObj2 != null) ? ((Object)baseLoyaltyObj2).name : null)));
					Object.Destroy((Object)(object)val2);
				}
				else
				{
					component.sprite = ModAssetManager.GrowIcon;
					((Behaviour)component).enabled = true;
					((TMP_Text)val3).text = card.GrowCount.ToString();
					((Behaviour)val3).enabled = true;
					val2.SetActive(true);
				}
			}
			else if ((Object)(object)val2 != (Object)null)
			{
				val2.SetActive(false);
			}
		}
	}
}
namespace YuukaMod.model
{
	public sealed class YuukaModel : UnitModelTemplate
	{
		public static bool useInGameModel = BepinexPlugin.useInGameModel;

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

		public static string spellsprite_name = "YuukaStand.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)YuukaLocalization.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 YuukaMod.Localization
{
	public sealed class YuukaLocalization
	{
		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 string Jadeboxes = "Jadeboxes";

		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 BatchLocalization JadeboxesBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(StatusEffectTemplate), Jadeboxes, (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);
			JadeboxesBatchLoc.DiscoverAndLoadLocFiles(Jadeboxes);
		}
	}
}
namespace YuukaMod.Keywords
{
	public static class YuukaKeywords
	{
		public static CardKeyword YuukaArrangedKW => new CardKeyword("YuukaArrangedKeyword", false)
		{
			descPos = (KwDescPos)1
		};
	}
}
namespace YuukaMod.Source.Keywords
{
	internal static class YuukaCharacterArrangedHandle
	{
		public static int ArrangePriority = 10;

		public static GameEvent<UnitEventArgs> GetBounceEvent(BattleController battle)
		{
			return ((Unit)battle.Player).TurnEnding;
		}

		public static GameEvent<CardMovingEventArgs> GetCardMovedEvent(BattleController battle)
		{
			return battle.CardMoved;
		}

		public static void RegisterHandlers()
		{
			CHandlerManager.RegisterBattleEventHandler<CardMovingEventArgs>((EventProvider<CardMovingEventArgs, BattleController>)((BattleController b) => GetCardMovedEvent(b)), (GameEventHandler<CardMovingEventArgs>)OnCardMoved, (Predicate<BattleController>)null, (GameEventPriority)ArrangePriority);
		}

		private static void OnCardMoved(CardMovingEventArgs args)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			if (KeywordManager.HasCustomKeyword(args.Card, "YuukaArrangedKeyword") && ((int)args.SourceZone == 5 || (int)args.SourceZone == 2) && ((int)args.DestinationZone == 3 || (int)args.DestinationZone == 4))
			{
				KeywordManager.RemoveCustomKeyword(args.Card, YuukaKeywords.YuukaArrangedKW);
			}
		}
	}
	internal static class YuukaSecondCardTracker
	{
		private static int cardCounter = 0;

		public static int TrackerPriority = 10;

		public static Card SecondCard { get; private set; }

		public static void RegisterHandlers()
		{
			CHandlerManager.RegisterBattleEventHandler<GameEventArgs>((EventProvider<GameEventArgs, BattleController>)((BattleController b) => b.BattleStarted), (GameEventHandler<GameEventArgs>)OnBattleStart, (Predicate<BattleController>)null, (GameEventPriority)TrackerPriority);
			CHandlerManager.RegisterBattleEventHandler<CardUsingEventArgs>((EventProvider<CardUsingEventArgs, BattleController>)((BattleController b) => b.CardUsing), (GameEventHandler<CardUsingEventArgs>)OnCardUsed, (Predicate<BattleController>)null, (GameEventPriority)TrackerPriority);
			CHandlerManager.RegisterBattleEventHandler<GameEventArgs>((EventProvider<GameEventArgs, BattleController>)((BattleController b) => b.BattleEnded), (GameEventHandler<GameEventArgs>)OnBattleEnd, (Predicate<BattleController>)null, (GameEventPriority)TrackerPriority);
		}

		private static void OnBattleStart(GameEventArgs args)
		{
			ResetTracker();
		}

		private static void OnCardUsed(CardUsingEventArgs args)
		{
			cardCounter++;
			if (cardCounter == 2)
			{
				SecondCard = args.Card;
			}
		}

		private static void OnBattleEnd(GameEventArgs args)
		{
			ResetTracker();
		}

		private static void ResetTracker()
		{
			cardCounter = 0;
			SecondCard = null;
		}
	}
	internal class YuukaGardenArchitectValues
	{
	}
	internal class YuukaWheelOfSeasonsValues
	{
	}
}
namespace YuukaMod.Logic
{
	public static class BloomUtility
	{
		public static int GetBloomLevel(BattleController battle)
		{
			YuukaBloomSe statusEffect = ((Unit)battle.Player).GetStatusEffect<YuukaBloomSe>();
			return (statusEffect != null) ? ((StatusEffect)statusEffect).Level : 0;
		}

		public static bool CheckBloomLevel(BattleController battle, int threshold)
		{
			return GetBloomLevel(battle) >= threshold;
		}
	}
	public class FlourishChoiceResult
	{
		public bool FlourishChosen { get; set; }

		public IEnumerable<BattleAction> Actions { get; set; }
	}
	public static class FlourishUtility
	{
		public static FlourishChoiceResult OfferFlourishChoice<TCard>(TCard sourceCard, int bloomRequirement) where TCard : YuukaCard
		{
			FlourishChoiceResult result = new FlourishChoiceResult
			{
				FlourishChosen = false,
				Actions = Enumerable.Empty<BattleAction>()
			};
			if (!BloomUtility.CheckBloomLevel(((Card)sourceCard).Battle, bloomRequirement))
			{
				return result;
			}
			List<TCard> copies = Library.CreateCards<TCard>(2, ((Card)sourceCard).IsUpgraded).ToList();
			TCard val = copies[0];
			TCard flourishCard = copies[1];
			((Card)val).ChoiceCardIndicator = 1;
			((Card)flourishCard).ChoiceCardIndicator = 2;
			((Card)val).SetBattle(((Card)sourceCard).Battle);
			((Card)flourishCard).SetBattle(((Card)sourceCard).Battle);
			result.Actions = actionIterator();
			return result;
			IEnumerable<BattleAction> actionIterator()
			{
				MiniSelectCardInteraction choiceInteraction = new MiniSelectCardInteraction((IEnumerable<Card>)copies, false, false, false)
				{
					Source = (GameEntity)(object)sourceCard
				};
				yield return (BattleAction)new InteractionAction((Interaction)(object)choiceInteraction, false);
				result.FlourishChosen = choiceInteraction.SelectedCard == flourishCard;
			}
		}

		public static IEnumerable<BattleAction> ApplyFlourishCost<TCard>(TCard sourceCard, int bloomCost) where TCard : YuukaCard
		{
			BattleController battle = ((Card)sourceCard).Battle;
			YuukaBloomSe statusEffect = ((Unit)battle.Player).GetStatusEffect<YuukaBloomSe>();
			if (statusEffect != null)
			{
				((StatusEffect)statusEffect).Level = ((StatusEffect)statusEffect).Level - bloomCost;
				YuukaShedBloomShieldBornSe shieldEffect = ((Unit)battle.Player).GetStatusEffect<YuukaShedBloomShieldBornSe>();
				if (shieldEffect != null)
				{
					yield return (BattleAction)new CastBlockShieldAction((Unit)(object)battle.Player, 0, ((StatusEffect)shieldEffect).Level * bloomCost, (BlockShieldType)2, true);
				}
				if (((StatusEffect)statusEffect).Level <= 0)
				{
					yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)statusEffect, true, 0.1f);
				}
			}
		}
	}
}
namespace YuukaMod.JadeBoxes
{
	[EntityLogic(typeof(GardenOfDreamsJadeBoxDef))]
	public sealed class GardenOfDreamsJadeBox : JadeBox
	{
		[HarmonyPatch(typeof(GameRunController), "RollCards")]
		[HarmonyPatch(new Type[]
		{
			typeof(RandomGen),
			typeof(CardWeightTable),
			typeof(int),
			typeof(ManaGroup?),
			typeof(bool),
			typeof(bool),
			typeof(bool),
			typeof(bool),
			typeof(Predicate<CardConfig>)
		})]
		private class GameRunController_RollCards_Patch
		{
			private static void Postfix(ref Card[] __result, GameRunController __instance, bool battleRolling, RandomGen rng)
			{
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Invalid comparison between Unknown and I4
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Invalid comparison between Unknown and I4
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Invalid comparison between Unknown and I4
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				if (!IsActive(__instance) || battleRolling || __result == null || __result.Length == 0)
				{
					return;
				}
				GardenOfDreamsJadeBox gardenOfDreamsJadeBox = null;
				foreach (JadeBox jadeBox in __instance.JadeBoxes)
				{
					if (jadeBox is GardenOfDreamsJadeBox gardenOfDreamsJadeBox2)
					{
						gardenOfDreamsJadeBox = gardenOfDreamsJadeBox2;
						break;
					}
				}
				if (gardenOfDreamsJadeBox == null)
				{
					BepinexPlugin.log.LogWarning((object)"GardenOfDreamsJadeBox: IsActive was true, but couldn't find the JadeBox instance in GameRunController.JadeBoxes.");
					return;
				}
				int value = ((JadeBox)gardenOfDreamsJadeBox).Value1;
				CardConfig val = CardConfig.FromId(ReplacementCardId);
				if (val == null)
				{
					BepinexPlugin.log.LogError((object)("GardenOfDreamsJadeBox: Replacement card ID '" + ReplacementCardId + "' not found."));
					return;
				}
				List<Card> list = new List<Card>(__result.Length);
				Card[] array = __result;
				foreach (Card val2 in array)
				{
					if (val2 == null)
					{
						list.Add(null);
						continue;
					}
					if ((int)val2.CardType == 6)
					{
						list.Add(val2);
						continue;
					}
					Rarity rarity = val2.Config.Rarity;
					bool flag = (int)rarity == 1;
					bool flag2 = (int)rarity == 2;
					if ((flag || flag2) && val2.Config.Id != ReplacementCardId)
					{
						bool flag3 = true;
						if (value < 100)
						{
							int num = rng.NextInt(0, 99);
							if (num >= value)
							{
								flag3 = false;
								BepinexPlugin.log.LogInfo((object)$"GardenOfDreamsJadeBox: Rolled {num}, NOT replacing {((GameEntity)val2).Name} due to {value}% chance.");
							}
						}
						if (flag3)
						{
							BepinexPlugin.log.LogDebug((object)$"GardenOfDreamsJadeBox: Attempting to replace {((GameEntity)val2).Name} (Rarity: {rarity})");
							Card val3 = Library.CreateCard(ReplacementCardId);
							if (val3 != null)
							{
								((GameEntity)val3).GameRun = __instance;
								list.Add(val3);
								BepinexPlugin.log.LogInfo((object)("GardenOfDreamsJadeBox: Replaced '" + ((GameEntity)val2).Name + "' with '" + ((GameEntity)val3).Name + "'."));
							}
							else
							{
								BepinexPlugin.log.LogError((object)("GardenOfDreamsJadeBox: Failed to create instance of '" + ReplacementCardId + "'. Keeping original '" + ((GameEntity)val2).Name + "'."));
								list.Add(val2);
							}
						}
						else
						{
							list.Add(val2);
						}
					}
					else
					{
						list.Add(val2);
					}
				}
				__result = list.ToArray();
			}
		}

		private static string ReplacementCardId => "YuukaCharacterGardenOfBorrowedDreams";

		public int currentReplacementChance => ((JadeBox)this).Value1;

		public static bool IsActive(GameRunController run)
		{
			return run != null && run.HasJadeBox<GardenOfDreamsJadeBox>();
		}
	}
	public sealed class GardenOfDreamsJadeBoxDef : JadeBoxTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("GardenOfDreamsJadeBox");
		}

		public override JadeBoxConfig MakeConfig()
		{
			JadeBoxConfig val = ((JadeBoxTemplate)this).DefaultConfig();
			int value = BepinexPlugin.gardenJadeboxReplacementChance.Value;
			val.Value1 = Mathf.Clamp(value, 0, 100);
			return val;
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.jadeboxLoc.AddEntity((EntityDefinition)(object)this);
		}
	}
}
namespace YuukaMod.ImageLoader
{
	public sealed class YuukaImageLoader
	{
		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)1, ".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 YuukaMod.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 YuukaMod.Exhibits
{
	public sealed class YuukaExhibitADef : YuukaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Value1 = 2;
			defaultExhibitConfig.Value2 = 4;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Green = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)5;
			defaultExhibitConfig.RelativeEffects = new List<string> { "YuukaBloomSe" };
			defaultExhibitConfig.RelativeCards = new List<string> { "YuukaCharacterTokenBlossomSmall", "YuukaCharacterTokenBlossomMedium", "YuukaCharacterTokenBlossomLarge" };
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(YuukaExhibitADef))]
	public sealed class YuukaExhibitA : ShiningExhibit
	{
		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnEnding, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnEnding);
		}

		private IEnumerable<BattleAction> OnPlayerTurnEnding(UnitEventArgs args)
		{
			if (((Unit)((Exhibit)this).Battle.Player).TurnCounter == ((Exhibit)this).Value1)
			{
				<>n__0();
				yield return (BattleAction)(object)new ApplyStatusEffectAction<YuukaBloomSe>((Unit)(object)((Exhibit)this).Owner, (int?)((Exhibit)this).Value2, (int?)null, (int?)null, (int?)null, 0f, true);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
	public sealed class YuukaExhibitBDef : YuukaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Value1 = 4;
			defaultExhibitConfig.Value2 = 12;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Red = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)4;
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.InitialCounter = 0;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			defaultExhibitConfig.RelativeCards = new List<string> { "YuukaCharacterTokenZeal" };
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(YuukaExhibitBDef))]
	public sealed class YuukaExhibitB : ShiningExhibit
	{
		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnStarting, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnStarting);
			((Exhibit)this).ReactBattleEvent<GameEventArgs>(((Exhibit)this).Battle.BattleEnded, (EventSequencedReactor<GameEventArgs>)OnBattleEnded);
			((Exhibit)this).Battle.MaxHand = ((Exhibit)this).Value2;
		}

		private IEnumerable<BattleAction> OnPlayerTurnStarting(UnitEventArgs args)
		{
			((Exhibit)this).Counter = ((Exhibit)this).Counter + 1;
			if (((Unit)((Exhibit)this).Battle.Player).TurnCounter == ((Exhibit)this).Value1)
			{
				<>n__0();
				yield return (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<YuukaCharacterTokenZeal>(1, false), (AddCardsType)0);
			}
		}

		private IEnumerable<BattleAction> OnBattleEnded(GameEventArgs args)
		{
			((Exhibit)this).Counter = 0;
			yield break;
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
	public class YuukaExhibitTemplate : 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(YuukaDefaultConfig.GetDefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public ExhibitConfig GetDefaultExhibitConfig()
		{
			return YuukaDefaultConfig.GetDefaultExhibitConfig();
		}
	}
}
namespace YuukaMod.Enemies
{
	[EntityLogic(typeof(YuukaEnemyUnitDef))]
	public sealed class YuukaMod : EnemyUnit
	{
		private enum MoveType
		{
			Attack3x,
			AttackFrail,
			AttackGraze,
			AttackJunk,
			BarrierBuff,
			SpellCard
		}

		private enum BossPhase
		{
			RandomMoves,
			BarrierBuff,
			SpellCard
		}

		private BossPhase currentPhase;

		private int randomMovesUsed;

		private static readonly Random rng = new Random();

		private MoveType lastMove = MoveType.Attack3x;

		public string Attack3x => ((EnemyUnit)this).GetSpellCardName((int?)0, 1);

		public string AttackFrail => ((EnemyUnit)this).GetSpellCardName((int?)0, 2);

		public string AttackGraze => ((EnemyUnit)this).GetSpellCardName((int?)0, 3);

		public string BarrierBuff => ((EnemyUnit)this).GetSpellCardName((int?)0, 4);

		public string SpellCard => ((EnemyUnit)this).GetSpellCardName((int?)5, 6);

		public string AttackJunk => ((EnemyUnit)this).GetSpellCardName((int?)0, 7);

		protected override void OnEnterBattle(BattleController battle)
		{
			currentPhase = BossPhase.RandomMoves;
			randomMovesUsed = 0;
			((EnemyUnit)this).CountDown = 5;
			((Unit)this).ReactBattleEvent<GameEventArgs>(((Unit)this).Battle.BattleStarted, (Func<GameEventArgs, IEnumerable<BattleAction>>)OnBattleStarted);
		}

		public override void OnSpawn(EnemyUnit spawner)
		{
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)new ApplyStatusEffectAction<YuukaBossSleepingTerrorSe>((Unit)(object)this, (int?)((EnemyUnit)this).Count1, (int?)null, (int?)null, (int?)((EnemyUnit)this).Count2, 1f, true)));
		}

		private IEnumerable<BattleAction> OnBattleStarted(GameEventArgs arg)
		{
			int? num = ((EnemyUnit)this).Count2;
			yield return (BattleAction)(object)new ApplyStatusEffectAction<YuukaBossSleepingTerrorSe>((Unit)(object)this, (int?)((EnemyUnit)this).Count1, (int?)null, (int?)null, num, 1f, true);
		}

		protected override IEnumerable<IEnemyMove> GetTurnMoves()
		{
			switch (currentPhase)
			{
			case BossPhase.RandomMoves:
				switch (ChooseRandomRandomMove())
				{
				case MoveType.Attack3x:
					yield return ((EnemyUnit)this).AttackMove(Attack3x, ((EnemyUnit)this).Gun1, ((EnemyUnit)this).Damage1, 3, false, "Instant", true);
					break;
				case MoveType.AttackFrail:
					yield return ((EnemyUnit)this).AttackMove(AttackFrail, ((EnemyUnit)this).Gun2, ((EnemyUnit)this).Damage2, 2, false, "Instant", true);
					yield return ((EnemyUnit)this).NegativeMove((string)null, typeof(Fragil), (int?)null, (int?)2, false, false, (PerformAction)null);
					break;
				case MoveType.AttackGraze:
					yield return ((EnemyUnit)this).AttackMove(AttackGraze, ((EnemyUnit)this).Gun3, ((EnemyUnit)this).Damage3, 1, false, "Instant", true);
					yield return ((EnemyUnit)this).DefendMove((Unit)(object)this, (string)null, 0, 0, 2, true, (PerformAction)null);
					break;
				default:
					yield return ((EnemyUnit)this).AttackMove(AttackJunk, EnemyUnit.GetRandomGun((IReadOnlyList<string>)new List<string> { GunNameID.GetGunFromId(7041) }), 14, 1, false, "Instant", true);
					yield return ((EnemyUnit)this).AddCardMove((string)null, typeof(Riguang), 1, (AddCardZone)0, (PerformAction)null, false);
					break;
				}
				if (((EnemyUnit)this).CountDown == 2)
				{
					yield return (IEnemyMove)new SimpleEnemyMove(Intention.CountDown(((EnemyUnit)this).CountDown));
				}
				break;
			case BossPhase.BarrierBuff:
				if (((Unit)this).Hp <= ((Unit)this).MaxHp - ((EnemyUnit)this).Defend)
				{
					yield return (IEnemyMove)new SimpleEnemyMove(Intention.Heal().WithMoveName(BarrierBuff), (IEnumerable<BattleAction>)(object)new BattleAction[2]
					{
						(BattleAction)new EnemyMoveAction((EnemyUnit)(object)this, ((EnemyUnit)this).GetMove(1), true),
						(BattleAction)new HealAction((Unit)(object)this, (Unit)(object)this, ((EnemyUnit)this).Defend, (HealType)0, 0.2f)
					});
				}
				else
				{
					yield return (IEnemyMove)new SimpleEnemyMove(Intention.Defend().WithMoveName(BarrierBuff), (IEnumerable<BattleAction>)(object)new BattleAction[2]
					{
						(BattleAction)new EnemyMoveAction((EnemyUnit)(object)this, ((EnemyUnit)this).GetMove(1), true),
						(BattleAction)new CastBlockShieldAction((Unit)(object)this, 0, ((EnemyUnit)this).Defend, (BlockShieldType)1, true)